syncraft 0.1.18__tar.gz → 0.1.20__tar.gz

{syncraft-0.1.18 → syncraft-0.1.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncraft
-Version: 0.1.18
+Version: 0.1.20
 Summary: Parser combinator library
 Author-email: Michael Afmokt <michael@esacca.com>
 License-Expression: MIT
@@ -31,6 +31,7 @@ pip install syncraft
 
 
 ## TODO
-- [ ] Test Walker.get/set for bidirectional mapping between source code and data class
-- [ ] Annotate sqlite3 grammar with named nodes and data classes
-- [ ] 
+- [ ] Add a collect method to AST to collect all named entries and pack them into a dict or a custom dataclass. This method will be called as the last step of my current bimap. So it shares the signature of bimap and can combine with the current bimap
+- [ ] Amend all, first, last, and named helper functions to support bimap and named results.
+- [ ] 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.20/README.md

@@ -0,0 +1,22 @@
+# Syncraft
+
+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
+
+```bash
+pip install syncraft
+```
+
+
+## TODO
+- [ ] Add a collect method to AST to collect all named entries and pack them into a dict or a custom dataclass. This method will be called as the last step of my current bimap. So it shares the signature of bimap and can combine with the current bimap
+- [ ] Amend all, first, last, and named helper functions to support bimap and named results.
+- [ ] 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.18 → syncraft-0.1.20}/pyproject.toml

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

{syncraft-0.1.18 → syncraft-0.1.20}/syncraft/algebra.py

@@ -1,163 +1,120 @@
-"""
-We want to parse a token stream into an AST, and then generate a new token stream from that AST.
-The generation should be a dual to the parsing. By 'dual' we mean that the generation algebra should be 
-as close as possible to the parsing algebra. The closest algebra to the parsing algebra is the parsing 
-algebra itself. 
-
-Given:
-AST = Syntax(Parser)(ParserState([Token, ...]))
-AST =?= Syntax(Parser)(GenState(AST))
-
-where =?= means the LHS and RHS induce the same text output, e.g. the same token stream 
-inspite of the token metadata, token types, and/or potentially different structure of the AST.
-
-With the above setting, Generator as a dual to Parser, can reuse most of the parsing combinator, the 
-change needed is to introduce randomness in the generation process, e.g. to generate a random variable name, etc.
-
-[Token, ...] == Syntax(Generator)(GenState(AST))
-
-"""
-
-
 from __future__ import annotations
-
 from typing import (
     Optional, List, Any, TypeVar, Generic, Callable, Tuple, cast, 
-    Dict, Type, ClassVar, Hashable,
-    Mapping, Iterator
+    Dict, Type, ClassVar, Hashable
 )
 
 import traceback
-from dataclasses import dataclass, fields, replace, field
-from functools import cached_property
+from dataclasses import dataclass, replace
 from weakref import WeakKeyDictionary
-from abc import ABC, abstractmethod
+from abc import ABC
 from enum import Enum
+from functools import reduce
 
 
-
-
-class Insptectable(ABC):
-    @abstractmethod
-    def to_string(self, interested: Callable[[Any], bool]) -> Optional[str]:
-        raise NotImplementedError("Subclasses must implement to_string")
-    
-    @cached_property
-    def _string(self)->Optional[str]:
-        return self.to_string(lambda _: True)
-
-    def __repr__(self) -> str:
-        return self._string or self.__class__.__name__
-    def __str__(self) -> str:
-        return self._string or self.__class__.__name__
-
-
-A = TypeVar('A')  # Result type
-B = TypeVar('B')  # Result type for mapping
-
-S = TypeVar('S')  # State type for the Algebra
-
-    
-    
-class FrozenDict(Generic[A]):
-    def __init__(self, items: Mapping[str, A]):
-        for k, v in items.items():
-            if not isinstance(k, Hashable) or not isinstance(v, Hashable):
-                raise TypeError(f"Metadata key or value not hashable: {k} = {v}")
-        self._items = tuple(sorted(items.items()))
-
-    def __getitem__(self, key: str) -> A:
-        return dict(self._items)[key]
-
-    def __contains__(self, key: str) -> bool:
-        return key in dict(self._items)
-
-    def items(self) -> Iterator[tuple[str, A]]:
-        return iter(self._items)
-
-    def to_dict(self) -> dict[str, A]:
-        return dict(self._items)
-
-    def __hash__(self) -> int:
-        return hash(self._items)
-
-    def __eq__(self, other: object) -> bool:
-        return isinstance(other, FrozenDict) and self._items == other._items
-
-    def __repr__(self) -> str:
-        return f"FrozenDict({dict(self._items)})"
-
+A = TypeVar('A')  
+B = TypeVar('B')  
+C = TypeVar('C')  
+S = TypeVar('S')  
 
 
 @dataclass(frozen=True)
-class Lens(Generic[S, A]):
-    get: Callable[[S], A]
-    set: Callable[[S, A], S]    
-
-    def modify(self, source: S, f: Callable[[A], A]) -> S:
-        return self.set(source, f(self.get(source)))
-    
-    def bimap(self, ff: Callable[[A], B], bf: Callable[[B], A]) -> Lens[S, B]:
-        def getf(data: S) -> B:
-            return ff(self.get(data))
-
-        def setf(data: S, value: B) -> S:
-            return self.set(data, bf(value))
-
-        return Lens(get=getf, set=setf)
-
-    def __truediv__(self, other: Lens[A, B]) -> Lens[S, B]:
-        def get_composed(obj: S) -> B:
-            return other.get(self.get(obj))        
-        def set_composed(obj: S, value: B) -> S:
-            return self.set(obj, other.set(self.get(obj), value))
-        return Lens(get=get_composed, set=set_composed)
+class Bimap(Generic[S, A, B]):
+    forward: Callable[[S, A], Tuple[S, B]]
+    inverse: Callable[[S, B], Tuple[S, A]]
+    def __rshift__(self, other: Bimap[S, B, C]) -> Bimap[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 Bimap(
+            forward=fwd,
+            inverse=inv
+        )
+    @staticmethod
+    def identity()->Bimap[S, A, A]:
+        return Bimap(
+            forward=lambda s, x: (s, x),
+            inverse=lambda s, y: (s, y)
+        )
+    @staticmethod
+    def variable(value: A)->Bimap[S, A, A]:
+        return Bimap(
+            forward=lambda s, _: (s, value),
+            inverse=lambda s, y: (s, y)
+        )
+    @staticmethod
+    def const(state: S, value: A)->Bimap[Any, A, A]:
+        return Bimap(
+            forward=lambda s, _: (state, value),
+            inverse=lambda s, y: (state, value)
+        )
+    @staticmethod
+    def combine(*biarrows: Bimap[Any, Any, Any]) -> Bimap[Any, Any, Any]:
+        return reduce(lambda a, b: a >> b, biarrows, Bimap.identity()) 
+            
     
-    def __rtruediv__(self, other: Lens[B, S])->Lens[B, A]:
-        return other.__truediv__(self)
         
 class StructuralResult:
-    def bimap(self, ctx: Any)->Tuple[Any, Callable[[Any], StructuralResult]]:
-        return (self, lambda x: self)
-
+    def bimap(self, arr: Bimap[Any, Any, Any] = Bimap.identity()) -> Bimap[Any, Any, Any]:
+        return Bimap.identity()
         
 @dataclass(frozen=True)
 class NamedResult(Generic[A], StructuralResult):
     name: str
     value: A
-    def bimap(self, ctx: Any)->Tuple[NamedResult[Any], Callable[[NamedResult[Any]], StructuralResult]]:
-        value, backward = self.value.bimap(ctx) if isinstance(self.value, StructuralResult) else (self.value, lambda x: x)
-        def named_back(data: Any)->NamedResult[Any]:
-            v = backward(data)
-            if isinstance(v, NamedResult):
-                return replace(v, name=self.name)
-            else:
-                return NamedResult(name=self.name, value=v)
-        return NamedResult(self.name, value), named_back
-
+    def bimap(self, arr: Bimap[Any, Any, Any] = Bimap.identity()) -> Bimap[Any, NamedResult[A], NamedResult[Any]]:
+        inner_b = self.value.bimap(arr) if isinstance(self.value, StructuralResult) else arr
+        def fwd(s: S, a: NamedResult[A])-> Tuple[S, NamedResult[Any]]:
+            assert a == self, f"Expected {self}, got {a}"
+            inner_s, inner_v = inner_b.forward(s, a.value)
+            return (inner_s, replace(a, value=inner_v)) if not isinstance(inner_v, NamedResult) else (inner_s, inner_v)
+        
+        def inv(s: S, a: NamedResult[Any]) -> Tuple[S, NamedResult[A]]:
+            assert isinstance(a, NamedResult), f"Expected NamedResult, got {type(a)}"
+            inner_s, inner_v = inner_b.inverse(s, a.value)
+            return (inner_s, replace(self, value=inner_v)) if not isinstance(inner_v, NamedResult) else (inner_s, replace(self, value=inner_v.value))
+        
+        return Bimap(
+            forward=fwd,
+            inverse=inv
+        )    
 @dataclass(eq=True, frozen=True)
 class ManyResult(Generic[A], StructuralResult):
     value: Tuple[A, ...]
-    def bimap(self, ctx: Any)->Tuple[List[Any], Callable[[List[Any]], StructuralResult]]:
-        transformed = [v.bimap(ctx) if isinstance(v, StructuralResult) else (v, lambda x: x) for v in self.value]
-        backmaps = [b for (_, b) in transformed]
-        ret = [a for (a, _) in transformed]
-        def backward(data: List[Any]) -> StructuralResult:
-            if len(data) != len(transformed):
-                raise ValueError("Incompatible data length")
-            return ManyResult(value=tuple([backmaps[i](x) for i, x in enumerate(data)]))
-        return ret, lambda data: backward(data)
-
-
-
+    def bimap(self, arr: Bimap[Any, Any, Any] = Bimap.identity()) -> Bimap[Any, ManyResult[A], List[A]]:
+        inner_b = [v.bimap(arr) if isinstance(v, StructuralResult) else arr for v in self.value]
+        def fwd(s: Any, a: ManyResult[A]) -> Tuple[Any, List[A]]:
+            assert a == self, f"Expected {self}, got {a}"
+            return s, [inner_b[i].forward(s, v)[1] for i, v in enumerate(a.value)]
+            
+        def inv(s: Any, a: List[A]) -> Tuple[Any, ManyResult[A]]:
+            assert isinstance(a, list), f"Expected list, got {type(a)}"
+            assert len(a) == len(inner_b), f"Expected {len(inner_b)} elements, got {len(a)}"
+            return s, ManyResult(value=tuple(inner_b[i].inverse(s, v)[1] for i, v in enumerate(a)))
+        return Bimap(
+            forward=fwd,
+            inverse=inv
+        )    
 @dataclass(eq=True, frozen=True)
 class OrResult(Generic[A], StructuralResult):
     value: A
-    def bimap(self, ctx: Any) -> Tuple[Any, Callable[[Any], StructuralResult]]:
-        value, backward = self.value.bimap(ctx) if isinstance(self.value, StructuralResult) else (self.value, lambda x: x)
-        return value, lambda data: OrResult(value=backward(data))
-
-
+    def bimap(self, arr: Bimap[Any, Any, Any] = Bimap.identity()) -> Bimap[Any, OrResult[A], Any]:
+        inner_b = self.value.bimap(arr) if isinstance(self.value, StructuralResult) else arr
+        def fwd(s: Any, a: OrResult[A]) -> Tuple[Any, Any]:
+            assert a == self, f"Expected {self}, got {a}"
+            return inner_b.forward(s, a.value)
+        
+        def inv(s: Any, a: Any) -> Tuple[Any, OrResult[A]]:
+            inner_s, inner_v = inner_b.inverse(s, a)
+            return inner_s, OrResult(value=inner_v) 
+        
+        return Bimap(
+            forward=fwd,
+            inverse=inv
+        )    
 class ThenKind(Enum):
     BOTH = '+'
     LEFT = '//'
@@ -168,49 +125,60 @@ class ThenResult(Generic[A, B], StructuralResult):
     kind: ThenKind
     left: A
     right: B
-    def bimap(self, ctx: Any) -> Tuple[Any, Callable[[Any], StructuralResult]]:
-        def branch(b: Any) -> Tuple[Any, Callable[[Any], StructuralResult]]:
-            return b.bimap(ctx) if isinstance(b, StructuralResult) else (b, lambda x: x)
-        match self.kind:
-            case ThenKind.BOTH:
-                left_value, left_bmap = branch(self.left)
-                right_value, right_bmap = branch(self.right)
-                def backward(x: Tuple[Any, Any]) -> StructuralResult:
-                    return ThenResult(self.kind, left_bmap(x[0]), right_bmap(x[1]))
-                x, y = ThenResult.flat((left_value, right_value))
-                return x, lambda data: backward(y(data))
-            case ThenKind.LEFT:
-                left_value, left_bmap = branch(self.left)
-                return left_value, lambda data: ThenResult(self.kind, left_bmap(data), self.right)
-            case ThenKind.RIGHT:
-                right_value, right_bmap = branch(self.right)
-                return right_value, lambda data: ThenResult(self.kind, self.left, right_bmap(data))
-    @staticmethod
-    def flat(array: Tuple[Any, Any]) -> Tuple[Tuple[Any, ...], Callable[[Tuple[Any, ...]], Tuple[Any, Any]]]:
-        index: Dict[int, int] = {}
-        ret: List[Any] = []
-        for e in array:
-            if isinstance(e, tuple):
-                index[len(ret)] = len(e)
-                ret.extend(e)
-            else:
-                ret.append(e)
-        def backward(data: Tuple[Any, ...]) -> Tuple[Any, Any]:
-            tmp: List[Any] = []
-            skip: int = 0
-            for i, e in enumerate(data):
-                if skip <= 0:
-                    if i in index:
-                        tmp.append(tuple(data[i:i + index[i]]))
-                        skip = index[i] - 1
-                    else:
-                        tmp.append(e)
-                else:
-                    skip -= 1
-            return tuple(tmp)
-        return tuple(ret), backward
-
-
+    def arity(self)->int:
+        if self.kind == ThenKind.LEFT:
+            return self.left.arity() if isinstance(self.left, ThenResult) else 1
+        elif self.kind == ThenKind.RIGHT:
+            return self.right.arity() if isinstance(self.right, ThenResult) else 1
+        elif self.kind == ThenKind.BOTH:
+            left_arity = self.left.arity() if isinstance(self.left, ThenResult) else 1
+            right_arity = self.right.arity() if isinstance(self.right, ThenResult) else 1
+            return left_arity + right_arity
+        else:
+            return 1
+                
+    def bimap(self, arr: Bimap[Any, Any, Any] = Bimap.identity()) -> Bimap[Any, ThenResult[A, B], Tuple[Any, ...] | Any]:
+        kind = self.kind
+        lb = self.left.bimap(arr) if isinstance(self.left, StructuralResult) else arr
+        rb = self.right.bimap(arr) if isinstance(self.right, StructuralResult) else arr
+        left_size = self.left.arity() if isinstance(self.left, ThenResult) else 1
+        right_size = self.right.arity() if isinstance(self.right, ThenResult) else 1
+        def fwd(s : S, a : ThenResult[A, B]) -> Tuple[S, Tuple[Any, ...] | Any]:
+            assert a == self, f"Expected {self}, got {a}"
+            match kind:
+                case ThenKind.LEFT:
+                    return lb.forward(s, a.left)
+                case ThenKind.RIGHT:
+                    return rb.forward(s, a.right)
+                case ThenKind.BOTH:
+                    s1, left_v = lb.forward(s, a.left)
+                    s2, right_v = rb.forward(s1, a.right)
+                    left_v = (left_v,) if not isinstance(a.left, ThenResult) else left_v
+                    right_v = (right_v,) if not isinstance(a.right, ThenResult) else right_v
+                    return s2, left_v + right_v
+
+        def inv(s: S, b: Tuple[Any, ...] | Any) -> Tuple[S, ThenResult[A, B]]:
+            match kind:
+                case ThenKind.LEFT:
+                    s1, lv = lb.inverse(s, b)
+                    return s1, replace(self, left=lv)
+                case ThenKind.RIGHT:
+                    s1, rv = rb.inverse(s, b)
+                    return s1, replace(self, right=rv)
+                case ThenKind.BOTH:
+                    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
+                    s1, lv = lb.inverse(s, lraw)
+                    s2, rv = rb.inverse(s1, rraw)
+                    return s2, replace(self, left=lv, right=rv)
+            
+        return Bimap(
+            forward=fwd,
+            inverse=inv
+        )
+    
 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
@@ -233,7 +201,7 @@ class Right(Either[L, R]):
 
 
 @dataclass(frozen=True)
-class Error(Insptectable):
+class Error:
     this: Any
     message: Optional[str] = None
     error: Optional[Any] = None    
@@ -254,59 +222,9 @@ class Error(Insptectable):
             state=state,
             previous=self
         )
-    
-
 
 
-    def to_list(self, interested: Callable[[Any], bool]) -> List[Dict[str, str]]:
-
-        def to_dict() -> Dict[str, str]:
-            data: Dict[str, str] = {}
-            for f in fields(self):
-                value = getattr(self, f.name)
-                if isinstance(value, Error):
-                    # self.previous
-                    pass
-                elif isinstance(value, Insptectable):
-                    # self.this
-                    def inst(x: Any) -> bool:
-                        return x in self.algebras
-                    s = value.to_string(inst) 
-                    data[f.name] = s if s is not None else repr(value)
-                elif value is not None:
-                    # self.committed, self.message, self.expect, self.exception
-                    data[f.name] = repr(value)
-            return data
-        ret = []
-        tmp : None | Error = self
-        while tmp is not None:
-            ret.append(to_dict())
-            tmp = tmp.previous
-        return ret
-
-    def find(self, predicate: Callable[[Error], bool]) -> Optional[Error]:
-        if predicate(self):
-            return self
-        if self.previous is not None:
-            return self.previous.find(predicate)
-        return None
-    
-    def to_string(self, interested: Callable[[Any], bool])->str:
-        lst = self.to_list(interested)
-        root, leaf = lst[0], lst[-1]
-        root_fields = ',\n  '.join([f"{key}: {value}" for key, value in root.items() if value is not None])
-        leaf_fields = ',\n  '.join([f"{key}: {value}" for key, value in leaf.items() if value is not None])
-
-        return  f"{self.__class__.__name__}: ROOT\n"\
-                f"  {root_fields}\n"\
-                f"\u25cf \u25cf \u25cf  LEAF\n"\
-                f"  {leaf_fields}\n"
 
-
-    @cached_property
-    def algebras(self) -> List[Any]:
-        return [self.this] + (self.previous.algebras if self.previous is not None else [])
-        
 @dataclass(frozen=True)        
 class Algebra(ABC, Generic[A, S]):
 ######################################################## shared among all subclasses ########################################################

{syncraft-0.1.18 → syncraft-0.1.20}/syncraft/ast.py

@@ -3,12 +3,11 @@
 from __future__ import annotations
 import re
 from typing import (
-    Optional, Any, TypeVar, Tuple, runtime_checkable, Dict,
+    Optional, Any, TypeVar, Tuple, runtime_checkable, 
     Protocol, Generic, Callable, Union, cast
 )
 from syncraft.algebra import (
-    OrResult,ThenResult, ManyResult, ThenKind,NamedResult, StructuralResult,
-    Lens
+    OrResult,ThenResult, ManyResult, ThenKind,NamedResult, StructuralResult
 )
 from dataclasses import dataclass, replace, is_dataclass, asdict
 from enum import Enum
@@ -67,13 +66,17 @@ class AST(Generic[T]):
     pruned: bool = False
     parent: Optional[AST[T]] = None
 
-
-    def bimap(self, ctx: Any) -> Tuple[Any, Callable[[Any], AST[T]]]:
-        value, backward = self.focus.bimap(ctx) if isinstance(self.focus, StructuralResult) else (self.focus, lambda x: x)
-        def back2ast(data: Any) -> AST[T]:
-            return replace(self, focus=backward(data)) # type: ignore
-        return value, back2ast
-
+    def bimap(self)->Tuple[Any, Callable[[Any], AST[T]]]:
+        if isinstance(self.focus, StructuralResult):
+            b = self.focus.bimap() 
+            s, v = b.forward(None, self.focus)
+            def inverse(data: Any) -> AST[T]:
+                s1, v1 = b.inverse(None, data)
+                return replace(self, focus=v1)
+            return v, inverse
+        else:
+            return self.focus, lambda x: replace(self, focus=x)
+        
     def wrapper(self)-> Callable[[Any], Any]:
         if isinstance(self.focus, NamedResult):
             focus = cast(NamedResult[Any], self.focus)

{syncraft-0.1.18 → syncraft-0.1.20}/syncraft/diagnostic.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 from rich import print
 from rich.table import Table as RichTable
 from typing import Tuple, Any, Set
-from syncraft.dsl import DSL
+from syncraft.syntax import Syntax
 from syncraft.algebra import  Left, Right, Error, Either, Algebra
 
 from syncraft.parser import ParserState, Token
@@ -44,7 +44,7 @@ def rich_debug(this: Algebra[Any, ParserState[Any]],
                 return prefix + value.sql()
             elif isinstance(value, Token):
                 return prefix + f"{value.token_type.name}({value.text})"
-            elif isinstance(value, (Error, ParserState, DSL)):
+            elif isinstance(value, (Error, ParserState, Syntax)):
                 return prefix + (value._string or 'N/A')
             else:
                 return prefix + str(value)

{syncraft-0.1.18 → syncraft-0.1.20}/syncraft/generator.py

@@ -2,15 +2,17 @@ from __future__ import annotations
 
 from typing import (
     Any, TypeVar, Tuple, Optional,  Callable, Generic, Union, 
-    List
+    List, Generator as YieldGen
 )
 from functools import cached_property
 from dataclasses import dataclass, replace
 from syncraft.algebra import (
-    Algebra, ThenResult, Either, Left, Right, Error, Insptectable, 
-    OrResult, ManyResult
+    Algebra, ThenResult, Either, Left, Right, Error, 
+    OrResult, ManyResult, NamedResult
 )
+
 from syncraft.ast import TokenProtocol, ParseResult, AST, Token, TokenSpec
+from syncraft.syntax import Syntax
 from sqlglot import TokenType
 import re
 import rstr
@@ -29,7 +31,7 @@ GenResult = Union[
 ]
 
 @dataclass(frozen=True)
-class GenState(Generic[T], Insptectable):
+class GenState(Generic[T]):
     ast: Optional[AST[T]]
     seed: int
 
@@ -270,7 +272,8 @@ class Generator(Algebra[GenResult[T], GenState[T]]):
 
 
 
-def generate(gen: Algebra[Any, Any], data: Optional[AST[Any]] = None, seed: int = 0) -> AST[Any] | Any:
+def generate(syntax: Syntax[Any, Any], data: Optional[AST[Any]] = None, seed: int = 0) -> AST[Any] | Any:
+    gen = syntax(Generator)
     state = GenState.from_ast(data, seed)
     result = gen.run(state, use_cache=False)
     if isinstance(result, Right):
@@ -278,3 +281,28 @@ def generate(gen: Algebra[Any, Any], data: Optional[AST[Any]] = None, seed: int
     assert isinstance(result, Left), "Generator must return Either[Any, Tuple[Any, Any]]"
     return result.value
 
+
+def matches(syntax: Syntax[Any, Any], data: AST[Any])-> bool:
+    gen = syntax(Generator)
+    state = GenState.from_ast(data)
+    result = gen.run(state, use_cache=True)
+    return isinstance(result, Right)
+
+
+def search(syntax: Syntax[Any, Any], data: AST[Any]) -> YieldGen[AST[Any], None, None]:
+    if matches(syntax, data):
+        yield data
+    match data.focus:
+        case ThenResult(left = left, right=right):
+            yield from search(syntax, AST(left))
+            yield from search(syntax, AST(right))
+        case ManyResult(value = value):
+            for e in value:
+                yield from search(syntax, AST(e))
+        case NamedResult(value=value):
+            yield from search(syntax, AST(value))
+        case OrResult(value=value):
+            yield from search(syntax, AST(value))
+        case _:
+            pass
+