syncraft 0.1.12__tar.gz → 0.1.14__tar.gz

{syncraft-0.1.12 → syncraft-0.1.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncraft
-Version: 0.1.12
+Version: 0.1.14
 Summary: Parser combinator library
 Author-email: Michael Afmokt <michael@esacca.com>
 License-Expression: MIT

{syncraft-0.1.12 → syncraft-0.1.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "syncraft"
-version = "0.1.12"
+version = "0.1.14"
 description = "Parser combinator library"
 license = "MIT"
 license-files = ["LICENSE"]

{syncraft-0.1.12 → syncraft-0.1.14}/syncraft/algebra.py

@@ -28,7 +28,7 @@ from typing import (
 )
 
 import traceback
-from dataclasses import dataclass, fields, replace
+from dataclasses import dataclass, fields, replace, field
 from functools import cached_property
 from weakref import WeakKeyDictionary
 from abc import ABC, abstractmethod
@@ -54,15 +54,11 @@ class Insptectable(ABC):
 
 A = TypeVar('A')  # Result type
 B = TypeVar('B')  # Result type for mapping
-C = TypeVar('C')  # Result type for composing lenses
+
 S = TypeVar('S')  # State type for the Algebra
 
     
     
-
-class StructuralResult:
-    pass    
-
 class FrozenDict(Generic[A]):
     def __init__(self, items: Mapping[str, A]):
         for k, v in items.items():
@@ -119,63 +115,47 @@ class Lens(Generic[S, A]):
     
     def __rtruediv__(self, other: Lens[B, S])->Lens[B, A]:
         return other.__truediv__(self)
-    
-    
+        
+class StructuralResult:
+    def bimap(self, ctx: Any)->Tuple[Any, Callable[[Any], StructuralResult]]:
+        return (self, lambda x: self)
 
-@dataclass(eq=True, frozen=True)
-class NamedResult(Generic[A, B], StructuralResult):
-    value: A
+        
+@dataclass(frozen=True)
+class NamedResult(Generic[A], StructuralResult):
     name: str
-    forward_map: Callable[[A], B] | None = None
-    backward_map: Callable[[B], A] | None = None
-    aggregator: Callable[..., Any] | None = None
-
-    def __post_init__(self)->None:
-        if (self.forward_map or self.backward_map) and self.aggregator is not None:
-            raise ValueError("NamedResult can have either bimap or aggregator, never both.")
-
-    @staticmethod
-    def lens() -> Lens[NamedResult[A, B], A]:
-        def get(data: NamedResult[A, B]) -> A:
-            return data.value
-
-        def set(data: NamedResult[A, B], value: A) -> NamedResult[A, B]:
-            return replace(data, value = value)
-
-        return Lens(get=get, set=set)
-    
-
+    value: A
+    def bimap(self, ctx: Any)->Tuple[NamedResult[Any], Callable[[NamedResult[Any]], StructuralResult]]:
+        value, backward = self.value.bimap(ctx) if isinstance(self.value, StructuralResult) else (self.value, lambda x: x)
+        def named_back(data: Any)->NamedResult[Any]:
+            v = backward(data)
+            if isinstance(v, NamedResult):
+                return replace(v, name=self.name)
+            else:
+                return NamedResult(name=self.name, value=v)
+        return NamedResult(self.name, value), named_back
 
 @dataclass(eq=True, frozen=True)
 class ManyResult(Generic[A], StructuralResult):
     value: Tuple[A, ...]
+    def bimap(self, ctx: Any)->Tuple[List[Any], Callable[[List[Any]], StructuralResult]]:
+        transformed = [v.bimap(ctx) if isinstance(v, StructuralResult) else (v, lambda x: x) for v in self.value]
+        backmaps = [b for (_, b) in transformed]
+        ret = [a for (a, _) in transformed]
+        def backward(data: List[Any]) -> StructuralResult:
+            if len(data) != len(transformed):
+                raise ValueError("Incompatible data length")
+            return ManyResult(value=tuple([backmaps[i](x) for i, x in enumerate(data)]))
+        return ret, lambda data: backward(data)
 
-    @staticmethod
-    def lens(index: int) -> Lens[ManyResult[A], A]:
-        def get(data: ManyResult[A]) -> A:
-            return data.value[index]
-
-        def set(data: ManyResult[A], value: A) -> ManyResult[A]:
-            new_value = list(data.value)
-            new_value[index] = value
-            return ManyResult(value=tuple(new_value))
-
-        return Lens(get=get, set=set)
 
 
 @dataclass(eq=True, frozen=True)
 class OrResult(Generic[A], StructuralResult):
     value: A
-
-    @staticmethod
-    def lens() -> Lens[OrResult[A], A]:
-        def get(data: OrResult[A]) -> A:
-            return data.value
-
-        def set(data: OrResult[A], value: A) -> OrResult[A]:
-            return OrResult(value=value)
-
-        return Lens(get=get, set=set)
+    def bimap(self, ctx: Any) -> Tuple[Any, Callable[[Any], StructuralResult]]:
+        value, backward = self.value.bimap(ctx) if isinstance(self.value, StructuralResult) else (self.value, lambda x: x)
+        return value, lambda data: OrResult(value=backward(data))
 
 
 class ThenKind(Enum):
@@ -188,89 +168,57 @@ class ThenResult(Generic[A, B], StructuralResult):
     kind: ThenKind
     left: A
     right: B
-    @cached_property
-    def flatten(self)-> Tuple[Any, ...]:
-        def _flatten_side(side: Any)->Tuple[Any, ...]:
-            return side.flatten if isinstance(side, ThenResult) else (side,)
+    def bimap(self, ctx: Any) -> Tuple[Any, Callable[[Any], StructuralResult]]:
+        def branch(b: Any) -> Tuple[Any, Callable[[Any], StructuralResult]]:
+            if isinstance(b, ThenResult):
+                value, backward = b.bimap(ctx)
+                if isinstance(value, tuple):
+                    x, y = ThenResult.flat(value)
+                    return x, lambda data: ThenResult(self.kind, y(data), self.right)
+                else:
+                    return value, backward
+            elif isinstance(b, StructuralResult):
+                return b.bimap(ctx)
+            else:
+                return b, lambda x: x
         match self.kind:
             case ThenKind.BOTH:
-                return _flatten_side(self.left) + _flatten_side(self.right)
+                left_value, left_bmap = branch(self.left)
+                right_value, right_bmap = branch(self.right)
+                def backward(x: Tuple[Any, Any]) -> StructuralResult:
+                    return ThenResult(self.kind, left_bmap(x[0]), right_bmap(x[1]))
+                x, y = ThenResult.flat((left_value, right_value))
+                return x, lambda data: backward(y(data))
             case ThenKind.LEFT:
-                return _flatten_side(self.left)
+                left_value, left_bmap = branch(self.left)
+                return left_value, lambda data: ThenResult(self.kind, left_bmap(data), self.right)
             case ThenKind.RIGHT:
-                return _flatten_side(self.right)
-            
+                right_value, right_bmap = branch(self.right)
+                return right_value, lambda data: ThenResult(self.kind, self.left, right_bmap(data))
     @staticmethod
-    def lens(kind: ThenKind) -> Lens[ThenResult[A, B], Tuple[A, B]] | Lens[ThenResult[A, B], A] | Lens[ThenResult[A, B], B]:
-        def both_lens() -> Lens[ThenResult[A, B], Tuple[A, B]]:
-            def get(data: ThenResult[A, B]) -> Tuple[A, B]:
-                match data:
-                    case ThenResult(left=left, right=right, kind=ThenKind.BOTH):
-                        return left, right
-                    case _:
-                        raise ValueError(f"Unexpected ThenResult type: {type(data)}")
-
-            def set(data: ThenResult[A, B], value: Tuple[A, B] | ThenResult[A, B]) -> ThenResult[A, B]:
-                match data:
-                    case ThenResult(left=_, right=_, kind=ThenKind.BOTH):
-                        if isinstance(value, tuple) and len(value) == 2:
-                            return ThenResult(left=value[0], right=value[1], kind=ThenKind.BOTH)
-                        elif isinstance(value, ThenResult):
-                            return ThenResult(left=value.left, right=value.right, kind=ThenKind.BOTH)
-                        else:
-                            raise ValueError(f"Expected a tuple or ThenResult, got: {type(value)}")
-                    case _:
-                        raise ValueError(f"Unexpected ThenResult type: {type(data)}")
-            return Lens(get=get, set=set)
-
-        def left_lens()-> Lens[ThenResult[A, B], A]:
-            def left_get(data: ThenResult[A, B]) -> A:
-                match data:
-                    case ThenResult(left=left, right=_, kind=ThenKind.LEFT):
-                        return left
-                    case _:
-                        raise ValueError(f"Unexpected ParseResult type: {type(data)}")
-
-            def left_set(data: ThenResult[A, B], v: A) -> ThenResult[A, B]:
-                match data:
-                    case ThenResult(kind=ThenKind.LEFT):
-                        return replace(data, left=v)
-                    case _:
-                        raise ValueError(f"Unexpected ParseResult type: {type(data)}")
-                return 
-            return Lens(
-                get=left_get, 
-                set=left_set
-            )
-    
-        def right_lens()-> Lens[ThenResult[A, B], B]:
-            def right_get(data: ThenResult[A, B]) -> B:
-                match data:
-                    case ThenResult(left=_, right=right, kind=ThenKind.RIGHT):
-                        return right
-                    case _:
-                        raise ValueError(f"Unexpected ParseResult type: {type(data)}")
-
-            def right_set(data: ThenResult[A, B], v: B) -> ThenResult[A, B]:
-                match data:
-                    case ThenResult(kind=ThenKind.RIGHT):
-                        return replace(data, right=v)
-                    case _:
-                        raise ValueError(f"Unexpected ParseResult type: {type(data)}")
-                return
-            return Lens(
-                get=right_get,
-                set=right_set
-            )
-        match kind:
-            case ThenKind.BOTH:
-                return both_lens()
-            case ThenKind.LEFT:
-                return left_lens()
-            case ThenKind.RIGHT:
-                return right_lens()
-            case _:
-                raise ValueError(f"Unknown ThenKind: {kind}")
+    def flat(array: Tuple[Any, Any]) -> Tuple[Tuple[Any, ...], Callable[[Tuple[Any, ...]], Tuple[Any, Any]]]:
+        index: Dict[int, int] = {}
+        ret: List[Any] = []
+        for e in array:
+            if isinstance(e, tuple):
+                index[len(ret)] = len(e)
+                ret.extend(e)
+            else:
+                ret.append(e)
+        def backward(data: Tuple[Any, ...]) -> Tuple[Any, Any]:
+            tmp: List[Any] = []
+            skip: int = 0
+            for i, e in enumerate(data):
+                if skip <= 0:
+                    if i in index:
+                        tmp.append(tuple(data[i:i + index[i]]))
+                        skip = index[i] - 1
+                    else:
+                        tmp.append(e)
+                else:
+                    skip -= 1
+            return tuple(tmp)
+        return tuple(ret), backward
 
 
 InProgress = object()  # Marker for in-progress state, used to prevent re-entrance in recursive calls

syncraft-0.1.14/syncraft/ast.py

@@ -0,0 +1,132 @@
+
+
+from __future__ import annotations
+import re
+from typing import (
+    Optional, Any, TypeVar, Tuple, runtime_checkable, Dict,
+    Protocol, Generic, Callable, Union, cast
+)
+from syncraft.algebra import (
+    OrResult,ThenResult, ManyResult, ThenKind,NamedResult, StructuralResult,
+    Lens
+)
+from dataclasses import dataclass, replace, is_dataclass, asdict
+from enum import Enum
+from functools import cached_property
+
+@runtime_checkable
+class TokenProtocol(Protocol):
+    @property
+    def token_type(self) -> Enum: ...
+    @property
+    def text(self) -> str: ...
+    
+
+@dataclass(frozen=True)
+class Token:
+    token_type: Enum
+    text: str
+    def __str__(self) -> str:
+        return f"{self.token_type.name}({self.text})"
+    
+    def __repr__(self) -> str:
+        return self.__str__()
+
+@dataclass(frozen=True)
+class TokenSpec:
+    token_type: Optional[Enum] = None
+    text: Optional[str] = None
+    case_sensitive: bool = False
+    regex: Optional[re.Pattern[str]] = None
+        
+    def is_valid(self, token: TokenProtocol) -> bool:
+        type_match = self.token_type is None or token.token_type == self.token_type
+        value_match = self.text is None or (token.text.strip() == self.text.strip() if self.case_sensitive else 
+                                                    token.text.strip().upper() == self.text.strip().upper())
+        value_match = value_match or (self.regex is not None and self.regex.fullmatch(token.text) is not None)
+        return type_match and value_match
+
+
+
+
+T = TypeVar('T', bound=TokenProtocol)  
+
+
+ParseResult = Union[
+    ThenResult['ParseResult[T]', 'ParseResult[T]'], 
+    NamedResult['ParseResult[T]'],
+    ManyResult['ParseResult[T]'],
+    OrResult['ParseResult[T]'],
+    T,
+]
+@dataclass(frozen=True)
+class AST(Generic[T]):
+    focus: ParseResult[T]
+    pruned: bool = False
+    parent: Optional[AST[T]] = None
+
+
+    def bimap(self, ctx: Any) -> Tuple[Any, Callable[[Any], AST[T]]]:
+        value, backward = self.focus.bimap(ctx) if isinstance(self.focus, StructuralResult) else (self.focus, lambda x: x)
+        def back2ast(data: Any) -> AST[T]:
+            return replace(self, focus=backward(data)) # type: ignore
+        return value, back2ast
+
+    def wrapper(self)-> Callable[[Any], Any]:
+        if isinstance(self.focus, NamedResult):
+            focus = cast(NamedResult[Any], self.focus)
+            return lambda x: NamedResult(name = focus.name, value = x)
+        else:
+            return lambda x: x
+        
+    def is_named(self) -> bool: 
+        return isinstance(self.focus, NamedResult)
+
+    def left(self) -> Optional[AST[T]]:
+        match self.focus:
+            case ThenResult(left=left, kind=kind):
+                return replace(self, focus=left, parent=self, pruned = self.pruned or kind == ThenKind.RIGHT)
+            case _:
+                raise TypeError(f"Invalid focus type({self.focus}) for left traversal")
+
+    def right(self) -> Optional[AST[T]]:
+        match self.focus:
+            case ThenResult(right=right, kind=kind):
+                return replace(self, focus=right, parent=self, pruned = self.pruned or kind == ThenKind.LEFT)
+            case _:
+                raise TypeError(f"Invalid focus type({self.focus}) for right traversal")
+
+
+    def down(self, index: int) -> Optional[AST[T]]:
+        match self.focus:
+            case ManyResult(value=children):
+                if 0 <= index < len(children):
+                    return replace(self, focus=children[index], parent=self, pruned=self.pruned)
+                else:
+                    raise IndexError(f"Index {index} out of bounds for ManyResult with {len(children)} children")
+            case OrResult(value=value):
+                if index == 0:
+                    return replace(self, focus=value, parent=self, pruned=self.pruned)
+                else:
+                    raise IndexError(f"Index {index} out of bounds for OrResult")
+            case NamedResult(value=value):
+                return replace(self, focus=value, parent=self, pruned=self.pruned)
+            case _:
+                raise TypeError(f"Invalid focus type({self.focus}) for down traversal")
+
+    def how_many(self)->int:
+        focus = self.focus.value if isinstance(self.focus, NamedResult) else self.focus
+        match focus:
+            case ManyResult(value=children):
+                return len(children)
+            case _:
+                raise TypeError(f"Invalid focus type({self.focus}) for how_many")
+            
+    
+
+    @cached_property
+    def root(self) -> AST[T]:
+        while self.parent is not None:
+            self = self.parent  
+        return self
+    

{syncraft-0.1.12 → syncraft-0.1.14}/syncraft/dsl.py

@@ -4,9 +4,9 @@ from typing import (
     Optional, List, Any, TypeVar, Generic, Callable, Tuple, cast,
     Type, Literal
 )
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from functools import reduce
-from syncraft.algebra import Algebra, Error, Either, Insptectable, NamedResult, ThenResult, ManyResult, ThenKind
+from syncraft.algebra import Algebra, Error, Either, Insptectable, ThenResult, ManyResult, ThenKind, NamedResult
 from types import MethodType, FunctionType
 
 
@@ -226,75 +226,14 @@ class DSL(Generic[A, S], Insptectable):
 
 
 ######################################################################## data processing combinators #########################################################
-
-    def _attach(self, 
-               name: str, 
-               *,
-               forward_map: Callable[[B], C] | None,
-               backward_map: Callable[[C], B] | None,
-               aggregator_f: Callable[..., Any] | None,
-               ) -> DSL[NamedResult[A, C], S]:
-        def attach_f(x: A | NamedResult[A, B]) -> NamedResult[A, C]:
-            if isinstance(x, NamedResult):
-                if x.backward_map is not None:
-                    b_f = x.backward_map
-                    def combined_bf(a: Any)->A:
-                        if backward_map is not None:
-                            return b_f(backward_map(a))
-                        else:
-                            return b_f(a)
-                if x.forward_map is not None:
-                    f_f = x.forward_map
-                    def combined_ff(a: Any)->Any:
-                        if forward_map is not None:
-                            return forward_map(f_f(a))
-                        else:
-                            return f_f(a)
-                if x.aggregator is not None:
-                    agg_f = x.aggregator
-                    def combined_agg(a: Any)->Any:
-                        if aggregator_f is not None:
-                            return aggregator_f(agg_f(a))
-                        else:
-                            return agg_f(a)
-                return NamedResult(
-                    name=name,
-                    value=x.value,
-                    forward_map=forward_map if x.forward_map is None else combined_ff, # type: ignore
-                    backward_map=backward_map if x.backward_map is None else combined_bf, # type: ignore
-                    aggregator=aggregator_f if x.aggregator is None else combined_agg
-                )
+    def bind(self, name: str) -> DSL[NamedResult[A], S]:
+        def bind_f(value: A) -> NamedResult[A]:
+            if isinstance(value, NamedResult):
+                return replace(value, name=name)    
             else:
-                return NamedResult(
-                    name=name,
-                    value=x,
-                    forward_map=forward_map, # type: ignore
-                    backward_map=backward_map, # type: ignore
-                    aggregator=aggregator_f,
-
-                )            
-            
-        return self.map(attach_f)
-
-    def bind(self, name: str) -> DSL[NamedResult[Any, Any], S]:
-        return self._attach(name, 
-                           forward_map=None, 
-                           backward_map=None, 
-                           aggregator_f=None,
-                           ).describe(name=f'bind("{name}")', fixity='postfix', parameter=[self])            
-
-    def bimap(self, name: str, *, forward_map: Callable[[Any], Any], backward_map: Callable[[Any], Any]) -> DSL[NamedResult[Any, Any], S]:
-        return self._attach(name, 
-                           forward_map=forward_map, 
-                           backward_map=backward_map, 
-                           aggregator_f=None,
-                           ).describe(name=f'bimap("{name}")', fixity='postfix', parameter=[self])            
-    def to(self, name: str, aggregator_f: Callable[..., Any]) -> DSL[NamedResult[A, Any], S]:
-        return self._attach(name, 
-                           forward_map=None, 
-                           backward_map=None, 
-                           aggregator_f=aggregator_f,
-                           ).describe(name=f'to("{name}")', fixity='postfix', parameter=[self])
+                return NamedResult(name=name, value=value)
+        return self.map(bind_f).describe(name=f'bind("{name}")', fixity='postfix', parameter=[self]) 
+
 
     def dump_error(self, formatter: Optional[Callable[[Error], None]] = None) -> DSL[A, S]:
         def dump_error_run(err: Any)->Any:

{syncraft-0.1.12 → syncraft-0.1.14}/syncraft/generator.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 
 from typing import (
-    Any, TypeVar, Tuple, Optional,  Callable, Generic, Union, Iterable, Hashable, 
-    cast, List
+    Any, TypeVar, Tuple, Optional,  Callable, Generic, Union, 
+    List
 )
 from functools import cached_property
 from dataclasses import dataclass, replace
 from syncraft.algebra import (
     Algebra, ThenResult, Either, Left, Right, Error, Insptectable, 
-    NamedResult, OrResult, ManyResult, ThenKind
+    OrResult, ManyResult
 )
 from syncraft.ast import TokenProtocol, ParseResult, AST, Token, TokenSpec
 from sqlglot import TokenType
@@ -24,7 +24,7 @@ GenResult = Union[
     ThenResult['GenResult[T]', 'GenResult[T]'], 
     ManyResult['GenResult[T]'],
     OrResult['GenResult[T]'],
-    Iterable[T],
+
     T
 ]
 
@@ -52,7 +52,16 @@ class GenState(Generic[T], Insptectable):
         if self.ast is None:
             return None
         return self.ast.focus
+
+    @property
+    def is_named(self)->bool:
+        return self.ast is not None and self.ast.is_named()
     
+    def wrapper(self)->Callable[[Any], Any]:
+        if self.ast is not None:
+            return self.ast.wrapper()
+        else:
+            return lambda x: x
 
     def left(self)-> GenState[T]:
         if self.ast is None:
@@ -64,10 +73,7 @@ class GenState(Generic[T], Insptectable):
             return self
         return replace(self, ast=self.ast.right())
     
-    def up(self)->GenState[T]:
-        if self.ast is None:
-            return self
-        return replace(self, ast=self.ast.up())
+
     
     def down(self, index: int) -> GenState[T]:
         if self.ast is None:
@@ -142,13 +148,19 @@ class TokenGen(TokenSpec):
 class Generator(Algebra[GenResult[T], GenState[T]]):  
     def flat_map(self, f: Callable[[GenResult[T]], Algebra[B, GenState[T]]]) -> Algebra[B, GenState[T]]: 
         def flat_map_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[B, GenState[T]]]:
-            lft = input.left()
+            wrapper = input.wrapper()
+            input = input if not input.is_named else input.down(0)  # If the input is named, we need to go down to the first child
+            lft = input.left() 
             match self.run(lft, use_cache=use_cache):
                 case Left(error):
                     return Left(error)
                 case Right((value, next_input)):
-                    r = input.right()
-                    return f(value).run(r, use_cache)
+                    r = input.right() 
+                    match f(value).run(r, use_cache):
+                        case Left(e):
+                            return Left(e)
+                        case Right((result, next_input)):
+                            return Right((wrapper(result), next_input))
             raise ValueError("flat_map should always return a value or an error.")
         return Generator(run_f = flat_map_run, name=self.name) # type: ignore  
     
@@ -158,6 +170,8 @@ class Generator(Algebra[GenResult[T], GenState[T]]):
         assert at_least > 0, "at_least must be greater than 0"
         assert at_most is None or at_least <= at_most, "at_least must be less than or equal to at_most"
         def many_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[ManyResult[GenResult[T]], GenState[T]]]:
+            wrapper = input.wrapper()
+            input = input if not input.is_named else input.down(0)  # If the input is named, we need to go down to the first child
             if input.pruned:
                 upper = at_most if at_most is not None else at_least + 2
                 count = input.rng("many").randint(at_least, upper)
@@ -169,7 +183,7 @@ class Generator(Algebra[GenResult[T], GenState[T]]):
                             ret.append(value)
                         case Left(_):
                             pass
-                return Right((ManyResult(tuple(ret)), input))
+                return Right((wrapper(ManyResult(tuple(ret))), input))
             else:
                 ret = []
                 for index in range(input.how_many): 
@@ -190,7 +204,7 @@ class Generator(Algebra[GenResult[T], GenState[T]]):
                         this=self,
                         state=input.down(index)
                     )) 
-                return Right((ManyResult(tuple(ret)), input))
+                return Right((wrapper(ManyResult(tuple(ret))), input))
         return self.__class__(many_run, name=f"many({self.name})")  # type: ignore
     
  
@@ -198,21 +212,23 @@ class Generator(Algebra[GenResult[T], GenState[T]]):
                 other: Algebra[GenResult[T], GenState[T]]
                 ) -> Algebra[OrResult[GenResult[T]], GenState[T]]: 
         def or_else_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[OrResult[GenResult[T]], GenState[T]]]:
+            wrapper = input.wrapper()
+            input = input if not input.is_named else input.down(0)  # If the input is named, we need to go down to the first child
             if input.pruned:
                 forked_input = input.fork(tag="or_else")
                 match forked_input.rng("or_else").choice((self, other)).run(forked_input, use_cache):
                     case Right((value, next_input)):
-                        return Right((OrResult(value), next_input))
+                        return Right((wrapper(OrResult(value)), next_input))
                     case Left(error):
                         return Left(error)
             else:
                 match self.run(input.down(0), use_cache):
                     case Right((value, next_input)):
-                        return Right((OrResult(value), next_input))
+                        return Right((wrapper(OrResult(value)), next_input))
                     case Left(error):
                         match other.run(input.down(0), use_cache):
                             case Right((value, next_input)):
-                                return Right((OrResult(value), next_input))
+                                return Right((wrapper(OrResult(value)), next_input))
                             case Left(error):
                                 return Left(error)
             raise ValueError("or_else should always return a value or an error.")
@@ -228,6 +244,8 @@ class Generator(Algebra[GenResult[T], GenState[T]]):
         gen = TokenGen(token_type=token_type, text=text, case_sensitive=case_sensitive, regex=regex)  
         lazy_self: Algebra[GenResult[T], GenState[T]]
         def token_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[GenResult[Token], GenState[T]]]:
+            wrapper = input.wrapper()
+            input = input if not input.is_named else input.down(0)  # If the input is named, we need to go down to the first child
             if input.pruned:
                 return Right((gen.gen(), input))
             else:
@@ -236,7 +254,7 @@ class Generator(Algebra[GenResult[T], GenState[T]]):
                     return Left(Error(None, 
                                       message=f"Expected a Token, but got {type(current)}.", 
                                       state=input))
-                return Right((current, input))
+                return Right((wrapper(current), input))
         lazy_self = cls(token_run, name=cls.__name__ + f'.token({token_type or text or regex})')  # type: ignore
         return lazy_self
 

{syncraft-0.1.12 → syncraft-0.1.14}/syncraft/parser.py

@@ -77,23 +77,23 @@ class ParserState(Generic[T], Insptectable):
 
     
 @dataclass(frozen=True)
-class Parser(Algebra[Tuple[T,...] | T, ParserState[T]]):
+class Parser(Algebra[T, ParserState[T]]):
     @classmethod
     def token(cls, 
               token_type: Optional[Enum] = None, 
               text: Optional[str] = None, 
               case_sensitive: bool = False,
               regex: Optional[re.Pattern[str]] = None
-              )-> Algebra[Tuple[T,...] | T, ParserState[T]]:
+              )-> Algebra[T, ParserState[T]]:
         spec = TokenSpec(token_type=token_type, text=text, case_sensitive=case_sensitive, regex=regex)
-        def token_run(state: ParserState[T], use_cache:bool) -> Either[Any, Tuple[Tuple[T,...] | T, ParserState[T]]]:
+        def token_run(state: ParserState[T], use_cache:bool) -> Either[Any, Tuple[T, ParserState[T]]]:
             if state.ended():
                 return Left(state)
             token = state.current()
             if token is None or not spec.is_valid(token):
                 return Left(state)
             return Right((Token(token_type = token.token_type, text=token.text), state.advance()))  # type: ignore
-        captured: Algebra[Tuple[T,...] | T, ParserState[T]] = cls(token_run, name=cls.__name__ + f'.token({token_type}, {text})')
+        captured: Algebra[T, ParserState[T]] = cls(token_run, name=cls.__name__ + f'.token({token_type}, {text})')
         def error_fn(err: Any) -> Error:
             if isinstance(err, ParserState):
                 return Error(message=f"Cannot match token at {err}", this=captured, state=err)            
@@ -111,52 +111,79 @@ class Parser(Algebra[Tuple[T,...] | T, ParserState[T]]):
               inclusive: bool = True, 
               strict: bool = True) -> Algebra[Any, ParserState[T]]:
         def until_run(state: ParserState[T], use_cache:bool) -> Either[Any, Tuple[Any, ParserState[T]]]:
-            counters = [0] * len(open_close)
+            # Use a stack to enforce proper nesting across multiple open/close pairs.
             tokens: List[Any] = []
             if not terminator and len(open_close) == 0:
-                return Left(Error(this=until_run, message="No terminator and no open/close parsers, nothing to parse", state=state))  
-            def run_oc(s: ParserState[T], 
-                       sign: int, 
-                       *oc: Algebra[Any, ParserState[T]])->Tuple[bool, ParserState[T]]:
-                matched = False
-                for i, p in enumerate(oc):
-                    new = p.run(s, use_cache)
-                    if isinstance(new, Right):
-                        matched = True
-                        counters[i] += sign
-                        if inclusive:
-                            tokens.append(new.value[0])
-                        s = new.value[1]
-                return matched, s
+                return Left(Error(this=until_run, message="No terminator and no open/close parsers, nothing to parse", state=state))
+
+            # Helper to try matching any of the parsers once, returning early on first match
+            def try_match(s: ParserState[T], *parsers: Algebra[Any, ParserState[T]]) -> Tuple[bool, Optional[int], Optional[Any], ParserState[T]]:
+                for i, p in enumerate(parsers):
+                    res = p.run(s, use_cache)
+                    if isinstance(res, Right):
+                        val, ns = res.value
+                        return True, i, val, ns
+                return False, None, None, s
+
             opens, closes = zip(*open_close) if len(open_close) > 0 else ((), ())
             tmp_state: ParserState[T] = state.copy()
-            if strict:
-                c = reduce(lambda a, b: a.or_else(b), opens).run(tmp_state)
+            stack: List[int] = []  # indices into open_close indicating expected closer
+
+            # If strict, require the very next token to be an opener of any kind
+            if strict and len(opens) > 0:
+                c = reduce(lambda a, b: a.or_else(b), opens).run(tmp_state, use_cache)
                 if c.is_left():
-                    return Left(Error(
-                        this=until_run,
-                        message="No opening parser matched",
-                        state=tmp_state
-                    ))
+                    return Left(Error(this=until_run, message="No opening parser matched", state=tmp_state))
+
             while not tmp_state.ended():
-                mopen, tmp_state = run_oc(tmp_state, 1, *opens)
-                mclose, tmp_state = run_oc(tmp_state, -1, *closes)
-                matched = mopen or mclose
-                if all(c == 0 for c in counters):
-                    if terminator :
-                        new = terminator.run(tmp_state, use_cache)
-                        if isinstance(new, Right):
-                            matched = True
+                # Try to open
+                o_matched, o_idx, o_tok, o_state = try_match(tmp_state, *opens)
+                if o_matched and o_idx is not None:
+                    stack.append(o_idx)
+                    if inclusive:
+                        tokens.append(o_tok)
+                    tmp_state = o_state
+                    continue
+
+                # Try to close
+                c_matched, c_idx, c_tok, c_state = try_match(tmp_state, *closes)
+                if c_matched and c_idx is not None:
+                    if not stack or stack[-1] != c_idx:
+                        return Left(Error(this=until_run, message="Mismatched closing parser", state=tmp_state))
+                    stack.pop()
+                    if inclusive:
+                        tokens.append(c_tok)
+                    tmp_state = c_state
+                    # After closing, if stack empty, we may terminate on a terminator
+                    if len(stack) == 0:
+                        if terminator:
+                            term = terminator.run(tmp_state, use_cache)
+                            if isinstance(term, Right):
+                                if inclusive:
+                                    tokens.append(term.value[0])
+                                return Right((tuple(tokens), term.value[1]))
+                        else:
+                            return Right((tuple(tokens), tmp_state))
+                    continue
+
+                # If nothing structural matched, check termination when not nested
+                if len(stack) == 0:
+                    if terminator:
+                        term2 = terminator.run(tmp_state, use_cache)
+                        if isinstance(term2, Right):
                             if inclusive:
-                                tokens.append(new.value[0])
-                            return Right((tuple(tokens), new.value[1]))
+                                tokens.append(term2.value[0])
+                            return Right((tuple(tokens), term2.value[1]))
                     else:
                         return Right((tuple(tokens), tmp_state))
-                elif any(c < 0 for c in counters):
-                    return Left(Error(this=until_run, message="Unmatched closing parser", state=tmp_state))
-                if not matched:
-                    tokens.append(tmp_state.current())
-                    tmp_state = tmp_state.advance()
+
+                # Otherwise, consume one token as payload and continue
+                tokens.append(tmp_state.current())
+                tmp_state = tmp_state.advance()
+
+            # Reached end of input
+            if len(stack) != 0:
+                return Left(Error(this=until_run, message="Unterminated group", state=tmp_state))
             return Right((tuple(tokens), tmp_state))
         return cls(until_run, name=cls.__name__ + '.until')
 

{syncraft-0.1.12 → syncraft-0.1.14}/syncraft/sqlite3.py

@@ -280,7 +280,7 @@ HAVING = dsl.lift(TokenType.HAVING)
 HINT = dsl.lift(TokenType.HINT)
 IGNORE = dsl.lift(TokenType.IGNORE)
 ILIKE = dsl.lift(TokenType.ILIKE)
-ILIKE_ANY = dsl.lift(TokenType.ILIKE_ANY)
+
 IN = dsl.lift(TokenType.IN)
 INDEX = dsl.lift(TokenType.INDEX)
 INNER = dsl.lift(TokenType.INNER)
@@ -301,7 +301,7 @@ LANGUAGE = dsl.lift(TokenType.LANGUAGE)
 LATERAL = dsl.lift(TokenType.LATERAL)
 LEFT = dsl.lift(TokenType.LEFT)
 LIKE = dsl.lift(TokenType.LIKE)
-LIKE_ANY = dsl.lift(TokenType.LIKE_ANY)
+
 LIMIT = dsl.lift(TokenType.LIMIT)
 LIST = dsl.lift(TokenType.LIST)
 LOAD = dsl.lift(TokenType.LOAD)

{syncraft-0.1.12 → syncraft-0.1.14}/syncraft.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncraft
-Version: 0.1.12
+Version: 0.1.14
 Summary: Parser combinator library
 Author-email: Michael Afmokt <michael@esacca.com>
 License-Expression: MIT

{syncraft-0.1.12 → syncraft-0.1.14}/syncraft.egg-info/SOURCES.txt

@@ -16,4 +16,5 @@ syncraft.egg-info/SOURCES.txt
 syncraft.egg-info/dependency_links.txt
 syncraft.egg-info/requires.txt
 syncraft.egg-info/top_level.txt
-tests/test_parse.py
+tests/test_parse.py
+tests/test_until.py

{syncraft-0.1.12 → syncraft-0.1.14}/tests/test_parse.py

@@ -1,7 +1,6 @@
 from syncraft.parser import AST, literal, variable, parse, Parser
 import syncraft.generator as gen
 from typing import Any
-from rich import print
 
 IF = literal("if")
 ELSE = literal("else")
@@ -32,5 +31,5 @@ def test_many_or()->None:
     syntax = (IF.many() | THEN.many()).many() // END
     sql = "if if then end"
     ast:AST[Any] = parse(syntax(Parser), sql, dialect='sqlite')
-    generated = gen.generate(syntax(gen.Generator))
-    # assert ast == generated, "Parsed and generated results do not match."
+    generated = gen.generate(syntax(gen.Generator), ast)
+    assert ast == generated, "Parsed and generated results do not match."

syncraft-0.1.14/tests/test_until.py

@@ -0,0 +1,40 @@
+from typing import Any
+from syncraft.parser import parse, until, literal, Parser
+from syncraft.ast import AST
+
+# Define common pair DSLs
+LP, RP = literal("("), literal(")")
+LB, RB = literal("["), literal("]")
+
+
+def test_until_accepts_proper_nesting() -> None:
+    sql = "([])"
+    syntax = until((LP, RP), (LB, RB))
+    ast: AST[Any] | Any = parse(syntax(Parser), sql, dialect="sqlite")
+    assert isinstance(ast, AST), f"Expected AST for proper nesting, got {ast}"
+
+
+def test_until_rejects_mismatched_pairs() -> None:
+    # Mismatched: ( ] should fail immediately
+    sql = "(]"
+    syntax = until((LP, RP), (LB, RB))
+    res = parse(syntax(Parser), sql, dialect="sqlite")
+    from syncraft.algebra import Error
+    assert isinstance(res, Error), "Mismatched pairs should be rejected with an Error"
+
+def test_until_rejects_unterminated_group() -> None:
+    # Unterminated: ( ... EOF
+    sql = "("
+    syntax = until((LP, RP))
+    res = parse(syntax(Parser), sql, dialect="sqlite")
+    from syncraft.algebra import Error
+    assert isinstance(res, Error), "Unterminated group should be rejected with an Error"
+
+def test_until_rejects_crossing_pairs() -> None:
+    # Crossing/interleaved: ([)] should be rejected
+    sql = "([)]"
+    syntax = until((LP, RP), (LB, RB))
+    # Use postgres dialect so [ and ] are tokenized distinctly (not as bracketed identifier)
+    res = parse(syntax(Parser), sql, dialect="postgres")
+    from syncraft.algebra import Error
+    assert isinstance(res, Error), "Crossing pairs should be rejected with an Error"

syncraft-0.1.12/syncraft/ast.py

@@ -1,202 +0,0 @@
-
-
-from __future__ import annotations
-import re
-from typing import (
-    Optional, Any, TypeVar, Tuple, runtime_checkable, Dict,
-    Protocol, Generic, Callable, Union
-)
-from syncraft.algebra import (
-    NamedResult, OrResult,ThenResult, ManyResult, ThenKind,
-    Lens
-)
-from dataclasses import dataclass, field, replace, is_dataclass, asdict
-from enum import Enum
-from functools import cached_property
-
-@runtime_checkable
-class TokenProtocol(Protocol):
-    @property
-    def token_type(self) -> Enum: ...
-    @property
-    def text(self) -> str: ...
-    
-
-@dataclass(frozen=True)
-class Token:
-    token_type: Enum
-    text: str
-    def __str__(self) -> str:
-        return f"{self.token_type.name}({self.text})"
-    
-    def __repr__(self) -> str:
-        return self.__str__()
-
-@dataclass(frozen=True)
-class TokenSpec:
-    token_type: Optional[Enum] = None
-    text: Optional[str] = None
-    case_sensitive: bool = False
-    regex: Optional[re.Pattern[str]] = None
-        
-    def is_valid(self, token: TokenProtocol) -> bool:
-        type_match = self.token_type is None or token.token_type == self.token_type
-        value_match = self.text is None or (token.text.strip() == self.text.strip() if self.case_sensitive else 
-                                                    token.text.strip().upper() == self.text.strip().upper())
-        value_match = value_match or (self.regex is not None and self.regex.fullmatch(token.text) is not None)
-        return type_match and value_match
-
-
-
-
-T = TypeVar('T', bound=TokenProtocol)  
-
-
-ParseResult = Union[
-    ThenResult['ParseResult[T]', 'ParseResult[T]'], 
-    NamedResult['ParseResult[T]', Any], 
-    ManyResult['ParseResult[T]'],
-    OrResult['ParseResult[T]'],
-    Tuple[T, ...],
-    T,
-] 
-
-
-
-
-    
-
-
-@dataclass(frozen=True)
-class NamedRecord:
-    lens: Lens[Any, Any]
-    value: Any
-
-@dataclass(frozen=True)
-class Walker:
-    lens: Optional[Lens[Any, Any]] = None
-    def get(self, root: ParseResult[Any]) -> Dict[str, NamedRecord]:
-        match root:
-            case ManyResult(value=children):
-                new_named: Dict[str, NamedRecord] = {}
-                for i, child in enumerate(children):
-                    new_walker = replace(self, lens=(self.lens / ManyResult.lens(i)) if self.lens else ManyResult.lens(i))
-                    new_named |= new_walker.get(child)
-                return new_named
-            case OrResult(value=value):
-                new_walker = replace(self, lens=(self.lens / OrResult.lens()) if self.lens else OrResult.lens())
-                return new_walker.get(value)
-            case ThenResult(left=left, 
-                            right=right, 
-                            kind=kind):
-                new_walker = replace(self, lens=(self.lens / ThenResult.lens(kind)) if self.lens else ThenResult.lens(kind))
-                return new_walker.get(left) | new_walker.get(right)
-            case NamedResult(name=name, 
-                             value=value, 
-                             forward_map=forward_map,
-                             backward_map=backward_map,
-                             aggregator=aggregator):
-                this_lens = (self.lens / NamedResult.lens()) if self.lens else NamedResult.lens()
-                if callable(forward_map) and callable(backward_map):
-                    this_lens = this_lens.bimap(forward_map, backward_map) 
-                elif callable(forward_map):
-                    this_lens = this_lens.bimap(forward_map, lambda _: value)
-                elif callable(backward_map):
-                    raise ValueError("backward_map provided without forward_map")
-                new_walker = replace(self, lens=this_lens)
-                child_named = new_walker.get(value)
-                if aggregator is not None:
-                    return child_named | {name: NamedRecord(lens=this_lens, 
-                                                            value=aggregator(child_named))}
-                else:
-                    return child_named
-        return {}
-
-    def set(self, root: ParseResult[Any], updated_values: Dict[str, Any]) -> ParseResult[Any]:
-        named_records = self.get(root)
-        def apply_update(name: str, value: Any, root: ParseResult[Any]) -> ParseResult[Any]:
-            if name not in named_records:
-                # Skip unknown names safely
-                return root
-            record = named_records[name]
-            target_named: NamedResult[Any, Any] = record.lens.get(root)
-            assert isinstance(target_named, NamedResult)
-
-            if target_named.aggregator is not None:
-                # Break apart dataclass/dict into child fields
-                if isinstance(value, dict):
-                    child_updates = value
-                elif is_dataclass(value) and not isinstance(value, type):
-                    child_updates = asdict(value)
-                else:
-                    raise TypeError(f"Unsupported aggregator value for '{name}': {type(value)}")
-
-                # Recursively apply each child update
-                for child_name, child_value in child_updates.items():
-                    root = apply_update(child_name, child_value, root)
-                return root
-
-            else:
-                # Leaf: just replace the value
-                updated_named = replace(target_named, value=value)
-                return record.lens.set(root, updated_named)
-
-        for name, value in updated_values.items():
-            root = apply_update(name, value, root)
-
-        return root
-
-@dataclass(frozen=True)
-class AST(Generic[T]):
-    focus: ParseResult[T]
-    pruned: bool = False
-    parent: Optional[AST[T]] = None
-
-    def up(self)->Optional[AST[T]]:
-        return self.parent
-
-    def left(self) -> Optional[AST[T]]:
-        match self.focus:
-            case ThenResult(left=left, kind=kind):
-                return replace(self, focus=left, parent=self, pruned = self.pruned or kind == ThenKind.RIGHT)
-            case _:
-                raise TypeError(f"Invalid focus type({self.focus}) for left traversal")
-
-    def right(self) -> Optional[AST[T]]:
-        match self.focus:
-            case ThenResult(right=right, kind=kind):
-                return replace(self, focus=right, parent=self, pruned = self.pruned or kind == ThenKind.LEFT)
-            case _:
-                raise TypeError(f"Invalid focus type({self.focus}) for right traversal")
-
-
-    def down(self, index: int) -> Optional[AST[T]]:
-        match self.focus:
-            case ManyResult(value=children):
-                if 0 <= index < len(children):
-                    return replace(self, focus=children[index], parent=self, pruned=self.pruned)
-                else:
-                    raise IndexError(f"Index {index} out of bounds for ManyResult with {len(children)} children")
-            case OrResult(value=value):
-                if index == 0:
-                    return replace(self, focus=value, parent=self, pruned=self.pruned)
-                else:
-                    raise IndexError(f"Index {index} out of bounds for OrResult")
-            case _:
-                raise TypeError(f"Invalid focus type({self.focus}) for down traversal")
-
-    def how_many(self)->int:
-        match self.focus:
-            case ManyResult(value=children):
-                return len(children)
-            case _:
-                raise TypeError(f"Invalid focus type({self.focus}) for how_many")
-            
-    
-
-    @cached_property
-    def root(self) -> AST[T]:
-        while self.parent is not None:
-            self = self.parent  
-        return self
-