syncraft 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

syncraft/__init__.py

@@ -1,32 +1,49 @@
 from .syntax import (
+    Description,
 	Syntax,
+    regex,
+    literal,
 	choice,
 	lazy,
 	success,
 	fail,
+    when,
     run,
 )
+from .walker import (
+    walk,
+)
+from .algebra import (
+    Algebra,
+    Error,
+    Left,
+    Right,
+    Either,
+)
 from .parser import (
+    Parser,
 	parse,
 	sqlglot,
 	token,
 	identifier,
 	variable,
-	literal,
 	number,
 	string,
-	regex,
-	until,
 )
 from .generator import (
+    Generator,
 	generate,
+    generate_with,
+    validate,
 )
 from .finder import (
+    Finder,
 	find,
 	matches,
 	anything,
 )
 from .constraint import (
+    FrozenDict,
 	Constraint,
 	Quantifier,
 	forall,
@@ -34,6 +51,8 @@ from .constraint import (
 )
 from .ast import (
 	AST,
+    Bimap,
+    Biarrow,
 	Token,
 	Then,
 	ThenKind,
@@ -45,15 +64,17 @@ from .ast import (
 )
 
 __all__ = [
+    # algebra
+    "Algebra", "Error", "Left", "Right", "Either",
 	# syntax & core
-	"Syntax", "choice", "lazy", "success", "fail", "run",
+	"Syntax", "choice", "lazy", "success", "fail", "run", "Description", "when",
 	# parsing/generation helpers
-	"parse", "sqlglot", "token", "identifier", "variable", "literal", "number", "string", "regex", "until",
-	"generate",
+	"parse", "sqlglot", "token", "identifier", "variable", "literal", "number", "string", "regex", "walk",
+	"generate", "generate_with", "validate", "Parser", "Generator",
 	# finder
-	"find", "matches", "anything",
+	"find", "matches", "anything", "Finder",
 	# constraints
-	"Constraint", "Quantifier", "forall", "exists",
+	"Constraint", "Quantifier", "forall", "exists", "FrozenDict",
 	# ast
-	"AST", "Token", "Then", "ThenKind", "Choice", "ChoiceKind", "Many", "Marked", "Collect",
+	"AST", "Token", "Then", "ThenKind", "Choice", "ChoiceKind", "Many", "Marked", "Collect", "Bimap", "Biarrow"
 ]

syncraft/algebra.py

@@ -1,16 +1,14 @@
 from __future__ import annotations
 from typing import (
     Optional, List, Any, TypeVar, Generic, Callable, Tuple, cast, 
-    Dict, Type, ClassVar, Hashable
+    Dict, Type, Hashable, Generator
 )
 
-import traceback
 from dataclasses import dataclass, replace
-from weakref import WeakKeyDictionary
-from syncraft.ast import ThenKind, Then, Choice, Many, ChoiceKind, shallow_dict
+from syncraft.ast import ThenKind, Then, Choice, Many, ChoiceKind, shallow_dict, SyncraftError
+from syncraft.cache import Cache
 from syncraft.constraint import Bindable
-
-
+from rich import print
 
 
 S = TypeVar('S', bound=Bindable)
@@ -19,7 +17,6 @@ A = TypeVar('A')  # Result type
 B = TypeVar('B')  # Mapped result type
 
 
-InProgress = object()  # Marker for in-progress state, used to prevent re-entrance in recursive calls
 L = TypeVar('L')  # Left type for combined results
 R = TypeVar('R')  # Right type for combined results
 
@@ -38,7 +35,9 @@ class Right(Either[L, R]):
     value: R
 
 
-
+@dataclass(frozen=True)
+class Incomplete(Generic[S]):
+    state: S
 
 @dataclass(frozen=True)
 class Error:
@@ -47,7 +46,7 @@ class Error:
     error: Optional[Any] = None    
     state: Optional[Any] = None
     committed: bool = False
-    stack: Optional[str] = None
+    fatal: bool = False
     previous: Optional[Error] = None
     
     def attach( self, 
@@ -76,147 +75,71 @@ class Error:
 @dataclass(frozen=True)        
 class Algebra(Generic[A, S]):
 ######################################################## shared among all subclasses ########################################################
-    run_f: Callable[[S, bool], Either[Any, Tuple[A, S]]] 
+    run_f: Callable[[S, bool], Generator[Incomplete[S], S, Either[Any, Tuple[A, S]]]] 
     name: Hashable
-    _cache: ClassVar[WeakKeyDictionary[Any, Dict[Any, object | Either[Any, Tuple[Any, Any]]]]] = WeakKeyDictionary()
+    cache: Cache[ S, Either[Any, Tuple[A, S]] ]
 
     @classmethod
-    def state(cls, *args:Any, **kwargs:Any)->Optional[S]: 
+    def state(cls, **kwargs:Any)->Optional[S]: 
         return None
         
     def named(self, name: Hashable) -> 'Algebra[A, S]':
         return replace(self, name=name)
-
-    def __post_init__(self)-> None:
-        self._cache.setdefault(self.run_f, dict())
         
-    def __call__(self, input: S, use_cache: bool) -> Either[Any, Tuple[A, S]]:
+    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)
 
-    def run(self, input: S, use_cache: bool) -> Either[Any, Tuple[A, S]]:
-        """Execute this algebra on the given state with optional memoization.
-
-        This is the core evaluation entry point used by all combinators. It
-        supports per-"parser" memoization and protects against infinite
-        recursion by detecting left-recursive re-entrance.
-
-        Args:
-            input: The initial state to run against. Must be hashable as it's
-                used as a cache key.
-            use_cache: When True, memoize results for ``(self.run_f, input)``
-                so repeated calls short-circuit. When False, the cache entry is
-                cleared after the run to effectively disable the cache. 
-
-        Returns:
-            Either[Error, Tuple[A, S]]: On success, ``Right((value, next_state))``.
-            On failure, ``Left(Error)``. Errors produced downstream are
-            automatically enriched with ``this=self`` and ``state=input`` to
-            preserve context. If an exception escapes the user code, it's
-            captured and returned as ``Left(Error)`` with a traceback in
-            ``stack``.
-
-        Notes:
-            - Left recursion: if a re-entrant call is observed on the same
-              ``input`` while an evaluation is in progress, a ``Left(Error)``
-              is returned indicating left-recursion was detected.
-            - Memoization scope: results are cached per ``run_f`` (the concrete
-              compiled function of this algebra) and keyed by the input state.
-            - Commitment: downstream combinators (e.g. ``cut``) may set the
-              ``committed`` flag in ``Error``; ``run`` preserves that flag but
-              does not set it itself.
-        """
-        cache = self._cache[self.run_f]
-        assert cache is not None, "Cache should be initialized in __post_init__"
-        if input in cache:
-            v = cache.get(input, None)
-            if v is InProgress:
-                return Left(
-                    Error(
-                        message="Left-recursion detected in parser",
-                        this=self,
-                        state=input
-                    ))
-            else:
-                return cast(Either[Error, Tuple[A, S]], v)
-        try:
-            cache[input] = InProgress
-            result = self.run_f(input, use_cache)
-            cache[input] = result
-            if not use_cache:
-                cache.pop(input, None)  # Clear the cache entry if not using cache
-            if isinstance(result, Left):
-                if isinstance(result.value, Error):
-                    result = Left(result.value.attach(this=self, state=input))
-        except Exception as e:
-            cache.pop(input, None)  # Clear the cache entry on exception
-            # traceback.print_exc()
-            # print(f"Exception from self.run(S): {e}")
-            return Left(
-                Error(
-                    message="Exception from self.run(S): {e}",
-                    this=self,
-                    state=input,
-                    error=e,
-                    stack=traceback.format_exc()
-                ))
-        return result
+    def run(self, input: S, use_cache: bool) -> Generator[Incomplete[S], S, Either[Any, Tuple[A, S]]]:
+        return (yield from self.cache.gen(self.run_f, input, use_cache))
+        
 
     def as_(self, typ: Type[B])->B:
         return cast(typ, self) # type: ignore
         
     @classmethod
-    def lazy(cls, thunk: Callable[[], Algebra[A, S]]) -> Algebra[A, S]:
-        """Lazily construct an algebra at run time.
-
-        Useful for recursive definitions. The thunk is evaluated when this
-        algebra runs, and the resulting algebra is executed.
-
-        Args:
-            thunk: Zero-argument function returning the underlying algebra.
-
-        Returns:
-            An algebra that defers to the thunk-provided algebra.
-        """
-        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')
+    def lazy(cls, 
+             thunk: Callable[[], Algebra[A, S]], 
+             *, 
+             cache: Cache) -> Algebra[A, S]:
+        def algebra_lazy_run(input: S, use_cache:bool) -> Generator[Incomplete[S], S, Either[Any, Tuple[A, S]]]:
+            alg = thunk()
+            # print('--' * 20, "Algebra.lazy.algebra_lazy_run", '--' * 20)
+            # print('thunk', thunk, id(thunk))
+            # print('input', input, id(input))
+            # print('alg', alg, id(alg))
+            result = yield from alg.run(input, use_cache)
+            return result
+        return cls(algebra_lazy_run, name=cls.__name__ + '.lazy', cache=cache)
     
     @classmethod
-    def fail(cls, error: Any) -> Algebra[Any, S]:
-        """Return an algebra that always fails with ``error``.
-
-        Args:
-            error: The error payload to wrap in ``Left``.
-
-        Returns:
-            An algebra producing ``Left(Error(...))`` without consuming input.
-        """
-        def fail_run(input: S, use_cache:bool) -> Either[Any, Tuple[Any, S]]:
+    def fail(cls, 
+             error: Any,
+             *,
+             cache: Cache) -> Algebra[Any, S]:
+        def fail_run(input: S, use_cache:bool) -> Generator[Incomplete[S], S, Either[Any, Tuple[A, S]]]:
+            yield from ()
             return Left(Error(
                 error=error,
                 this=cls,
                 state=input
             ))
-        return cls(fail_run, name=cls.__name__ + '.fail')
+        return cls(fail_run, name=cls.__name__ + '.fail', cache=cache)
     
     @classmethod
-    def success(cls, value: Any) -> Algebra[Any, S]:
-        """Return an algebra that always succeeds with ``value``.
-
-        The input state is passed through unchanged.
-
-        Args:
-            value: The constant value to return.
-
-        Returns:
-            ``Right((value, input))`` for any input state.
-        """
-        def success_run(input: S, use_cache:bool) -> Either[Any, Tuple[Any, S]]:
+    def success(cls, 
+                value: Any, 
+                *, 
+                cache: Cache) -> Algebra[Any, S]:
+        def success_run(input: S, use_cache:bool) -> Generator[Incomplete[S], S, Either[Any, Tuple[A, S]]]:
+            yield from ()
             return Right((value, input))
-        return cls(success_run, name=cls.__name__ + '.success')
+        return cls(success_run, name=cls.__name__ + '.success', cache=cache)
     
     @classmethod
-    def factory(cls, name: str, *args: Any, **kwargs: Any) -> Algebra[A, S]:
+    def factory(cls,
+                name: str, 
+                *args: Any, 
+                **kwargs: Any) -> Algebra[A, S]:
         """Call a named class method to construct an algebra.
 
         Args:
@@ -232,10 +155,29 @@ class Algebra(Generic[A, S]):
         """
         method = getattr(cls, name, None)
         if method is None or not callable(method):
-            raise ValueError(f"Method {name} is not defined in {cls.__name__}")
+            raise SyncraftError(f"Method {name} is not defined in {cls.__name__}", offending=method, expect='callable')
         return cast(Algebra[A, S], method(*args, **kwargs))
 
+    def fatal(self) -> Algebra[A, S]:
+        """Commit this branch by marking failures as fatal.
 
+        Converts downstream errors into fatal errors (``fatal=True``),
+        which prevents alternatives from being tried in ``or_else``.
+
+        Returns:
+            An algebra that fails fatally on errors produced by this one.
+        """
+        def fail_all_error(e: Any) -> Error:
+            match e:
+                case Error():
+                    return replace(e, fatal=True)
+                case _:
+                    return Error(
+                        error=e,
+                        this=self,
+                        fatal=True
+                    )
+        return self.map_error(fail_all_error)
 
     def cut(self) -> Algebra[A, S]:
         """Commit this branch by marking failures as committed.
@@ -266,8 +208,9 @@ class Algebra(Generic[A, S]):
                         Left[Any, Tuple[A, S]], 
                         Any
                     ], 
-                    Either[Any, Tuple[B, S]]], 
-                    ctx: Optional[Any] = None) -> Algebra[A | B, S]:
+                        Either[Any, Tuple[B, S]]
+                    ], 
+                ctx: Optional[Any] = None) -> Algebra[A | B, S]:
         """Run a handler only when this algebra fails.
 
         Args:
@@ -278,12 +221,13 @@ class Algebra(Generic[A, S]):
             An algebra that intercepts failures and can recover or transform them.
         """
         assert callable(func), "func must be callable"
-        def fail_run(input: S, use_cache:bool) -> Either[Any, Tuple[A | B, S]]:
-            result = self.run(input, use_cache)
+        def fail_run(input: S, use_cache:bool) -> Generator[Incomplete[S], S, Either[Any, Tuple[A|B, S]]]:
+            result = yield from self.run(input, use_cache)
             if isinstance(result, Left):
                 return cast(Either[Any, Tuple[A | B, S]], func(self, input, result, ctx))
-            return cast(Either[Any, Tuple[A | B, S]], result)
-        return self.__class__(fail_run, name=self.name) # type: ignore
+            else:
+                return cast(Either[Any, Tuple[A | B, S]], result)
+        return self.__class__(fail_run, name=self.name, cache=self.cache) # type: ignore
 
     def on_success(self, 
                     func: Callable[
@@ -293,8 +237,9 @@ class Algebra(Generic[A, S]):
                             Right[Any, Tuple[A, S]], 
                             Any
                         ], 
-                        Either[Any, Tuple[B, S]]], 
-                        ctx: Optional[Any] = None) -> Algebra[A | B, S]:
+                            Either[Any, Tuple[B, S]]
+                        ], 
+                    ctx: Optional[Any] = None) -> Algebra[A | B, S]:
         """Run a handler only when this algebra succeeds.
 
         Args:
@@ -305,41 +250,14 @@ class Algebra(Generic[A, S]):
             An algebra that can transform or post-process successes.
         """
         assert callable(func), "func must be callable"
-        def success_run(input: S, use_cache:bool) -> Either[Any, Tuple[A | B, S]]:
-            result = self.run(input, use_cache)
+        def success_run(input: S, use_cache:bool) -> Generator[Incomplete[S], S, Either[Any, Tuple[A|B, S]]]:
+            result = yield from self.run(input, use_cache)
             if isinstance(result, Right):
                 return cast(Either[Any, Tuple[A | B, S]], func(self, input, result, ctx))
-            return cast(Either[Any, Tuple[A | B, S]], result)
-        return self.__class__(success_run, name=self.name) # type: ignore
-
-    def debug(self, 
-              label: str, 
-              formatter: Optional[Callable[[
-                  Algebra[Any, S], 
-                  S, 
-                  Either[Any, Tuple[Any, S]]], None]]=None) -> Algebra[A, S]:
-        def default_formatter(alg: Algebra[Any, S], input: S, result: Either[Any, Tuple[Any, S]]) -> None:
-            print(f"Debug: {'*' * 40} {alg.name} - State {'*' * 40}")
-            print(input)
-            print(f"Debug: {'~' * 40} (Result, State) {'~' * 40}")
-            print(result)
-            print()
-            print()
-        lazy_self: Algebra[A, S]
-        def debug_run(input: S, use_cache:bool) -> Either[Any, Tuple[A, S]]:
-            result = self.run(input, use_cache)
-            try:
-                if formatter is not None:
-                    formatter(lazy_self, input, result)
-                else:
-                    default_formatter(lazy_self, input, result)
-            except Exception as e:
-                traceback.print_exc()
-                print(f"Error occurred while formatting debug information: {e}")
-            finally:
-                return result
-        lazy_self = self.__class__(debug_run, name=label)  
-        return lazy_self
+            else:
+                return cast(Either[Any, Tuple[A | B, S]], result)
+        return self.__class__(success_run, name=self.name, cache=self.cache) # type: ignore
+
 
 ######################################################## map on state ###########################################
     def map_state(self, f: Callable[[S], S]) -> Algebra[A, S]:
@@ -351,30 +269,12 @@ class Algebra(Generic[A, S]):
         Returns:
             An algebra that runs with ``f(state)``.
         """
-        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 map_state_run(state: S, use_cache:bool) -> Generator[Incomplete[S], S, Either[Any, Tuple[A, S]]]:
+            result = yield from self.run(f(state), use_cache)
+            return result
+        return self.__class__(map_state_run, name=self.name, cache=self.cache) 
 
 
-    def map_all(self, f: Callable[[A, S], Tuple[B, S]]) -> Algebra[B, S]:
-        """Map both the produced value and the resulting state on success.
-
-        Args:
-            f: Function mapping ``(value, state)`` to ``(new_value, new_state)``.
-
-        Returns:
-            An algebra producing the transformed value and state.
-        """
-        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 map(self, f: Callable[[A], B]) -> Algebra[B, S]:
         """Transform the success value, leaving the state unchanged.
@@ -385,13 +285,13 @@ class Algebra(Generic[A, S]):
         Returns:
             An algebra that yields ``B`` with the same resulting state.
         """
-        def map_run(input: S, use_cache:bool) -> Either[Any, Tuple[B, S]]:
-            parsed = self.run(input, use_cache)
+        def map_run(input: S, use_cache:bool) -> Generator[Incomplete[S], S, Either[Any, Tuple[B, S]]]:
+            parsed = yield from self.run(input, use_cache)
             if isinstance(parsed, Right):
                 return Right((f(parsed.value[0]), parsed.value[1]))            
             else:
                 return cast(Either[Any, Tuple[B, S]], parsed)
-        return self.__class__(map_run, name=self.name)  # type: ignore
+        return self.__class__(map_run, name=self.name, cache=self.cache)  # type: ignore
 
         
     def bimap(self, f: Callable[[A], B], i: Callable[[B], A]) -> Algebra[B, S]:
@@ -424,12 +324,13 @@ class Algebra(Generic[A, S]):
         Returns:
             An algebra that preserves successes and maps failures.
         """
-        def map_error_run(input: S, use_cache:bool) -> Either[Any, Tuple[A, S]]:
-            parsed = self.run(input, use_cache)
+        def map_error_run(input: S, use_cache:bool) -> Generator[Incomplete[S], S, Either[Any, Tuple[A, S]]]:
+            parsed = yield from self.run(input, use_cache)
             if isinstance(parsed, Left):
                 return Left(f(parsed.value))
-            return parsed
-        return self.__class__(map_error_run, name=self.name)  
+            else:
+                return parsed
+        return self.__class__(map_error_run, name=self.name, cache=self.cache)  
 
     def flat_map(self, f: Callable[[A], Algebra[B, S]]) -> Algebra[B, S]:
         """Chain computations where the next algebra depends on the value.
@@ -443,13 +344,31 @@ class Algebra(Generic[A, S]):
         Returns:
             An algebra yielding the result of the chained computation.
         """
-        def flat_map_run(input: S, use_cache:bool) -> Either[Any, Tuple[B, S]]:
-            parsed = self.run(input, use_cache)
+        def flat_map_run(input: S, use_cache:bool) -> Generator[Incomplete[S], S, Either[Any, Tuple[B, S]]]:
+            parsed = yield from self.run(input, use_cache)
             if isinstance(parsed, Right):
-                return f(parsed.value[0]).run(parsed.value[1], use_cache)  
+                result = yield from f(parsed.value[0]).run(parsed.value[1], use_cache)  
+                return result
             else:
                 return cast(Either[Any, Tuple[B, S]], parsed)
-        return self.__class__(flat_map_run, name=self.name)  # type: ignore
+        return self.__class__(flat_map_run, name=self.name, cache=self.cache)  # type: ignore
+
+    def map_all(self, f: Callable[[A, S], Tuple[B, S]]) -> Algebra[B, S]:
+        """Map both the produced value and the resulting state on success.
+
+        Args:
+            f: Function mapping ``(value, state)`` to ``(new_value, new_state)``.
+
+        Returns:
+            An algebra producing the transformed value and state.
+        """
+        def map_all_f(a : A) -> Algebra[B, 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.flat_map(map_all_f)
+
 
     
     def or_else(self: Algebra[A, S], other: Algebra[B, S]) -> Algebra[Choice[A, B], S]:
@@ -465,21 +384,26 @@ class Algebra(Generic[A, S]):
             An algebra producing ``Choice.LEFT`` for this success or
             ``Choice.RIGHT`` for the other's success.
         """
-        def or_else_run(input: S, use_cache:bool) -> Either[Any, Tuple[Choice[A, B], S]]:
-            match self.run(input, use_cache):
+        def or_else_run(input: S, use_cache:bool) -> Generator[Incomplete[S], S, Either[Any, Tuple[Choice[A, B], S]]]:
+            self_result = yield from self.run(input, use_cache)
+            match self_result:
                 case Right((value, state)):
                     return Right((Choice(kind=ChoiceKind.LEFT, value=value), state))
                 case Left(err):
-                    if isinstance(err, Error) and err.committed:
-                        return Left(replace(err, committed=False))
-                    match other.run(input, use_cache):
+                    if isinstance(err, Error):
+                        if err.fatal:
+                            return Left(err)
+                        elif err.committed:
+                            return Left(replace(err, committed=False))
+                    other_result = yield from other.run(input, use_cache)
+                    match other_result:
                         case 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
+                    raise SyncraftError(f"Unexpected result type from {other}", offending=other_result, expect=(Left, Right))
+            raise SyncraftError(f"Unexpected result type from {self}", offending=self_result, expect=(Left, Right))
+        return self.__class__(or_else_run, name=f'{self.name} | {other.name}', cache=self.cache | other.cache)  # type: ignore
 
     def then_both(self, other: Algebra[B, S]) -> Algebra[Then[A, B], S]:
         """Sequence two algebras and keep both values.
@@ -496,7 +420,8 @@ class Algebra(Generic[A, S]):
             def combine(b: B) -> Then[A, B]:
                 return Then(left=a, right=b, kind=ThenKind.BOTH)
             return other.map(combine)
-        return self.flat_map(then_both_f).named(f'{self.name} + {other.name}')
+        ret = self.flat_map(then_both_f).named(f'{self.name} + {other.name}')
+        return replace(ret, cache=self.cache | other.cache)  
 
     def then_left(self, other: Algebra[B, S]) -> Algebra[Then[A, B], S]:
         """Sequence two algebras, keep the left value in the result.
@@ -513,7 +438,8 @@ class Algebra(Generic[A, S]):
             def combine(b: B) -> Then[A, B]:
                 return Then(left=a, right=b, kind=ThenKind.LEFT)
             return other.map(combine)
-        return self.flat_map(then_left_f).named(f'{self.name} // {other.name}')
+        ret = self.flat_map(then_left_f).named(f'{self.name} // {other.name}')
+        return replace(ret, cache=self.cache | other.cache)  
 
     def then_right(self, other: Algebra[B, S]) -> Algebra[Then[A, B], S]:
         """Sequence two algebras, keep the right value in the result.
@@ -530,7 +456,8 @@ class Algebra(Generic[A, S]):
             def combine(b: B) -> Then[A, B]:
                 return Then(left=a, right=b, kind=ThenKind.RIGHT)
             return other.map(combine)
-        return self.flat_map(then_right_f).named(f'{self.name} >> {other.name}')
+        ret = self.flat_map(then_right_f).named(f'{self.name} >> {other.name}')
+        return replace(ret, cache=self.cache | other.cache)  
 
     def many(self, *, at_least: int, at_most: Optional[int]) -> Algebra[Many[A], S]:
         """Repeat this algebra and collect results into ``Many``.
@@ -552,18 +479,20 @@ class Algebra(Generic[A, S]):
             ``at_most<at_least``).
         """
         if at_least <=0 or (at_most is not None and at_most < at_least):
-            raise ValueError(f"Invalid arguments for many: at_least={at_least}, at_most={at_most}")
-        def many_run(input: S, use_cache:bool) -> Either[Any, Tuple[Many[A], S]]:
+            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: S, use_cache:bool) -> Generator[Incomplete[S], S, Either[Any, Tuple[Many[A], S]]]:
             ret: List[A] = []
             current_input = input
             while True:
-                match self.run(current_input, use_cache):
+                result = yield from self.run(current_input, use_cache)
+                match result:
                     case Left(_):
                         break
                     case Right((value, next_input)):
-                        ret.append(value)
                         if next_input == current_input:
                             break  # No progress, stop to avoid infinite loop
+                        else:
+                            ret.append(value)
                         current_input = next_input
                         if at_most is not None and len(ret) > at_most:
                             return Left(Error(
@@ -578,7 +507,7 @@ class Algebra(Generic[A, S]):
                         state=current_input
                     )) 
             return Right((Many(value=tuple(ret)), current_input))
-        return self.__class__(many_run, name=f'*({self.name})') # type: ignore
+        return self.__class__(many_run, name=f'*({self.name})', cache=self.cache) # type: ignore