syncraft 0.1.27__py3-none-any.whl → 0.1.29__py3-none-any.whl

syncraft/algebra.py

@@ -8,7 +8,10 @@ import traceback
 from dataclasses import dataclass, replace, asdict
 from weakref import WeakKeyDictionary
 from abc import ABC
-from syncraft.ast import ThenKind, Then, S, Choice, Many, ChoiceKind
+from syncraft.ast import ThenKind, Then, Choice, Many, ChoiceKind
+from syncraft.constraint import Bindable
+
+S = TypeVar('S', bound=Bindable)
     
 A = TypeVar('A')  # Result type
 B = TypeVar('B')  # Mapped result type
@@ -128,10 +131,7 @@ class Algebra(ABC, Generic[A, S]):
         def lazy_run(input: S, use_cache:bool) -> Either[Any, Tuple[A, S]]:
             return thunk().run(input, use_cache)
         return cls(lazy_run, name=cls.__name__ + '.lazy')
-
-
-
-
+    
     @classmethod
     def fail(cls, error: Any) -> Algebra[Any, S]:
         def fail_run(input: S, use_cache:bool) -> Either[Any, Tuple[Any, S]]:
@@ -141,6 +141,7 @@ class Algebra(ABC, Generic[A, S]):
                 state=input
             ))
         return cls(fail_run, name=cls.__name__ + '.fail')
+    
     @classmethod
     def success(cls, value: Any) -> Algebra[Any, S]:
         def success_run(input: S, use_cache:bool) -> Either[Any, Tuple[Any, S]]:
@@ -234,7 +235,35 @@ class Algebra(ABC, Generic[A, S]):
         lazy_self = self.__class__(debug_run, name=label)  
         return lazy_self
 
+######################################################## map on state ###########################################
+    def post_state(self, f: Callable[[S], S]) -> Algebra[A, S]:
+        def post_state_run(input: S, use_cache:bool) -> Either[Any, Tuple[A, S]]:
+            match self.run(input, use_cache):
+                case Right((value, state)):
+                    return Right((value, f(state)))
+                case Left(err):
+                    return Left(err)
+                case x:
+                    raise ValueError(f"Unexpected result from self.run {x}")
+        return self.__class__(post_state_run, name=self.name) 
+
+    def pre_state(self, f: Callable[[S], S]) -> Algebra[A, S]:
+        def pre_state_run(state: S, use_cache:bool) -> Either[Any, Tuple[A, S]]:
+            return self.run(f(state), use_cache)
+        return self.__class__(pre_state_run, name=self.name) 
+
 
+    def map_all(self, f: Callable[[A, S], Tuple[B, S]]) -> Algebra[B, S]:
+        def map_all_run(input: S, use_cache:bool) -> Either[Any, Tuple[B, S]]:
+            match self.run(input, use_cache):
+                case Right((value, state)):
+                    new_value, new_state = f(value, state)
+                    return Right((new_value, new_state))
+                case Left(err):
+                    return Left(err)
+                case x:
+                    raise ValueError(f"Unexpected result from self.run {x}")
+        return self.__class__(map_all_run, name=self.name) # type: ignore
 ######################################################## fundamental combinators ############################################    
     def fmap(self, f: Callable[[A], B]) -> Algebra[B, S]:
         def fmap_run(input: S, use_cache:bool) -> Either[Any, Tuple[B, S]]:
@@ -245,20 +274,12 @@ class Algebra(ABC, Generic[A, S]):
                 return cast(Either[Any, Tuple[B, S]], parsed)
         return self.__class__(fmap_run, name=self.name)  # type: ignore
 
-    def imap(self, f: Callable[[B], A]) -> Algebra[A, S]:
-        return self.map_state(lambda s: s.map(f))
     
     def map(self, f: Callable[[A], B]) -> Algebra[B, S]:
         return self.fmap(f)
     
-    def bimap(self, f: Callable[[A], B], i: Callable[[B], A]) -> Algebra[A, S]:
-        return self.fmap(f).as_(Algebra[A, S]).imap(i)
-
-    def map_all(self, f: Callable[[Either[Any, Tuple[A, S]]], Either[Any, Tuple[B, S]]])->Algebra[B, S]:
-        def map_all_run(input: S, use_cache:bool) -> Either[Any, Tuple[B, S]]:
-            parsed = self.run(input, use_cache)
-            return f(parsed)
-        return self.__class__(map_all_run, name=self.name) # type: ignore
+    def bimap(self, f: Callable[[A], B], i: Callable[[B], A]) -> Algebra[B, S]:
+        return self.fmap(f).pre_state(lambda s: s.map(i))
 
     def map_error(self, f: Callable[[Optional[Any]], Any]) -> Algebra[A, S]:
         def map_error_run(input: S, use_cache:bool) -> Either[Any, Tuple[A, S]]:
@@ -268,12 +289,6 @@ class Algebra(ABC, Generic[A, S]):
             return parsed
         return self.__class__(map_error_run, name=self.name)  
 
-    def map_state(self, f: Callable[[S], S]) -> Algebra[A, S]:
-        def map_state_run(state: S, use_cache:bool) -> Either[Any, Tuple[A, S]]:
-            return self.run(f(state), use_cache)
-        return self.__class__(map_state_run, name=self.name) 
-
-
     def flat_map(self, f: Callable[[A], Algebra[B, S]]) -> Algebra[B, S]:
         def flat_map_run(input: S, use_cache:bool) -> Either[Any, Tuple[B, S]]:
             parsed = self.run(input, use_cache)
@@ -288,34 +303,34 @@ class Algebra(ABC, Generic[A, S]):
         def or_else_run(input: S, use_cache:bool) -> Either[Any, Tuple[Choice[A, B], S]]:
             match self.run(input, use_cache):
                 case Right((value, state)):
-                    return Right((Choice(kind=ChoiceKind.LEFT, left=value, right=None), state))
+                    return Right((Choice(kind=ChoiceKind.LEFT, value=value), state))
                 case Left(err):
                     if isinstance(err, Error) and err.committed:
-                        return Left(err)
+                        return Left(replace(err, committed=False))
                     match other.run(input, use_cache):
                         case Right((other_value, other_state)):
-                            return Right((Choice(kind=ChoiceKind.RIGHT, left=None, right=other_value), other_state))
+                            return Right((Choice(kind=ChoiceKind.RIGHT, value=other_value), other_state))
                         case Left(other_err):
                             return Left(other_err)
                     raise TypeError(f"Unexpected result type from {other}")
             raise TypeError(f"Unexpected result type from {self}")
         return self.__class__(or_else_run, name=f'{self.name} | {other.name}')  # type: ignore
 
-    def then_both(self, other: 'Algebra[B, S]') -> 'Algebra[Then[A, B], S]':
+    def then_both(self, other: Algebra[B, S]) -> Algebra[Then[A, B], S]:
         def then_both_f(a: A) -> Algebra[Then[A, B], S]:
             def combine(b: B) -> Then[A, B]:
                 return Then(left=a, right=b, kind=ThenKind.BOTH)
             return other.fmap(combine)
         return self.flat_map(then_both_f).named(f'{self.name} + {other.name}')
 
-    def then_left(self, other: Algebra[B, S]) -> 'Algebra[Then[A, B], S]':
+    def then_left(self, other: Algebra[B, S]) -> Algebra[Then[A, B], S]:
         def then_left_f(a: A) -> Algebra[Then[A, B], S]:
             def combine(b: B) -> Then[A, B]:
                 return Then(left=a, right=b, kind=ThenKind.LEFT)
             return other.fmap(combine)
         return self.flat_map(then_left_f).named(f'{self.name} // {other.name}')
 
-    def then_right(self, other: Algebra[B, S]) -> 'Algebra[Then[A, B], S]':
+    def then_right(self, other: Algebra[B, S]) -> Algebra[Then[A, B], S]:
         def then_right_f(a: A) -> Algebra[Then[A, B], S]:
             def combine(b: B) -> Then[A, B]:
                 return Then(left=a, right=b, kind=ThenKind.RIGHT)

syncraft/ast.py

@@ -3,54 +3,138 @@
 from __future__ import annotations
 import re
 from typing import (
-    Optional, Any, TypeVar, Tuple, runtime_checkable, 
-    Dict, Generic, Callable, Union, Protocol
+    Optional, Any, TypeVar, Tuple, runtime_checkable, cast,
+    Generic, Callable, Union, Protocol, Type, List, ClassVar
 )
 
 
-from dataclasses import dataclass
+from dataclasses import dataclass, replace, is_dataclass, asdict, fields
 from enum import Enum
-from syncraft.constraint import Bindable
+
 
 
 
 A = TypeVar('A')
 B = TypeVar('B')  
 C = TypeVar('C')  
-S = TypeVar('S', bound=Bindable)  
+D = TypeVar('D')
+S = TypeVar('S')  
+S1 = TypeVar('S1')
+
 
 @dataclass(frozen=True)
-class Reducer(Generic[A, S]):
-    run_f: Callable[[A, S], S]
-    def __call__(self, a: A, s: S) -> S:
-        return self.run_f(a, s)
-    
-    def map(self, f: Callable[[B], A]) -> Reducer[B, S]:
-        def map_run(b: B, s: S) -> S:
-            return self(f(b), s)
-        return Reducer(map_run)
+class Biarrow(Generic[A, B]):
+    forward: Callable[[A], B]
+    inverse: Callable[[B], A]
+    def __rshift__(self, other: Biarrow[B, C]) -> Biarrow[A, C]:
+        def fwd(a: A) -> C:
+            b = self.forward(a)
+            return other.forward(b)
+        def inv(c: C) -> A:
+            b = other.inverse(c)
+            return self.inverse(b)
+        return Biarrow(
+            forward=fwd,
+            inverse=inv
+        )
+    @staticmethod
+    def identity()->Biarrow[A, A]:
+        return Biarrow(
+            forward=lambda x: x,
+            inverse=lambda y: y
+        )
+            
+    @staticmethod
+    def when(condition: Callable[..., bool], 
+             then: Biarrow[A, B], 
+             otherwise: Optional[Biarrow[A, B]] = None) -> Callable[..., Biarrow[A, B]]:
+        def _when(*args:Any, **kwargs:Any) -> Biarrow[A, B]:
+            return then if condition(*args, **kwargs) else (otherwise or Biarrow.identity())
+        return _when
+
+
+@dataclass(frozen=True)
+class Lens(Generic[C, A]):
+    get: Callable[[C], A]
+    set: Callable[[C, A], C]    
+
+    def modify(self, source: C, f: Callable[[A], A]) -> C:
+        return self.set(source, f(self.get(source)))
     
+    def bimap(self, ff: Callable[[A], B], bf: Callable[[B], A]) -> Lens[C, B]:
+        def getf(data: C) -> B:
+            return ff(self.get(data))
 
+        def setf(data: C, value: B) -> C:
+            return self.set(data, bf(value))
+
+        return Lens(get=getf, set=setf)
+
+    def __truediv__(self, other: Lens[A, B]) -> Lens[C, B]:
+        def get_composed(obj: C) -> B:
+            return other.get(self.get(obj))        
+        def set_composed(obj: C, value: B) -> C:
+            return self.set(obj, other.set(self.get(obj), value))
+        return Lens(get=get_composed, set=set_composed)
     
+    def __rtruediv__(self, other: Lens[B, C])->Lens[B, A]:
+        return other.__truediv__(self)
+    
+
 @dataclass(frozen=True)
 class Bimap(Generic[A, B]):
     run_f: Callable[[A], Tuple[B, Callable[[B], A]]]
     def __call__(self, a: A) -> Tuple[B, Callable[[B], A]]:
         return self.run_f(a)    
-    def __rshift__(self, other: Bimap[B, C]) -> Bimap[A, C]:
-        def then_run(a: A) -> Tuple[C, Callable[[C], A]]:
-            b, inv1 = self(a)
-            c, inv2 = other(b)
-            def inv(c2: C) -> A:
-                return inv1(inv2(c2))
-            return c, inv
-        return Bimap(then_run)
+    def __rshift__(self, other: Bimap[B, C] | Biarrow[B, C]) -> Bimap[A, C]:
+        if isinstance(other, Biarrow):
+            def biarrow_then_run(a: A) -> Tuple[C, Callable[[C], A]]:
+                b, inv1 = self(a)
+                c = other.forward(b)
+                def inv(c2: C) -> A:
+                    b2 = other.inverse(c2)
+                    return inv1(b2)
+                return c, inv
+            return Bimap(biarrow_then_run)
+        elif isinstance(other, Bimap):
+            def bimap_then_run(a: A) -> Tuple[C, Callable[[C], A]]:
+                b, inv1 = self(a)
+                c, inv2 = other(b)
+                def inv(c2: C) -> A:
+                    return inv1(inv2(c2))
+                return c, inv
+            return Bimap(bimap_then_run)
+        else:
+            raise TypeError(f"Unsupported type for Bimap >>: {type(other)}")
+    def __rrshift__(self, other: Bimap[C, A] | Biarrow[C, A]) -> Bimap[C, B]:
+        if isinstance(other, Biarrow):
+            def biarrow_then_run(c: C) -> Tuple[B, Callable[[B], C]]:
+                a = other.forward(c)
+                b2, inv1 = self(a)
+                def inv(a2: B) -> C:
+                    a3 = inv1(a2)
+                    return other.inverse(a3)
+                return b2, inv
+            return Bimap(biarrow_then_run)
+        elif isinstance(other, Bimap):
+            def bimap_then_run(c: C)->Tuple[B, Callable[[B], C]]:
+                a, a2c = other(c)
+                b2, b2a = self(a)
+                def inv(b3: B) -> C:
+                    a2 = b2a(b3)
+                    return a2c(a2)
+                return b2, inv
+            return Bimap(bimap_then_run)
+        else:
+            raise TypeError(f"Unsupported type for Bimap <<: {type(other)}")
+
+
     @staticmethod
     def const(a: B)->Bimap[B, B]:
         return Bimap(lambda _: (a, lambda b: b))
 
     @staticmethod
-    def identity()->Bimap[Any, Any]:
+    def identity()->Bimap[A, A]:
         return Bimap(lambda a: (a, lambda b: b))
 
     @staticmethod
@@ -65,86 +149,179 @@ class Bimap(Generic[A, B]):
             return abc, inv_f
         return Bimap(when_run)
     
-    
 
 @dataclass(frozen=True)
-class Biarrow(Generic[S, A, B]):
-    forward: Callable[[S, A], Tuple[S, B]]
-    inverse: Callable[[S, B], Tuple[S, A]]
-    def __rshift__(self, other: Biarrow[S, B, C]) -> Biarrow[S, A, C]:
-        def fwd(s: S, a: A) -> Tuple[S, C]:
-            s1, b = self.forward(s, a)
-            return other.forward(s1, b)
-        def inv(s: S, c: C) -> Tuple[S, A]:
-            s1, b = other.inverse(s, c)
-            return self.inverse(s1, b)
-        return Biarrow(
-            forward=fwd,
-            inverse=inv
-        )
-    @staticmethod
-    def identity()->Biarrow[S, A, A]:
-        return Biarrow(
-            forward=lambda s, x: (s, x),
-            inverse=lambda s, y: (s, y)
-        )
-            
-    @staticmethod
-    def when(condition: Callable[..., bool], 
-             then: Biarrow[S, A, B], 
-             otherwise: Optional[Biarrow[S, A, B]] = None) -> Callable[..., Biarrow[S, A, B]]:
-        def _when(*args:Any, **kwargs:Any) -> Biarrow[S, A, B]:
-            return then if condition(*args, **kwargs) else (otherwise or Biarrow.identity())
-        return _when
+class Reducer(Generic[A, S]):
+    run_f: Callable[[A, S], S]
+    def __call__(self, a: A, s: S) -> S:
+        return self.run_f(a, s)
+    
+    def map(self, f: Callable[[B], A]) -> Reducer[B, S]:
+        def map_run(b: B, s: S) -> S:
+            return self(f(b), s)
+        return Reducer(map_run)
+    
+    def __rshift__(self, other: Reducer[A, S]) -> Reducer[A, S]:
+        return Reducer(lambda a, s: other(a, self(a, s)))
+    
+    def zip(self, other: Reducer[A, S1])-> Reducer[A, Tuple[S, S1]]:
+        return Reducer(lambda a, s: (self(a, s[0]), other(a, s[1])))
+    
+    def diff(self, other: Reducer[B, S]) -> Reducer[Tuple[A, B], S]:
+        return Reducer(lambda ab, s: other(ab[1], self(ab[0], s)))
     
+    def filter(self, f: Callable[[A, S], bool]) -> Reducer[A, S]:
+        return Reducer(lambda a, s: self(a, s) if f(a, s) else s)
+
+
 
 @dataclass(frozen=True)    
 class AST:
-    pass
+    def bimap(self, r: Bimap[Any, Any]=Bimap.identity()) -> Tuple[Any, Callable[[Any], Any]]:
+        return r(self)
+
+@dataclass(frozen=True)
+class Nothing(AST):
+    def __str__(self)->str:
+        return self.__class__.__name__
+    def __repr__(self)->str:
+        return self.__str__()
 
+
+@dataclass(frozen=True)
+class Marked(Generic[A], AST):
+    name: str
+    value: A
+    def bimap(self, r: Bimap[A, B]=Bimap.identity()) -> Tuple[Marked[B], Callable[[Marked[B]], Marked[A]]]:
+        v, inner_f = self.value.bimap(r) if isinstance(self.value, AST) else r(self.value)
+        return Marked(name=self.name, value=v), lambda b: Marked(name = b.name, value=inner_f(b.value))
+    
 class ChoiceKind(Enum):
     LEFT = 'left'
     RIGHT = 'right'
-    
+
 @dataclass(frozen=True)
 class Choice(Generic[A, B], AST):
-    kind: ChoiceKind
-    left: Optional[A] 
-    right: Optional[B] 
-
+    kind: Optional[ChoiceKind]
+    value: Optional[A | B] = None
+    def bimap(self, r: Bimap[A | B, C]=Bimap.identity()) -> Tuple[Optional[C], Callable[[Optional[C]], Choice[A, B]]]:
+        if self.value is None:
+            return None, lambda c: replace(self, value=None, kind=None)
+        else:
+            v, inv = self.value.bimap(r) if isinstance(self.value, AST) else r(self.value)
+            return v, lambda c: replace(self, value=inv(c) if c is not None else None, kind=None)
 
 @dataclass(frozen=True)
 class Many(Generic[A], AST):
     value: Tuple[A, ...]
+    def bimap(self, r: Bimap[A, B]=Bimap.identity()) -> Tuple[List[B], Callable[[List[B]], Many[A]]]:
+        ret = [v.bimap(r) if isinstance(v, AST) else r(v) for v in self.value]
+        def inv(bs: List[B]) -> Many[A]:
+            if len(bs) <= len(ret):
+                return Many(value = tuple(ret[i][1](bs[i]) for i in range(len(bs)))) 
+            else:
+                half = [ret[i][1](bs[i]) for i in range(len(bs))]
+                tmp = [ret[-1][1](bs[i]) for i in range(len(ret)-1, len(bs))]
+                return Many(value = tuple(half + tmp))
+        return [v[0] for v in ret], inv
 
-@dataclass(frozen=True)
-class Marked(Generic[A], AST):
-    name: str
-    value: A
 class ThenKind(Enum):
     BOTH = '+'
     LEFT = '//'
     RIGHT = '>>'
     
-FlatThen = Tuple[Any, ...]
-MarkedThen = Tuple[Dict[str, Any] | Any, FlatThen]
-
 @dataclass(eq=True, frozen=True)
 class Then(Generic[A, B], AST):
     kind: ThenKind
-    left: Optional[A]
-    right: Optional[B]
-        
-@runtime_checkable
-class TokenProtocol(Protocol):
-    @property
-    def token_type(self) -> Enum: ...
-    @property
-    def text(self) -> str: ...
-    
+    left: A
+    right: B
+    def arity(self)->int:
+        if self.kind == ThenKind.LEFT:
+            return self.left.arity() if isinstance(self.left, Then) else 1
+        elif self.kind == ThenKind.RIGHT:
+            return self.right.arity() if isinstance(self.right, Then) else 1
+        elif self.kind == ThenKind.BOTH:
+            left_arity = self.left.arity() if isinstance(self.left, Then) else 1
+            right_arity = self.right.arity() if isinstance(self.right, Then) else 1
+            return left_arity + right_arity
+        else:
+            return 1
+
+    def bimap(self, r: Bimap[A|B, Any]=Bimap.identity()) -> Tuple[Any | Tuple[Any, ...], Callable[[Any | Tuple[Any, ...]], Then[A, B]]]:
+        def need_wrap(x: Any) -> bool:
+            return not (isinstance(x, Then) and x.kind == ThenKind.BOTH)
+        match self.kind:
+            case ThenKind.LEFT:
+                lb, linv = self.left.bimap(r) if isinstance(self.left, AST) else r(self.left)
+                return lb, lambda c: replace(self, left=cast(A, linv(c)))
+            case ThenKind.RIGHT:
+                rb, rinv = self.right.bimap(r) if isinstance(self.right, AST) else r(self.right)
+                return rb, lambda c: replace(self, right=cast(B, rinv(c)))
+            case ThenKind.BOTH:
+                lb, linv = self.left.bimap(r) if isinstance(self.left, AST) else r(self.left)
+                rb, rinv = self.right.bimap(r) if isinstance(self.right, AST) else r(self.right)
+                left_v = (lb,) if need_wrap(self.left) else lb
+                right_v = (rb,) if need_wrap(self.right) else rb
+                def invf(b: Tuple[C, ...]) -> Then[A, B]:
+                    left_size = self.left.arity() if isinstance(self.left, Then) else 1
+                    right_size = self.right.arity() if isinstance(self.right, Then) else 1
+                    lraw: Tuple[Any, ...] = b[:left_size]
+                    rraw: Tuple[Any, ...] = b[left_size:left_size + right_size]
+                    lraw = lraw[0] if left_size == 1 else lraw
+                    rraw = rraw[0] if right_size == 1 else rraw
+                    la = linv(lraw)
+                    ra = rinv(rraw)
+                    return replace(self, left=cast(A, la), right=cast(B, ra))
+                return left_v + right_v, invf
+
+
+class DataclassInstance(Protocol):
+    __dataclass_fields__: ClassVar[dict[str, Any]]
 
+
+E = TypeVar("E", bound=DataclassInstance)
+
+Collector = Type[E] | Callable[..., E]
 @dataclass(frozen=True)
-class Token:
+class Collect(Generic[A, E], AST): 
+    collector: Collector
+    value: A
+    def bimap(self, r: Bimap[A, B]=Bimap.identity()) -> Tuple[B | E, Callable[[B | E], Collect[A, E]]]:
+        b, inner_f = r(self.value)
+        if isinstance(self.value, Then) and self.value.kind == ThenKind.BOTH:
+            assert isinstance(b, tuple), f"Expected tuple from Then.BOTH combinator, got {type(b)}"
+            index: List[str | int] = []
+            named_count = 0
+            for i, v in enumerate(b):
+                if isinstance(v, Marked):
+                    index.append(v.name)
+                    named_count += 1
+                else:
+                    index.append(i - named_count)
+            named = {v.name: v.value for v in b if isinstance(v, Marked)}
+            unnamed = [v for v in b if not isinstance(v, Marked)]
+            ret: E = self.collector(*unnamed, **named)
+            def invf(e: E) -> Tuple[Any, ...]:
+                assert is_dataclass(e), f"Expected dataclass instance for collector inverse, got {type(e)}"
+                named_dict = asdict(e)     
+                unnamed = []           
+                for f in fields(e):
+                    if f.name not in named:
+                        unnamed.append(named_dict[f.name])
+                tmp = []
+                for x in index:
+                    if isinstance(x, str):
+                        tmp.append(Marked(name=x, value=named_dict[x]))
+                    else:
+                        tmp.append(unnamed[x])
+                return tuple(tmp)
+            return ret, lambda e: replace(self, value=inner_f(invf(e))) # type: ignore
+        else:
+            return b, lambda e: replace(self, value=inner_f(e)) # type: ignore
+
+#########################################################################################################################
+@dataclass(frozen=True)
+class Token(AST):
     token_type: Enum
     text: str
     def __str__(self) -> str:
@@ -152,8 +329,16 @@ class Token:
     
     def __repr__(self) -> str:
         return self.__str__()
+            
+@runtime_checkable
+class TokenProtocol(Protocol):
+    @property
+    def token_type(self) -> Enum: ...
+    @property
+    def text(self) -> str: ...
+
+T = TypeVar('T', bound=TokenProtocol)  
 
-    
 
 @dataclass(frozen=True)
 class TokenSpec:
@@ -170,16 +355,13 @@ class TokenSpec:
         return type_match and value_match
 
 
-
-
-T = TypeVar('T', bound=TokenProtocol)  
-
-
 ParseResult = Union[
     Then['ParseResult[T]', 'ParseResult[T]'], 
     Marked['ParseResult[T]'],
     Choice['ParseResult[T]', 'ParseResult[T]'],
     Many['ParseResult[T]'],
+    Collect['ParseResult[T]', Any],
+    Nothing,
     T,
 ]
 

syncraft/finder.py

@@ -1,40 +1,40 @@
 from __future__ import annotations
 
 from typing import (
-    Any, Tuple, Generator as YieldGen
+    Any, Tuple, Generator as YieldGen, TypeVar
 )
 from dataclasses import dataclass
 from syncraft.algebra import (
     Algebra, Either, Right, 
 )
-from syncraft.ast import T, ParseResult, Choice, Many, Then, Marked
+from syncraft.ast import TokenProtocol, ParseResult, Choice, Many, Then, Marked, Collect
 
 from syncraft.generator import GenState, Generator
 
 from syncraft.syntax import Syntax
 
 
-
+T=TypeVar('T', bound=TokenProtocol)
 @dataclass(frozen=True)
 class Finder(Generator[T]):
     @classmethod
     def anything(cls)->Algebra[Any, GenState[T]]:
         def anything_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[Any, GenState[T]]]:
             return Right((input.ast, input))
-        return cls(anything_run, name=cls.__name__ + '.anything()')
+        return cls(anything_run, name=cls.__name__ + '.anything')
 
 
 
-anything = Syntax(lambda cls: cls.factory('anything')).describe(name="anything", fixity='infix') 
+anything = Syntax(lambda cls: cls.factory('anything')).describe(name="Anything", fixity='infix') 
 
-def matches(syntax: Syntax[Any, Any], data: ParseResult[T])-> bool:
+def matches(syntax: Syntax[Any, Any], data: ParseResult[Any])-> bool:
     gen = syntax(Finder)
-    state = GenState.from_ast(ast = data, restore_pruned=True)
+    state = GenState[Any].from_ast(ast = data, restore_pruned=True)
     result = gen.run(state, use_cache=True)
     return isinstance(result, Right)
 
 
-def find(syntax: Syntax[Any, Any], data: ParseResult[T]) -> YieldGen[ParseResult[T], None, None]:
+def find(syntax: Syntax[Any, Any], data: ParseResult[Any]) -> YieldGen[ParseResult[Any], None, None]:
     if matches(syntax, data):
         yield data
     match data:
@@ -48,10 +48,10 @@ def find(syntax: Syntax[Any, Any], data: ParseResult[T]) -> YieldGen[ParseResult
                 yield from find(syntax, e)
         case Marked(value=value):
             yield from find(syntax, value)
-        case Choice(left=left, right=right):
-            if left is not None:
-                yield from find(syntax, left)
-            if right is not None:
-                yield from find(syntax, right)
+        case Choice(value=value):
+            if value is not None:
+                yield from find(syntax, value)
+        case Collect(value=value):
+            yield from find(syntax, value)
         case _:
             pass

syncraft/generator.py

@@ -11,8 +11,8 @@ from syncraft.algebra import (
 )
 
 from syncraft.ast import (
-    T, ParseResult, AST, Token, TokenSpec, 
-    Bindable, 
+    ParseResult, AST, Token, TokenSpec, 
+    Nothing, TokenProtocol,
     Choice, Many, ChoiceKind,
     Then, ThenKind, Marked
 )
@@ -23,6 +23,14 @@ import re
 import rstr
 from functools import lru_cache
 import random
+from rich import print
+from syncraft.constraint import Bindable
+
+T = TypeVar('T', bound=TokenProtocol)  
+
+S = TypeVar('S', bound=Bindable)
+
+
 
 B = TypeVar('B')
 
@@ -63,9 +71,7 @@ class GenState(Bindable, Generic[T]):
         if isinstance(self.ast, Then) and (self.ast.kind != ThenKind.LEFT or self.restore_pruned):
             return replace(self, ast=self.ast.right)
         return replace(self, ast=None)
-    
 
-    
     def down(self, index: int) -> GenState[T]:
         if self.ast is None:
             return self        
@@ -76,19 +82,27 @@ class GenState(Bindable, Generic[T]):
                 raise TypeError(f"Invalid AST type({self.ast}) for down traversal")
     
     @classmethod
-    def from_ast(cls, *, ast: Optional[ParseResult[T]], seed: int = 0, restore_pruned:bool=False) -> GenState[T]:
+    def from_ast(cls, 
+                 *, 
+                 ast: Optional[ParseResult[T]], 
+                 seed: int = 0, 
+                 restore_pruned:bool=False) -> GenState[T]:
         return cls(ast=ast, seed=seed, restore_pruned=restore_pruned)
     
-
-
-
-
 @lru_cache(maxsize=None)
-def token_type_from_string(token_type: Optional[TokenType], text: str, case_sensitive:bool)-> TokenType:
+def token_type_from_string(token_type: Optional[TokenType], 
+                           text: str, 
+                           case_sensitive:bool = False)-> TokenType:
     if not isinstance(token_type, TokenType) or token_type == TokenType.VAR:
-        for t in TokenType:
-            if t.value == text or str(t.value).lower() == text.lower():
-                return t
+        if case_sensitive:
+            for t in TokenType:
+                if t.value == text:
+                    return t
+        else:
+            text = text.lower()
+            for t in TokenType:
+                if t.value == text or str(t.value).lower() == text:
+                    return t
         return TokenType.VAR
     return token_type
 
@@ -121,13 +135,10 @@ class TokenGen(TokenSpec):
         else:
             text = "VALUE"
 
-        return Token(token_type= token_type_from_string(self.token_type,
-                                                        text, 
-                                                        self.case_sensitive), 
-                     text=text)        
+        return Token(token_type=token_type_from_string(self.token_type, text, case_sensitive=False), text=text)        
 
     @staticmethod
-    def from_string(string: str)->Token:
+    def from_string(string: str) -> Token:
         return Token(token_type=token_type_from_string(None, string, case_sensitive=False), text=string)
 
 
@@ -136,7 +147,7 @@ class Generator(Algebra[ParseResult[T], GenState[T]]):
     def flat_map(self, f: Callable[[ParseResult[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]]]:
             try:
-                if not isinstance(input.ast, Then):
+                if not isinstance(input.ast, Then) or isinstance(input.ast, Nothing):
                     return Left(Error(this=self, 
                                       message=f"Expect Then got {input.ast}",
                                       state=input))
@@ -179,7 +190,7 @@ class Generator(Algebra[ParseResult[T], GenState[T]]):
                             pass
                 return Right((Many(value=tuple(ret)), input))
             else:
-                if not isinstance(input.ast, Many):
+                if not isinstance(input.ast, Many) or isinstance(input.ast, Nothing):
                     return Left(Error(this=self, 
                                       message=f"Expect Many got {input.ast}",
                                       state=input))
@@ -194,7 +205,7 @@ class Generator(Algebra[ParseResult[T], GenState[T]]):
                                         this=self,
                                         state=input.inject(x)
                                     ))                             
-                        case Left(_):
+                        case Left(e):
                             pass
                 if len(ret) < at_least:
                     return Left(Error(
@@ -210,22 +221,34 @@ class Generator(Algebra[ParseResult[T], GenState[T]]):
                 other: Algebra[ParseResult[T], GenState[T]]
                 ) -> Algebra[Choice[ParseResult[T], ParseResult[T]], GenState[T]]: 
         def or_else_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[Choice[ParseResult[T], ParseResult[T]], GenState[T]]]:
-            def exec(kind: ChoiceKind, 
+            def exec(kind: ChoiceKind | None, 
                      left: GenState[T], 
                      right: GenState[T])->Either[Any, Tuple[Choice[ParseResult[T], ParseResult[T]], GenState[T]]]:
                 match kind:
                     case ChoiceKind.LEFT:
                         match self.run(left, use_cache):
                             case Right((value, next_input)):
-                                return Right((Choice(kind=ChoiceKind.LEFT, left=value, right=None), next_input))
+                                return Right((Choice(kind=ChoiceKind.LEFT, value=value), next_input))
                             case Left(error):
                                 return Left(error)
                     case ChoiceKind.RIGHT:
                         match other.run(right, use_cache):
                             case Right((value, next_input)):
-                                return Right((Choice(kind=ChoiceKind.RIGHT, left=None, right=value), next_input))
+                                return Right((Choice(kind=ChoiceKind.RIGHT, value=value), next_input))
                             case Left(error):
                                 return Left(error)
+                    case None:
+                        match self.run(left, use_cache):
+                            case Right((value, next_input)):
+                                return Right((Choice(kind=ChoiceKind.LEFT, value=value), next_input))
+                            case Left(error):
+                                if isinstance(error, Error) and error.committed:
+                                    return Left(replace(error, committed=False))
+                                match other.run(left, use_cache):
+                                    case Right((value, next_input)):
+                                        return Right((Choice(kind=ChoiceKind.RIGHT, value=value), next_input))
+                                    case Left(error):
+                                        return Left(error)
                 raise ValueError(f"Invalid ChoiceKind: {kind}")
 
             if input.pruned:
@@ -233,14 +256,14 @@ class Generator(Algebra[ParseResult[T], GenState[T]]):
                 which = forked_input.rng("or_else").choice((ChoiceKind.LEFT, ChoiceKind.RIGHT))
                 return exec(which, forked_input, forked_input)
             else:
-                if isinstance(input.ast, Choice):
-                    return exec(input.ast.kind, 
-                                input.inject(input.ast.left), 
-                                input.inject(input.ast.right))
-                else:
+                if not isinstance(input.ast, Choice) or isinstance(input.ast, Nothing):
                     return Left(Error(this=self, 
                                       message=f"Expect Choice got {input.ast}",
                                       state=input))
+                else:
+                    return exec(input.ast.kind, 
+                                input.inject(input.ast.value), 
+                                input.inject(input.ast.value))
         return self.__class__(or_else_run, name=f"or_else({self.name} | {other.name})") # type: ignore
 
     @classmethod
@@ -259,7 +282,7 @@ class Generator(Algebra[ParseResult[T], GenState[T]]):
                 current = input.ast
                 if not isinstance(current, Token) or not gen.is_valid(current):
                     return Left(Error(None, 
-                                      message=f"Expected a Token, but got {type(current)}.", 
+                                      message=f"Expected a Token({gen.text}), but got {current}.", 
                                       state=input))
                 return Right((current, input))
         lazy_self = cls(token_run, name=cls.__name__ + f'.token({token_type or text or regex})')  # type: ignore

syncraft/parser.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 import re
 from sqlglot import tokenize, TokenType, Parser as GlotParser, exp
 from typing import (
-    Optional, List, Any, Tuple,
+    Optional, List, Any, Tuple, TypeVar,
     Generic
 )
 from syncraft.algebra import (
@@ -13,9 +13,11 @@ from enum import Enum
 from functools import reduce
 from syncraft.syntax import Syntax
 
-from syncraft.ast import Token, TokenSpec, AST, T, Bindable
+from syncraft.ast import Token, TokenSpec, AST, TokenProtocol
+from syncraft.constraint import Bindable
 
 
+T = TypeVar('T', bound=TokenProtocol)
 @dataclass(frozen=True)
 class ParserState(Bindable, Generic[T]):
     input: Tuple[T, ...] = field(default_factory=tuple)

syncraft/syntax.py

@@ -8,20 +8,22 @@ from dataclasses import dataclass, field, replace
 from functools import reduce
 from syncraft.algebra import Algebra, Error, Either, Right
 from syncraft.constraint import Variable, Bindable
-from syncraft.ast import Then, ThenKind, Marked
+from syncraft.ast import Then, ThenKind, Marked, Choice, Many, ChoiceKind, Nothing, Collect, E, Collector
 from types import MethodType, FunctionType
 
-
+from rich import print
 
 
 A = TypeVar('A')  # Result type
 B = TypeVar('B')  # Result type for mapping
 C = TypeVar('C')  # Result type for else branch
+D = TypeVar('D')  # Result type for else branch
 S = TypeVar('S', bound=Bindable)  # State type
 
 
 
 
+
 @dataclass(frozen=True)
 class Description:
     name: Optional[str] = None
@@ -134,49 +136,50 @@ class Syntax(Generic[A, S]):
 ######################################################## value transformation ########################################################
     def map(self, f: Callable[[A], B]) -> Syntax[B, S]:
         return self.__class__(lambda cls: self.alg(cls).map(f), meta = self.meta) # type: ignore
-    
-    def imap(self, f: Callable[[B], A]) -> Syntax[A, S]:
-        return self.__class__(lambda cls: self.alg(cls).imap(f), meta=self.meta)
-    
-    def bimap(self, f: Callable[[A], B], i: Callable[[B], A]) -> Syntax[A, S]:
-        return self.__class__(lambda cls: self.alg(cls).bimap(f, i), meta=self.meta)
+        
+    def bimap(self, f: Callable[[A], B], i: Callable[[B], A]) -> Syntax[B, S]:
+        return self.__class__(lambda cls: self.alg(cls).bimap(f, i), meta=self.meta) # type: ignore
 
-    def map_all(self, f: Callable[[Either[Any, Tuple[A, S]]], Either[Any, Tuple[B, S]]]) -> Syntax[B, S]:
+    def map_all(self, f: Callable[[A, S], Tuple[B, S]]) -> Syntax[B, S]:
         return self.__class__(lambda cls: self.alg(cls).map_all(f), meta=self.meta) # type: ignore
-
+    
     def map_error(self, f: Callable[[Optional[Any]], Any]) -> Syntax[A, S]:
         return self.__class__(lambda cls: self.alg(cls).map_error(f), meta=self.meta)
     
-    def map_state(self, f: Callable[[S], S]) -> Syntax[A, S]:
-        return self.__class__(lambda cls: self.alg(cls).map_state(f), meta=self.meta)
+    def pre_state(self, f: Callable[[S], S]) -> Syntax[A, S]:
+        return self.__class__(lambda cls: self.alg(cls).pre_state(f), meta=self.meta)
     
+    def post_state(self, f: Callable[[S], S]) -> Syntax[A, S]:
+        return self.__class__(lambda cls: self.alg(cls).post_state(f), meta=self.meta)
 
     def flat_map(self, f: Callable[[A], Algebra[B, S]]) -> Syntax[B, S]:
         return self.__class__(lambda cls: self.alg(cls).flat_map(f)) # type: ignore
 
-    def many(self, *, at_least: int = 1, at_most: Optional[int] = None) -> Syntax[Tuple[A, ...], S]:
+    def many(self, *, at_least: int = 1, at_most: Optional[int] = None) -> Syntax[Many[A], S]:
         return self.__class__(lambda cls:self.alg(cls).many(at_least=at_least, at_most=at_most)).describe(name='*', # type: ignore
                                                  fixity='prefix', 
                                                  parameter=(self,))  
     
 ################################################ facility combinators ############################################################
 
-
-
-    def between(self, left: Syntax[Any, S], right: Syntax[Any, S]) -> Syntax[Then[Any, Then[A, Any]], S]:
+    def between(self, left: Syntax[B, S], right: Syntax[C, S]) -> Syntax[Then[B, Then[A, C]], S]:
         return left >> self // right
 
-    def sep_by(self, sep: Syntax[Any, S]) -> Syntax[Tuple[A, ...], S]:
-        return (self + (sep >> self).many().optional()).describe( # type: ignore
+    def sep_by(self, sep: Syntax[B, S]) -> Syntax[Then[A, Choice[Many[Then[B, A]], Optional[Nothing]]], S]:
+        ret: Syntax[Then[A, Choice[Many[Then[B, A]], Optional[Nothing]]], S] = (self + (sep >> self).many().optional())
+        return ret.describe( 
                     name='sep_by',
                     fixity='prefix',
                     parameter=(self, sep))
-    
-    def parens(self, sep: Syntax[Any, S], open: Syntax[Any, S], close: Syntax[Any, S]) -> Syntax[Any, S]:
+
+    def parens(self, 
+               sep: Syntax[C, S], 
+               open: Syntax[B, S], 
+               close: Syntax[D, S]) -> Syntax[Then[B, Then[Then[A, Choice[Many[Then[C, A]], Optional[Nothing]]], D]], S]:
         return self.sep_by(sep=sep).between(left=open, right=close)
             
-    def optional(self, default: Optional[B] = None) -> Syntax[Optional[A | B], S]:
-        return (self | success(default)).describe(name='~', fixity='prefix', parameter=(self,))
+    def optional(self) -> Syntax[Choice[A, Optional[Nothing]], S]:
+        return (self | success(Nothing())).describe(name='~', fixity='prefix', parameter=(self,))
 
 
     def cut(self) -> Syntax[A, S]:
@@ -184,63 +187,80 @@ class Syntax(Generic[A, S]):
 
 
 ####################################################### operator overloading #############################################
-    def __floordiv__(self, other: Syntax[B, S]) -> Syntax[Then[A, None], S]:
+    def __floordiv__(self, other: Syntax[B, S]) -> Syntax[Then[A, B], S]:
         other = other if isinstance(other, Syntax) else self.lift(other).as_(Syntax[B, S])
-        return self.__class__(
-            lambda cls: self.alg(cls).then_left(other.alg(cls))   # type: ignore
-            ).describe(name=ThenKind.LEFT.value, fixity='infix', parameter=(self, other)).as_(Syntax[Then[A, None], S]) 
+        ret: Syntax[Then[A, B], S] = self.__class__(lambda cls: self.alg(cls).then_left(other.alg(cls))) # type: ignore
+        return ret.describe(name=ThenKind.LEFT.value, fixity='infix', parameter=(self, other)).as_(Syntax[Then[A, B], S]) 
+
+    def __lshift__(self, other: Syntax[B, S]) -> Syntax[Then[A, B], S]:
+        return self.__floordiv__(other)
 
-    def __rfloordiv__(self, other: Syntax[B, S]) -> Syntax[Then[B, None], S]:
+    def __rfloordiv__(self, other: Syntax[B, S]) -> Syntax[Then[B, A], S]:
         other = other if isinstance(other, Syntax) else self.lift(other).as_(Syntax[B, S])
         return other.__floordiv__(self)
+        
+    def __rlshift__(self, other: Syntax[B, S]) -> Syntax[Then[B, A], S]:
+        return self.__rfloordiv__(other)
 
-    def __invert__(self) -> Syntax[A | None, S]:
-        return self.optional()
+    def __add__(self, other: Syntax[B, S]) -> Syntax[Then[A, B], S]:
+        other = other if isinstance(other, Syntax) else self.lift(other).as_(Syntax[B, S])
+        ret: Syntax[Then[A, B], S] = self.__class__(lambda cls: self.alg(cls).then_both(other.alg(cls))) # type: ignore
+        return ret.describe(name=ThenKind.BOTH.value, fixity='infix', parameter=(self, other)).as_(Syntax[Then[A, B], S]) 
 
     def __radd__(self, other: Syntax[B, S]) -> Syntax[Then[B, A], S]:
         other = other if isinstance(other, Syntax) else self.lift(other).as_(Syntax[B, S])
         return other.__add__(self)
 
-    def __add__(self, other: Syntax[B, S]) -> Syntax[Then[A, B], S]:
-        other = other if isinstance(other, Syntax) else self.lift(other).as_(Syntax[B, S])
-        return self.__class__( 
-            lambda cls: self.alg(cls).then_both(other.alg(cls)) # type: ignore
-            ).describe(name=ThenKind.BOTH.value, fixity='infix', parameter=(self, other))
-
-    def __rshift__(self, other: Syntax[B, S]) -> Syntax[Then[None, B], S]:
+    def __rshift__(self, other: Syntax[B, S]) -> Syntax[Then[A, B], S]:
         other = other if isinstance(other, Syntax) else self.lift(other).as_(Syntax[B, S])
-        return self.__class__(
-            lambda cls: self.alg(cls).then_right(other.alg(cls))   # type: ignore
-            ).describe(name=ThenKind.RIGHT.value, fixity='infix', parameter=(self, other)).as_(Syntax[Then[None, B], S])   
-
+        ret: Syntax[Then[A, B], S] = self.__class__(lambda cls: self.alg(cls).then_right(other.alg(cls))) # type: ignore
+        return ret.describe(name=ThenKind.RIGHT.value, fixity='infix', parameter=(self, other)).as_(Syntax[Then[A, B], S])   
 
-    def __rrshift__(self, other: Syntax[B, S]) -> Syntax[Then[None, A], S]:
+    def __rrshift__(self, other: Syntax[B, S]) -> Syntax[Then[B, A], S]:
         other = other if isinstance(other, Syntax) else self.lift(other).as_(Syntax[B, S])
         return other.__rshift__(self)  
-
-
-    def __or__(self, other: Syntax[B, S]) -> Syntax[A | B, S]:
+        
+    def __or__(self, other: Syntax[B, S]) -> Syntax[Choice[A, B], S]:
         other = other if isinstance(other, Syntax) else self.lift(other).as_(Syntax[B, S])
-        return self.__class__(lambda cls: self.alg(cls).or_else(other.alg(cls))).describe(name='|', fixity='infix', parameter=[self, other]) # type: ignore
-
+        ret: Syntax[Choice[A, B], S] = self.__class__(lambda cls: self.alg(cls).or_else(other.alg(cls))) # type: ignore
+        return ret.describe(name='|', fixity='infix', parameter=(self, other))
 
-    def __ror__(self, other: Syntax[B, S]) -> Syntax[A | B, S]:
+    def __ror__(self, other: Syntax[B, S]) -> Syntax[Choice[B, A], S]:
         other = other if isinstance(other, Syntax) else self.lift(other).as_(Syntax[B, S])
-        return other.__or__(self).as_(Syntax[A | B, S]) 
+        return other.__or__(self)
+
+    def __invert__(self) -> Syntax[Choice[A, Optional[Nothing]], S]:
+        return self.optional()
 
 
 ######################################################################## data processing combinators #########################################################
-    def bind(self, var: Variable) -> Syntax[A, S]:
-        def bind_v(result: Either[Any, Tuple[A, S]])->Either[Any, Tuple[A, S]]:
-            if isinstance(result, Right):
-                value, state = result.value
-                return Right((value, state.bind(var, value)))
-            return result
-        
-        ret = self.mark(var.name).map_all(bind_v) if var.name else self.map_all(bind_v) # type: ignore
+    def bind(self, 
+             var: Variable, 
+             collector: Optional[Type[E]]=None) -> Syntax[A | 
+                                                                   Marked[A] | 
+                                                                   Marked[Collect[A, E]] | 
+                                                                   Collect[A, E], S]:
+        def bind_v(v: A | Marked[A] | Marked[Collect[A, E]] | Collect[A, E], 
+                   s: S)->Tuple[A | Marked[A] | Marked[Collect[A, E]] | Collect[A, E], S]:
+            return v, s.bind(var, v)
+        if callable(collector):
+            ret = self.to(collector).mark(var.name).map_all(bind_v) if var.name else self.to(collector).map_all(bind_v) 
+        else:
+            ret = self.mark(var.name).map_all(bind_v) if var.name else self.map_all(bind_v)
         return ret.describe(name=f'bind({var.name})', fixity='postfix', parameter=(self,))
 
-    def mark(self, var: str) -> Syntax[A, S]:
+    def to(self, f: Collector[E])-> Syntax[Collect[A, E], S]:
+        def to_f(v: A) -> Collect[A, E]:
+            if isinstance(v, Collect):
+                return replace(v, collector=f)
+            else:
+                return Collect(collector=f, value=v)
+        def ito_f(c: Collect[A, E]) -> A:
+            return c.value if isinstance(c, Collect) else c
+        return self.bimap(to_f, ito_f).describe(name=f'to({f})', fixity='postfix', parameter=(self,))
+
+
+    def mark(self, var: str) -> Syntax[Marked[A], S]:
         def bind_s(value: A) -> Marked[A]:
             if isinstance(value, Marked):
                 return replace(value, name=var)    
@@ -278,17 +298,17 @@ def success(value: Any) -> Syntax[Any, Any]:
     return Syntax(lambda alg: alg.success(value)).describe(name=f'success({value})', fixity='prefix')
 
 def choice(*parsers: Syntax[Any, S]) -> Syntax[Any, S]:
-    return reduce(lambda a, b: a | b, parsers) if len(parsers) > 0 else success(None)
+    return reduce(lambda a, b: a | b, parsers) if len(parsers) > 0 else success(Nothing())
 
 
 def all(*parsers: Syntax[Any, S]) -> Syntax[Then[Any, Any], S]:
-    return reduce(lambda a, b: a + b, parsers) if len(parsers) > 0 else success(None)
+    return reduce(lambda a, b: a + b, parsers) if len(parsers) > 0 else success(Nothing())
 
 def first(*parsers: Syntax[Any, S]) -> Syntax[Any, S]:
-    return reduce(lambda a, b: a // b, parsers) if len(parsers) > 0 else success(None)
+    return reduce(lambda a, b: a // b, parsers) if len(parsers) > 0 else success(Nothing())
 
 def last(*parsers: Syntax[Any, S]) -> Syntax[Any, S]:
-    return reduce(lambda a, b: a >> b, parsers) if len(parsers) > 0 else success(None)
+    return reduce(lambda a, b: a >> b, parsers) if len(parsers) > 0 else success(Nothing())
 
 def bound(* parsers: Syntax[Any, S] | Tuple[str|Variable, Syntax[Any, S]]) -> Syntax[Any, S]:
     def is_named_parser(x: Any) -> bool:
@@ -325,5 +345,5 @@ def bound(* parsers: Syntax[Any, S] | Tuple[str|Variable, Syntax[Any, S]]) -> Sy
             else:
                 ret = ret >> just_parser
     
-    return ret if ret is not None else success(None) 
+    return ret if ret is not None else success(Nothing()) 
 

{syncraft-0.1.27.dist-info → syncraft-0.1.29.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncraft
-Version: 0.1.27
+Version: 0.1.29
 Summary: Parser combinator library
 Author-email: Michael Afmokt <michael@esacca.com>
 License-Expression: MIT
@@ -19,8 +19,6 @@ Syncraft is a parser/generator combinator library with full round-trip support:
 
 - Parse source code into AST or dataclasses
 - Generate source code from dataclasses
-- Bidirectional transformations via lenses
-- Convenience combinators: `all`, `first`, `last`, `named`
 - SQLite syntax support included
 
 ## Installation
@@ -33,5 +31,7 @@ pip install syncraft
 ## TODO
 - [ ] simplify the result of then_left and then_right by bimap the result in syntax.
 - [ ] simplify the result of sep_by and between by bimap the result in syntax
+- [ ] convert to dict/dataclass via bimap in syntax
+- [ ] define DSL over Variable to construct predicates
 - [ ] Try the parsing, generation, and data processing machinery on SQLite3 syntax. So that I can have direct feedback on the usability of this library and a fully functional SQLite3 library.
 - [ ] Make the library as fast as possible and feasible.

syncraft-0.1.29.dist-info/RECORD

@@ -0,0 +1,16 @@
+syncraft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syncraft/algebra.py,sha256=gXs4rD6Inp6kGf5Vd5kHGgmb2K_qFlWFQ09i7tmcCmo,15662
+syncraft/ast.py,sha256=MSzEvpXoEPxbLX_tYwKbvNEpPzyGc22-poGtHsc1S30,13747
+syncraft/constraint.py,sha256=uT-ELzvv8J-s-Y1VYkXePUezseqCLhqzYUzFBYs0HsE,6418
+syncraft/diagnostic.py,sha256=cgwcQnCcgrCRX3h-oGTDb5rcJAtitPV3LfH9eLvO93E,2837
+syncraft/finder.py,sha256=L75A0bAjdlntWk-Y1rCeINBOzGeGdE_zHrTmcpQ7m9g,1875
+syncraft/generator.py,sha256=C3N0Nxk9grN6iPxLHt1Ur2xzS5S-9LsNvMMc-ehd36E,12981
+syncraft/parser.py,sha256=RkQwFv00rOI-n4kvG4baGVTdK46T-_Hw7OJ0FB7g72g,11379
+syncraft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syncraft/sqlite3.py,sha256=Pq09IHZOwuWg5W82l9D1flzd36QV0TOHQpTJ5U02V8g,34701
+syncraft/syntax.py,sha256=a3g-qcTHpIicMO0KseHuKe5liNfYawLRO-M1eCBS6d4,16574
+syncraft-0.1.29.dist-info/licenses/LICENSE,sha256=wHSV424U5csa3339dy1AZbsz2xsd0hrkMx2QK48CcUk,1062
+syncraft-0.1.29.dist-info/METADATA,sha256=OcqydNw8LWB6R94v-AV_SS4-YSA6QxxTioAqnViK-2w,1204
+syncraft-0.1.29.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+syncraft-0.1.29.dist-info/top_level.txt,sha256=Kq3t8ESXB2xW1Xt3uPmkENFc-c4f2pamNmaURBk7zc8,9
+syncraft-0.1.29.dist-info/RECORD,,

syncraft-0.1.27.dist-info/RECORD

@@ -1,16 +0,0 @@
-syncraft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-syncraft/algebra.py,sha256=FBy0cCl4RGnsi1uxoIIZPRcHgfHxWwUal9iLV_Mtc6I,14791
-syncraft/ast.py,sha256=5WW3NsnCWWPLHr1tP2dDrZQgkl03h4xsz9zJsaABaq0,5049
-syncraft/constraint.py,sha256=uT-ELzvv8J-s-Y1VYkXePUezseqCLhqzYUzFBYs0HsE,6418
-syncraft/diagnostic.py,sha256=cgwcQnCcgrCRX3h-oGTDb5rcJAtitPV3LfH9eLvO93E,2837
-syncraft/finder.py,sha256=GJYnUyBlteMb9gblVKkwy_vVxOMxTwP5P80tWA3kM2Q,1813
-syncraft/generator.py,sha256=CGasCEu79ce8pC56Lb6_gcGCS7pHN6MERv5OEh_Cl-c,11751
-syncraft/parser.py,sha256=UpNtTckygIwWG8cX2ZvdEcUi3Il8gpC7aZAzPKx2crg,11289
-syncraft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-syncraft/sqlite3.py,sha256=Pq09IHZOwuWg5W82l9D1flzd36QV0TOHQpTJ5U02V8g,34701
-syncraft/syntax.py,sha256=JqydSdFkD4Bj0A-S6tqM47ZSbDQEoioNBhOy0WqCEY8,15005
-syncraft-0.1.27.dist-info/licenses/LICENSE,sha256=wHSV424U5csa3339dy1AZbsz2xsd0hrkMx2QK48CcUk,1062
-syncraft-0.1.27.dist-info/METADATA,sha256=vF7-9O08fDH43chYaXyXqKNvwPwuWbIfrROdSCag2wA,1199
-syncraft-0.1.27.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-syncraft-0.1.27.dist-info/top_level.txt,sha256=Kq3t8ESXB2xW1Xt3uPmkENFc-c4f2pamNmaURBk7zc8,9
-syncraft-0.1.27.dist-info/RECORD,,