syncraft 0.1.26__tar.gz → 0.1.28__tar.gz

{syncraft-0.1.26 → syncraft-0.1.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncraft
-Version: 0.1.26
+Version: 0.1.28
 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.26 → syncraft-0.1.28}/README.md

@@ -4,8 +4,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
@@ -18,5 +16,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.26 → syncraft-0.1.28}/pyproject.toml

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

{syncraft-0.1.26 → syncraft-0.1.28}/syncraft/algebra.py

@@ -128,10 +128,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 +138,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 +232,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 +271,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 +286,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 +300,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-0.1.28/syncraft/ast.py

@@ -0,0 +1,378 @@
+
+
+from __future__ import annotations
+import re
+from typing import (
+    Optional, Any, TypeVar, Tuple, runtime_checkable, Self,
+    Dict, Generic, Callable, Union, Protocol, Type
+)
+
+
+from dataclasses import dataclass
+from enum import Enum
+from syncraft.constraint import Bindable
+
+
+
+A = TypeVar('A')
+B = TypeVar('B')  
+C = TypeVar('C')  
+D = TypeVar('D')
+S = TypeVar('S', bound=Bindable)  
+
+@dataclass(frozen=True)
+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 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)))
+    
+@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] | 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[A, A]:
+        return Bimap(lambda a: (a, lambda b: b))
+
+    @staticmethod
+    def when(cond: Callable[[A], bool],
+             then: Bimap[A, B],
+             otherwise: Optional[Bimap[A, C]] = None) -> Bimap[A, A | B | C]:
+        def when_run(a:A) -> Tuple[A | B | C, Callable[[A | B | C], A]]:
+            bimap = then if cond(a) else (otherwise if otherwise is not None else Bimap.identity())
+            abc, inv = bimap(a)
+            def inv_f(b: Any) -> A:
+                return inv(b)
+            return abc, inv_f
+        return Bimap(when_run)
+    
+    
+
+    
+
+@dataclass(frozen=True)    
+class AST:
+    def walk(self, r: Reducer[Any, S], s: S) -> S:
+        return s
+
+@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 walk(self, r: Reducer[A, S], s: S) -> S:
+        return self.value.walk(r, s) if isinstance(self.value, AST) else r(self.value, s)
+
+
+class DataclassProtocol(Protocol):
+    __dataclass_fields__: dict
+
+E = TypeVar("E")
+@dataclass(frozen=True)
+class Collect(Generic[A, E], AST): 
+    collector: Type[E]
+    value: A
+
+class ChoiceKind(Enum):
+    LEFT = 'left'
+    RIGHT = 'right'
+
+@dataclass(frozen=True)
+class Choice(Generic[A, B], AST):
+    kind: Optional[ChoiceKind]
+    value: Optional[A | B] = None
+    def walk(self, r: Reducer[A | B, S], s: S) -> S:
+        if self.value is not None:
+            if isinstance(self.value, AST):
+                return self.value.walk(r, s)
+            else:
+                return r(self.value, s)
+        return s
+
+@dataclass(frozen=True)
+class Many(Generic[A], AST):
+    value: Tuple[A, ...]
+    def walk(self, r: Reducer[A, S], s: S) -> S:
+        for item in self.value:
+            if isinstance(item, AST):
+                s = item.walk(r, s)
+            else:
+                s = r(item, s)
+        return s
+
+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: A
+    right: B
+    def walk(self, r: Reducer[A | B, S], s: S) -> S:
+        if isinstance(self.left, AST):
+            s = self.left.walk(r, s)
+        else:
+            s = r(self.left, s)
+        if isinstance(self.right, AST):
+            s = self.right.walk(r, s)
+        else:
+            s = r(self.right, s)
+        return s
+
+@dataclass(frozen=True)
+class Token(AST):
+    token_type: Enum
+    text: str
+    def __str__(self) -> str:
+        return f"{self.token_type.name}({self.text})"
+    
+    def __repr__(self) -> str:
+        return self.__str__()
+    
+    def walk(self, r: Reducer['Token', S], s: S) -> S:
+        return r(self, s)
+
+        
+@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:
+    token_type: Optional[Enum] = None
+    text: Optional[str] = None
+    case_sensitive: bool = False
+    regex: Optional[re.Pattern[str]] = None
+        
+    def is_valid(self, token: TokenProtocol) -> bool:
+        type_match = self.token_type is None or token.token_type == self.token_type
+        value_match = self.text is None or (token.text.strip() == self.text.strip() if self.case_sensitive else 
+                                                    token.text.strip().upper() == self.text.strip().upper())
+        value_match = value_match or (self.regex is not None and self.regex.fullmatch(token.text) is not None)
+        return type_match and value_match
+
+
+ParseResult = Union[
+    Then['ParseResult[T]', 'ParseResult[T]'], 
+    Marked['ParseResult[T]'],
+    Choice['ParseResult[T]', 'ParseResult[T]'],
+    Many['ParseResult[T]'],
+    Nothing,
+    T,
+]
+
+
+
+"""
+    @staticmethod
+    def collect_marked(a: FlatThen, f: Optional[Callable[..., Any]] = None)->Tuple[MarkedThen, Callable[[MarkedThen], FlatThen]]:
+        index: List[str | int] = []
+        named_count = 0
+        for i, v in enumerate(a):
+            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 a if isinstance(v, Marked)}
+        unnamed = [v for v in a if not isinstance(v, Marked)]
+        if f is None:
+            ret = (named, tuple(unnamed))
+        else:
+            ret = (f(**named), tuple(unnamed))
+        def invf(b: MarkedThen) -> Tuple[Any, ...]:
+            named_value, unnamed_value = b 
+            assert isinstance(named_value, dict) or is_dataclass(named_value), f"Expected dict or dataclass for named values, got {type(named_value)}"
+            if is_dataclass(named_value):
+                named_dict = named | asdict(cast(Any, named_value))    
+            else:
+                named_dict = named | named_value
+            ret = []
+            for x in index:
+                if isinstance(x, str):
+                    assert x in named_dict, f"Missing named value: {x}"
+                    ret.append(named_dict[x])
+                else:
+                    assert 0 <= x < len(unnamed_value), f"Missing unnamed value at index: {x}"
+                    ret.append(unnamed_value[x])
+            return tuple(ret)
+        return ret, invf
+
+    def bimap(self, f: Bimap[Any, Any]=Bimap.identity()) -> Tuple[FlatThen, Callable[[FlatThen], Then[A, B]]]:
+        match self.kind:
+            case ThenKind.LEFT:
+                lb, linv = self.left.bimap(f) if isinstance(self.left, AST) else f(self.left)
+                return lb, lambda b: replace(self, left=linv(b))
+            case ThenKind.RIGHT:
+                rb, rinv = self.right.bimap(f) if isinstance(self.right, AST) else f(self.right)
+                return rb, lambda b: replace(self, right=rinv(b))
+            case ThenKind.BOTH:
+                lb, linv = self.left.bimap(f) if isinstance(self.left, AST) else f(self.left)
+                rb, rinv = self.right.bimap(f) if isinstance(self.right, AST) else f(self.right)
+                left_v = (lb,) if not isinstance(self.left, Then) else lb
+                right_v = (rb,) if not isinstance(self.right, Then) else rb
+                def invf(b: Tuple[Any, ...]) -> 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 = b[:left_size]
+                    rraw = 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=la, right=ra)
+                return left_v + right_v, invf
+            
+    def bimap_collected(self, f: Bimap[Any, Any]=Bimap.identity()) -> Tuple[MarkedThen, Callable[[MarkedThen], Then[A, B]]]:
+        data, invf = self.bimap(f)                
+        data, func = Then.collect_marked(data)
+        return data, lambda d: invf(func(d))
+
+
+    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
+
+
+"""

{syncraft-0.1.26 → syncraft-0.1.28}/syncraft/finder.py

@@ -1,18 +1,18 @@
 from __future__ import annotations
 
 from typing import (
-    Any, Tuple, Optional, Generator as YieldGen
+    Any, Tuple, Generator as YieldGen
 )
-from dataclasses import dataclass, replace
+from dataclasses import dataclass
 from syncraft.algebra import (
     Algebra, Either, Right, 
 )
 from syncraft.ast import T, ParseResult, Choice, Many, Then, Marked
 
 from syncraft.generator import GenState, Generator
-from sqlglot import TokenType
+
 from syncraft.syntax import Syntax
-import re
+
 
 
 @dataclass(frozen=True)

{syncraft-0.1.26 → syncraft-0.1.28}/syncraft/generator.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from typing import (
-    Any, TypeVar, Tuple, Optional,  Callable, Generic, cast,
+    Any, TypeVar, Tuple, Optional,  Callable, Generic, 
     List, 
 )
 from functools import cached_property
@@ -11,8 +11,8 @@ from syncraft.algebra import (
 )
 
 from syncraft.ast import (
-    T, ParseResult, AST, Token, TokenSpec, Binding, Variable, 
-    Bindable, 
+    T, ParseResult, AST, Token, TokenSpec, 
+    Bindable, Nothing,
     Choice, Many, ChoiceKind,
     Then, ThenKind, Marked
 )
@@ -23,7 +23,7 @@ import re
 import rstr
 from functools import lru_cache
 import random
-
+from rich import print
 B = TypeVar('B')
 
 
@@ -136,7 +136,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 +179,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 +194,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 +210,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 +245,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 +271,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-0.1.26 → syncraft-0.1.28}/syncraft/syntax.py

@@ -1,27 +1,29 @@
 from __future__ import annotations
 
 from typing import (
-    Optional, List, Any, TypeVar, Generic, Callable, Tuple, cast,
+    Optional, Any, TypeVar, Generic, Callable, Tuple, cast,
     Type, Literal
 )
 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
 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: Type[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.26 → syncraft-0.1.28}/syncraft.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncraft
-Version: 0.1.26
+Version: 0.1.28
 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.26 → syncraft-0.1.28}/tests/test_bimap.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from syncraft.ast import Then, ThenKind, Many
+from syncraft.ast import Then, ThenKind, Many, Choice, ChoiceKind, Token
 from syncraft.algebra import Error
 from syncraft.parser import literal, parse
 import syncraft.generator as gen
@@ -248,7 +248,7 @@ def test_ambiguous() -> None:
     sql = "a"
     ast = parse(syntax, sql, dialect="sqlite")
     # Does it prefer A (shorter) or B (fails)? Depends on design.
-    # assert ast == Choice(TokenGen.from_string("a"))
+    assert ast == Choice[Token, Token](value=TokenGen.from_string("a"), kind=ChoiceKind.LEFT)
 
 
 def test_combo() -> None:
@@ -258,8 +258,11 @@ def test_combo() -> None:
     syntax = ((A + B).many() | C) + B
     sql = "a b a b c b"
     # Should fail, as we discussed earlier
+    # the working syntax should be ((A + B) | C).many() + B
     ast = parse(syntax, sql, dialect="sqlite")
     assert isinstance(ast, Error)
+    ast = parse(((A + B) | C).many() + B, sql, dialect="sqlite")
+    assert not isinstance(ast, Error)
 
 
 def test_optional():

syncraft-0.1.26/syncraft/ast.py

@@ -1,187 +0,0 @@
-
-
-from __future__ import annotations
-import re
-from typing import (
-    Optional, Any, TypeVar, Tuple, runtime_checkable, 
-    Dict, Generic, Callable, Union, cast, List, Protocol, Type
-)
-
-
-from dataclasses import dataclass, replace, is_dataclass, asdict
-from enum import Enum
-
-from syncraft.constraint import Binding, Variable, Bindable
-
-
-
-A = TypeVar('A')
-B = TypeVar('B')  
-C = TypeVar('C')  
-S = TypeVar('S', bound=Bindable)  
-
-@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)
-    
-
-    
-@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)
-    @staticmethod
-    def const(a: B)->Bimap[B, B]:
-        return Bimap(lambda _: (a, lambda b: b))
-
-    @staticmethod
-    def identity()->Bimap[Any, Any]:
-        return Bimap(lambda a: (a, lambda b: b))
-
-    @staticmethod
-    def when(cond: Callable[[A], bool],
-             then: Bimap[A, B],
-             otherwise: Optional[Bimap[A, C]] = None) -> Bimap[A, A | B | C]:
-        def when_run(a:A) -> Tuple[A | B | C, Callable[[A | B | C], A]]:
-            bimap = then if cond(a) else (otherwise if otherwise is not None else Bimap.identity())
-            abc, inv = bimap(a)
-            def inv_f(b: Any) -> A:
-                return inv(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
-    
-
-@dataclass(frozen=True)    
-class AST:
-    pass
-
-class ChoiceKind(Enum):
-    LEFT = 'left'
-    RIGHT = 'right'
-@dataclass(frozen=True)
-class Choice(Generic[A, B], AST):
-    kind: ChoiceKind
-    left: Optional[A] 
-    right: Optional[B] 
-
-
-@dataclass(frozen=True)
-class Many(Generic[A], AST):
-    value: Tuple[A, ...]
-
-@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: ...
-    
-
-@dataclass(frozen=True)
-class Token:
-    token_type: Enum
-    text: str
-    def __str__(self) -> str:
-        return f"{self.token_type.name}({self.text})"
-    
-    def __repr__(self) -> str:
-        return self.__str__()
-
-    
-
-@dataclass(frozen=True)
-class TokenSpec:
-    token_type: Optional[Enum] = None
-    text: Optional[str] = None
-    case_sensitive: bool = False
-    regex: Optional[re.Pattern[str]] = None
-        
-    def is_valid(self, token: TokenProtocol) -> bool:
-        type_match = self.token_type is None or token.token_type == self.token_type
-        value_match = self.text is None or (token.text.strip() == self.text.strip() if self.case_sensitive else 
-                                                    token.text.strip().upper() == self.text.strip().upper())
-        value_match = value_match or (self.regex is not None and self.regex.fullmatch(token.text) is not None)
-        return type_match and value_match
-
-
-
-
-T = TypeVar('T', bound=TokenProtocol)  
-
-
-ParseResult = Union[
-    Then['ParseResult[T]', 'ParseResult[T]'], 
-    Marked['ParseResult[T]'],
-    Choice['ParseResult[T]', 'ParseResult[T]'],
-    Many['ParseResult[T]'],
-    T,
-]
-
-
-