Unsigned | Match

sinclairzx81 · sinclairzx81 · commit bec63b72174d · 2026-03-27T16:31:57.000+09:00
diff --git a/src/token/bigint.ts b/src/token/bigint.ts
@@ -28,7 +28,7 @@ THE SOFTWARE.
 
 // deno-fmt-ignore-file
 
-import { Match } from './internal/result.ts'
+import { Match } from './internal/match.ts'
 import { type TTake, Take } from './internal/take.ts'
 import { type TInteger, Integer } from './integer.ts'
 
diff --git a/src/token/ident.ts b/src/token/ident.ts
@@ -28,7 +28,7 @@ THE SOFTWARE.
 
 // deno-fmt-ignore-file
 
-import { Match } from './internal/result.ts'
+import { Match } from './internal/match.ts'
 import { type TTrim, Trim } from './internal/trim.ts'
 import { type TTake, Take } from './internal/take.ts'
 
diff --git a/src/token/integer.ts b/src/token/integer.ts
@@ -28,7 +28,7 @@ THE SOFTWARE.
 
 // deno-fmt-ignore-file
 
-import { Match } from './internal/result.ts'
+import { Match } from './internal/match.ts'
 import { type TTrim, Trim } from './internal/trim.ts'
 import { type TOptional, Optional } from './internal/optional.ts'
 import { type THyphen, Hyphen } from './internal/char.ts'
diff --git a/src/token/internal/many.ts b/src/token/internal/many.ts
@@ -28,7 +28,7 @@ THE SOFTWARE.
 
 // deno-fmt-ignore-file
 
-import { IsResultTrue } from './result.ts'
+import { Match } from './match.ts'
 import { type TTake, Take } from './take.ts'
 
 // ------------------------------------------------------------------
@@ -58,15 +58,10 @@ export type TMany<Allowed extends string[], Discard extends string[], Input exte
     : [Result, Input]
 )
 /** Takes characters from the Input until no-match. The Discard set is used to omit characters from the match */
-export function Many<Allowed extends string[], Discard extends string[], Input extends string>
-  (allowed: [...Allowed], discard: [...Discard], input: Input, result: string = ''): 
-    TMany<Allowed, Discard, Input> {
-  const takeResult = Take(allowed, input) as [string, string]
-  return (
-    IsResultTrue(takeResult)
-      ? IsDiscard(discard, takeResult[0])
-        ? Many(allowed, discard, takeResult[1], result)
-        : Many(allowed, discard, takeResult[1], `${result}${takeResult[0]}`)
-      : [result, input]
-  ) as never
+export function Many<Allowed extends string[], Discard extends string[], Input extends string>(allowed: [...Allowed], discard: [...Discard], input: Input, result: string = ''): TMany<Allowed, Discard, Input> {
+  return Match(Take(allowed, input), (Char, Rest) => 
+    IsDiscard(discard, Char)
+      ? Many(allowed, discard, Rest, result)
+      : Many(allowed, discard, Rest, `${result}${Char}`), 
+    () => [result, input]) as never
 }
diff --git a/src/token/internal/match.ts b/src/token/internal/match.ts
@@ -31,10 +31,10 @@ import { IsArray, IsEqual } from './guard.ts'
 type TResult = [string, string] | []
 
 /** Checks the value is a Tuple-2 [string, string] result */
-export function IsResultTrue(value: unknown): value is [string, string] {
-  return IsArray(value) && IsEqual(value.length, 2)
+export function IsMatch(value: TResult): value is [string, string] {
+  return IsEqual(value.length, 2)
 }
 /** Matches on a result and dispatches either left or right arm */
 export function Match(input: TResult, ok: (value: string, rest: string) => TResult, fail: () => TResult): TResult {
-  return (IsResultTrue(input) ? ok(input[0], input[1]) : fail()) as never
-}
+  return IsMatch(input) ? ok(input[0], input[1]) : fail()
+}
diff --git a/src/token/internal/optional.ts b/src/token/internal/optional.ts
@@ -28,7 +28,7 @@ THE SOFTWARE.
 
 // deno-fmt-ignore-file
 
-import { IsResultTrue } from './result.ts'
+import { Match } from './match.ts'
 import { type TTake, Take } from './take.ts'
 
 /** Matches the given Value or empty string if no match. This function never fails */
@@ -38,12 +38,8 @@ export type TOptional<Value extends string, Input extends string> = (
     : ['', Input]
 )
 /** Matches the given Value or empty string if no match. This function never fails */
-export function Optional<Value extends string, Input extends string>
-  (value: Value, input: Input): TOptional<Value, Value> {
-  const result = Take([value], input)
-  return (
-    IsResultTrue(result) 
-      ? result 
-      : ['', input]
-  ) as never
+export function Optional<Value extends string, Input extends string>(value: Value, input: Input): TOptional<Value, Value> {
+  return Match(Take([value], input), (Optional, Rest) => 
+    [Optional, Rest],
+    () => ['', input]) as never
 }
diff --git a/src/token/number.ts b/src/token/number.ts
@@ -29,7 +29,7 @@ THE SOFTWARE.
 // deno-fmt-ignore-file
 
 import { IsEqual } from './internal/guard.ts'
-import { IsResultTrue, Match } from './internal/result.ts'
+import { IsMatch, Match } from './internal/match.ts'
 import { type TTrim, Trim } from './internal/trim.ts'
 import { type TTake, Take } from './internal/take.ts'
 import { type TMany, Many } from './internal/many.ts'
@@ -62,7 +62,7 @@ type TIsLeadingDot<Input extends string> = (
   TTake<[TDot], Input> extends [string, string] ? true : false
 )
 function IsLeadingDot<Input extends string>(input: Input): TIsLeadingDot<Input> {
-  return IsResultTrue(Take([Dot], input)) as never
+  return IsMatch(Take([Dot], input)) as never
 }
 // ------------------------------------------------------------------
 // TakeFractional
diff --git a/src/token/span.ts b/src/token/span.ts
@@ -28,7 +28,7 @@ THE SOFTWARE.
 
 // deno-fmt-ignore-file
 
-import { Match } from './internal/result.ts'
+import { Match } from './internal/match.ts'
 import { type TTrim, Trim } from './internal/trim.ts'
 import { type TNewLine, NewLine } from './internal/char.ts'
 import { type TTake, Take } from './internal/take.ts'
diff --git a/src/token/string.ts b/src/token/string.ts
@@ -28,7 +28,7 @@ THE SOFTWARE.
 
 // deno-fmt-ignore-file
 
-import { Match } from './internal/result.ts'
+import { Match } from './internal/match.ts'
 import { type TTake, Take } from './internal/take.ts'
 import { type TTrim, Trim } from './internal/trim.ts'
 import { type TSpan, Span } from './span.ts'
diff --git a/src/token/unsigned_integer.ts b/src/token/unsigned_integer.ts
@@ -28,7 +28,7 @@ THE SOFTWARE.
 
 // deno-fmt-ignore-file
 
-import { Match } from './internal/result.ts'
+import { Match } from './internal/match.ts'
 import { type TTrim, Trim } from './internal/trim.ts'
 import { type TTake, Take } from './internal/take.ts'
 import { type TMany, Many } from './internal/many.ts'
diff --git a/src/token/until.ts b/src/token/until.ts
@@ -28,51 +28,69 @@ THE SOFTWARE.
 
 // deno-fmt-ignore-file
 
+import { Match } from './internal/match.ts'
 import { IsEqual, IsString } from './internal/guard.ts'
-import { Match } from './internal/result.ts'
 
 // ------------------------------------------------------------------
-// IsEnd
+// TakeOne
 // ------------------------------------------------------------------
-type TIsEnd<End extends string[], Input extends string> = (
+type TTakeOne<Input extends string> = (
+  Input extends `${infer Left extends string}${infer Right extends string}`
+    ? [Left, Right]
+    : []
+)
+function TakeOne<Input extends string>(input: string): TTakeOne<Input> {
+  const result = IsEqual(input, '') ? [] : [input.slice(0, 1), input.slice(1)]
+  return result as never
+}
+// ------------------------------------------------------------------
+// IsInputMatchSentinal
+// ------------------------------------------------------------------
+type TIsInputMatchSentinal<End extends string[], Input extends string> = (
   End extends [infer Left extends string, ...infer Right extends string[]] 
     ? Input extends `${Left}${string}` 
       ? true
-      : TIsEnd<Right, Input>
+      : TIsInputMatchSentinal<Right, Input>
     : false
 )
-function IsEnd<End extends string[], Input extends string>(end: [...End], input: Input): TIsEnd<End, Input> {
+function IsInputMatchSentinal<End extends string[], Input extends string>(end: [...End], input: Input): TIsInputMatchSentinal<End, Input> {
   const [left, ...right] = end
   return (
     IsString(left) 
       ? input.startsWith(left) 
         ? true 
-        : IsEnd(right, input) 
+        : IsInputMatchSentinal(right, input) 
       : false
   ) as never
 }
+
 // ------------------------------------------------------------------
 // Until
+//
+// Implementation Note: This function performs a 1-character lookahead 
+// check against the Sentinel set. We must check IsInputMatchSentinal 
+// against the current Input *before* consuming the next character via 
+// TUntil recursion. 
+//
+// We cannot check the Sentinel before TakeOne because the Sentinel 
+// length is variable; we only know when to stop (Match), not how 
+// far to advance on a non-match. Therefore, we advance by a 
+// fixed 1-character increment until a Sentinel prefix is detected.
+//
 // ------------------------------------------------------------------
 /** Match Input until but not including End. No match if End not found. */
 export type TUntil<End extends string[], Input extends string, Result extends string = ''> = (
-  Input extends ``
-    ? [] // fail: Input is empty
-    : TIsEnd<End, Input> extends true 
-      ? [Result, Input]
-      : Input extends `${infer Left extends string}${infer Right extends string}` 
-        ? TUntil<End, Right, `${Result}${Left}`>
-        : []
+  TTakeOne<Input> extends [infer One extends string, infer Rest extends string]
+    ? TIsInputMatchSentinal<End, Input> extends true
+      ? [Result, Input]                      // ok: at sentinal 
+      : TUntil<End, Rest, `${Result}${One}`> // fail: advance + 1
+    : []
 )
 /** Match Input until but not including End. No match if End not found. */
 export function Until<End extends string[], Input extends string>(end: [...End], input: Input, result: string = ''): TUntil<End, Input> {
-  return (
-    IsEqual(input, '') 
-      ? [] // fail: Input is empty
-      : IsEnd(end, input) 
-        ? [result, input] : (() => {
-        const [left, right] = [input.slice(0, 1), input.slice(1)]
-        return Until(end, right, `${result}${left}`)
-      })()
-  ) as never
+  return Match(TakeOne(input), (One, Rest) => 
+    IsInputMatchSentinal(end, input)
+      ? [result, input]                     // ok: at sentinal 
+      : Until(end, Rest, `${result}${One}`) // fail: advance + 1
+    , () => []) as never
 }
diff --git a/src/token/until_1.ts b/src/token/until_1.ts
@@ -29,7 +29,7 @@ THE SOFTWARE.
 // deno-fmt-ignore-file
 
 import { IsEqual } from './internal/guard.ts'
-import { IsResultTrue } from './internal/result.ts'
+import { Match } from './internal/match.ts'
 import { type TUntil, Until } from './until.ts'
 
 // ------------------------------------------------------------------
@@ -45,12 +45,9 @@ export type TUntil_1<End extends string[], Input extends string> = (
 )
 /** Match Input until but not including End. No match if End not found or match is zero-length. */
 export function Until_1<End extends string[], Input extends string>(end: [...End], input: Input): TUntil_1<End, Input> {
-  const until = Until(end, input)
-  return (
-    IsResultTrue(until) 
-      ? IsEqual(until[0], '') 
-        ? [] // fail: match has no characters
-        : until 
-      : [] // fail: did not match Until
-  ) as never
+  return Match(Until(end, input), (Until, UntilRest) => 
+    IsEqual(Until, '')
+      ? [] // fail: match has no characters
+      : [Until, UntilRest],
+    () => []) as never // fail: did not match Until
 }
