syncraft 0.1.12__py3-none-any.whl → 0.1.14__py3-none-any.whl

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/ast.py

@@ -4,13 +4,13 @@ from __future__ import annotations
 import re
 from typing import (
     Optional, Any, TypeVar, Tuple, runtime_checkable, Dict,
-    Protocol, Generic, Callable, Union
+    Protocol, Generic, Callable, Union, cast
 )
 from syncraft.algebra import (
-    NamedResult, OrResult,ThenResult, ManyResult, ThenKind,
+    OrResult,ThenResult, ManyResult, ThenKind,NamedResult, StructuralResult,
     Lens
 )
-from dataclasses import dataclass, field, replace, is_dataclass, asdict
+from dataclasses import dataclass, replace, is_dataclass, asdict
 from enum import Enum
 from functools import cached_property
 
@@ -54,106 +54,33 @@ T = TypeVar('T', bound=TokenProtocol)
 
 ParseResult = Union[
     ThenResult['ParseResult[T]', 'ParseResult[T]'], 
-    NamedResult['ParseResult[T]', Any], 
+    NamedResult['ParseResult[T]'],
     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 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:
@@ -182,11 +109,14 @@ class AST(Generic[T]):
                     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:
-        match self.focus:
+        focus = self.focus.value if isinstance(self.focus, NamedResult) else self.focus
+        match focus:
             case ManyResult(value=children):
                 return len(children)
             case _:

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/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/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/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.dist-info → syncraft-0.1.14.dist-info}/METADATA

@@ -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.14.dist-info/RECORD

@@ -0,0 +1,15 @@
+syncraft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syncraft/algebra.py,sha256=T2pcGOgoJptb7fYS2WqPldcEtmVe-jfPLbK_Uu7d6tA,23173
+syncraft/ast.py,sha256=s3BDm67IKd8WNEPszkGRgJ-SJAKewbERL0baLgfkXaQ,4634
+syncraft/cmd.py,sha256=DzXgU8QLVOg0YTFKpmOyzbf02LKPphQ4EeKSLzqpJ_s,2012
+syncraft/diagnostic.py,sha256=_kLbl1LlU4Y2PtsLLZFA_OLqeZqq1f2rjT_LRXLnDaI,2813
+syncraft/dsl.py,sha256=AxAZKu6MBfaG7Wzss3UISbQsrFaigc1L-hS3p_CAXWQ,13620
+syncraft/generator.py,sha256=U27EAWsuZL9AsQT2cGjgyM1isAfdQaPhOCyyn-yB-Ak,10983
+syncraft/parser.py,sha256=c1cCCW0RNw2y4XlNIUkrMf7q5lkm8wes4v5xbjLAUGg,11573
+syncraft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syncraft/sqlite3.py,sha256=WR4wFf2CraRkb7C5rph3wsu6sGbG_7EjEZDUsPH8xqU,34677
+syncraft-0.1.14.dist-info/licenses/LICENSE,sha256=wHSV424U5csa3339dy1AZbsz2xsd0hrkMx2QK48CcUk,1062
+syncraft-0.1.14.dist-info/METADATA,sha256=EboJguSsSHYP0EYNfYBBXc0ewPPf0unH2_lC-SecSJk,946
+syncraft-0.1.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+syncraft-0.1.14.dist-info/top_level.txt,sha256=Kq3t8ESXB2xW1Xt3uPmkENFc-c4f2pamNmaURBk7zc8,9
+syncraft-0.1.14.dist-info/RECORD,,

syncraft-0.1.12.dist-info/RECORD

@@ -1,15 +0,0 @@
-syncraft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-syncraft/algebra.py,sha256=jiqdo1GbXVwi_7Uoh1zBLe-TparNaHp8jW2IFt8PzBc,24494
-syncraft/ast.py,sha256=y48DKYO-rSzmrObxsLXq2k_DfAplMnXjJBURY4Gv30U,7582
-syncraft/cmd.py,sha256=DzXgU8QLVOg0YTFKpmOyzbf02LKPphQ4EeKSLzqpJ_s,2012
-syncraft/diagnostic.py,sha256=_kLbl1LlU4Y2PtsLLZFA_OLqeZqq1f2rjT_LRXLnDaI,2813
-syncraft/dsl.py,sha256=T89zkcE6xKvQSP4PJDHaWp9TsygXCTAzgx6r91KysFc,16504
-syncraft/generator.py,sha256=SD9CRWnJrllWlZeiZmyBEkQ_WOVMjWKgrcAGo-27o14,9970
-syncraft/parser.py,sha256=rk3YF8B0G8PG3JKYpeMQsYmHC5JxqrkCMXZAPfaqgME,10210
-syncraft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-syncraft/sqlite3.py,sha256=2JNGDymSJti3mdc7hdeXIF78S6SsSLpKJwe6AzivskQ,34757
-syncraft-0.1.12.dist-info/licenses/LICENSE,sha256=wHSV424U5csa3339dy1AZbsz2xsd0hrkMx2QK48CcUk,1062
-syncraft-0.1.12.dist-info/METADATA,sha256=ObEtoVoxfp6uKYMU9ZW_ABAs6T-RH7TRu__Pjt9mwIA,946
-syncraft-0.1.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-syncraft-0.1.12.dist-info/top_level.txt,sha256=Kq3t8ESXB2xW1Xt3uPmkENFc-c4f2pamNmaURBk7zc8,9
-syncraft-0.1.12.dist-info/RECORD,,