syncraft 0.1.19__py3-none-any.whl → 0.1.21__py3-none-any.whl

syncraft/algebra.py

@@ -1,163 +1,136 @@
-"""
-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)))
+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 when(condition: Callable[..., bool], 
+             then: Bimap[S, A, B], 
+             otherwise: Optional[Bimap[S, A, B]] = None) -> Callable[..., Bimap[S, A, B]]:
+        def _when(*args:Any, **kwargs:Any) -> Bimap[S, A, B]:
+            return then if condition(*args, **kwargs) else (otherwise or Bimap.identity())
+        return _when
     
-    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)
     
-    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, 
+              before: Callable[[Any], Bimap[Any, Any, Any]] = lambda _: Bimap.identity(),
+              after: Callable[[Any], Bimap[Any, Any, Any]] = lambda _: 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, 
+              before: Callable[[Any], Bimap[Any, Any, Any]] = lambda _: Bimap.identity(),
+              after: Callable[[Any], Bimap[Any, Any, Any]] = lambda _: Bimap.identity()
+              ) -> Bimap[Any, NamedResult[A], NamedResult[Any]]:
+        inner_b = self.value.bimap(before, after) if isinstance(self.value, StructuralResult) else before(self.value) >> after(self.value)
+        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))
+        ret: Bimap[Any, Any, Any]  = Bimap(
+            forward=fwd,
+            inverse=inv
+        )    
+        return before(self) >> ret >> after(self)
 @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, 
+              before: Callable[[Any], Bimap[Any, Any, Any]] = lambda _: Bimap.identity(),
+              after: Callable[[Any], Bimap[Any, Any, Any]] = lambda _: Bimap.identity()
+              ) -> Bimap[Any, ManyResult[A], List[A]]:
+        # We don't allow zero length ManyResult e.g. many(at_least >= 1) at the syntax level
+        # so inner_b has at least 1 element
+        assert len(self.value) > 0, "ManyResult must have at least one element"
+        inner_b = [v.bimap(before, after) if isinstance(v, StructuralResult) else before(v) >> after(v) 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)}"
+            ret = [inner_b[i].inverse(s, v)[1] for i, v in enumerate(a)]
+            if len(ret) <= len(inner_b):
+                return s, ManyResult(value=tuple(ret))
+            else:
+                extra = [inner_b[-1].inverse(s, v)[1] for v in a[len(inner_b):]]
+                return s, ManyResult(value=tuple(ret + extra))
 
+        ret = Bimap(
+            forward=fwd,
+            inverse=inv
+        )    
+        return before(self) >> ret >> after(self)
 
 @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, 
+              before: Callable[[Any], Bimap[Any, Any, Any]] = lambda _: Bimap.identity(),
+              after: Callable[[Any], Bimap[Any, Any, Any]] = lambda _: Bimap.identity()              
+              ) -> Bimap[Any, OrResult[A], Any]:
+        inner_b = self.value.bimap(before, after) if isinstance(self.value, StructuralResult) else before(self.value) >> after(self.value)
+        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) 
+        
+        ret = Bimap(
+            forward=fwd,
+            inverse=inv
+        )    
+        return before(self) >> ret >> after(self)
 class ThenKind(Enum):
     BOTH = '+'
     LEFT = '//'
@@ -168,49 +141,64 @@ 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, 
+              before: Callable[[Any], Bimap[Any, Any, Any]] = lambda _: Bimap.identity(),
+              after: Callable[[Any], Bimap[Any, Any, Any]] = lambda _: Bimap.identity()            
+              ) -> Bimap[Any, ThenResult[A, B], Tuple[Any, ...] | Any]:
+        kind = self.kind
+        lb = self.left.bimap(before, after) if isinstance(self.left, StructuralResult) else before(self.left) >> after(self.left)
+        rb = self.right.bimap(before, after) if isinstance(self.right, StructuralResult) else before(self.right) >> after(self.right)
+        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)
+            
+        ret: Bimap[Any, Any, Any] = Bimap(
+            forward=fwd,
+            inverse=inv
+        )
+        return before(self) >> ret >> after(self)
+    
 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 +221,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 +242,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/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/finder.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+from typing import (
+    Any, Tuple, Optional,  Callable,
+    List, Generator as YieldGen
+)
+from dataclasses import dataclass
+from syncraft.algebra import (
+    Algebra, Either, Left, Right, Error, 
+    OrResult, ManyResult, ThenResult, NamedResult
+)
+
+from syncraft.ast import T, ParseResult, Token, AST
+from syncraft.generator import GenState, TokenGen, B
+from sqlglot import TokenType
+from syncraft.syntax import Syntax
+import re
+
+@dataclass(frozen=True)
+class Finder(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(original: GenState[T], use_cache:bool) -> Either[Any, Tuple[B, GenState[T]]]:
+            wrapper = original.wrapper()
+            input = original if not original.is_named else original.down(0)  # If the input is named, we need to go down to the first child
+            try:
+                lft = input.left() 
+                match self.run(lft, use_cache=use_cache):
+                    case Left(error):
+                        return Left(error)
+                    case Right((value, next_input)):
+                        r = input.right() 
+                        match f(value).run(r, use_cache):
+                            case Left(e):
+                                return Left(e)
+                            case Right((result, next_input)):
+                                return Right((wrapper(result), next_input))
+                raise ValueError("flat_map should always return a value or an error.")
+            except Exception as e:
+                return Left(Error(
+                    message=str(e),
+                    this=self,
+                    state=original,
+                    error=e
+                ))
+        return Finder(run_f = flat_map_run, name=self.name) # type: ignore
+
+
+    def many(self, *, at_least: int, at_most: Optional[int]) -> Algebra[ManyResult[ParseResult[T]], GenState[T]]:
+        assert at_least > 0, "at_least must be greater than 0"
+        assert at_most is None or at_least <= at_most, "at_least must be less than or equal to at_most"
+        def many_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[ManyResult[ParseResult[T]], GenState[T]]]:
+            wrapper = input.wrapper()
+            input = input if not input.is_named else input.down(0)  # If the input is named, we need to go down to the first child
+            ret = []
+            for index in range(input.how_many): 
+                match self.run(input.down(index), use_cache):
+                    case Right((value, next_input)):
+                        ret.append(value)
+                        if at_most is not None and len(ret) > at_most:
+                            return Left(Error(
+                                    message=f"Expected at most {at_most} matches, got {len(ret)}",
+                                    this=self,
+                                    state=input.down(index)
+                                ))                             
+                    case Left(_):
+                        pass
+            if len(ret) < at_least:
+                return Left(Error(
+                    message=f"Expected at least {at_least} matches, got {len(ret)}",
+                    this=self,
+                    state=input.down(index)
+                )) 
+            return Right((wrapper(ManyResult(tuple(ret))), input))
+        return self.__class__(many_run, name=f"many({self.name})")  # type: ignore
+    
+ 
+    def or_else(self, # type: ignore
+                other: Algebra[ParseResult[T], GenState[T]]
+                ) -> Algebra[OrResult[ParseResult[T]], GenState[T]]: 
+        def or_else_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[OrResult[ParseResult[T]], GenState[T]]]:
+            wrapper = input.wrapper()
+            input = input if not input.is_named else input.down(0)  # If the input is named, we need to go down to the first child
+            match self.run(input.down(0), use_cache):
+                case Right((value, next_input)):
+                    return Right((wrapper(OrResult(value)), next_input))
+                case Left(error):
+                    match other.run(input.down(0), use_cache):
+                        case Right((value, next_input)):
+                            return Right((wrapper(OrResult(value)), next_input))
+                        case Left(error):
+                            return Left(error)
+            raise ValueError("or_else should always return a value or an error.")
+        return self.__class__(or_else_run, name=f"or_else({self.name} | {other.name})") # type: ignore
+
+    @classmethod
+    def token(cls, 
+              token_type: Optional[TokenType] = None, 
+              text: Optional[str] = None, 
+              case_sensitive: bool = False,
+              regex: Optional[re.Pattern[str]] = None
+              )-> Algebra[ParseResult[T], GenState[T]]:      
+        gen = TokenGen(token_type=token_type, text=text, case_sensitive=case_sensitive, regex=regex)  
+        lazy_self: Algebra[ParseResult[T], GenState[T]]
+        def token_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[ParseResult[Token], GenState[T]]]:
+            wrapper = input.wrapper()
+            input = input if not input.is_named else input.down(0)  # If the input is named, we need to go down to the first child
+            current = input.focus
+            if not isinstance(current, Token) or not gen.is_valid(current):
+                return Left(Error(None, 
+                                    message=f"Expected a Token, but got {type(current)}.", 
+                                    state=input))
+            return Right((wrapper(current), input))
+        lazy_self = cls(token_run, name=cls.__name__ + f'.token({token_type or text or regex})')  # type: ignore
+        return lazy_self
+
+    @classmethod
+    def anything(cls)->Algebra[ParseResult[T], GenState[T]]:
+        def anything_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[ParseResult[T], GenState[T]]]:
+            wrapper = input.wrapper()
+            return Right((wrapper(input.focus), input))
+        return cls(anything_run, name=cls.__name__ + '.anything()')
+
+
+
+anything = Syntax(lambda cls: cls.factory('anything')).describe(name="anything", fixity='infix') 
+
+def matches(syntax: Syntax[Any, Any], data: AST[Any])-> bool:
+    gen = syntax(Finder)
+    state = GenState.from_ast(data)
+    result = gen.run(state, use_cache=True)
+    return isinstance(result, Right)
+
+
+def find(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 find(syntax, AST(left))
+            yield from find(syntax, AST(right))
+        case ManyResult(value = value):
+            for e in value:
+                yield from find(syntax, AST(e))
+        case NamedResult(value=value):
+            yield from find(syntax, AST(value))
+        case OrResult(value=value):
+            yield from find(syntax, AST(value))
+        case _:
+            pass

syncraft/generator.py

@@ -1,17 +1,17 @@
 from __future__ import annotations
 
 from typing import (
-    Any, TypeVar, Tuple, Optional,  Callable, Generic, Union, 
-    List, Generator as YieldGen
+    Any, TypeVar, Tuple, Optional,  Callable, Generic, 
+    List, 
 )
 from functools import cached_property
 from dataclasses import dataclass, replace
 from syncraft.algebra import (
-    Algebra, ThenResult, Either, Left, Right, Error, Insptectable, 
-    OrResult, ManyResult, NamedResult
+    Algebra, Either, Left, Right, Error, 
+    OrResult, ManyResult
 )
 
-from syncraft.ast import TokenProtocol, ParseResult, AST, Token, TokenSpec
+from syncraft.ast import T, ParseResult, AST, Token, TokenSpec
 from syncraft.syntax import Syntax
 from sqlglot import TokenType
 import re
@@ -20,18 +20,10 @@ from functools import lru_cache
 import random
 
 B = TypeVar('B')
-T = TypeVar('T', bound=TokenProtocol)  
 
-GenResult = Union[
-    ThenResult['GenResult[T]', 'GenResult[T]'], 
-    ManyResult['GenResult[T]'],
-    OrResult['GenResult[T]'],
-
-    T
-]
 
 @dataclass(frozen=True)
-class GenState(Generic[T], Insptectable):
+class GenState(Generic[T]):
     ast: Optional[AST[T]]
     seed: int
 
@@ -150,8 +142,8 @@ class TokenGen(TokenSpec):
 
 
 @dataclass(frozen=True)
-class Generator(Algebra[GenResult[T], GenState[T]]):  
-    def flat_map(self, f: Callable[[GenResult[T]], Algebra[B, GenState[T]]]) -> Algebra[B, GenState[T]]: 
+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(original: GenState[T], use_cache:bool) -> Either[Any, Tuple[B, GenState[T]]]:
             wrapper = original.wrapper()
             input = original if not original.is_named else original.down(0)  # If the input is named, we need to go down to the first child
@@ -178,10 +170,10 @@ class Generator(Algebra[GenResult[T], GenState[T]]):
         return Generator(run_f = flat_map_run, name=self.name) # type: ignore
 
 
-    def many(self, *, at_least: int, at_most: Optional[int]) -> Algebra[ManyResult[GenResult[T]], GenState[T]]:
+    def many(self, *, at_least: int, at_most: Optional[int]) -> Algebra[ManyResult[ParseResult[T]], GenState[T]]:
         assert at_least > 0, "at_least must be greater than 0"
         assert at_most is None or at_least <= at_most, "at_least must be less than or equal to at_most"
-        def many_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[ManyResult[GenResult[T]], GenState[T]]]:
+        def many_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[ManyResult[ParseResult[T]], GenState[T]]]:
             wrapper = input.wrapper()
             input = input if not input.is_named else input.down(0)  # If the input is named, we need to go down to the first child
             if input.pruned:
@@ -221,9 +213,9 @@ class Generator(Algebra[GenResult[T], GenState[T]]):
     
  
     def or_else(self, # type: ignore
-                other: Algebra[GenResult[T], GenState[T]]
-                ) -> Algebra[OrResult[GenResult[T]], GenState[T]]: 
-        def or_else_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[OrResult[GenResult[T]], GenState[T]]]:
+                other: Algebra[ParseResult[T], GenState[T]]
+                ) -> Algebra[OrResult[ParseResult[T]], GenState[T]]: 
+        def or_else_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[OrResult[ParseResult[T]], GenState[T]]]:
             wrapper = input.wrapper()
             input = input if not input.is_named else input.down(0)  # If the input is named, we need to go down to the first child
             if input.pruned:
@@ -252,10 +244,10 @@ class Generator(Algebra[GenResult[T], GenState[T]]):
               text: Optional[str] = None, 
               case_sensitive: bool = False,
               regex: Optional[re.Pattern[str]] = None
-              )-> Algebra[GenResult[T], GenState[T]]:      
+              )-> Algebra[ParseResult[T], GenState[T]]:      
         gen = TokenGen(token_type=token_type, text=text, case_sensitive=case_sensitive, regex=regex)  
-        lazy_self: Algebra[GenResult[T], GenState[T]]
-        def token_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[GenResult[Token], GenState[T]]]:
+        lazy_self: Algebra[ParseResult[T], GenState[T]]
+        def token_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[ParseResult[Token], GenState[T]]]:
             wrapper = input.wrapper()
             input = input if not input.is_named else input.down(0)  # If the input is named, we need to go down to the first child
             if input.pruned:
@@ -282,27 +274,4 @@ def generate(syntax: Syntax[Any, Any], data: Optional[AST[Any]] = None, seed: in
     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
     

syncraft/parser.py

@@ -6,7 +6,7 @@ from typing import (
     Generic, Callable
 )
 from syncraft.algebra import (
-    Either, Left, Right, Error, Insptectable, Algebra
+    Either, Left, Right, Error, Algebra
 )
 from dataclasses import dataclass, field, replace
 from enum import Enum
@@ -16,15 +16,8 @@ from syncraft.syntax import Syntax
 from syncraft.ast import Token, TokenSpec, AST, T
 
 
-
-
-
-
-
-
-
 @dataclass(frozen=True)
-class ParserState(Generic[T], Insptectable):
+class ParserState(Generic[T]):
     input: Tuple[T, ...] = field(default_factory=tuple)
     index: int = 0
     
@@ -40,13 +33,6 @@ class ParserState(Generic[T], Insptectable):
     def after(self, length: Optional[int] = 5)->str:
         length = min(length, len(self.input) - self.index) if length is not None else len(self.input) - self.index
         return " ".join(token.text for token in self.input[self.index:self.index + length])
- 
-    def to_string(self, interested: Callable[[Any], bool])->str:
-        return f"ParserState(\n"\
-               f"index={self.index}, \n"\
-               f"input({len(self.input)})=[{self.token_sample_string()}, ...]), \n"\
-               f"before=({self.before()}), \n"\
-               f"after=({self.after()})"  
 
 
     def current(self)->T:

syncraft/syntax.py

@@ -6,7 +6,7 @@ from typing import (
 )
 from dataclasses import dataclass, field, replace
 from functools import reduce
-from syncraft.algebra import Algebra, Error, Either, Insptectable, ThenResult, ManyResult, ThenKind, NamedResult
+from syncraft.algebra import Algebra, Error, Either, ThenResult, ManyResult, ThenKind, NamedResult
 from types import MethodType, FunctionType
 
 
@@ -17,8 +17,35 @@ B = TypeVar('B')  # Result type for mapping
 C = TypeVar('C')  # Result type for else branch
 S = TypeVar('S')  # State type
 
+
+class Variable(Generic[A]):
+    def __init__(self, name: Optional[str] = None):
+        self.name = name
+        self.initialized = False
+        self._value = None
+    def __call__(self, a: Any) -> Any:
+        if self.initialized:
+            if self._value != a:
+                raise ValueError(f"Variable {self.name or ''} is already initialized")
+            else:
+                return a
+        elif self.name is not None and isinstance(a, NamedResult):
+            if a.name == self.name:
+                self._value = a.value
+                self.initialized = True
+        else:
+            self._value = a
+            self.initialized = True
+        return a
+    @property
+    def value(self) -> A:
+        if self.initialized is False or self._value is None:
+            raise ValueError(f"Variable {self.name or ''} is not initialized")
+        return self._value
+
+
 @dataclass(frozen=True)
-class Description(Insptectable):
+class Description:
     name: Optional[str] = None
     newline: Optional[str] = None
     fixity: Literal['infix', 'prefix', 'postfix'] = 'infix'
@@ -67,7 +94,7 @@ class Description(Insptectable):
 
 
 @dataclass(frozen=True)
-class Syntax(Generic[A, S], Insptectable):
+class Syntax(Generic[A, S]):
     alg: Callable[[Type[Algebra[Any, Any]]], Algebra[A, S]]
     meta: Description = field(default_factory=Description, repr=False)
 
@@ -98,8 +125,6 @@ class Syntax(Generic[A, S], Insptectable):
         return self.__class__(alg=algebra_run, meta=self.meta)
                 
 
-
-
     def as_(self, typ: Type[B])->B:
         return cast(typ, self) # type: ignore
         
@@ -234,6 +259,8 @@ class Syntax(Generic[A, S], Insptectable):
                 return NamedResult(name=name, value=value)
         return self.map(bind_f).describe(name=f'bind("{name}")', fixity='postfix', parameter=[self]) 
 
+    def assign(self, var: Variable[A]) -> Syntax[A, S]:
+        return self.map(var).describe(name=f'assign({var.name or ""})', fixity='postfix', parameter=[self])
 
     def dump_error(self, formatter: Optional[Callable[[Error], None]] = None) -> Syntax[A, S]:
         def dump_error_run(err: Any)->Any:
@@ -263,12 +290,6 @@ def choice(*parsers: Syntax[Any, S]) -> Syntax[Any, S]:
     return reduce(lambda a, b: a | b, parsers) if len(parsers) > 0 else success(None)
 
 
-
-
-
-
-
-
 def all(*parsers: Syntax[Any, S]) -> Syntax[ThenResult[Any, Any], S]:
     return reduce(lambda a, b: a + b, parsers) if len(parsers) > 0 else success(None)
 

{syncraft-0.1.19.dist-info → syncraft-0.1.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncraft
-Version: 0.1.19
+Version: 0.1.21
 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.21.dist-info/RECORD

@@ -0,0 +1,16 @@
+syncraft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syncraft/algebra.py,sha256=bya-2b5WpCcOMxgJjGqrFaNG8dCjs5NUqnxbJTc4uOM,21908
+syncraft/ast.py,sha256=Hn88_xOqSzrHYtPjNFKREJuE6yISmNI-VVTcU6PJKI0,4737
+syncraft/cmd.py,sha256=DzXgU8QLVOg0YTFKpmOyzbf02LKPphQ4EeKSLzqpJ_s,2012
+syncraft/diagnostic.py,sha256=mnzzceE9HpN2jVa7ztecZCz3sbCD79JxgkdLhJRBsvY,2822
+syncraft/finder.py,sha256=zADOQQdcHu60413ZrRxTSq-E5EAJ9xv0OQodCpoYpo0,7202
+syncraft/generator.py,sha256=Mh9Sx1hNR0EAWcox6MMvVw7aq2s33TU4stGZFZ1N1cw,11287
+syncraft/parser.py,sha256=PSy9s3q_KXQh-Qlg0NxvJixxcgVYi3yCq0ebqlA5WwM,11288
+syncraft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syncraft/sqlite3.py,sha256=Pq09IHZOwuWg5W82l9D1flzd36QV0TOHQpTJ5U02V8g,34701
+syncraft/syntax.py,sha256=yUp3DmDnkwNEqDAFZH4vesjdnbIUsrwFjWN-Ljy1qN4,14880
+syncraft-0.1.21.dist-info/licenses/LICENSE,sha256=wHSV424U5csa3339dy1AZbsz2xsd0hrkMx2QK48CcUk,1062
+syncraft-0.1.21.dist-info/METADATA,sha256=cJyW-BifZOf3RdmFKp1-auJv13aMNjRwk1VDqPG5gR4,1381
+syncraft-0.1.21.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+syncraft-0.1.21.dist-info/top_level.txt,sha256=Kq3t8ESXB2xW1Xt3uPmkENFc-c4f2pamNmaURBk7zc8,9
+syncraft-0.1.21.dist-info/RECORD,,

syncraft-0.1.19.dist-info/RECORD

@@ -1,15 +0,0 @@
-syncraft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-syncraft/algebra.py,sha256=l_ptzSkXbRGSLzu46GXixcNQPdXAi1s5R9nRDI86JkY,22785
-syncraft/ast.py,sha256=9CuHqXRiw_7UMDLd4x2def3kHgTVQ0hnPxyIbBlx1Zc,4640
-syncraft/cmd.py,sha256=DzXgU8QLVOg0YTFKpmOyzbf02LKPphQ4EeKSLzqpJ_s,2012
-syncraft/diagnostic.py,sha256=mnzzceE9HpN2jVa7ztecZCz3sbCD79JxgkdLhJRBsvY,2822
-syncraft/generator.py,sha256=P2NoSBnTn4i3YV-fuIozmzXwRPR7J8sN-Paj3gQXrtg,12383
-syncraft/parser.py,sha256=BzNOiuc9iLt0wSxN79bNC9x0xsMIQcDdIN1Ndp0D3B8,11642
-syncraft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-syncraft/sqlite3.py,sha256=Pq09IHZOwuWg5W82l9D1flzd36QV0TOHQpTJ5U02V8g,34701
-syncraft/syntax.py,sha256=XTXx0Sf2Elbt0GVTYPt-g-1InTPvZeptcpquugf8My0,13884
-syncraft-0.1.19.dist-info/licenses/LICENSE,sha256=wHSV424U5csa3339dy1AZbsz2xsd0hrkMx2QK48CcUk,1062
-syncraft-0.1.19.dist-info/METADATA,sha256=c-xyYpD0DMsrsZCHNzqyK7X5e8JneLA84Rm5T7m2kHc,946
-syncraft-0.1.19.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-syncraft-0.1.19.dist-info/top_level.txt,sha256=Kq3t8ESXB2xW1Xt3uPmkENFc-c4f2pamNmaURBk7zc8,9
-syncraft-0.1.19.dist-info/RECORD,,