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

syncraft/algebra.py

@@ -39,34 +39,33 @@ class Bimap(Generic[S, A, B]):
             forward=lambda s, x: (s, x),
             inverse=lambda s, y: (s, y)
         )
-    @staticmethod
-    def variable(value: A)->Bimap[S, A, A]:
-        return Bimap(
-            forward=lambda s, _: (s, value),
-            inverse=lambda s, y: (s, y)
-        )
-    @staticmethod
-    def const(state: S, value: A)->Bimap[Any, A, A]:
-        return Bimap(
-            forward=lambda s, _: (state, value),
-            inverse=lambda s, y: (state, value)
-        )
-    @staticmethod
-    def combine(*biarrows: Bimap[Any, Any, Any]) -> Bimap[Any, Any, Any]:
-        return reduce(lambda a, b: a >> b, biarrows, Bimap.identity()) 
             
+    @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
+    
+
     
-        
 class StructuralResult:
-    def bimap(self, arr: Bimap[Any, Any, Any] = Bimap.identity()) -> Bimap[Any, Any, Any]:
+    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, arr: Bimap[Any, Any, Any] = Bimap.identity()) -> Bimap[Any, NamedResult[A], NamedResult[Any]]:
-        inner_b = self.value.bimap(arr) if isinstance(self.value, StructuralResult) else arr
+    def 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)
@@ -76,33 +75,49 @@ class NamedResult(Generic[A], StructuralResult):
             assert isinstance(a, NamedResult), f"Expected NamedResult, got {type(a)}"
             inner_s, inner_v = inner_b.inverse(s, a.value)
             return (inner_s, replace(self, value=inner_v)) if not isinstance(inner_v, NamedResult) else (inner_s, replace(self, value=inner_v.value))
-        
-        return Bimap(
+        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, arr: Bimap[Any, Any, Any] = Bimap.identity()) -> Bimap[Any, ManyResult[A], List[A]]:
-        inner_b = [v.bimap(arr) if isinstance(v, StructuralResult) else arr for v in self.value]
+    def 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)}"
-            assert len(a) == len(inner_b), f"Expected {len(inner_b)} elements, got {len(a)}"
-            return s, ManyResult(value=tuple(inner_b[i].inverse(s, v)[1] for i, v in enumerate(a)))
-        return Bimap(
+            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, arr: Bimap[Any, Any, Any] = Bimap.identity()) -> Bimap[Any, OrResult[A], Any]:
-        inner_b = self.value.bimap(arr) if isinstance(self.value, StructuralResult) else arr
+    def 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)
@@ -111,10 +126,11 @@ class OrResult(Generic[A], StructuralResult):
             inner_s, inner_v = inner_b.inverse(s, a)
             return inner_s, OrResult(value=inner_v) 
         
-        return Bimap(
+        ret = Bimap(
             forward=fwd,
             inverse=inv
         )    
+        return before(self) >> ret >> after(self)
 class ThenKind(Enum):
     BOTH = '+'
     LEFT = '//'
@@ -137,10 +153,13 @@ class ThenResult(Generic[A, B], StructuralResult):
         else:
             return 1
                 
-    def bimap(self, arr: Bimap[Any, Any, Any] = Bimap.identity()) -> Bimap[Any, ThenResult[A, B], Tuple[Any, ...] | Any]:
+    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(arr) if isinstance(self.left, StructuralResult) else arr
-        rb = self.right.bimap(arr) if isinstance(self.right, StructuralResult) else arr
+        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]:
@@ -174,10 +193,11 @@ class ThenResult(Generic[A, B], StructuralResult):
                     s2, rv = rb.inverse(s1, rraw)
                     return s2, replace(self, left=lv, right=rv)
             
-        return Bimap(
+        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

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, 
-    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,15 +20,7 @@ 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]):
@@ -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

@@ -16,13 +16,6 @@ from syncraft.syntax import Syntax
 from syncraft.ast import Token, TokenSpec, AST, T
 
 
-
-
-
-
-
-
-
 @dataclass(frozen=True)
 class ParserState(Generic[T]):
     input: Tuple[T, ...] = field(default_factory=tuple)

syncraft/syntax.py

@@ -17,6 +17,33 @@ 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:
     name: Optional[str] = None
@@ -98,8 +125,6 @@ class Syntax(Generic[A, S]):
         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]):
                 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.20.dist-info → syncraft-0.1.21.dist-info}/METADATA

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

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.20.dist-info/RECORD

@@ -1,15 +0,0 @@
-syncraft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-syncraft/algebra.py,sha256=utnhCbrF5GFG6P2Oef_Ru6YVgVCgsGccMh6wx80ok5E,20519
-syncraft/ast.py,sha256=Hn88_xOqSzrHYtPjNFKREJuE6yISmNI-VVTcU6PJKI0,4737
-syncraft/cmd.py,sha256=DzXgU8QLVOg0YTFKpmOyzbf02LKPphQ4EeKSLzqpJ_s,2012
-syncraft/diagnostic.py,sha256=mnzzceE9HpN2jVa7ztecZCz3sbCD79JxgkdLhJRBsvY,2822
-syncraft/generator.py,sha256=ygt5HXfKG5z1LcTxhU8adqEePegqmokLjbP6pi34hGA,12355
-syncraft/parser.py,sha256=hk67kvOTBToOB2GhAh4weJQHR9xv73YPNQnqrW_qYv8,11295
-syncraft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-syncraft/sqlite3.py,sha256=Pq09IHZOwuWg5W82l9D1flzd36QV0TOHQpTJ5U02V8g,34701
-syncraft/syntax.py,sha256=NtxkfPvSNsmpbRcESxEgRAW9d04ZHukWQoSJqIHsHNk,13842
-syncraft-0.1.20.dist-info/licenses/LICENSE,sha256=wHSV424U5csa3339dy1AZbsz2xsd0hrkMx2QK48CcUk,1062
-syncraft-0.1.20.dist-info/METADATA,sha256=j3Ylao4YeT_HxO4Gv95chaRvpoZLBallacoeoaoLQjk,1381
-syncraft-0.1.20.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-syncraft-0.1.20.dist-info/top_level.txt,sha256=Kq3t8ESXB2xW1Xt3uPmkENFc-c4f2pamNmaURBk7zc8,9
-syncraft-0.1.20.dist-info/RECORD,,