syncraft 0.2.9__tar.gz → 0.2.10__tar.gz

{syncraft-0.2.9/syncraft.egg-info → syncraft-0.2.10}/PKG-INFO

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

{syncraft-0.2.9 → syncraft-0.2.10}/pyproject.toml

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

{syncraft-0.2.9 → syncraft-0.2.10}/syncraft/algebra.py

@@ -8,6 +8,7 @@ from dataclasses import dataclass, replace
 from syncraft.ast import ThenKind, Then, Choice, Many, ChoiceKind, shallow_dict, SyncraftError
 from syncraft.cache import Cache
 from syncraft.constraint import Bindable
+from functools import cached_property
 from rich import print
 
 
@@ -76,16 +77,22 @@ class Error:
 class Algebra(Generic[A, S]):
 ######################################################## shared among all subclasses ########################################################
     run_f: Callable[[S, bool], Generator[Incomplete[S], S, Either[Any, Tuple[A, S]]]] 
-    name: Hashable
+    name: str
     cache: Cache[Either[Any, Tuple[A, S]]]
+    
 
     @classmethod
     def state(cls, **kwargs:Any)->Optional[S]: 
         return None
         
-    def named(self, name: Hashable) -> 'Algebra[A, S]':
+    def named(self, name: str) -> Algebra[A, S]:
         return replace(self, name=name)
-        
+
+    @cached_property
+    def hashable(self)->Hashable:
+        return frozenset({'name': self.name, 'run_f': self.run_f})
+
+
     def __call__(self, input: S, use_cache: bool) -> Generator[Incomplete[S], S, Either[Any, Tuple[A, S]]]:
         return self.run(input, use_cache=use_cache)
 
@@ -366,7 +373,7 @@ class Algebra(Generic[A, S]):
             def map_all_run_f(input:S, use_cache:bool) -> Generator[Incomplete[S], S, Either[Any, Tuple[B, S]]]:
                 yield from ()
                 return Right(f(a, input))
-            return self.__class__(map_all_run_f, name=self.name, cache=self.cache) # type: ignore
+            return self.__class__(map_all_run_f, name=self.name, cache=self.cache)  # type: ignore
         return self.flat_map(map_all_f)
 
 

{syncraft-0.2.9 → syncraft-0.2.10}/syncraft/ast.py

@@ -5,11 +5,11 @@ import re
 from typing import (
     Optional, Any, TypeVar, Tuple, runtime_checkable, cast,
     Generic, Callable, Union, Protocol, Type, List, ClassVar,
-    Dict
+    Dict, Hashable
 )
 
 
-from dataclasses import dataclass, replace, is_dataclass, fields
+from dataclasses import dataclass, replace, is_dataclass, fields, field
 from enum import Enum
 
 
@@ -480,26 +480,51 @@ T = TypeVar('T', bound=TokenProtocol)
 
 @dataclass(frozen=True)
 class SyntaxSpec:
-    pass
-@dataclass(frozen=True)
-class ChoiceSpec(SyntaxSpec, Generic[A, B]):
-    left: A
-    right: B
+    id: int = field(init=False)
+    def __post_init__(self) -> None:
+        object.__setattr__(self, 'id', id(self))
 
 @dataclass(frozen=True)
+class RefSpec(SyntaxSpec, Generic[A]):
+    ref: int | A 
+    referent: str
+@dataclass(frozen=True)
 class LazySpec(SyntaxSpec, Generic[A]):
+    name: str
     value: None | A
 @dataclass(frozen=True)
 class ThenSpec(SyntaxSpec, Generic[A, B]):
+    name: str
     kind: ThenKind
     left: A
     right: B
+    # def __repr__(self) -> str:
+    #     return f"ThenSpec(id={id(self)}, kind={self.kind}, left={self.left}, right={self.right})"
+    # def __str__(self) -> str:
+    #     return self.__repr__()
+
+@dataclass(frozen=True)
+class ChoiceSpec(SyntaxSpec, Generic[A, B]):
+    name: str
+    left: A
+    right: B
+
+    # def __repr__(self) -> str:
+    #     return f"ChoiceSpec(id={id(self)}, left={self.left}, right={self.right})"
+    # def __str__(self) -> str:
+    #     return self.__repr__()
 
 @dataclass(frozen=True)
 class ManySpec(SyntaxSpec, Generic[A]):
+    name: str
     value: A
     at_least: int
     at_most: Optional[int]
+    # def __repr__(self) -> str:
+    #     return f"ManySpec(id={id(self)}, value={self.value}, at_least={self.at_least}, at_most={self.at_most})"
+    # def __str__(self) -> str:
+    #     return self.__repr__()
+
 
 
 @dataclass(frozen=True)
@@ -509,6 +534,19 @@ class TokenSpec(SyntaxSpec):
     case_sensitive: bool = False
     regex: Optional[re.Pattern[str]] = None
 
+    def __repr__(self) -> str:
+        parts = []
+        if self.token_type is not None:
+            parts.append(f"type={self.token_type.name}")
+        if self.text is not None:
+            parts.append(f"text={'`'+self.text+'`' if self.case_sensitive else self.text}")
+        if self.regex is not None:
+            parts.append(f"regex=/{self.regex.pattern}/")
+        return f"TokenSpec(id={id(self)}, " + ", ".join(parts) + ")"
+        
+    def __str__(self) -> str:
+        return self.__repr__()
+    
     @classmethod
     def create(cls, 
                *, 

{syncraft-0.2.9 → syncraft-0.2.10}/syncraft/syntax.py

@@ -107,7 +107,7 @@ class Syntax(Generic[A, S]):
         *,
         name: Optional[str] = None,
         fixity: Optional[Literal['infix', 'prefix', 'postfix']] = None,
-        parameter: Optional[Tuple[Syntax[Any, S], ...]] = None,
+        parameter: Optional[Tuple[Syntax[Any, S] | Any, ...]] = None,
     ) -> Syntax[A, S]:
         return self.__class__(
             alg=self.alg,
@@ -116,7 +116,16 @@ class Syntax(Generic[A, S]):
             ),
         )
 
+    def named(self, name: str) -> Syntax[A, S]:
+        """Assign a name to this syntax node for better debugging output.
 
+        Args:
+            name: Name to assign; must be a valid identifier.
+
+        Returns:
+            Syntax with the given name.
+        """
+        return self.__class__(lambda cls, cache: self(cls, cache).named(name), meta=self.meta)
     ######################################################## value transformation ########################################################
     def map(self, f: Callable[[A], B]) -> Syntax[B, S]:
         """Map the produced value while preserving state and metadata.
@@ -219,7 +228,7 @@ class Syntax(Generic[A, S]):
         Returns:
             Syntax producing nested Then with all parts.
         """
-        return left >> self // right
+        return (left >> self // right).describe(name='between', fixity='postfix', parameter=(self, left, right)) 
 
     def sep_by(self, sep: Syntax[B, S]) -> Syntax[Then[A, Choice[Many[Then[B, A]], Optional[Nothing]]], S]:
         """Parse one or more items separated by sep.
@@ -316,7 +325,7 @@ class Syntax(Generic[A, S]):
         Returns:
             Syntax that marks downstream failures as committed.
         """
-        return self.__class__(lambda cls, cache: self(cls, cache).cut())
+        return self.__class__(lambda cls, cache: self(cls, cache).cut()).describe(name='cut', fixity='postfix', parameter=(self,))
 
     ###################################################### operator overloading #############################################
     def __floordiv__(self, other: Syntax[B, S]) -> Syntax[Then[A, B], S]:
@@ -433,7 +442,7 @@ class Syntax(Generic[A, S]):
             else:
                 return v, s
 
-        return self.map_all(bind_v).describe(name=f'bind({name})', fixity='postfix', parameter=(self,))
+        return self.map_all(bind_v).describe(name='bind', fixity='infix', parameter=(self, name))
 
     def to(self, f: Collector[E]) -> Syntax[Collect[A, E], S]:
         """Attach a collector to the produced value.
@@ -457,7 +466,7 @@ class Syntax(Generic[A, S]):
         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,))
+        return self.bimap(to_f, ito_f).describe(name='to', fixity='infix', parameter=(self, f))
 
     def mark(self, name: str) -> Syntax[Marked[A], S]:
         """Mark the produced value with a name.
@@ -481,7 +490,7 @@ class Syntax(Generic[A, S]):
         def imark_s(m: Marked[A]) -> A:
             return m.value if isinstance(m, Marked) else m
 
-        return self.bimap(mark_s, imark_s).describe(name=f'mark("{name}")', fixity='postfix', parameter=(self,))
+        return self.bimap(mark_s, imark_s).describe(name='mark', fixity='infix', parameter=(self, name))
     
 def when(f: Callable[[], bool], then: Syntax[A, S], otherwise: Syntax[B, S]) -> Syntax[A | B, S]:
     """
@@ -495,7 +504,7 @@ def when(f: Callable[[], bool], then: Syntax[A, S], otherwise: Syntax[B, S]) ->
     Returns:
         A Syntax object representing the chosen branch.
     """
-    return lazy(lambda: then if f() else otherwise).describe(name='when(?)', fixity='postfix', parameter=(then, otherwise)) # type: ignore
+    return lazy(lambda: then if f() else otherwise).describe(name='when', fixity='postfix', parameter=(then, otherwise)) # type: ignore
 
 def fail(error: Any) -> Syntax[Any, Any]:
     """
@@ -507,7 +516,7 @@ def fail(error: Any) -> Syntax[Any, Any]:
     Returns:
         A Syntax object that always fails.
     """
-    return Syntax(lambda alg, cache: alg.fail(error, cache=cache)).describe(name=f'fail({error})', fixity='prefix')
+    return Syntax(lambda alg, cache: alg.fail(error, cache=cache)).describe(name='fail', fixity='prefix', parameter=(error,))
 
 def success(value: Any) -> Syntax[Any, Any]:
     """
@@ -519,7 +528,7 @@ def success(value: Any) -> Syntax[Any, Any]:
     Returns:
         A Syntax object that always succeeds.
     """
-    return Syntax(lambda alg, cache: alg.success(value, cache=cache)).describe(name=f'success({value})', fixity='prefix')
+    return Syntax(lambda alg, cache: alg.success(value, cache=cache)).describe(name='success', fixity='prefix', parameter=(value,))
 
 
 
@@ -581,7 +590,7 @@ def lazy(thunk: Callable[[], Syntax[A, S]]) -> Syntax[A, S]:
             algebra = cls.lazy(algebra_lazy_f, cache=cache)
             previous_cls = cls
         return algebra
-    return Syntax(syntax_lazy_run).describe(name='lazy(?)', fixity='postfix') 
+    return Syntax(syntax_lazy_run).describe(name='lazy', fixity='prefix', parameter=(lambda: syntax,))  
 
 
 

syncraft-0.2.10/syncraft/walker.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+from typing import (
+    Any, Tuple, Generator as PyGenerator, TypeVar, Generic, Optional, Callable, Hashable
+)
+from dataclasses import dataclass, replace, field
+from syncraft.algebra import (
+    Algebra, Either, Right, Incomplete, Left, SyncraftError
+)
+from syncraft.ast import TokenSpec, ThenSpec, ManySpec, ChoiceSpec, LazySpec, ThenKind, RefSpec
+from syncraft.parser import TokenType
+from syncraft.constraint import Bindable, FrozenDict
+
+import re
+from syncraft.syntax import Syntax
+from syncraft.cache import Cache, RecursionError
+from rich import print
+
+
+S = TypeVar('S', bound=Bindable)
+A = TypeVar('A')
+B = TypeVar('B')
+SS = TypeVar('SS', bound=Hashable)
+
+
+@dataclass(frozen=True)
+class WalkerState(Bindable):
+    visited: FrozenDict = field(default_factory=FrozenDict)
+    def visit(self, algebra: Algebra, data: Hashable) -> WalkerState:
+        return replace(self, visited=self.visited | FrozenDict({algebra.hashable: data}))
+
+        
+
+@dataclass(frozen=True)
+class Walker(Algebra[Any, WalkerState]):
+    @classmethod
+    def state(cls, **kwargs: Any)->WalkerState:
+        return WalkerState()
+
+    def map(self, f: Callable[[Any], Any]) -> Algebra[Any, WalkerState]:
+        return self
+
+    def map_state(self, f: Callable[[WalkerState], WalkerState]) -> Algebra[Any, WalkerState]:
+        return self
+    
+    def bimap(self, f: Callable[[Any], Any], g: Callable[[Any], Any]) -> Algebra[Any, WalkerState]:
+        return self
+
+    def map_all(self, f: Callable[[Any, WalkerState], Tuple[Any, WalkerState]]) -> Algebra[Any, WalkerState]:
+        return self
+    
+    def flat_map(self, f: Callable[[Any], Algebra[Any, WalkerState]]) -> Algebra[Any, WalkerState]:
+        return self
+
+    def run(self, 
+            input: WalkerState, 
+            use_cache: bool = True
+            ) -> PyGenerator[Incomplete[WalkerState], WalkerState, Either[Any, Tuple[Any, WalkerState]]]:
+        try:
+            if self.hashable in input.visited:
+                ref = input.visited[self.hashable]
+                return Right((RefSpec(ref=id(ref), referent= '' if not hasattr(ref, 'name') else ref.name), input))
+            return (yield from self.cache.gen(self.run_f, input, use_cache))
+        except RecursionError as e:
+            if self.hashable in input.visited:
+                ref = input.visited[self.hashable]
+                return Right((RefSpec(ref=id(ref), referent= '' if not hasattr(ref, 'name') else ref.name), input))
+            else:
+                return Right((RefSpec(ref=e.offending, referent=''), input))
+        
+    @classmethod
+    def token(cls, 
+              *,
+              cache: Cache,
+              token_type: Optional[TokenType] = None, 
+              text: Optional[str] = None, 
+              case_sensitive: bool = False,
+              regex: Optional[re.Pattern[str]] = None
+              )-> Algebra[Any, WalkerState]:      
+        name = f'Token({token_type or text or (regex.pattern if regex else "")})'
+        this: None | Algebra[Any, WalkerState] = None
+        def token_run(input: WalkerState, use_cache:bool) -> PyGenerator[Incomplete[WalkerState], WalkerState, Either[Any, Tuple[Any, WalkerState]]]:
+            yield from ()
+            data = TokenSpec(token_type=token_type, text=text, regex=regex, case_sensitive=case_sensitive)
+            return Right((data, input.visit(this, data) if this is not None else input))
+        this = cls(token_run, name=name, cache=cache)  
+        return this
+
+    @classmethod
+    def lazy(cls, 
+             thunk: Callable[[], Algebra[Any, WalkerState]], 
+             cache: Cache) -> Algebra[Any, WalkerState]:
+        this: None | Algebra[Any, WalkerState] = None
+        def algebra_lazy_run(input: WalkerState, use_cache:bool) -> PyGenerator[Incomplete[WalkerState], WalkerState, Either[Any, Tuple[Any, WalkerState]]]:
+            alg = thunk()
+            thunk_result = yield from alg.run(input, use_cache)
+            match thunk_result:
+                case Right((value, from_thunk)):
+                    data: LazySpec[Any] = LazySpec(name=alg.name, value=value)
+                    from_thunk = from_thunk.visit(alg, value) 
+                    return Right((data, from_thunk.visit(this, data) if this is not None else from_thunk))
+            raise SyncraftError("flat_map should always return a value or an error.", offending=thunk_result, expect=(Left, Right))
+        this = cls(algebra_lazy_run, name='lazy(?)', cache=cache)
+        return this
+
+
+    def then_all(self, other: Algebra[Any, WalkerState], kind: ThenKind) -> Algebra[Any, WalkerState]:
+        name = f"{self.name} {kind.value} {other.name}"
+        this: None | Algebra[Any, WalkerState] = None
+        def then_run(input: WalkerState, use_cache:bool) -> PyGenerator[Incomplete[WalkerState], WalkerState, Either[Any, Tuple[Any, WalkerState]]]:
+            self_result = yield from self.run(input, use_cache=use_cache)
+            match self_result:
+                case Right((value, from_left)):
+                    other_result = yield from other.run(from_left.visit(self, value), use_cache)
+                    match other_result:
+                        case Right((result, from_right)):
+                            data = ThenSpec(name=name, kind=kind, left=value, right=result)
+                            from_right = from_right.visit(other, result) 
+                            return Right((data, from_right.visit(this, data) if this is not None else from_right))
+            raise SyncraftError("flat_map should always return a value or an error.", offending=self_result, expect=(Left, Right))
+        this = self.__class__(then_run, name=name, cache=self.cache | other.cache) 
+        return this
+
+
+
+    def then_both(self, other: Algebra[Any, WalkerState]) -> Algebra[Any, WalkerState]:
+        return self.then_all(other, ThenKind.BOTH)
+
+    def then_left(self, other: Algebra[Any, WalkerState]) -> Algebra[Any, WalkerState]:
+        return self.then_all(other, ThenKind.LEFT)
+
+    def then_right(self, other: Algebra[Any, WalkerState]) -> Algebra[Any, WalkerState]:
+        return self.then_all(other, ThenKind.RIGHT)
+
+
+    def many(self, *, at_least: int, at_most: Optional[int]) -> Algebra[Any, WalkerState]:
+        if at_least <=0 or (at_most is not None and at_most < at_least):
+            raise SyncraftError(f"Invalid arguments for many: at_least={at_least}, at_most={at_most}", offending=(at_least, at_most), expect="at_least>0 and (at_most is None or at_most>=at_least)")
+        this: None | Algebra[Any, WalkerState] = None
+        def many_run(input: WalkerState, use_cache:bool) -> PyGenerator[Incomplete[WalkerState], WalkerState, Either[Any, Tuple[Any, WalkerState]]]:
+            self_result = yield from self.run(input, use_cache)
+            match self_result:
+                case Right((value, from_self)):
+                    data = ManySpec(name=f"*({self.name})", value=value, at_least=at_least, at_most=at_most)
+                    from_self = from_self.visit(self, value)
+                    return Right((data, from_self.visit(this, data) if this is not None else from_self))
+            raise SyncraftError("many should always return a value or an error.", offending=self_result, expect=(Left, Right))
+        this = self.__class__(many_run, name=self.name, cache=self.cache)  
+        return this
+    
+ 
+    def or_else(self, other: Algebra[Any, WalkerState]) -> Algebra[Any, WalkerState]: 
+        pattern = re.compile(r'\s')
+        self_name = self.name.strip() 
+        self_name = f"({self_name})" if bool(pattern.search(self_name)) else self_name
+        other_name = other.name.strip()
+        other_name = f"({other_name})" if bool(pattern.search(other_name)) else other_name
+        name = f"{self_name} | {other_name}"
+        this: None | Algebra[Any, WalkerState] = None
+        def or_else_run(input: WalkerState, use_cache:bool) -> PyGenerator[Incomplete[WalkerState], WalkerState, Either[Any, Tuple[Any, WalkerState]]]:
+            self_result = yield from self.run(input, use_cache=use_cache)
+            match self_result:
+                case Right((value, from_left)):
+                    other_result = yield from other.run(from_left.visit(self, value), use_cache)
+                    match other_result:
+                        case Right((result, from_right)):
+                            data = ChoiceSpec(name=name, left=value, right=result)
+                            from_right = from_right.visit(other, result) 
+                            return Right((data, from_right.visit(this, data) if this is not None else from_right))
+            raise SyncraftError("", offending=self)
+        this = self.__class__(or_else_run, name=name, cache=self.cache | other.cache) 
+        return this
+
+
+
+def walk(syntax: Syntax[Any, Any], reducer: Optional[Callable[[Any, Any], SS]] = None, init: Optional[SS] = None) -> Any:
+    from syncraft.syntax import run
+    v, s = run(syntax=syntax, 
+               alg=Walker, 
+               use_cache=True, 
+               reducer=reducer or (lambda a, s: s), 
+               init=init)
+    if reducer is None:
+        return v
+    else:
+        if s is not None:
+            return s.acc
+        else:
+            return None

{syncraft-0.2.9 → syncraft-0.2.10/syncraft.egg-info}/PKG-INFO

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

syncraft-0.2.9/syncraft/walker.py

@@ -1,147 +0,0 @@
-from __future__ import annotations
-
-from typing import (
-    Any, Tuple, Generator as PyGenerator, TypeVar, Generic, Optional, Callable, Hashable
-)
-from dataclasses import dataclass, replace, field
-from syncraft.algebra import (
-    Algebra, Either, Right, Incomplete, Left, SyncraftError
-)
-from syncraft.ast import TokenSpec, ThenSpec, ManySpec, ChoiceSpec, LazySpec, ThenKind
-from syncraft.parser import TokenType
-from syncraft.constraint import Bindable, FrozenDict
-
-import re
-from syncraft.syntax import Syntax
-from syncraft.cache import Cache, RecursionError
-from rich import print
-
-
-S = TypeVar('S', bound=Bindable)
-A = TypeVar('A')
-B = TypeVar('B')
-SS = TypeVar('SS', bound=Hashable)
-
-
-@dataclass(frozen=True)
-class WalkerState(Bindable, Generic[SS]):
-    reducer: Optional[Callable[[Any, SS], SS]] = None
-    acc: Optional[SS] = None
-
-    def reduce(self, value: Any) -> WalkerState[SS]:
-        if self.reducer:
-            new_acc = self.reducer(value, self.acc) if self.acc is not None else value
-            return replace(self, acc=new_acc)
-        else:
-            return replace(self, acc=value)
-        
-
-@dataclass(frozen=True)
-class Walker(Algebra[SS, WalkerState[SS]]):
-    @classmethod
-    def state(cls, reducer: Callable[[Any, SS], SS], init: SS )->WalkerState[SS]: # type: ignore
-        assert callable(reducer), f"reducer must be a Reducer or None, got {type(reducer)}"
-        return WalkerState(reducer=reducer, acc=init)
-
-
-
-    @classmethod
-    def token(cls, 
-              *,
-              cache: Cache,
-              token_type: Optional[TokenType] = None, 
-              text: Optional[str] = None, 
-              case_sensitive: bool = False,
-              regex: Optional[re.Pattern[str]] = None
-              )-> Algebra[Any, WalkerState[SS]]:      
-        def token_run(input: WalkerState[SS], use_cache:bool) -> PyGenerator[Incomplete[WalkerState[SS]], WalkerState[SS], Either[Any, Tuple[Any, WalkerState[SS]]]]:
-            yield from ()
-            data = TokenSpec(token_type=token_type, text=text, regex=regex, case_sensitive=case_sensitive)
-            return Right((data, input.reduce(data)))
-        return cls(token_run, name=cls.__name__ + f'.token({token_type or text or regex})', cache=cache)  
-
-    @classmethod
-    def lazy(cls, 
-             thunk: Callable[[], Algebra[Any, WalkerState[SS]]], 
-             cache: Cache) -> Algebra[Any, WalkerState[SS]]:
-        def algebra_lazy_run(input: WalkerState[SS], use_cache:bool) -> PyGenerator[Incomplete[WalkerState[SS]], WalkerState[SS], Either[Any, Tuple[Any, WalkerState[SS]]]]:
-            alg = thunk()
-            # print('--' * 20, "Walker.lazy.algebra_lazy_run", '--' * 20)
-            # print('thunk', thunk, id(thunk))
-            # print('input', input, id(input))
-            # print('alg', alg, id(alg))
-            try:
-                thunk_result = yield from alg.run(input, use_cache)
-                match thunk_result:
-                    case Right((value, from_thunk)):
-                        data: LazySpec[Any] = LazySpec(value=value)
-                        return Right((data, from_thunk.reduce(data)))
-                raise SyncraftError("flat_map should always return a value or an error.", offending=thunk_result, expect=(Left, Right))
-            except RecursionError as e:
-                return Right((LazySpec(value=None), input))
-        return cls(algebra_lazy_run, name=cls.__name__ + '.lazy', cache=cache)
-
-
-
-    def then_both(self, other: Algebra[Any, WalkerState[SS]]) -> Algebra[Any, WalkerState[SS]]:
-        def then_run(input: WalkerState[SS], use_cache:bool) -> PyGenerator[Incomplete[WalkerState[SS]], WalkerState[SS], Either[Any, Tuple[Any, WalkerState[SS]]]]:
-            self_result = yield from self.run(input, use_cache=use_cache)
-            match self_result:
-                case Right((value, from_left)):
-                    other_result = yield from other.run(from_left, use_cache)
-                    match other_result:
-                        case Right((result, from_right)):
-                            data = ThenSpec(kind=ThenKind.BOTH, left=value, right=result)
-                            return Right((data, from_right.reduce(data)))
-            raise SyncraftError("flat_map should always return a value or an error.", offending=self_result, expect=(Left, Right))
-        return self.__class__(then_run, name=self.name, cache=self.cache | other.cache) 
-
-    def then_left(self, other: Algebra[Any, WalkerState[SS]]) -> Algebra[Any, WalkerState[SS]]:
-        return self.then_both(other).map(lambda t: replace(t, kind=ThenKind.LEFT))
-
-    def then_right(self, other: Algebra[Any, WalkerState[SS]]) -> Algebra[Any, WalkerState[SS]]:
-        return self.then_both(other).map(lambda t: replace(t, kind=ThenKind.RIGHT))
-
-
-    def many(self, *, at_least: int, at_most: Optional[int]) -> Algebra[Any, WalkerState[SS]]:
-        if at_least <=0 or (at_most is not None and at_most < at_least):
-            raise SyncraftError(f"Invalid arguments for many: at_least={at_least}, at_most={at_most}", offending=(at_least, at_most), expect="at_least>0 and (at_most is None or at_most>=at_least)")
-        def many_run(input: WalkerState[SS], use_cache:bool) -> PyGenerator[Incomplete[WalkerState[SS]], WalkerState[SS], Either[Any, Tuple[Any, WalkerState[SS]]]]:
-            self_result = yield from self.run(input, use_cache)
-            match self_result:
-                case Right((value, from_self)):
-                    data = ManySpec(value=value, at_least=at_least, at_most=at_most)
-                    return Right((data, from_self.reduce(data)))
-            raise SyncraftError("many should always return a value or an error.", offending=self_result, expect=(Left, Right))
-        return self.__class__(many_run, name=f"many({self.name})", cache=self.cache)  
-    
- 
-    def or_else(self, other: Algebra[Any, WalkerState[SS]]) -> Algebra[Any, WalkerState[SS]]: 
-        def or_else_run(input: WalkerState[SS], use_cache:bool) -> PyGenerator[Incomplete[WalkerState[SS]], WalkerState[SS], Either[Any, Tuple[Any, WalkerState[SS]]]]:
-            self_result = yield from self.run(input, use_cache=use_cache)
-            match self_result:
-                case Right((value, from_left)):
-                    other_result = yield from other.run(from_left, use_cache)
-                    match other_result:
-                        case Right((result, from_right)):
-                            data = ChoiceSpec(left=value, right=result)
-                            return Right((data, from_right.reduce(data)))
-            raise SyncraftError("", offending=self)
-        return self.__class__(or_else_run, name=f"or_else({self.name} | {other.name})", cache=self.cache | other.cache) 
-
-
-
-def walk(syntax: Syntax[Any, Any], reducer: Optional[Callable[[Any, Any], SS]] = None, init: Optional[SS] = None) -> Any:
-    from syncraft.syntax import run
-    v, s = run(syntax=syntax, 
-               alg=Walker, 
-               use_cache=True, 
-               reducer=reducer or (lambda a, s: s), 
-               init=init)
-    if reducer is None:
-        return v
-    else:
-        if s is not None:
-            return s.acc
-        else:
-            return None