Escape $ in docs for undefined variables

Author: ashawley

library/src/scala/Console.scala

@@ -45,9 +45,9 @@ import scala.util.DynamicVariable
  *        val prime = (2 to candidate - 1).forall(candidate % _ != 0)
  *
  *        if (prime)
- *          Console.println(s"${RESET}${GREEN}yes${RESET}")
+ *          Console.println(s"\${RESET}\${GREEN}yes\${RESET}")
  *        else
- *          Console.err.println(s"${RESET}${YELLOW_B}${RED}${UNDERLINED}NO!${RESET}")
+ *          Console.err.println(s"\${RESET}\${YELLOW_B}\${RED}\${UNDERLINED}NO!\${RESET}")
  *      }
  *
  *      def main(args: Array[String]): Unit = isPrime()
@@ -56,10 +56,10 @@ import scala.util.DynamicVariable
  *  }}}
  *
  *  <table style="border: 10px solid #000;width:100%">
- *    <tr><td style="background-color:#000;color:#fff">$ scala PrimeTest</td></tr>
+ *    <tr><td style="background-color:#000;color:#fff">\$ scala PrimeTest</td></tr>
  *    <tr><td style="background-color:#000;color:#fff">1234567891</td></tr>
  *    <tr><td style="background-color:#000;color:#0f0">yes</td></tr>
- *    <tr><td style="background-color:#000;color:#fff">$ scala PrimeTest</td></tr>
+ *    <tr><td style="background-color:#000;color:#fff">\$ scala PrimeTest</td></tr>
  *    <tr><td style="background-color:#000;color:#fff">56474</td></tr>
  *    <tr><td style="background-color:#000;color:#fff"><span style="background-color:#ff0;color:#f00;text-decoration:underline">NO!</span></td></tr>
  *  </table>
@@ -76,7 +76,7 @@ import scala.util.DynamicVariable
  *
  *      def isPrime(candidate: Int): Boolean = {
  *
- *        val input = new StringReader(s"$candidate\n")
+ *        val input = new StringReader(s"\$candidate\n")
  *        val outCapture = new ByteArrayOutputStream
  *        val errCapture = new ByteArrayOutputStream
  *
@@ -97,15 +97,15 @@ import scala.util.DynamicVariable
  *
  *      def main(args: Array[String]): Unit = {
  *        val primes = (2 to 50) filter (isPrime)
- *        println(s"First primes: $primes")
+ *        println(s"First primes: \$primes")
  *      }
  *
  *    }
  *  }}}
  *
  *
  *  <table style="border: 10px solid #000;width:100%">
- *    <tr><td style="background-color:#000;color:#fff">$ scala FunctionalPrimeTest</td></tr>
+ *    <tr><td style="background-color:#000;color:#fff">\$ scala FunctionalPrimeTest</td></tr>
  *    <tr><td style="background-color:#000;color:#fff">First primes: Vector(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47)</td></tr>
  *  </table>
  *

library/src/scala/Option.scala

@@ -99,7 +99,7 @@ object Option {
  * bMaybe = Option(abc.get(2))
  * bMaybe match {
  *   case Some(b) =>
- *     println(s"Found $b")
+ *     println(s"Found \$b")
  *   case None =>
  *     println("Not found")
  * }

library/src/scala/StringContext.scala

@@ -21,13 +21,13 @@ import scala.annotation.tailrec
  * Here's an example:
  * {{{
  *   val name = "James"
- *   println(s"Hello, $name")  // Hello, James
+ *   println(s"Hello, \$name")  // Hello, James
  * }}}
  *
  * Any processed string literal is rewritten as an instantiation and
  * method call against this class.   For example:
  * {{{
- *   s"Hello, $name"
+ *   s"Hello, \$name"
  * }}}
  *
  * is rewritten to be:
@@ -45,7 +45,7 @@ import scala.annotation.tailrec
  *    implicit class JsonHelper(private val sc: StringContext) extends AnyVal {
  *      def json(args: Any*): JSONObject = ...
  *    }
- *    val x: JSONObject = json"{ a: $a }"
+ *    val x: JSONObject = json"{ a: \$a }"
  * }}}
  *
  *  Here the `JsonHelper` extension class implicitly adds the `json` method to
@@ -77,14 +77,14 @@ case class StringContext(parts: String*) {
    *  Here's an example of usage:
    *  {{{
    *    val name = "James"
-   *    println(s"Hello, $name")  // Hello, James
+   *    println(s"Hello, \$name")  // Hello, James
    *  }}}
-   *  In this example, the expression $name is replaced with the `toString` of the
+   *  In this example, the expression \$name is replaced with the `toString` of the
    *  variable `name`.
    *  The `s` interpolator can take the `toString` of any arbitrary expression within
-   *  a `${}` block, for example:
+   *  a `\${}` block, for example:
    *  {{{
-   *    println(s"1 + 1 = ${1 + 1}")
+   *    println(s"1 + 1 = \${1 + 1}")
    *  }}}
    *  will print the string `1 + 1 = 2`.
    *
@@ -149,7 +149,7 @@ case class StringContext(parts: String*) {
    *  {{{
    *    val height = 1.9d
    *    val name = "James"
-   *    println(f"$name%s is $height%2.2f meters tall")  // James is 1.90 meters tall
+   *    println(f"\$name%s is \$height%2.2f meters tall")  // James is 1.90 meters tall
    *  }}}
    *
    *  @param `args` The arguments to be inserted into the resulting string.

library/src/scala/annotation/implicitAmbiguous.scala

@@ -17,7 +17,7 @@ package scala.annotation
   * multiple ambiguous values, annotate at least one of the implicit values
   * `@implicitAmbiguous`. Assuming the implicit value is a method with type
   * parameters `X1,..., XN`, the error message will be the result of replacing
-  * all occurrences of `${Xi}` in the string `msg` with the string representation
+  * all occurrences of `\${Xi}` in the string `msg` with the string representation
   * of the corresponding type argument `Ti`.
   *
   * If more than one `@implicitAmbiguous` annotation is collected, the compiler is
@@ -31,7 +31,7 @@ package scala.annotation
   *
   * implicit def neq[E, F] : E =!= F = null
   *
-  * @annotation.implicitAmbiguous("Could not prove ${J} =!= ${J}")
+  * @annotation.implicitAmbiguous("Could not prove \${J} =!= \${J}")
   * implicit def neqAmbig1[G, H, J] : J =!= J = null
   * implicit def neqAmbig2[I] : I =!= I = null
   *

library/src/scala/io/AnsiColor.scala

@@ -25,7 +25,7 @@ package io
   *
   * object ColorDemo extends App {
   *
-  *   println(s"${REVERSED}${BOLD}Hello 1979!${RESET}")
+  *   println(s"\${REVERSED}\${BOLD}Hello 1979!\${RESET}")
   * }
   * }}}
   *

library/src/scala/reflect/ClassTag.scala

@@ -30,7 +30,7 @@ import java.lang.{ Class => jClass }
  * For example:
  * {{{
  *   scala> def mkArray[T : ClassTag](elems: T*) = Array[T](elems: _*)
- *   mkArray: [T](elems: T*)(implicit evidence$1: scala.reflect.ClassTag[T])Array[T]
+ *   mkArray: [T](elems: T*)(implicit evidence\$1: scala.reflect.ClassTag[T])Array[T]
  *
  *   scala> mkArray(42, 13)
  *   res0: Array[Int] = Array(42, 13)

library/src/scala/util/Either.scala

@@ -35,8 +35,8 @@ package util
  *    }
  *
  *  result match {
- *    case Right(x) => s"You passed me the Int: $x, which I will increment. $x + 1 = ${x+1}"
- *    case Left(x)  => s"You passed me the String: $x"
+ *    case Right(x) => s"You passed me the Int: \$x, which I will increment. \$x + 1 = \${x+1}"
+ *    case Left(x)  => s"You passed me the String: \$x"
  *  }
  *  }}}
  *
@@ -159,10 +159,10 @@ sealed abstract class Either[+A, +B] extends Product with Serializable {
    *   val report = for (result <- interactWithDB(someQuery)) yield generateReport(result)
    *   report match {
    *     case Right(r) => send(r)
-   *     case Left(e)  => log(s"report not generated, reason was $e")
+   *     case Left(e)  => log(s"report not generated, reason was \$e")
    *   }
    *   // only report errors
-   *   for (e <- interactWithDB(someQuery).left) log(s"query failed, reason was $e")
+   *   for (e <- interactWithDB(someQuery).left) log(s"query failed, reason was \$e")
    *   }}}
    */
   def left = Either.LeftProjection(this)
@@ -178,8 +178,8 @@ sealed abstract class Either[+A, +B] extends Product with Serializable {
    *  @example {{{
    *  val result = util.Try("42".toInt).toEither
    *  result.fold(
-   *    e => s"Operation failed with $e",
-   *    v => s"Operation produced value: $v"
+   *    e => s"Operation failed with \$e",
+   *    v => s"Operation produced value: \$v"
    *  )
    *  }}}
    *
@@ -452,7 +452,7 @@ object Either {
    *  Either.cond(
    *    userInput.forall(_.isDigit) && userInput.size == 10,
    *    PhoneNumber(userInput),
-   *    s"The input ($userInput) does not look like a phone number"
+   *    s"The input (\$userInput) does not look like a phone number"
    *  }}}
    */
   def cond[A, B](test: Boolean, right: => B, left: => A): Either[A, B] =

library/src/scala/util/matching/Regex.scala

@@ -59,7 +59,7 @@ import java.util.regex.{ Pattern, Matcher }
  *
  *  {{{
  *  "2004-01-20" match {
- *    case date(year, month, day) => s"$year was a good year for PLs."
+ *    case date(year, month, day) => s"\$year was a good year for PLs."
  *  }
  *  }}}
  *
@@ -78,7 +78,7 @@ import java.util.regex.{ Pattern, Matcher }
  *
  *  {{{
  *  "2004-01-20" match {
- *    case date(year, _*) => s"$year was a good year for PLs."
+ *    case date(year, _*) => s"\$year was a good year for PLs."
  *  }
  *  }}}
  *
@@ -121,7 +121,7 @@ import java.util.regex.{ Pattern, Matcher }
  *  val mi = date.findAllIn(dates)
  *  while (mi.hasNext) {
  *    val d = mi.next
- *    if (mi.group(1).toInt < 1960) println(s"$d: An oldie but goodie.")
+ *    if (mi.group(1).toInt < 1960) println(s"\$d: An oldie but goodie.")
  *  }
  *  }}}
  *
@@ -165,8 +165,8 @@ import java.util.regex.{ Pattern, Matcher }
  *  {{{
  *  val redacted    = date.replaceAllIn(dates, "XXXX-XX-XX")
  *  val yearsOnly   = date.replaceAllIn(dates, m => m.group(1))
- *  val months      = (0 to 11).map { i => val c = Calendar.getInstance; c.set(2014, i, 1); f"$c%tb" }
- *  val reformatted = date.replaceAllIn(dates, _ match { case date(y,m,d) => f"${months(m.toInt - 1)} $d, $y" })
+ *  val months      = (0 to 11).map { i => val c = Calendar.getInstance; c.set(2014, i, 1); f"\$c%tb" }
+ *  val reformatted = date.replaceAllIn(dates, _ match { case date(y,m,d) => f"\${months(m.toInt - 1)} \$d, \$y" })
  *  }}}
  *
  *  Pattern matching the `Match` against the `Regex` that created it does not reapply the `Regex`.
@@ -191,7 +191,7 @@ import java.util.regex.{ Pattern, Matcher }
  *  @param groupNames A mapping from names to indices in capture groups
  *
  *  @define replacementString
- *  In the replacement String, a dollar sign (`$`) followed by a number will be
+ *  In the replacement String, a dollar sign (`\$`) followed by a number will be
  *  interpreted as a reference to a group in the matched pattern, with numbers
  *  1 through 9 corresponding to the first nine groups, and 0 standing for the
  *  whole match. Any other character is an error. The backslash (`\`) character
@@ -380,7 +380,7 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends
    *  {{{
    *  val madhatter = "(h)(?=(at[^a]+))".r
    *  val madhats   = madhatter.findAllMatchIn(hathaway).map {
-   *    case madhatter(x,y) => s"$x$y"
+   *    case madhatter(x,y) => s"\$x\$y"
    *  }.toList                                       // List(hath, hatth, hattth, hatttt)
    *  }}}
    *
@@ -494,7 +494,7 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends
    * import scala.util.matching.Regex
    * val datePattern = new Regex("""(\d\d\d\d)-(\d\d)-(\d\d)""", "year", "month", "day")
    * val text = "From 2011-07-15 to 2011-07-17"
-   * val repl = datePattern replaceAllIn (text, m => s"${m group "month"}/${m group "day"}")
+   * val repl = datePattern replaceAllIn (text, m => s"\${m group "month"}/\${m group "day"}")
    * }}}
    *
    * $replacementString
@@ -517,7 +517,7 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends
    * {{{
    * import scala.util.matching.Regex._
    *
-   * val vars = Map("x" -> "a var", "y" -> """some $ and \ signs""")
+   * val vars = Map("x" -> "a var", "y" -> """some \$ and \ signs""")
    * val text = "A text with variables %x, %y and %z."
    * val varPattern = """%(\w+)""".r
    * val mapper = (m: Match) => vars get (m group 1) map (quoteReplacement(_))
@@ -564,7 +564,7 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends
    *  the entire String matches in extractor patterns.
    *
    *  Normally, matching on `date` behaves as though the pattern were
-   *  enclosed in anchors, `"^pattern$"`.
+   *  enclosed in anchors, `"^pattern\$"`.
    *
    *  The unanchored `Regex` behaves as though those anchors were removed.
    *
@@ -578,7 +578,7 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends
    *  val date(year, month, day) = "Date 2011-07-15"                       // OK
    *
    *  val copyright: String = "Date of this document: 2011-07-15" match {
-   *    case date(year, month, day) => s"Copyright $year"                  // OK
+   *    case date(year, month, day) => s"Copyright \$year"                  // OK
    *    case _                      => "No copyright"
    *  }
    *  }}}
@@ -766,7 +766,7 @@ object Regex {
    *
    *  val date = """(\d\d\d\d)-(\d\d)-(\d\d)""".r
    *  val text = "The doc spree happened on 2011-07-15."
-   *  val day = date replaceAllIn(text, _ match { case Groups(_, month, day) => s"$month/$day" })
+   *  val day = date replaceAllIn(text, _ match { case Groups(_, month, day) => s"\$month/\$day" })
    *  }}}
    */
   object Groups {
@@ -904,21 +904,21 @@ object Regex {
    *
    *  All regex metacharacters in the input match themselves literally in the output.
    *
-   *  @example {{{List("US$", "CAN$").map(Regex.quote).mkString("|").r}}}
+   *  @example {{{List("US\$", "CAN\$").map(Regex.quote).mkString("|").r}}}
    */
   def quote(text: String): String = Pattern quote text
 
   /** Quotes replacement strings to be used in replacement methods.
    *
    *  Replacement methods give special meaning to backslashes (`\`) and
-   *  dollar signs (`$`) in replacement strings, so they are not treated
+   *  dollar signs (`\$`) in replacement strings, so they are not treated
    *  as literals. This method escapes these characters so the resulting
    *  string can be used as a literal replacement representing the input
    *  string.
    *
    *  @param text The string one wishes to use as literal replacement.
    *  @return A string that can be used to replace matches with `text`.
-   *  @example {{{"CURRENCY".r.replaceAllIn(input, Regex quoteReplacement "US$")}}}
+   *  @example {{{"CURRENCY".r.replaceAllIn(input, Regex quoteReplacement "US\$")}}}
    */
   def quoteReplacement(text: String): String = Matcher quoteReplacement text
 }