Merge branch '2.12.x' into 2.13.x

no interesting merge conflicts.  versions.properties is always a
conflict factory, and HashMap.scala was because of parallel
collections removal.

% export mb=$(git merge-base origin/2.12.x origin/2.13.x)
% git log --graph --oneline --decorate $mb..origin/2.12.x | cat
*   96cdfb4 (origin/HEAD, origin/2.12.x) Merge pull request scala#5741 from monkey-mas/bump-up-sbt-jmh-to-0.2.21
|\
| * 08f753e Bump up sbt-jmh to 0.2.21
*   38baf2b Merge pull request scala#5771 from som-snytt/issue/regex-doc-err
|\
| * cc1b8f3 Fix and improve Regex doc
* |   6f905fd Merge pull request scala#5747 from dwijnand/fix-root-package-task
|\ \
| * | 4c1c8de Rewire package to osgiBundle for OSGi-enabled projects
|  /
* |   57948c8 Merge pull request scala#5791 from SethTisue/cruft-begone
|\ \
| * | 4b98161 remove test/pending directory too
| * | 25048bc (SethTisue/cruft-begone) rm -r test/{flaky,disabled*,checker-tests,support,debug}
| * | 0563c4b remove orphaned checkfiles
| * | 36357f3 remove two empty source files
| * | 8690809 fix typos
| * | 8177b99 unset a stray execute bit
* | |   c7c2152 Merge pull request scala#5776 from lrytz/numbersCleanup
|\ \ \
| * | | 77e0602 cleanups and clarifications in versions.properties
|  / /
* | |   95a263e Merge pull request scala#5789 from ceeph/patch-1
|\ \ \
| |/ /
|/| |
| * | a9ba3e6 Fix table formatting
|/ /
* |   6048c66 Merge pull request scala#5780 from lrytz/bootstrapOverwrite
|\ \
| * | 6ff3891 Use a single repository in the bootstrap job
|/ /
* |   0dab108 Merge pull request scala#5777 from som-snytt/issue/10226
|\ \
| * | c77b420 SI-10226 REPL handles paste when colorized
|/ /
* |   d0c2620 Merge pull request scala#5756 from rorygraves/2.12.x_depthboxing
|\ \
| * | f7cd76b Reduce boxing of scala.reflect.internal.Depth
|  /
* |   17e057b Merge pull request scala#5755 from rorygraves/2.12.x_map4
|\ \
| * | 0c6d4e5 Performance improvements for Map4 to HashMap nad Set4 to HashSet transitions
| * | aefc8f4 Add benchmarks for Map4 to HashMap and Set4 to HashSet transitions
| * | fad8b95 Fix compile error on existing ListBenchmark
|  /
* |   3fadf69 Merge pull request scala#5675 from piyush-jaiswal/issue/9729
|\ \
| |/
|/|
| * cc99026 Add tests for ConsoleReporter.
*   6e9268b Merge pull request scala#5761 from lrytz/sd329
|\
| * 6abb6ba Don't use `equals` for comparing java.lang.Double/Float
*   680d866 Merge pull request scala#5719 from retronym/ticket/10187
|\
| * 898fa00 SI-10187 Support mutation of mutable.HashMap in getOrElseUpdate
*   0e38f28 Merge pull request scala#5767 from som-snytt/issue/5621
|\
| * dea2171 SI-5621 Missing implicits are supplied by defaults
*   482879f Merge pull request scala#5769 from som-snytt/issue/8969
|\
| * 050811b SI-8969 Accept poly+implicit for assignment syntax
* cba77ce Merge pull request scala#5766 from lrytz/versionsReadme
* 8fcb9f1 Adapt README to new version numbers
% git merge origin/2.12.x
% git status
...
	both modified:   src/library/scala/collection/mutable/HashMap.scala
	deleted by them: test/pending/shootout/fasta.scala
	both modified:   versions.properties
% git rm --force test/pending/shootout/fasta.scala
% emacs versions.properties
% git add -u versions.properties
% emacs src/library/scala/collection/mutable/HashMap.scala
% git add -u src/library/scala/collection/mutable/HashMap.scala

Author: SethTisue

README.md

@@ -20,7 +20,7 @@ We're still using Jira for issue reporting, so please [report any issues](https:
 # Get in touch!
 If you need some help with your PR at any time, please feel free to @-mention anyone from the list below, and we will do our best to help you out:
 
-                                                                                                  | username                                                       | talk to me about...                               |
+|                                                                                                 | username                                                       | talk to me about...                               |
 --------------------------------------------------------------------------------------------------|----------------------------------------------------------------|---------------------------------------------------|
  <img src="https://avatars.githubusercontent.com/adriaanm"      height="50px" title="Adriaan Moors"/>        | [`@adriaanm`](https://github.com/adriaanm)           | type checker, pattern matcher, infrastructure, language spec |
  <img src="https://avatars.githubusercontent.com/SethTisue"     height="50px" title="Seth Tisue"/>           | [`@SethTisue`](https://github.com/SethTisue)         | build, developer docs, community build, Jenkins, library, the welcome-to-Scala experience |
@@ -104,10 +104,13 @@ Core commands:
   - `partest` runs partest tests (accepts options, try `partest --help`)
   - `publishLocal` publishes a distribution locally (can be used as `scalaVersion` in
     other sbt projects)
-    - Optionally `set baseVersionSuffix := "abcd123-SNAPSHOT"`
+    - Optionally `set baseVersionSuffix := "-bin-abcd123-SNAPSHOT"`
       where `abcd123` is the git hash of the revision being published. You can also
-      use something custom like `"mypatch"`. This changes the version number from
-      `2.12.0-SNAPSHOT` to something more stable (`2.12.0-abcd123-SNAPSHOT`).
+      use something custom like `"-bin-mypatch"`. This changes the version number from
+      `2.12.2-SNAPSHOT` to something more stable (`2.12.2-bin-abcd123-SNAPSHOT`).
+    - Note that the `-bin` string marks the version binary compatible. Using it in
+      sbt will cause the `scalaBinaryVersion` to be `2.12`. If the version is not
+      binary compatible, we recommend using `-pre`, e.g., `2.13.0-pre-abcd123-SNAPSHOT`.
     - Optionally `set publishArtifact in (Compile, packageDoc) in ThisBuild := false`
       to skip generating / publishing API docs (speeds up the process).
 
@@ -199,16 +202,17 @@ CI performs a full bootstrap. The first task, `validate-publish-core`, publishes
 a build of your commit to the temporary repository
 https://scala-ci.typesafe.com/artifactory/scala-pr-validation-snapshots.
 Note that this build is not yet bootstrapped, its bytecode is built using the
-current `starr`. The version number is `2.12.0-abcd123-SNAPSHOT` where `abcd123`
-is the commit hash.
+current `starr`. The version number is `2.12.2-bin-abcd123-SNAPSHOT` where `abcd123`
+is the commit hash. For binary incompatible builds, the version number is
+`2.13.0-pre-abcd123-SNAPSHOT`.
 
 You can use Scala builds in the validation repository locally by adding a resolver
 and specifying the corresponding `scalaVersion`:
 
 ```
 $ sbt
 > set resolvers += "pr" at "https://scala-ci.typesafe.com/artifactory/scala-pr-validation-snapshots/"
-> set scalaVersion := "2.12.0-abcd123-SNAPSHOT"
+> set scalaVersion := "2.12.2-bin-abcd123-SNAPSHOT"
 > console
 ```
 
@@ -228,10 +232,8 @@ The CI also publishes nightly API docs:
   - [2.11.x](http://www.scala-lang.org/files/archive/nightly/2.11.x/api/?C=M;O=D)
     - [symlink to the latest](http://www.scala-lang.org/files/archive/nightly/2.11.x/api/2.11.x/)
 
-Note that we currently don't publish nightly (or SNAPSHOT) builds in maven or ivy
-format to any repository. You can track progress on this front at
-[scala-jenkins-infra#133](https://github.com/scala/scala-jenkins-infra/issues/133)
-and [scala-dev#68](https://github.com/scala/scala-dev/issues/68).
+Using a nightly build in sbt is explained in
+[this answer on Stack Overflow](http://stackoverflow.com/questions/40622878)
 
 ## Scala CI Internals
 

build.sbt

@@ -670,7 +670,7 @@ lazy val test = project
       (baseDir / "test/files/lib").list.toSeq.filter(_.endsWith(".jar.desired.sha1"))
         .map(f => bootstrapDep(baseDir, "test/files/lib", f.dropRight(17)))
     },
-    // Two hardcoded depenencies in partest, resolved in the otherwise unused scope "test":
+    // Two hardcoded dependencies in partest, resolved in the otherwise unused scope "test":
     libraryDependencies += bootstrapDep((baseDirectory in ThisBuild).value, "test/files/codelib", "code") % "test",
     libraryDependencies += bootstrapDep((baseDirectory in ThisBuild).value, "test/files/speclib", "instrumented") % "test",
     // no main sources

project/MiMa.scala

@@ -51,7 +51,7 @@ object MiMa {
       "--curr", curr.getAbsolutePath,
       "--filters", filter.getAbsolutePath,
       "--generate-filters",
-      // !!! Command line MiMa (which we call rathan the sbt Plugin for reasons alluded to in f2d0f1e85) incorrectly
+      // !!! Command line MiMa (which we call rather than the sbt Plugin for reasons alluded to in f2d0f1e85) incorrectly
       //     defaults to no checking (!) if this isn't specified. Fixed in https://github.com/typesafehub/migration-manager/pull/138
       //     TODO: Try out the new "--direction both" mode of MiMa
       "--direction", "backwards"

project/Osgi.scala

@@ -50,7 +50,8 @@ object Osgi {
       "Bundle-SymbolicName" -> (bundleSymbolicName.value + ".source"),
       "Bundle-Version" -> versionProperties.value.osgiVersion,
       "Eclipse-SourceBundle" -> (bundleSymbolicName.value + ";version=\"" + versionProperties.value.osgiVersion + "\";roots:=\".\"")
-    )
+    ),
+    Keys.`package` := bundle.value
   )
 
   def bundleTask(headers: Map[String, String], jarlist: Boolean, fullClasspath: Seq[File], artifactPath: File,

project/PartestUtil.scala

@@ -87,7 +87,7 @@ object PartestUtil {
       token(grepOption <~ Space) ~> token(globOrPattern, tokenCompletion)
     }
 
-    val SrcPath = ((token(srcPathOption) <~ Space) ~ token(StringBasic.examples(Set("files", "pending", "scaladoc")))) map {
+    val SrcPath = ((token(srcPathOption) <~ Space) ~ token(StringBasic.examples(Set("files", "scaladoc")))) map {
       case opt ~ path =>
         srcPath = path
         opt + " " + path

scripts/jobs/integrate/bootstrap

@@ -3,7 +3,7 @@
 # Script Overview
 #  - determine scala version
 #  - determine module versions
-#  - build minimal core (aka locker) of Scala, use the determined version number, publish to scala-release-temp
+#  - build minimal core (aka locker) of Scala, use the determined version number, publish to scala-integration
 #  - build those modules where a binary compatible version doesn't exist, publish to scala-integration
 #  - build Scala using the previously built core and bootstrap modules, publish to scala-integration
 #  - for releases
@@ -98,15 +98,10 @@ mkdir -p $baseDir/ivy2
 rm -rf $baseDir/resolutionScratch_
 mkdir -p $baseDir/resolutionScratch_
 
-# repo for the starr and locker builds
-releaseTempRepoUrl=${releaseTempRepoUrl-"https://scala-ci.typesafe.com/artifactory/scala-release-temp/"}
-# repo for the modules and the quick build
+# repo to publish builds
 integrationRepoUrl=${integrationRepoUrl-"https://scala-ci.typesafe.com/artifactory/scala-integration/"}
 
-# the `releaseTempRepoUrl` needs to be in the repositories file to get starr when building quick and the modules.
-# `integrationRepoUrl` is there to find modules when building quick and other modules (e.g., partest requires xml).
-# the file is re-generated for running the stability test, this time with only `integrationRepoUrl`.
-generateRepositoriesConfig $releaseTempRepoUrl $integrationRepoUrl
+generateRepositoriesConfig $integrationRepoUrl
 
 # ARGH trying to get this to work on multiple versions of sbt-extras...
 # the old version (on jenkins, and I don't want to upgrade for risk of breaking other builds) honors -sbt-dir
@@ -413,7 +408,7 @@ bootstrap() {
         git clone --reference $WORKSPACE/.git $WORKSPACE/.git $STARR_DIR
         cd $STARR_DIR
         git co $STARR_REF
-        $SBT_CMD -no-colors $sbtArgs --warn "setupBootstrapStarr $releaseTempRepoUrl $STARR_VER" $clean publish >> $baseDir/logs/builds 2>&1
+        $SBT_CMD -no-colors $sbtArgs --warn "setupBootstrapStarr $integrationRepoUrl $STARR_VER" $clean publish >> $baseDir/logs/builds 2>&1
       )
   fi
 
@@ -427,7 +422,7 @@ bootstrap() {
   # publish more than just core: partest needs scalap
   # in sabbus lingo, the resulting Scala build will be used as starr to build the released Scala compiler
   if [ ! -z "$STARR_VER" ]; then SET_STARR=-Dstarr.version=$STARR_VER; fi
-  $SBT_CMD -no-colors $sbtArgs $SET_STARR --warn "setupBootstrapLocker $releaseTempRepoUrl $SCALA_VER" $clean publish >> $baseDir/logs/builds 2>&1
+  $SBT_CMD -no-colors $sbtArgs $SET_STARR --warn "setupBootstrapLocker $integrationRepoUrl $SCALA_VER" $clean publish >> $baseDir/logs/builds 2>&1
 
   echo "### Building modules using locker"
 
@@ -530,13 +525,9 @@ determineScalaVersion
 deriveModuleVersions
 
 removeExistingBuilds $integrationRepoUrl
-removeExistingBuilds $releaseTempRepoUrl
 
 bootstrap
 
-# for stability testing and sonatype publishing, use artifacts in `integrationRepoUrl`
-generateRepositoriesConfig $integrationRepoUrl
-
 if [ "$testStability" == "yes" ]
   then testStability
 fi

spec/04-basic-declarations-and-definitions.md

@@ -669,6 +669,15 @@ def f(a: Int = 0)(b: Int = a + 1) = b // OK
 f(10)()                               // returns 11 (not 1)
 ```
 
+If an [implicit argument](07-implicits.html#implicit-parameters)
+is not found by implicit search, it may be supplied using a default argument.
+
+```scala
+implicit val i: Int = 2
+def f(implicit x: Int, s: String = "hi") = s * x
+f                                     // "hihi"
+```
+
 ### By-Name Parameters
 
 ```ebnf

spec/06-expressions.md

@@ -320,7 +320,7 @@ would not typecheck.
 
 ### Named and Default Arguments
 
-If an application might uses named arguments $p = e$ or default
+If an application is to use named arguments $p = e$ or default
 arguments, the following conditions must hold.
 
 - For every named argument $p_i = e_i$ which appears left of a positional argument
@@ -330,7 +330,7 @@ arguments, the following conditions must hold.
   argument defines a parameter which is already specified by a
   positional argument.
 - Every formal parameter $p_j:T_j$ which is not specified by either a positional
-  or a named argument has a default argument.
+  or named argument has a default argument.
 
 If the application uses named or default
 arguments the following transformation is applied to convert it into
@@ -455,7 +455,7 @@ $e$.
 
 Type applications can be omitted if
 [local type inference](#local-type-inference) can infer best type parameters
-for a polymorphic functions from the types of the actual function arguments
+for a polymorphic function from the types of the actual function arguments
 and the expected result type.
 
 ## Tuples

src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala

@@ -1264,14 +1264,22 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
     def genEqEqPrimitive(l: Tree, r: Tree, success: asm.Label, failure: asm.Label, targetIfNoJump: asm.Label, pos: Position) {
 
       /* True if the equality comparison is between values that require the use of the rich equality
-       * comparator (scala.runtime.Comparator.equals). This is the case when either side of the
+       * comparator (scala.runtime.BoxesRunTime.equals). This is the case when either side of the
        * comparison might have a run-time type subtype of java.lang.Number or java.lang.Character.
-       * When it is statically known that both sides are equal and subtypes of Number of Character,
-       * not using the rich equality is possible (their own equals method will do ok.)
+       *
+       * When it is statically known that both sides are equal and subtypes of Number or Character,
+       * not using the rich equality is possible (their own equals method will do ok), except for
+       * java.lang.Float and java.lang.Double: their `equals` have different behavior around `NaN`
+       * and `-0.0`, see Javadoc (scala-dev#329).
        */
       val mustUseAnyComparator: Boolean = {
-        val areSameFinals = l.tpe.isFinalType && r.tpe.isFinalType && (l.tpe =:= r.tpe)
-        !areSameFinals && platform.isMaybeBoxed(l.tpe.typeSymbol) && platform.isMaybeBoxed(r.tpe.typeSymbol)
+        platform.isMaybeBoxed(l.tpe.typeSymbol) && platform.isMaybeBoxed(r.tpe.typeSymbol) && {
+          val areSameFinals = l.tpe.isFinalType && r.tpe.isFinalType && (l.tpe =:= r.tpe) && {
+            val sym = l.tpe.typeSymbol
+            sym != BoxedFloatClass && sym != BoxedDoubleClass
+          }
+          !areSameFinals
+        }
       }
 
       if (mustUseAnyComparator) {

src/compiler/scala/tools/nsc/reporters/ConsoleReporter.scala

@@ -77,10 +77,10 @@ class ConsoleReporter(val settings: Settings, reader: BufferedReader, writer: Pr
     if (reader != null) {
       reader.read match {
         case 'a' | 'A' =>
-          new Throwable().printStackTrace()
+          new Throwable().printStackTrace(writer)
           System.exit(1)
         case 's' | 'S' =>
-          new Throwable().printStackTrace()
+          new Throwable().printStackTrace(writer)
           writer.println()
           writer.flush()
         case _ =>

src/compiler/scala/tools/nsc/transform/AddInterfaces.scala

@@ -84,7 +84,7 @@ abstract class TailCalls extends Transform {
    * </p>
    * <p>
    *   Assumes: `Uncurry` has been run already, and no multiple
-   *            parameter lists exit.
+   *            parameter lists exist.
    * </p>
    */
   class TailCallElimination(unit: CompilationUnit) extends Transformer {

src/compiler/scala/tools/nsc/transform/TailCalls.scala

@@ -198,7 +198,7 @@ object Map extends ImmutableMapFactory[Map] {
       else if (key == key2) new Map4(key1, value1, key2, value, key3, value3, key4, value4)
       else if (key == key3) new Map4(key1, value1, key2, value2, key3, value, key4, value4)
       else if (key == key4) new Map4(key1, value1, key2, value2, key3, value3, key4, value)
-      else new HashMap + ((key1, value1), (key2, value2), (key3, value3), (key4, value4), (key, value))
+      else (new HashMap).updated(key1,value1).updated(key2, value2).updated(key3, value3).updated(key4, value4).updated(key, value)
     def + [V1 >: V](kv: (K, V1)): Map[K, V1] = updated(kv._1, kv._2)
     def - (key: K): Map[K, V] =
       if (key == key1)      new Map3(key2, value2, key3, value3, key4, value4)

src/library/scala/collection/immutable/Map.scala

@@ -190,7 +190,7 @@ object Set extends ImmutableSetFactory[Set] {
       elem == elem1 || elem == elem2 || elem == elem3 || elem == elem4
     def + (elem: A): Set[A] =
       if (contains(elem)) this
-      else new HashSet[A] + (elem1, elem2, elem3, elem4, elem)
+      else new HashSet[A] + elem1 + elem2 + elem3 + elem4 + elem
     def - (elem: A): Set[A] =
       if (elem == elem1) new Set3(elem2, elem3, elem4)
       else if (elem == elem2) new Set3(elem1, elem3, elem4)

src/library/scala/collection/immutable/Set.scala

@@ -68,17 +68,45 @@ extends AbstractMap[A, B]
     else Some(e.value)
   }
 
-  override def getOrElseUpdate(key: A, value: => B): B = {
-    val i = index(elemHashCode(key))
-    val e = findEntry0(key, i)
-    if (e ne null) e.value
+  override def getOrElseUpdate(key: A, defaultValue: => B): B = {
+    val hash = elemHashCode(key)
+    val i = index(hash)
+    val entry = findEntry(key, i)
+    if (entry != null) entry.value
     else {
-      val newEntry = createNewEntry(key, value)
-      addEntry0(newEntry, i)
-      newEntry.value
+      val table0 = table
+      val default = defaultValue
+      // Avoid recomputing index if the `defaultValue()` hasn't triggered
+      // a table resize.
+      val newEntryIndex = if (table0 eq table) i else index(hash)
+      addEntry(createNewEntry(key, default), newEntryIndex)
     }
   }
 
+  /* inlined HashTable.findEntry0 to preserve its visibility */
+  private[this] def findEntry(key: A, h: Int): Entry = {
+    var e = table(h).asInstanceOf[Entry]
+    while (notFound(key, e))
+      e = e.next
+    e
+  }
+  private[this] def notFound(key: A, e: Entry): Boolean = (e != null) && !elemEquals(e.key, key)
+
+  /* inlined HashTable.addEntry0 to preserve its visibility */
+  private[this] def addEntry(e: Entry, h: Int): B = {
+    if (tableSize >= threshold) addEntry(e)
+    else addEntry0(e, h)
+    e.value
+  }
+
+  /* extracted to make addEntry inlinable */
+  private[this] def addEntry0(e: Entry, h: Int) {
+    e.next = table(h).asInstanceOf[Entry]
+    table(h) = e
+    tableSize += 1
+    nnSizeMapAdd(h)
+  }
+
   override def put(key: A, value: B): Option[B] = {
     val e = findOrAddEntry(key, value)
     if (e eq null) None

src/library/scala/collection/mutable/HashMap.scala

@@ -41,11 +41,13 @@ import java.util.regex.{ Pattern, Matcher }
  *  implicitly for strings:
  *
  *  {{{
- *  val date = """(\d\d\d\d)-(\d\d)-(\d\d)""".r
+ *  val date = raw"(\d{4})-(\d{2})-(\d{2})".r
  *  }}}
  *
  *  Since escapes are not processed in multi-line string literals, using triple quotes
  *  avoids having to escape the backslash character, so that `"\\d"` can be written `"""\d"""`.
+ *  The same result is achieved with certain interpolators, such as `raw"\d".r` or
+ *  a custom interpolator `r"\d"` that also compiles the `Regex`.
  *
  *  === Extraction ===
  *  To extract the capturing groups when a `Regex` is matched, use it as
@@ -116,29 +118,41 @@ import java.util.regex.{ Pattern, Matcher }
  *  while (mi.hasNext) {
  *    val d = mi.next
  *    if (mi.group(1).toInt < 1960) println(s"$d: An oldie but goodie.")
+ *  }
  *  }}}
  *
- *  Note that `findAllIn` finds matches that don't overlap. (See [[findAllIn]] for more examples.)
+ *  Although the `MatchIterator` returned by `findAllIn` is used like any `Iterator`,
+ *  with alternating calls to `hasNext` and `next`, `hasNext` has the additional
+ *  side effect of advancing the underlying matcher to the next unconsumed match.
+ *  This effect is visible in the `MatchData` representing the "current match".
  *
  *  {{{
- *  val num = """(\d+)""".r
- *  val all = num.findAllIn("123").toList  // List("123"), not List("123", "23", "3")
+ *  val r = "(ab+c)".r
+ *  val s = "xxxabcyyyabbczzz"
+ *  r.findAllIn(s).start    // 3
+ *  val mi = r.findAllIn(s)
+ *  mi.hasNext              // true
+ *  mi.start                // 3
+ *  mi.next()               // "abc"
+ *  mi.start                // 3
+ *  mi.hasNext              // true
+ *  mi.start                // 9
+ *  mi.next()               // "abbc"
  *  }}}
  *
- *  Also, the "current match" of a `MatchIterator` may be advanced by either `hasNext` or `next`.
- *  By comparison, the `Iterator[Match]` returned by `findAllMatchIn` or `findAllIn.matchData`
- *  produces `Match` objects that remain valid after the iterator is advanced.
+ *  The example shows that methods on `MatchData` such as `start` will advance to
+ *  the first match, if necessary. It also shows that `hasNext` will advance to
+ *  the next unconsumed match, if `next` has already returned the current match.
+ *
+ *  The current `MatchData` can be captured using the `matchData` method.
+ *  Alternatively, `findAllMatchIn` returns an `Iterator[Match]`, where there
+ *  is no interaction between the iterator and `Match` objects it has already produced.
+ *
+ *  Note that `findAllIn` finds matches that don't overlap. (See [[findAllIn]] for more examples.)
  *
  *  {{{
- *  val ns = num.findAllIn("1 2 3")
- *  ns.start    // 0
- *  ns.hasNext  // true
- *  ns.start    // 2
- *  val ms = num.findAllMatchIn("1 2 3")
- *  val m  = ms.next()
- *  m.start     // 0
- *  ms.hasNext  // true
- *  m.start     // still 0
+ *  val num = raw"(\d+)".r
+ *  val all = num.findAllIn("123").toList  // List("123"), not List("123", "23", "3")
  *  }}}
  *
  *  === Replace Text ===