Rename Matching to Scanner

src/core/kaleidoscope.Kaleidoscope.scala

@@ -64,20 +64,20 @@ object Kaleidoscope:
   class NoExtraction(pattern: String):
     inline def apply(): Regex = Regex.make(List(pattern))(using Unsafe)
 
-    def unapply(scrutinee: Text)(using matching: Matching): Boolean =
-      matching.nextStart match
+    def unapply(scrutinee: Text)(using scanner: Scanner): Boolean =
+      scanner.nextStart match
         case Unset =>
           Regex.make(List(pattern))(using Unsafe).matches(scrutinee)
 
         case index: Int =>
           val regex = Regex.make(List(pattern))(using Unsafe)
           val matcher = regex.javaPattern.matcher(scrutinee.s).nn
           val found = matcher.find(index)
-          if found then matching.nextStart = matcher.start
+          if found then scanner.nextStart = matcher.start
           found
 
   class RExtractor[ResultType](parts: Seq[String]):
-    def unapply(scrutinee: Text)(using matching: Matching): ResultType =
+    def unapply(scrutinee: Text)(using scanner: Scanner): ResultType =
       val result = Regex.make(parts)(using Unsafe).matchGroups(scrutinee)
       val result2 = result.asInstanceOf[Option[IArray[List[Text] | Optional[Text]]]]
 

src/core/kaleidoscope.Regex.scala

@@ -259,9 +259,9 @@ case class Regex(pattern: Text, groups: List[Regex.Group]):
 
     recur(start.n0)
 
-  def matches(text: Text)(using Matching): Boolean = !matchGroups(text).isEmpty
+  def matches(text: Text)(using Scanner): Boolean = !matchGroups(text).isEmpty
 
-  def matchGroups(text: Text)(using matching: Matching)
+  def matchGroups(text: Text)(using scanner: Scanner)
   :     Option[IArray[List[Text] | Optional[Text]]] =
 
     val matcher: jur.Matcher = javaPattern.matcher(text.s).nn
@@ -294,20 +294,20 @@ case class Regex(pattern: Text, groups: List[Regex.Group]):
 
           recur(tail, matches2, index + 1)
 
-    matching.nextStart match
+    scanner.nextStart match
       case Unset =>
         if !matcher.matches then None else Some(IArray.from(recur(captureGroups, Nil, 0).reverse))
 
       case index: Int =>
         if !matcher.find(index) then None else
-          matching.nextStart = matcher.start + 1
+          scanner.nextStart = matcher.start + 1
           Some(IArray.from(recur(captureGroups, Nil, 0).reverse))
 
 def extract[ValueType](input: Text, start: Ordinal = Prim)
-   (lambda: Matching ?=> PartialFunction[Text, ValueType]): Stream[ValueType] =
+   (lambda: Scanner ?=> PartialFunction[Text, ValueType]): Stream[ValueType] =
   if start.n0 < input.s.length then
-    val matching = Matching(start.n0)
-    lambda(using matching).lift(input) match
-      case Some(head) => head #:: extract(input, Ordinal.zerary(matching.nextStart.or(0)))(lambda)
+    val scanner = Scanner(start.n0)
+    lambda(using scanner).lift(input) match
+      case Some(head) => head #:: extract(input, Ordinal.zerary(scanner.nextStart.or(0)))(lambda)
       case _          => Stream()
   else Stream()

src/core/kaleidoscope.Matching.scala → src/core/kaleidoscope.Scanner.scala

@@ -18,6 +18,6 @@ package kaleidoscope
 
 import vacuous.*
 
-object Matching:
-  given default: DummyImplicit => Matching = Matching(Unset)
-class Matching(var nextStart: Optional[Int] = Unset)
+object Scanner:
+  given default: DummyImplicit => Scanner = Scanner(Unset)
+class Scanner(var nextStart: Optional[Int] = Unset)

src/test/kaleidoscope.Tests.scala

@@ -214,7 +214,7 @@ object Tests extends Suite(t"Kaleidoscope tests"):
 
         . assert(_ == t"a(?<g0>(bc){3})")
 
-      suite(t"Matching patterns"):
+      suite(t"Scanner patterns"):
         test(t"Simple capture"):
           Regex.parse(List(t"foo", t"(bar)")).matchGroups(t"foobar")
           . map(_.to(List))