syncraft 0.1.24__py3-none-any.whl → 0.1.26__py3-none-any.whl

syncraft/algebra.py

@@ -8,7 +8,7 @@ import traceback
 from dataclasses import dataclass, replace, asdict
 from weakref import WeakKeyDictionary
 from abc import ABC
-from syncraft.ast import ThenKind, ThenResult, ManyResult, OrResult, S
+from syncraft.ast import ThenKind, Then, S, Choice, Many, ChoiceKind
     
 A = TypeVar('A')  # Result type
 B = TypeVar('B')  # Mapped result type
@@ -235,15 +235,24 @@ class Algebra(ABC, Generic[A, S]):
         return lazy_self
 
 
-######################################################## fundamental combinators ############################################
-    def map(self, f: Callable[[A], B]) -> Algebra[B, S]:
-        def map_run(input: S, use_cache:bool) -> Either[Any, Tuple[B, S]]:
+######################################################## fundamental combinators ############################################    
+    def fmap(self, f: Callable[[A], B]) -> Algebra[B, S]:
+        def fmap_run(input: S, use_cache:bool) -> Either[Any, Tuple[B, S]]:
             parsed = 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__(fmap_run, name=self.name)  # type: ignore
+
+    def imap(self, f: Callable[[B], A]) -> Algebra[A, S]:
+        return self.map_state(lambda s: s.map(f))
+    
+    def map(self, f: Callable[[A], B]) -> Algebra[B, S]:
+        return self.fmap(f)
+    
+    def bimap(self, f: Callable[[A], B], i: Callable[[B], A]) -> Algebra[A, S]:
+        return self.fmap(f).as_(Algebra[A, S]).imap(i)
 
     def map_all(self, f: Callable[[Either[Any, Tuple[A, S]]], Either[Any, Tuple[B, S]]])->Algebra[B, S]:
         def map_all_run(input: S, use_cache:bool) -> Either[Any, Tuple[B, S]]:
@@ -275,41 +284,48 @@ class Algebra(ABC, Generic[A, S]):
         return self.__class__(flat_map_run, name=self.name)  # type: ignore
 
     
-    def or_else(self: Algebra[A, S], other: Algebra[B, S]) -> Algebra[OrResult[A | B], S]:
-        def or_else_run(input: S, use_cache:bool) -> Either[Any, Tuple[OrResult[A | B], S]]:
+    def or_else(self: Algebra[A, S], other: Algebra[B, S]) -> Algebra[Choice[A, B], S]:
+        def or_else_run(input: S, use_cache:bool) -> Either[Any, Tuple[Choice[A, B], S]]:
             match self.run(input, use_cache):
                 case Right((value, state)):
-                    return Right((OrResult(value=value), state))
+                    return Right((Choice(kind=ChoiceKind.LEFT, left=value, right=None), state))
                 case Left(err):
                     if isinstance(err, Error) and err.committed:
                         return Left(err)
                     match other.run(input, use_cache):
                         case Right((other_value, other_state)):
-                            return Right((OrResult(value=other_value), other_state))
+                            return Right((Choice(kind=ChoiceKind.RIGHT, left=None, right=other_value), other_state))
                         case Left(other_err):
                             return Left(other_err)
                     raise TypeError(f"Unexpected result type from {other}")
             raise TypeError(f"Unexpected result type from {self}")
         return self.__class__(or_else_run, name=f'{self.name} | {other.name}')  # type: ignore
 
-    def then_both(self, other: 'Algebra[B, S]') -> 'Algebra[ThenResult[A, B], S]':
-        def then_both_f(a: A) -> Algebra[ThenResult[A, B], S]:
-            def combine(b: B) -> ThenResult[A, B]:
-                return ThenResult(left=a, right=b, kind=ThenKind.BOTH)
-            return other.map(combine)
+    def then_both(self, other: 'Algebra[B, S]') -> 'Algebra[Then[A, B], S]':
+        def then_both_f(a: A) -> Algebra[Then[A, B], S]:
+            def combine(b: B) -> Then[A, B]:
+                return Then(left=a, right=b, kind=ThenKind.BOTH)
+            return other.fmap(combine)
         return self.flat_map(then_both_f).named(f'{self.name} + {other.name}')
-            
-    def then_left(self, other: Algebra[B, S]) -> Algebra[ThenResult[A, B], S]:
-        return self.then_both(other).map(lambda b: replace(b, kind = ThenKind.LEFT)).named(f'{self.name} // {other.name}')
-
-    def then_right(self, other: Algebra[B, S]) -> Algebra[ThenResult[A, B], S]:
-        return self.then_both(other).map(lambda b: replace(b, kind=ThenKind.RIGHT)).named(f'{self.name} >> {other.name}')
-
 
-    def many(self, *, at_least: int, at_most: Optional[int]) -> Algebra[ManyResult[A], S]:
+    def then_left(self, other: Algebra[B, S]) -> 'Algebra[Then[A, B], S]':
+        def then_left_f(a: A) -> Algebra[Then[A, B], S]:
+            def combine(b: B) -> Then[A, B]:
+                return Then(left=a, right=b, kind=ThenKind.LEFT)
+            return other.fmap(combine)
+        return self.flat_map(then_left_f).named(f'{self.name} // {other.name}')
+
+    def then_right(self, other: Algebra[B, S]) -> 'Algebra[Then[A, B], S]':
+        def then_right_f(a: A) -> Algebra[Then[A, B], S]:
+            def combine(b: B) -> Then[A, B]:
+                return Then(left=a, right=b, kind=ThenKind.RIGHT)
+            return other.fmap(combine)
+        return self.flat_map(then_right_f).named(f'{self.name} >> {other.name}')
+
+    def many(self, *, at_least: int, at_most: Optional[int]) -> Algebra[Many[A], S]:
         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: S, use_cache:bool) -> Either[Any, Tuple[ManyResult[A], S]]:
+        def many_run(input: S, use_cache:bool) -> Either[Any, Tuple[Many[A], S]]:
             ret: List[A] = []
             current_input = input
             while True:
@@ -333,7 +349,7 @@ class Algebra(ABC, Generic[A, S]):
                         this=self,
                         state=current_input
                     )) 
-            return Right((ManyResult(value=tuple(ret)), current_input))
+            return Right((Many(value=tuple(ret)), current_input))
         return self.__class__(many_run, name=f'*({self.name})') # type: ignore
 
     

syncraft/ast.py

@@ -10,7 +10,7 @@ from typing import (
 
 from dataclasses import dataclass, replace, is_dataclass, asdict
 from enum import Enum
-from functools import cached_property
+
 from syncraft.constraint import Binding, Variable, Bindable
 
 
@@ -99,42 +99,28 @@ class Biarrow(Generic[S, A, B]):
         return _when
     
 
-    
-class StructuralResult:
-
-    def bimap(self, f: Bimap[Any, Any]=Bimap.identity())->Tuple[Any, Callable[[Any], Any]]:
-        return f(self)
+@dataclass(frozen=True)    
+class AST:
+    pass
 
-    
+class ChoiceKind(Enum):
+    LEFT = 'left'
+    RIGHT = 'right'
 @dataclass(frozen=True)
-class MarkedResult(Generic[A], StructuralResult):
-    name: str
-    value: A
-    def bimap(self, f: Bimap[A, B]=Bimap.identity())->Tuple[MarkedResult[B], Callable[[MarkedResult[B]], MarkedResult[A]]]:
-        b, inv = self.value.bimap(f) if isinstance(self.value, StructuralResult) else f(self.value)
-        return MarkedResult(name=self.name, value=b), lambda b: replace(self, value=inv(b.value))
+class Choice(Generic[A, B], AST):
+    kind: ChoiceKind
+    left: Optional[A] 
+    right: Optional[B] 
 
 
-@dataclass(eq=True, frozen=True)
-class ManyResult(Generic[A], StructuralResult):
+@dataclass(frozen=True)
+class Many(Generic[A], AST):
     value: Tuple[A, ...]
-    def bimap(self, f: Bimap[A, B]=Bimap.identity())->Tuple[List[B], Callable[[List[B]], ManyResult[A]]]:
-        assert self.value
-        forward = [v.bimap(f) if isinstance(v, StructuralResult) else f(v) for v in self.value]
-        def invf(b: List[B]) -> ManyResult[A]:
-            assert len(b) <= len(forward)
-            return replace(self, value=tuple([forward[i][1](bb) for i, bb in enumerate(b)]))
-        return [b for b, _ in forward], invf
 
-
-
-@dataclass(eq=True, frozen=True)
-class OrResult(Generic[A], StructuralResult):
+@dataclass(frozen=True)
+class Marked(Generic[A], AST):
+    name: str
     value: A
-    def bimap(self, f: Bimap[A, B]=Bimap.identity())->Tuple[B, Callable[[B], OrResult[A]]]:
-        b, inv = self.value.bimap(f) if isinstance(self.value, StructuralResult) else f(self.value)
-        return b, lambda b: replace(self, value=inv(b))
-
 class ThenKind(Enum):
     BOTH = '+'
     LEFT = '//'
@@ -144,83 +130,10 @@ FlatThen = Tuple[Any, ...]
 MarkedThen = Tuple[Dict[str, Any] | Any, FlatThen]
 
 @dataclass(eq=True, frozen=True)
-class ThenResult(Generic[A, B], StructuralResult):
+class Then(Generic[A, B], AST):
     kind: ThenKind
-    left: A
-    right: B
-    @staticmethod
-    def collect_marked(a: FlatThen, f: Optional[Callable[..., Any]] = None)->Tuple[MarkedThen, Callable[[MarkedThen], FlatThen]]:
-        index: List[str | int] = []
-        named_count = 0
-        for i, v in enumerate(a):
-            if isinstance(v, MarkedResult):
-                index.append(v.name)
-                named_count += 1
-            else:
-                index.append(i - named_count)
-        named = {v.name: v.value for v in a if isinstance(v, MarkedResult)}
-        unnamed = [v for v in a if not isinstance(v, MarkedResult)]
-        if f is None:
-            ret = (named, tuple(unnamed))
-        else:
-            ret = (f(**named), tuple(unnamed))
-        def invf(b: MarkedThen) -> Tuple[Any, ...]:
-            named_value, unnamed_value = b 
-            assert isinstance(named_value, dict) or is_dataclass(named_value), f"Expected dict or dataclass for named values, got {type(named_value)}"
-            if is_dataclass(named_value):
-                named_dict = named | asdict(cast(Any, named_value))    
-            else:
-                named_dict = named | named_value
-            ret = []
-            for x in index:
-                if isinstance(x, str):
-                    assert x in named_dict, f"Missing named value: {x}"
-                    ret.append(named_dict[x])
-                else:
-                    assert 0 <= x < len(unnamed_value), f"Missing unnamed value at index: {x}"
-                    ret.append(unnamed_value[x])
-            return tuple(ret)
-        return ret, invf
-
-    def bimap(self, f: Bimap[Any, Any]=Bimap.identity()) -> Tuple[MarkedThen, Callable[[MarkedThen], ThenResult[A, B]]]:
-        match self.kind:
-            case ThenKind.LEFT:
-                lb, linv = self.left.bimap(f) if isinstance(self.left, StructuralResult) else f(self.left)
-                return lb, lambda b: replace(self, left=linv(b))
-            case ThenKind.RIGHT:
-                rb, rinv = self.right.bimap(f) if isinstance(self.right, StructuralResult) else f(self.right)
-                return rb, lambda b: replace(self, right=rinv(b))
-            case ThenKind.BOTH:
-                lb, linv = self.left.bimap(f) if isinstance(self.left, StructuralResult) else f(self.left)
-                rb, rinv = self.right.bimap(f) if isinstance(self.right, StructuralResult) else f(self.right)
-                left_v = (lb,) if not isinstance(self.left, ThenResult) else lb
-                right_v = (rb,) if not isinstance(self.right, ThenResult) else rb
-                def invf(b: Tuple[Any, ...]) -> ThenResult[A, B]:
-                    left_size = self.left.arity() if isinstance(self.left, ThenResult) else 1
-                    right_size = self.right.arity() if isinstance(self.right, ThenResult) else 1
-                    lraw = b[:left_size]
-                    rraw = b[left_size:left_size + right_size]
-                    lraw = lraw[0] if left_size == 1 else lraw
-                    rraw = rraw[0] if right_size == 1 else rraw
-                    la = linv(lraw)
-                    ra = rinv(rraw)
-                    return replace(self, left=la, right=ra)
-                return left_v + right_v, invf
-                # data, func = ThenResult.collect_marked(left_v + right_v)
-                # return data, lambda d: invf(func(d))
-
-
-    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
+    left: Optional[A]
+    right: Optional[B]
         
 @runtime_checkable
 class TokenProtocol(Protocol):
@@ -263,83 +176,12 @@ T = TypeVar('T', bound=TokenProtocol)
 
 
 ParseResult = Union[
-    ThenResult['ParseResult[T]', 'ParseResult[T]'], 
-    MarkedResult['ParseResult[T]'],
-    ManyResult['ParseResult[T]'],
-    OrResult['ParseResult[T]'],
+    Then['ParseResult[T]', 'ParseResult[T]'], 
+    Marked['ParseResult[T]'],
+    Choice['ParseResult[T]', 'ParseResult[T]'],
+    Many['ParseResult[T]'],
     T,
 ]
 
 
 
-@dataclass(frozen=True)
-class AST(Generic[T]):
-    focus: ParseResult[T]
-    pruned: bool = False
-    parent: Optional[AST[T]] = None
-
-    def bimap(self)->Tuple[Any, Callable[[Any], AST[T]]]:
-        if isinstance(self.focus, StructuralResult):
-            data, invf = self.focus.bimap()
-            return data, lambda x: replace(self, focus=invf(x))
-        else:
-            return self.focus, lambda x: replace(self, focus=x)
-        
-    def wrapper(self)-> Callable[[Any], Any]:
-        if isinstance(self.focus, MarkedResult):
-            focus = cast(MarkedResult[Any], self.focus)
-            return lambda x: MarkedResult(name = focus.name, value = x)
-        else:
-            return lambda x: x
-        
-    def is_named(self) -> bool: 
-        return isinstance(self.focus, MarkedResult)
-
-    def left(self) -> Optional[AST[T]]:
-        match self.focus:
-            case ThenResult(left=left, kind=kind):
-                return replace(self, focus=left, parent=self, pruned = self.pruned or kind == ThenKind.RIGHT)
-            case _:
-                raise TypeError(f"Invalid focus type({self.focus}) for left traversal")
-
-    def right(self) -> Optional[AST[T]]:
-        match self.focus:
-            case ThenResult(right=right, kind=kind):
-                return replace(self, focus=right, parent=self, pruned = self.pruned or kind == ThenKind.LEFT)
-            case _:
-                raise TypeError(f"Invalid focus type({self.focus}) for right traversal")
-
-
-    def down(self, index: int) -> Optional[AST[T]]:
-        match self.focus:
-            case ManyResult(value=children):
-                if 0 <= index < len(children):
-                    return replace(self, focus=children[index], parent=self, pruned=self.pruned)
-                else:
-                    raise IndexError(f"Index {index} out of bounds for ManyResult with {len(children)} children")
-            case OrResult(value=value):
-                if index == 0:
-                    return replace(self, focus=value, parent=self, pruned=self.pruned)
-                else:
-                    raise IndexError(f"Index {index} out of bounds for OrResult")
-            case MarkedResult(value=value):
-                return replace(self, focus=value, parent=self, pruned=self.pruned)
-            case _:
-                raise TypeError(f"Invalid focus type({self.focus}) for down traversal")
-
-    def how_many(self)->int:
-        focus = self.focus.value if isinstance(self.focus, MarkedResult) else self.focus
-        match focus:
-            case ManyResult(value=children):
-                return len(children)
-            case _:
-                raise TypeError(f"Invalid focus type({self.focus}) for how_many")
-            
-    
-
-    @cached_property
-    def root(self) -> AST[T]:
-        while self.parent is not None:
-            self = self.parent  
-        return self
-    

syncraft/constraint.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Callable, Generic, Tuple, TypeVar, Optional, Any, Protocol
+from typing import Callable, Generic, Tuple, TypeVar, Optional, Any, Self
 from enum import Enum
 from dataclasses import dataclass, field, replace
 import collections.abc
@@ -109,9 +109,17 @@ class Binding:
             ret[var].append(node)
         return FrozenDict({k: tuple(vs) for k, vs in ret.items()})
 
-class Bindable(Protocol):
-    binding: Binding
-    def bind(self, var: Variable, node: Any) -> Any: ...
+
+A = TypeVar('A')
+@dataclass(frozen=True)
+class Bindable:
+    binding: Binding = field(default_factory=Binding)
+
+    def map(self, f: Callable[[Any], Any])->Self: 
+        return self
+    
+    def bind(self, var: Variable, node:Any)->Self:
+        return replace(self, binding=self.binding.bind(var, node))
 
 
 class Quantifier(Enum):

syncraft/finder.py

@@ -6,10 +6,9 @@ from typing import (
 from dataclasses import dataclass, replace
 from syncraft.algebra import (
     Algebra, Either, Right, 
-    OrResult, ManyResult, ThenResult, MarkedResult
 )
+from syncraft.ast import T, ParseResult, Choice, Many, Then, Marked
 
-from syncraft.ast import T, ParseResult, AST
 from syncraft.generator import GenState, Generator
 from sqlglot import TokenType
 from syncraft.syntax import Syntax
@@ -17,63 +16,42 @@ import re
 
 
 @dataclass(frozen=True)
-class Finder(Generator[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"
-        return self.map_state(lambda s: replace(s, is_pruned = False)).many(at_least=at_least, at_most=at_most)
-    
- 
-    def or_else(self, # type: ignore
-                other: Algebra[ParseResult[T], GenState[T]]
-                ) -> Algebra[OrResult[ParseResult[T]], GenState[T]]: 
-        return self.map_state(lambda s: replace(s, is_pruned = False)).or_else(other) 
-        
-
-    @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]]: 
-        return super().token(token_type=token_type, 
-                               text=text, 
-                               case_sensitive=case_sensitive, 
-                               regex=regex).map_state(lambda s: replace(s, is_pruned = False)) # type: ignore
-
-
+class Finder(Generator[T]):
     @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))
+    def anything(cls)->Algebra[Any, GenState[T]]:
+        def anything_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[Any, GenState[T]]]:
+            return Right((input.ast, 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:
+def matches(syntax: Syntax[Any, Any], data: ParseResult[T])-> bool:
     gen = syntax(Finder)
-    state = GenState.from_ast(data)
+    state = GenState.from_ast(ast = data, restore_pruned=True)
     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]:
+def find(syntax: Syntax[Any, Any], data: ParseResult[T]) -> YieldGen[ParseResult[T], 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):
+    match data:
+        case Then(left=left, right=right):
+            if left is not None:
+                yield from find(syntax, left)
+            if right is not None:
+                yield from find(syntax, right)
+        case Many(value = value):
             for e in value:
-                yield from find(syntax, AST(e))
-        case MarkedResult(value=value):
-            yield from find(syntax, AST(value))
-        case OrResult(value=value):
-            yield from find(syntax, AST(value))
+                yield from find(syntax, e)
+        case Marked(value=value):
+            yield from find(syntax, value)
+        case Choice(left=left, right=right):
+            if left is not None:
+                yield from find(syntax, left)
+            if right is not None:
+                yield from find(syntax, right)
         case _:
             pass

syncraft/generator.py

@@ -1,17 +1,21 @@
 from __future__ import annotations
 
 from typing import (
-    Any, TypeVar, Tuple, Optional,  Callable, Generic, 
+    Any, TypeVar, Tuple, Optional,  Callable, Generic, cast,
     List, 
 )
 from functools import cached_property
 from dataclasses import dataclass, replace
 from syncraft.algebra import (
-    Algebra, Either, Left, Right, Error, 
-    OrResult, ManyResult
+    Algebra, Either, Left, Right, Error
 )
 
-from syncraft.ast import T, ParseResult, AST, Token, TokenSpec, Binding, Variable, Bindable
+from syncraft.ast import (
+    T, ParseResult, AST, Token, TokenSpec, Binding, Variable, 
+    Bindable, 
+    Choice, Many, ChoiceKind,
+    Then, ThenKind, Marked
+)
 
 from syncraft.syntax import Syntax
 from sqlglot import TokenType
@@ -25,78 +29,56 @@ B = TypeVar('B')
 
 @dataclass(frozen=True)
 class GenState(Bindable, Generic[T]):
-    ast: Optional[AST[T]]
-    seed: int
-    is_pruned: Optional[bool] = None
-    binding: Binding = Binding()
-    def bind(self, var: Variable, node:ParseResult[T])->GenState[T]:
-        return replace(self, binding=self.binding.bind(var, node))
-
+    ast: Optional[ParseResult[T]] = None
+    restore_pruned: bool = False
+    seed: int = 0
+    def map(self, f: Callable[[Any], Any]) -> GenState[T]:
+        return replace(self, ast=f(self.ast))
+    
+    def inject(self, a: Any) -> GenState[T]:
+        return self.map(lambda _: a)
+    
     def fork(self, tag: Any) -> GenState[T]:
         return replace(self, seed=hash((self.seed, tag)))
 
     def rng(self, tag: Any = None) -> random.Random:
         return random.Random(self.seed if tag is None else hash((self.seed, tag)))
 
-    def to_string(self, interested: Callable[[Any], bool]) -> str | None:
-        return f"GenState(current={self.focus})"
+
 
     @cached_property
     def pruned(self)->bool:
-        if self.is_pruned is None:
-            return self.ast is None or self.ast.pruned
-        else:
-            return self.is_pruned
-    
-
-    @property
-    def focus(self) -> Optional[ParseResult[T]]:
-        if self.ast is None:
-            return None
-        return self.ast.focus
-
-    @property
-    def is_named(self)->bool:
-        return self.ast is not None and self.ast.is_named()
+        return self.ast is None
     
-    def wrapper(self)->Callable[[Any], Any]:
-        if self.ast is not None:
-            return self.ast.wrapper()
-        else:
-            return lambda x: x
-
     def left(self)-> GenState[T]:
         if self.ast is None:
             return self
-        return replace(self, ast=self.ast.left())
+        if isinstance(self.ast, Then) and (self.ast.kind != ThenKind.RIGHT or self.restore_pruned):
+            return replace(self, ast=self.ast.left)
+        return replace(self, ast=None) 
 
     def right(self) -> GenState[T]:
         if self.ast is None:
             return self
-        return replace(self, ast=self.ast.right())
+        if isinstance(self.ast, Then) and (self.ast.kind != ThenKind.LEFT or self.restore_pruned):
+            return replace(self, ast=self.ast.right)
+        return replace(self, ast=None)
     
 
     
     def down(self, index: int) -> GenState[T]:
         if self.ast is None:
-            return self
-        return replace(self, ast=self.ast.down(index))
+            return self        
+        match self.ast:
+            case Marked(value=value):
+                return replace(self, ast=value)
+            case _:
+                raise TypeError(f"Invalid AST type({self.ast}) for down traversal")
     
-    @cached_property
-    def how_many(self) -> int:
-        if self.ast is None:
-            return 0
-        return self.ast.how_many()
-
     @classmethod
-    def from_ast(cls, ast: Optional[AST[T]], seed: int = 0) -> GenState[T]:
-        return cls(ast=ast, seed=seed)
-
-
-    @classmethod
-    def from_parse_result(cls, parse_result: Optional[ParseResult[T]], seed: int = 0) -> GenState[T]:
-        return cls.from_ast(AST(parse_result) if parse_result else None, seed)
-
+    def from_ast(cls, *, ast: Optional[ParseResult[T]], seed: int = 0, restore_pruned:bool=False) -> GenState[T]:
+        return cls(ast=ast, seed=seed, restore_pruned=restore_pruned)
+    
 
 
 
@@ -152,10 +134,12 @@ class TokenGen(TokenSpec):
 @dataclass(frozen=True)
 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
+        def flat_map_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[B, GenState[T]]]:
             try:
+                if not isinstance(input.ast, Then):
+                    return Left(Error(this=self, 
+                                      message=f"Expect Then got {input.ast}",
+                                      state=input))
                 lft = input.left() 
                 match self.run(lft, use_cache=use_cache):
                     case Left(error):
@@ -166,47 +150,49 @@ class Generator(Algebra[ParseResult[T], GenState[T]]):
                             case Left(e):
                                 return Left(e)
                             case Right((result, next_input)):
-                                return Right((wrapper(result), next_input))
+                                return Right((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,
+                    state=input,
                     error=e
                 ))
         return self.__class__(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]]:
+    def many(self, *, at_least: int, at_most: Optional[int]) -> Algebra[Many[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
+        def many_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[Many[ParseResult[T]], GenState[T]]]:
             if input.pruned:
                 upper = at_most if at_most is not None else at_least + 2
                 count = input.rng("many").randint(at_least, upper)
                 ret: List[Any] = []
                 for i in range(count):
-                    forked_input = input.down(0).fork(tag=len(ret))
+                    forked_input = input.fork(tag=len(ret))
                     match self.run(forked_input, use_cache):
                         case Right((value, next_input)):
                             ret.append(value)
                         case Left(_):
                             pass
-                return Right((wrapper(ManyResult(tuple(ret))), input))
+                return Right((Many(value=tuple(ret)), input))
             else:
+                if not isinstance(input.ast, Many):
+                    return Left(Error(this=self, 
+                                      message=f"Expect Many got {input.ast}",
+                                      state=input))
                 ret = []
-                for index in range(input.how_many): 
-                    match self.run(input.down(index), use_cache):
+                for x in input.ast.value: 
+                    match self.run(input.inject(x), 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)
+                                        state=input.inject(x)
                                     ))                             
                         case Left(_):
                             pass
@@ -214,36 +200,47 @@ class Generator(Algebra[ParseResult[T], GenState[T]]):
                     return Left(Error(
                         message=f"Expected at least {at_least} matches, got {len(ret)}",
                         this=self,
-                        state=input.down(index)
+                        state=input.inject(x)
                     )) 
-                return Right((wrapper(ManyResult(tuple(ret))), input))
+                return Right((Many(value=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
-            if input.pruned:
-                forked_input = input.fork(tag="or_else")
-                match forked_input.rng("or_else").choice((self, other)).run(forked_input, use_cache):
-                    case Right((value, next_input)):
-                        return Right((wrapper(OrResult(value)), next_input))
-                    case Left(error):
-                        return Left(error)
-            else:
-                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):
+                ) -> Algebra[Choice[ParseResult[T], ParseResult[T]], GenState[T]]: 
+        def or_else_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[Choice[ParseResult[T], ParseResult[T]], GenState[T]]]:
+            def exec(kind: ChoiceKind, 
+                     left: GenState[T], 
+                     right: GenState[T])->Either[Any, Tuple[Choice[ParseResult[T], ParseResult[T]], GenState[T]]]:
+                match kind:
+                    case ChoiceKind.LEFT:
+                        match self.run(left, use_cache):
                             case Right((value, next_input)):
-                                return Right((wrapper(OrResult(value)), next_input))
+                                return Right((Choice(kind=ChoiceKind.LEFT, left=value, right=None), next_input))
                             case Left(error):
                                 return Left(error)
-            raise ValueError("or_else should always return a value or an error.")
+                    case ChoiceKind.RIGHT:
+                        match other.run(right, use_cache):
+                            case Right((value, next_input)):
+                                return Right((Choice(kind=ChoiceKind.RIGHT, left=None, right=value), next_input))
+                            case Left(error):
+                                return Left(error)
+                raise ValueError(f"Invalid ChoiceKind: {kind}")
+
+            if input.pruned:
+                forked_input = input.fork(tag="or_else")
+                which = forked_input.rng("or_else").choice((ChoiceKind.LEFT, ChoiceKind.RIGHT))
+                return exec(which, forked_input, forked_input)
+            else:
+                if isinstance(input.ast, Choice):
+                    return exec(input.ast.kind, 
+                                input.inject(input.ast.left), 
+                                input.inject(input.ast.right))
+                else:
+                    return Left(Error(this=self, 
+                                      message=f"Expect Choice got {input.ast}",
+                                      state=input))
         return self.__class__(or_else_run, name=f"or_else({self.name} | {other.name})") # type: ignore
 
     @classmethod
@@ -256,28 +253,29 @@ class Generator(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
             if input.pruned:
                 return Right((gen.gen(), input))
             else:
-                current = input.focus
+                current = input.ast
                 if not isinstance(current, Token) or not gen.is_valid(current):
                     return Left(Error(None, 
                                       message=f"Expected a Token, but got {type(current)}.", 
                                       state=input))
-                return Right((wrapper(current), input))
+                return Right((current, input))
         lazy_self = cls(token_run, name=cls.__name__ + f'.token({token_type or text or regex})')  # type: ignore
         return lazy_self
 
 
 
-def generate(syntax: Syntax[Any, Any], data: Optional[AST[Any]] = None, seed: int = 0) -> AST[Any] | Any:
+def generate(syntax: Syntax[Any, Any], 
+            data: Optional[ParseResult[Any]] = None, 
+            seed: int = 0, 
+            restore_pruned: bool = False) -> AST | Any:
     gen = syntax(Generator)
-    state = GenState.from_ast(data, seed)
+    state = GenState.from_ast(ast=data, seed=seed, restore_pruned=restore_pruned)
     result = gen.run(state, use_cache=False)
     if isinstance(result, Right):
-        return AST(result.value[0])
+        return result.value[0]
     assert isinstance(result, Left), "Generator must return Either[Any, Tuple[Any, Any]]"
     return result.value
 

syncraft/parser.py

@@ -3,7 +3,7 @@ import re
 from sqlglot import tokenize, TokenType, Parser as GlotParser, exp
 from typing import (
     Optional, List, Any, Tuple,
-    Generic, Callable, Hashable
+    Generic
 )
 from syncraft.algebra import (
     Either, Left, Right, Error, Algebra
@@ -13,16 +13,14 @@ from enum import Enum
 from functools import reduce
 from syncraft.syntax import Syntax
 
-from syncraft.ast import Token, TokenSpec, AST, T, ParseResult, Binding, Variable, Bindable
+from syncraft.ast import Token, TokenSpec, AST, T, Bindable
 
 
 @dataclass(frozen=True)
 class ParserState(Bindable, Generic[T]):
     input: Tuple[T, ...] = field(default_factory=tuple)
     index: int = 0
-    binding: Binding[ParseResult[T]] = Binding()
-    def bind(self, var: Variable, node:ParseResult[T])->ParserState[T]:
-        return replace(self, binding=self.binding.bind(var, node))
+
     
     def token_sample_string(self)-> str:
         def encode_tokens(*tokens:T) -> str:
@@ -184,12 +182,12 @@ def sqlglot(parser: Syntax[Any, Any],
 
 def parse(syntax: Syntax[Any, Any], 
           sql: str, 
-          dialect: str) -> AST[Any] | Any:
+          dialect: str) -> AST | Any:
     parser = syntax(Parser)
     input: ParserState[Token] = token_state(sql, dialect=dialect)
     result = parser.run(input, True)
     if isinstance(result, Right):
-        return AST(result.value[0])
+        return result.value[0]
     assert isinstance(result, Left), "Parser must return Either[E, Tuple[A, S]]"
     return result.value
 

syncraft/syntax.py

@@ -8,7 +8,7 @@ from dataclasses import dataclass, field, replace
 from functools import reduce
 from syncraft.algebra import Algebra, Error, Either, Right
 from syncraft.constraint import Variable, Bindable
-from syncraft.ast import ThenResult, ManyResult, ThenKind, MarkedResult
+from syncraft.ast import Then, ThenKind, Marked
 from types import MethodType, FunctionType
 
 
@@ -27,14 +27,14 @@ class Description:
     name: Optional[str] = None
     newline: Optional[str] = None
     fixity: Literal['infix', 'prefix', 'postfix'] = 'infix'
-    parameter: List[Any] = field(default_factory=list)
+    parameter: Tuple[Any, ...] = field(default_factory=tuple)
 
     def update(self, 
                *,
                newline: Optional[str] = None,
                name: Optional[str] = None,
                fixity: Optional[Literal['infix', 'prefix', 'postfix']] = None,
-               parameter: Optional[List[Any]] = None) -> 'Description':
+               parameter: Optional[Tuple[Any, ...]] = None) -> 'Description':
         return Description(
             name=name if name is not None else self.name,
             newline= newline if newline is not None else self.newline,
@@ -118,7 +118,7 @@ class Syntax(Generic[A, S]):
                  newline: Optional[str] = None,
                  name: Optional[str] = None, 
                  fixity: Optional[Literal['infix', 'prefix', 'postfix']] = None, 
-                 parameter: Optional[List[Syntax[Any, S]]] = None) -> Syntax[A, S]:
+                 parameter: Optional[Tuple[Syntax[Any, S], ...]] = None) -> Syntax[A, S]:
         return self.__class__(alg=self.alg,
                               meta=self.meta.update(name=name,
                                     newline=newline,
@@ -129,11 +129,17 @@ class Syntax(Generic[A, S]):
         return self.describe(newline=info)
 
     def terminal(self, name: str)->Syntax[A, S]:
-        return self.describe(name=name, fixity='prefix', parameter=[])
+        return self.describe(name=name, fixity='prefix')
 
 ######################################################## value transformation ########################################################
     def map(self, f: Callable[[A], B]) -> Syntax[B, S]:
         return self.__class__(lambda cls: self.alg(cls).map(f), meta = self.meta) # type: ignore
+    
+    def imap(self, f: Callable[[B], A]) -> Syntax[A, S]:
+        return self.__class__(lambda cls: self.alg(cls).imap(f), meta=self.meta)
+    
+    def bimap(self, f: Callable[[A], B], i: Callable[[B], A]) -> Syntax[A, S]:
+        return self.__class__(lambda cls: self.alg(cls).bimap(f, i), meta=self.meta)
 
     def map_all(self, f: Callable[[Either[Any, Tuple[A, S]]], Either[Any, Tuple[B, S]]]) -> Syntax[B, S]:
         return self.__class__(lambda cls: self.alg(cls).map_all(f), meta=self.meta) # type: ignore
@@ -148,30 +154,29 @@ class Syntax(Generic[A, S]):
     def flat_map(self, f: Callable[[A], Algebra[B, S]]) -> Syntax[B, S]:
         return self.__class__(lambda cls: self.alg(cls).flat_map(f)) # type: ignore
 
-    def many(self, *, at_least: int = 1, at_most: Optional[int] = None) -> Syntax[ManyResult[A], S]:
+    def many(self, *, at_least: int = 1, at_most: Optional[int] = None) -> Syntax[Tuple[A, ...], S]:
         return self.__class__(lambda cls:self.alg(cls).many(at_least=at_least, at_most=at_most)).describe(name='*', # type: ignore
                                                  fixity='prefix', 
-                                                 parameter=[self])  
+                                                 parameter=(self,))  
     
 ################################################ facility combinators ############################################################
 
 
 
-    def between(self, left: Syntax[Any, S], right: Syntax[Any, S]) -> Syntax[ThenResult[None, ThenResult[A, None]], S]:
+    def between(self, left: Syntax[Any, S], right: Syntax[Any, S]) -> Syntax[Then[Any, Then[A, Any]], S]:
         return left >> self // right
 
-    def sep_by(self, sep: Syntax[Any, S]) -> Syntax[ThenResult[A, ManyResult[ThenResult[None, A]]], S]:
-        return (self + (sep >> self).many()).describe(
-            name='sep_by',
-            fixity='prefix',
-            parameter=[self, sep]
-        )
+    def sep_by(self, sep: Syntax[Any, S]) -> Syntax[Tuple[A, ...], S]:
+        return (self + (sep >> self).many().optional()).describe( # type: ignore
+                    name='sep_by',
+                    fixity='prefix',
+                    parameter=(self, sep))
     
     def parens(self, sep: Syntax[Any, S], open: Syntax[Any, S], close: Syntax[Any, S]) -> Syntax[Any, S]:
         return self.sep_by(sep=sep).between(left=open, right=close)
             
     def optional(self, default: Optional[B] = None) -> Syntax[Optional[A | B], S]:
-        return (self | success(default)).describe(name='~', fixity='prefix', parameter=[self])
+        return (self | success(default)).describe(name='~', fixity='prefix', parameter=(self,))
 
 
     def cut(self) -> Syntax[A, S]:
@@ -179,45 +184,37 @@ class Syntax(Generic[A, S]):
 
 
 ####################################################### operator overloading #############################################
-    def __ge__(self, f: Callable[[A], Algebra[B, S]]) -> Syntax[B, S]:
-        return self.flat_map(f).describe(name='>=', fixity='infix', parameter=[self])
-
-
-    def __gt__(self, other: Callable[[A], B])->Syntax[B, S]:
-        return self.map(other)
-
-
-    def __floordiv__(self, other: Syntax[B, S]) -> Syntax[ThenResult[A, None], S]:
+    def __floordiv__(self, other: Syntax[B, S]) -> Syntax[Then[A, None], S]:
         other = other if isinstance(other, Syntax) else self.lift(other).as_(Syntax[B, S])
         return self.__class__(
             lambda cls: self.alg(cls).then_left(other.alg(cls))   # type: ignore
-            ).describe(name=ThenKind.LEFT.value, fixity='infix', parameter=[self, other]).as_(Syntax[ThenResult[A, None], S]) 
+            ).describe(name=ThenKind.LEFT.value, fixity='infix', parameter=(self, other)).as_(Syntax[Then[A, None], S]) 
 
-    def __rfloordiv__(self, other: Syntax[B, S]) -> Syntax[ThenResult[B, None], S]:
+    def __rfloordiv__(self, other: Syntax[B, S]) -> Syntax[Then[B, None], S]:
         other = other if isinstance(other, Syntax) else self.lift(other).as_(Syntax[B, S])
         return other.__floordiv__(self)
 
     def __invert__(self) -> Syntax[A | None, S]:
         return self.optional()
 
-    def __radd__(self, other: Syntax[B, S]) -> Syntax[ThenResult[B, A], S]:
+    def __radd__(self, other: Syntax[B, S]) -> Syntax[Then[B, A], S]:
         other = other if isinstance(other, Syntax) else self.lift(other).as_(Syntax[B, S])
         return other.__add__(self)
 
-    def __add__(self, other: Syntax[B, S]) -> Syntax[ThenResult[A, B], S]:
+    def __add__(self, other: Syntax[B, S]) -> Syntax[Then[A, B], S]:
         other = other if isinstance(other, Syntax) else self.lift(other).as_(Syntax[B, S])
         return self.__class__( 
             lambda cls: self.alg(cls).then_both(other.alg(cls)) # type: ignore
-            ).describe(name=ThenKind.BOTH.value, fixity='infix', parameter=[self, other])
+            ).describe(name=ThenKind.BOTH.value, fixity='infix', parameter=(self, other))
 
-    def __rshift__(self, other: Syntax[B, S]) -> Syntax[ThenResult[None, B], S]:
+    def __rshift__(self, other: Syntax[B, S]) -> Syntax[Then[None, B], S]:
         other = other if isinstance(other, Syntax) else self.lift(other).as_(Syntax[B, S])
         return self.__class__(
             lambda cls: self.alg(cls).then_right(other.alg(cls))   # type: ignore
-            ).describe(name=ThenKind.RIGHT.value, fixity='infix', parameter=[self, other]).as_(Syntax[ThenResult[None, B], S])   
+            ).describe(name=ThenKind.RIGHT.value, fixity='infix', parameter=(self, other)).as_(Syntax[Then[None, B], S])   
 
 
-    def __rrshift__(self, other: Syntax[B, S]) -> Syntax[ThenResult[None, A], S]:
+    def __rrshift__(self, other: Syntax[B, S]) -> Syntax[Then[None, A], S]:
         other = other if isinstance(other, Syntax) else self.lift(other).as_(Syntax[B, S])
         return other.__rshift__(self)  
 
@@ -239,15 +236,20 @@ class Syntax(Generic[A, S]):
                 value, state = result.value
                 return Right((value, state.bind(var, value)))
             return result
-        return self.map_all(bind_v).describe(name=f'bind({var.name})', fixity='postfix', parameter=[self])  
+        
+        ret = self.mark(var.name).map_all(bind_v) if var.name else self.map_all(bind_v) # type: ignore
+        return ret.describe(name=f'bind({var.name})', fixity='postfix', parameter=(self,))
 
-    def mark(self, var: str) -> Syntax[MarkedResult[A], S]:
-        def bind_s(value: A) -> MarkedResult[A]:
-            if isinstance(value, MarkedResult):
+    def mark(self, var: str) -> Syntax[A, S]:
+        def bind_s(value: A) -> Marked[A]:
+            if isinstance(value, Marked):
                 return replace(value, name=var)    
             else:
-                return MarkedResult(name=var, value=value)
-        return self.map(bind_s).describe(name=f'bind("{var}")', fixity='postfix', parameter=[self]) 
+                return Marked(name=var, value=value)
+        def ibind_s(m : Marked[A]) -> A:
+            return m.value if isinstance(m, Marked) else m
+            
+        return self.bimap(bind_s, ibind_s).describe(name=f'bind("{var}")', fixity='postfix', parameter=(self,))
 
 
 
@@ -279,7 +281,7 @@ 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]:
+def all(*parsers: Syntax[Any, S]) -> Syntax[Then[Any, Any], S]:
     return reduce(lambda a, b: a + b, parsers) if len(parsers) > 0 else success(None)
 
 def first(*parsers: Syntax[Any, S]) -> Syntax[Any, S]:

{syncraft-0.1.24.dist-info → syncraft-0.1.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncraft
-Version: 0.1.24
+Version: 0.1.26
 Summary: Parser combinator library
 Author-email: Michael Afmokt <michael@esacca.com>
 License-Expression: MIT
@@ -31,7 +31,7 @@ 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.
+- [ ] simplify the result of then_left and then_right by bimap the result in syntax.
+- [ ] simplify the result of sep_by and between by bimap the result in syntax
 - [ ] Try the parsing, generation, and data processing machinery on SQLite3 syntax. So that I can have direct feedback on the usability of this library and a fully functional SQLite3 library.
 - [ ] Make the library as fast as possible and feasible.

syncraft-0.1.26.dist-info/RECORD

@@ -0,0 +1,16 @@
+syncraft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syncraft/algebra.py,sha256=FBy0cCl4RGnsi1uxoIIZPRcHgfHxWwUal9iLV_Mtc6I,14791
+syncraft/ast.py,sha256=WwkA02H00BUNrotsMbvypzqHzJb8HiWROVb3qBDSR-8,5113
+syncraft/constraint.py,sha256=uT-ELzvv8J-s-Y1VYkXePUezseqCLhqzYUzFBYs0HsE,6418
+syncraft/diagnostic.py,sha256=cgwcQnCcgrCRX3h-oGTDb5rcJAtitPV3LfH9eLvO93E,2837
+syncraft/finder.py,sha256=qrBlPzQ3hK0rsLIfTD0QdypbrPegDKKCMZriWu-qHBA,1870
+syncraft/generator.py,sha256=BiwwFTjPkk7itXK1wAbB7SJhHi8npd0Wx_3bxR6t1Ww,11775
+syncraft/parser.py,sha256=UpNtTckygIwWG8cX2ZvdEcUi3Il8gpC7aZAzPKx2crg,11289
+syncraft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syncraft/sqlite3.py,sha256=Pq09IHZOwuWg5W82l9D1flzd36QV0TOHQpTJ5U02V8g,34701
+syncraft/syntax.py,sha256=aMXnAuGD12_WQxv0TIEvVw-7EO8Bupv0AD1hy6nMJMw,15011
+syncraft-0.1.26.dist-info/licenses/LICENSE,sha256=wHSV424U5csa3339dy1AZbsz2xsd0hrkMx2QK48CcUk,1062
+syncraft-0.1.26.dist-info/METADATA,sha256=h5K3SkaNZtfxw3hD5uc7Ac3D92XJMYCll8cMigf8rvs,1199
+syncraft-0.1.26.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+syncraft-0.1.26.dist-info/top_level.txt,sha256=Kq3t8ESXB2xW1Xt3uPmkENFc-c4f2pamNmaURBk7zc8,9
+syncraft-0.1.26.dist-info/RECORD,,

syncraft-0.1.24.dist-info/RECORD

@@ -1,16 +0,0 @@
-syncraft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-syncraft/algebra.py,sha256=Um8iMgVwlWcseQDkB_GqY-xmo0hR7zSw5j7oRRxrZhE,14122
-syncraft/ast.py,sha256=TM18FkdFIBbxaaKgEvTvellrcXdkzMLLjLm7sRuC7FY,12985
-syncraft/constraint.py,sha256=4io1HM_2y5SJzMoeVowAr0a-SDE2jR-7uhCcZpa_FlM,6219
-syncraft/diagnostic.py,sha256=cgwcQnCcgrCRX3h-oGTDb5rcJAtitPV3LfH9eLvO93E,2837
-syncraft/finder.py,sha256=QySZcIjWZFMbRxGJVlJDxK9cmIuNA5vnoE-vYwLJiqA,3005
-syncraft/generator.py,sha256=6jfkSODx952OiN-oOJdNubvU2TzYhLzh3wibZV-ImbI,11625
-syncraft/parser.py,sha256=nSQInixB4j7H22HV_9YdOXfRB5aCPnhQYvMC_N5jnlo,11538
-syncraft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-syncraft/sqlite3.py,sha256=Pq09IHZOwuWg5W82l9D1flzd36QV0TOHQpTJ5U02V8g,34701
-syncraft/syntax.py,sha256=wwMPAfae5mH4ip3Q2JOkvFkccPfoVDkb-Tk5o0U-ecI,14843
-syncraft-0.1.24.dist-info/licenses/LICENSE,sha256=wHSV424U5csa3339dy1AZbsz2xsd0hrkMx2QK48CcUk,1062
-syncraft-0.1.24.dist-info/METADATA,sha256=jleKB866QNoRRkpcmtNflWRHUS4HgNYqQsg9zfJHd4Q,1381
-syncraft-0.1.24.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-syncraft-0.1.24.dist-info/top_level.txt,sha256=Kq3t8ESXB2xW1Xt3uPmkENFc-c4f2pamNmaURBk7zc8,9
-syncraft-0.1.24.dist-info/RECORD,,