syncraft 0.2.8__py3-none-any.whl → 0.2.10__py3-none-any.whl

syncraft/algebra.py

@@ -8,6 +8,7 @@ from dataclasses import dataclass, replace
 from syncraft.ast import ThenKind, Then, Choice, Many, ChoiceKind, shallow_dict, SyncraftError
 from syncraft.cache import Cache
 from syncraft.constraint import Bindable
+from functools import cached_property
 from rich import print
 
 
@@ -76,16 +77,22 @@ class Error:
 class Algebra(Generic[A, S]):
 ######################################################## shared among all subclasses ########################################################
     run_f: Callable[[S, bool], Generator[Incomplete[S], S, Either[Any, Tuple[A, S]]]] 
-    name: Hashable
+    name: str
     cache: Cache[Either[Any, Tuple[A, S]]]
+    
 
     @classmethod
     def state(cls, **kwargs:Any)->Optional[S]: 
         return None
         
-    def named(self, name: Hashable) -> 'Algebra[A, S]':
+    def named(self, name: str) -> Algebra[A, S]:
         return replace(self, name=name)
-        
+
+    @cached_property
+    def hashable(self)->Hashable:
+        return frozenset({'name': self.name, 'run_f': self.run_f})
+
+
     def __call__(self, input: S, use_cache: bool) -> Generator[Incomplete[S], S, Either[Any, Tuple[A, S]]]:
         return self.run(input, use_cache=use_cache)
 
@@ -366,7 +373,7 @@ class Algebra(Generic[A, S]):
             def map_all_run_f(input:S, use_cache:bool) -> Generator[Incomplete[S], S, Either[Any, Tuple[B, S]]]:
                 yield from ()
                 return Right(f(a, input))
-            return self.__class__(map_all_run_f, name=self.name, cache=self.cache) # type: ignore
+            return self.__class__(map_all_run_f, name=self.name, cache=self.cache)  # type: ignore
         return self.flat_map(map_all_f)
 
 

syncraft/ast.py

@@ -5,11 +5,11 @@ import re
 from typing import (
     Optional, Any, TypeVar, Tuple, runtime_checkable, cast,
     Generic, Callable, Union, Protocol, Type, List, ClassVar,
-    Dict
+    Dict, Hashable
 )
 
 
-from dataclasses import dataclass, replace, is_dataclass, fields
+from dataclasses import dataclass, replace, is_dataclass, fields, field
 from enum import Enum
 
 
@@ -480,26 +480,51 @@ T = TypeVar('T', bound=TokenProtocol)
 
 @dataclass(frozen=True)
 class SyntaxSpec:
-    pass
-@dataclass(frozen=True)
-class ChoiceSpec(SyntaxSpec, Generic[A, B]):
-    left: A
-    right: B
+    id: int = field(init=False)
+    def __post_init__(self) -> None:
+        object.__setattr__(self, 'id', id(self))
 
 @dataclass(frozen=True)
+class RefSpec(SyntaxSpec, Generic[A]):
+    ref: int | A 
+    referent: str
+@dataclass(frozen=True)
 class LazySpec(SyntaxSpec, Generic[A]):
-    value: A
+    name: str
+    value: None | A
 @dataclass(frozen=True)
 class ThenSpec(SyntaxSpec, Generic[A, B]):
+    name: str
     kind: ThenKind
     left: A
     right: B
+    # def __repr__(self) -> str:
+    #     return f"ThenSpec(id={id(self)}, kind={self.kind}, left={self.left}, right={self.right})"
+    # def __str__(self) -> str:
+    #     return self.__repr__()
+
+@dataclass(frozen=True)
+class ChoiceSpec(SyntaxSpec, Generic[A, B]):
+    name: str
+    left: A
+    right: B
+
+    # def __repr__(self) -> str:
+    #     return f"ChoiceSpec(id={id(self)}, left={self.left}, right={self.right})"
+    # def __str__(self) -> str:
+    #     return self.__repr__()
 
 @dataclass(frozen=True)
 class ManySpec(SyntaxSpec, Generic[A]):
+    name: str
     value: A
     at_least: int
     at_most: Optional[int]
+    # def __repr__(self) -> str:
+    #     return f"ManySpec(id={id(self)}, value={self.value}, at_least={self.at_least}, at_most={self.at_most})"
+    # def __str__(self) -> str:
+    #     return self.__repr__()
+
 
 
 @dataclass(frozen=True)
@@ -509,6 +534,19 @@ class TokenSpec(SyntaxSpec):
     case_sensitive: bool = False
     regex: Optional[re.Pattern[str]] = None
 
+    def __repr__(self) -> str:
+        parts = []
+        if self.token_type is not None:
+            parts.append(f"type={self.token_type.name}")
+        if self.text is not None:
+            parts.append(f"text={'`'+self.text+'`' if self.case_sensitive else self.text}")
+        if self.regex is not None:
+            parts.append(f"regex=/{self.regex.pattern}/")
+        return f"TokenSpec(id={id(self)}, " + ", ".join(parts) + ")"
+        
+    def __str__(self) -> str:
+        return self.__repr__()
+    
     @classmethod
     def create(cls, 
                *, 

syncraft/cache.py

@@ -70,7 +70,7 @@ class Cache(Generic[Ret]):
         if key in c:
             v = c[key]
             if isinstance(v, InProgress):
-                raise RecursionError("Left-recursion detected in parser", offending=f, state=args)
+                raise RecursionError(f"Left-recursion detected in Algebra {f}", offending=f, state=args)
             else:
                 return v        
         try:
@@ -98,7 +98,7 @@ class Cache(Generic[Ret]):
         if key in c:
             v = c[key]
             if isinstance(v, InProgress):
-                raise RecursionError("Left-recursion detected in parser", offending=f, state=args)
+                raise RecursionError(f"Left-recursion detected in Algebra {f}", offending=f, state=args)
             else:
                 return v        
         try:

syncraft/syntax.py

@@ -107,7 +107,7 @@ class Syntax(Generic[A, S]):
         *,
         name: Optional[str] = None,
         fixity: Optional[Literal['infix', 'prefix', 'postfix']] = None,
-        parameter: Optional[Tuple[Syntax[Any, S], ...]] = None,
+        parameter: Optional[Tuple[Syntax[Any, S] | Any, ...]] = None,
     ) -> Syntax[A, S]:
         return self.__class__(
             alg=self.alg,
@@ -116,7 +116,16 @@ class Syntax(Generic[A, S]):
             ),
         )
 
+    def named(self, name: str) -> Syntax[A, S]:
+        """Assign a name to this syntax node for better debugging output.
 
+        Args:
+            name: Name to assign; must be a valid identifier.
+
+        Returns:
+            Syntax with the given name.
+        """
+        return self.__class__(lambda cls, cache: self(cls, cache).named(name), meta=self.meta)
     ######################################################## value transformation ########################################################
     def map(self, f: Callable[[A], B]) -> Syntax[B, S]:
         """Map the produced value while preserving state and metadata.
@@ -219,7 +228,7 @@ class Syntax(Generic[A, S]):
         Returns:
             Syntax producing nested Then with all parts.
         """
-        return left >> self // right
+        return (left >> self // right).describe(name='between', fixity='postfix', parameter=(self, left, right)) 
 
     def sep_by(self, sep: Syntax[B, S]) -> Syntax[Then[A, Choice[Many[Then[B, A]], Optional[Nothing]]], S]:
         """Parse one or more items separated by sep.
@@ -316,7 +325,7 @@ class Syntax(Generic[A, S]):
         Returns:
             Syntax that marks downstream failures as committed.
         """
-        return self.__class__(lambda cls, cache: self(cls, cache).cut())
+        return self.__class__(lambda cls, cache: self(cls, cache).cut()).describe(name='cut', fixity='postfix', parameter=(self,))
 
     ###################################################### operator overloading #############################################
     def __floordiv__(self, other: Syntax[B, S]) -> Syntax[Then[A, B], S]:
@@ -433,7 +442,7 @@ class Syntax(Generic[A, S]):
             else:
                 return v, s
 
-        return self.map_all(bind_v).describe(name=f'bind({name})', fixity='postfix', parameter=(self,))
+        return self.map_all(bind_v).describe(name='bind', fixity='infix', parameter=(self, name))
 
     def to(self, f: Collector[E]) -> Syntax[Collect[A, E], S]:
         """Attach a collector to the produced value.
@@ -457,7 +466,7 @@ class Syntax(Generic[A, S]):
         def ito_f(c: Collect[A, E]) -> A:
             return c.value if isinstance(c, Collect) else c
 
-        return self.bimap(to_f, ito_f).describe(name=f'to({f})', fixity='postfix', parameter=(self,))
+        return self.bimap(to_f, ito_f).describe(name='to', fixity='infix', parameter=(self, f))
 
     def mark(self, name: str) -> Syntax[Marked[A], S]:
         """Mark the produced value with a name.
@@ -481,7 +490,7 @@ class Syntax(Generic[A, S]):
         def imark_s(m: Marked[A]) -> A:
             return m.value if isinstance(m, Marked) else m
 
-        return self.bimap(mark_s, imark_s).describe(name=f'mark("{name}")', fixity='postfix', parameter=(self,))
+        return self.bimap(mark_s, imark_s).describe(name='mark', fixity='infix', parameter=(self, name))
     
 def when(f: Callable[[], bool], then: Syntax[A, S], otherwise: Syntax[B, S]) -> Syntax[A | B, S]:
     """
@@ -495,7 +504,7 @@ def when(f: Callable[[], bool], then: Syntax[A, S], otherwise: Syntax[B, S]) ->
     Returns:
         A Syntax object representing the chosen branch.
     """
-    return lazy(lambda: then if f() else otherwise).describe(name='when(?)', fixity='postfix', parameter=(then, otherwise)) # type: ignore
+    return lazy(lambda: then if f() else otherwise).describe(name='when', fixity='postfix', parameter=(then, otherwise)) # type: ignore
 
 def fail(error: Any) -> Syntax[Any, Any]:
     """
@@ -507,7 +516,7 @@ def fail(error: Any) -> Syntax[Any, Any]:
     Returns:
         A Syntax object that always fails.
     """
-    return Syntax(lambda alg, cache: alg.fail(error, cache=cache)).describe(name=f'fail({error})', fixity='prefix')
+    return Syntax(lambda alg, cache: alg.fail(error, cache=cache)).describe(name='fail', fixity='prefix', parameter=(error,))
 
 def success(value: Any) -> Syntax[Any, Any]:
     """
@@ -519,7 +528,7 @@ def success(value: Any) -> Syntax[Any, Any]:
     Returns:
         A Syntax object that always succeeds.
     """
-    return Syntax(lambda alg, cache: alg.success(value, cache=cache)).describe(name=f'success({value})', fixity='prefix')
+    return Syntax(lambda alg, cache: alg.success(value, cache=cache)).describe(name='success', fixity='prefix', parameter=(value,))
 
 
 
@@ -581,7 +590,7 @@ def lazy(thunk: Callable[[], Syntax[A, S]]) -> Syntax[A, S]:
             algebra = cls.lazy(algebra_lazy_f, cache=cache)
             previous_cls = cls
         return algebra
-    return Syntax(syntax_lazy_run).describe(name='lazy(?)', fixity='postfix') 
+    return Syntax(syntax_lazy_run).describe(name='lazy', fixity='prefix', parameter=(lambda: syntax,))  
 
 
 

syncraft/walker.py

@@ -7,13 +7,13 @@ from dataclasses import dataclass, replace, field
 from syncraft.algebra import (
     Algebra, Either, Right, Incomplete, Left, SyncraftError
 )
-from syncraft.ast import TokenSpec, ThenSpec, ManySpec, ChoiceSpec, LazySpec, ThenKind
+from syncraft.ast import TokenSpec, ThenSpec, ManySpec, ChoiceSpec, LazySpec, ThenKind, RefSpec
 from syncraft.parser import TokenType
 from syncraft.constraint import Bindable, FrozenDict
 
 import re
 from syncraft.syntax import Syntax
-from syncraft.cache import Cache
+from syncraft.cache import Cache, RecursionError
 from rich import print
 
 
@@ -23,37 +23,51 @@ B = TypeVar('B')
 SS = TypeVar('SS', bound=Hashable)
 
 
-
-
-
-
-
 @dataclass(frozen=True)
-class WalkerState(Bindable, Generic[SS]):
-    reducer: Optional[Callable[[Any, SS], SS]] = None
-    acc: Optional[SS] = None
+class WalkerState(Bindable):
+    visited: FrozenDict = field(default_factory=FrozenDict)
+    def visit(self, algebra: Algebra, data: Hashable) -> WalkerState:
+        return replace(self, visited=self.visited | FrozenDict({algebra.hashable: data}))
 
-
-    def reduce(self, value: Any) -> WalkerState[SS]:
-        if self.reducer:
-            new_acc = self.reducer(value, self.acc) if self.acc is not None else value
-            return replace(self, acc=new_acc)
-        else:
-            return replace(self, acc=value)
         
 
-
-
-
 @dataclass(frozen=True)
-class Walker(Algebra[SS, WalkerState[SS]]):
+class Walker(Algebra[Any, WalkerState]):
     @classmethod
-    def state(cls, reducer: Callable[[Any, SS], SS], init: SS )->WalkerState[SS]: # type: ignore
-        assert callable(reducer), f"reducer must be a Reducer or None, got {type(reducer)}"
-        return WalkerState(reducer=reducer, acc=init)
+    def state(cls, **kwargs: Any)->WalkerState:
+        return WalkerState()
 
+    def map(self, f: Callable[[Any], Any]) -> Algebra[Any, WalkerState]:
+        return self
 
+    def map_state(self, f: Callable[[WalkerState], WalkerState]) -> Algebra[Any, WalkerState]:
+        return self
+    
+    def bimap(self, f: Callable[[Any], Any], g: Callable[[Any], Any]) -> Algebra[Any, WalkerState]:
+        return self
 
+    def map_all(self, f: Callable[[Any, WalkerState], Tuple[Any, WalkerState]]) -> Algebra[Any, WalkerState]:
+        return self
+    
+    def flat_map(self, f: Callable[[Any], Algebra[Any, WalkerState]]) -> Algebra[Any, WalkerState]:
+        return self
+
+    def run(self, 
+            input: WalkerState, 
+            use_cache: bool = True
+            ) -> PyGenerator[Incomplete[WalkerState], WalkerState, Either[Any, Tuple[Any, WalkerState]]]:
+        try:
+            if self.hashable in input.visited:
+                ref = input.visited[self.hashable]
+                return Right((RefSpec(ref=id(ref), referent= '' if not hasattr(ref, 'name') else ref.name), input))
+            return (yield from self.cache.gen(self.run_f, input, use_cache))
+        except RecursionError as e:
+            if self.hashable in input.visited:
+                ref = input.visited[self.hashable]
+                return Right((RefSpec(ref=id(ref), referent= '' if not hasattr(ref, 'name') else ref.name), input))
+            else:
+                return Right((RefSpec(ref=e.offending, referent=''), input))
+        
     @classmethod
     def token(cls, 
               *,
@@ -62,82 +76,114 @@ class Walker(Algebra[SS, WalkerState[SS]]):
               text: Optional[str] = None, 
               case_sensitive: bool = False,
               regex: Optional[re.Pattern[str]] = None
-              )-> Algebra[Any, WalkerState[SS]]:      
-        def token_run(input: WalkerState[SS], use_cache:bool) -> PyGenerator[Incomplete[WalkerState[SS]], WalkerState[SS], Either[Any, Tuple[Any, WalkerState[SS]]]]:
+              )-> Algebra[Any, WalkerState]:      
+        name = f'Token({token_type or text or (regex.pattern if regex else "")})'
+        this: None | Algebra[Any, WalkerState] = None
+        def token_run(input: WalkerState, use_cache:bool) -> PyGenerator[Incomplete[WalkerState], WalkerState, Either[Any, Tuple[Any, WalkerState]]]:
             yield from ()
             data = TokenSpec(token_type=token_type, text=text, regex=regex, case_sensitive=case_sensitive)
-            return Right((data, input.reduce(data)))
-        return cls(token_run, name=cls.__name__ + f'.token({token_type or text or regex})', cache=cache)  
+            return Right((data, input.visit(this, data) if this is not None else input))
+        this = cls(token_run, name=name, cache=cache)  
+        return this
 
     @classmethod
     def lazy(cls, 
-             thunk: Callable[[], Algebra[Any, WalkerState[SS]]], 
-             cache: Cache) -> Algebra[Any, WalkerState[SS]]:
-        def algebra_lazy_run(input: WalkerState[SS], use_cache:bool) -> PyGenerator[Incomplete[WalkerState[SS]], WalkerState[SS], Either[Any, Tuple[Any, WalkerState[SS]]]]:
+             thunk: Callable[[], Algebra[Any, WalkerState]], 
+             cache: Cache) -> Algebra[Any, WalkerState]:
+        this: None | Algebra[Any, WalkerState] = None
+        def algebra_lazy_run(input: WalkerState, use_cache:bool) -> PyGenerator[Incomplete[WalkerState], WalkerState, Either[Any, Tuple[Any, WalkerState]]]:
             alg = thunk()
-            print('--' * 20, "Walker.lazy.algebra_lazy_run", '--' * 20)
-            print('thunk', thunk, id(thunk))
-            print('input', input, id(input))
-            print('alg', alg, id(alg))
             thunk_result = yield from alg.run(input, use_cache)
             match thunk_result:
                 case Right((value, from_thunk)):
-                    data = LazySpec(value=value)
-                    return Right((data, from_thunk.reduce(data)))
+                    data: LazySpec[Any] = LazySpec(name=alg.name, value=value)
+                    from_thunk = from_thunk.visit(alg, value) 
+                    return Right((data, from_thunk.visit(this, data) if this is not None else from_thunk))
             raise SyncraftError("flat_map should always return a value or an error.", offending=thunk_result, expect=(Left, Right))
-        return cls(algebra_lazy_run, name=cls.__name__ + '.lazy', cache=cache)
-
+        this = cls(algebra_lazy_run, name='lazy(?)', cache=cache)
+        return this
 
 
-    def then_both(self, other: Algebra[Any, WalkerState[SS]]) -> Algebra[Any, WalkerState[SS]]:
-        def then_run(input: WalkerState[SS], use_cache:bool) -> PyGenerator[Incomplete[WalkerState[SS]], WalkerState[SS], Either[Any, Tuple[Any, WalkerState[SS]]]]:
+    def then_all(self, other: Algebra[Any, WalkerState], kind: ThenKind) -> Algebra[Any, WalkerState]:
+        name = f"{self.name} {kind.value} {other.name}"
+        this: None | Algebra[Any, WalkerState] = None
+        def then_run(input: WalkerState, use_cache:bool) -> PyGenerator[Incomplete[WalkerState], WalkerState, Either[Any, Tuple[Any, WalkerState]]]:
             self_result = yield from self.run(input, use_cache=use_cache)
             match self_result:
                 case Right((value, from_left)):
-                    other_result = yield from other.run(from_left, use_cache)
+                    other_result = yield from other.run(from_left.visit(self, value), use_cache)
                     match other_result:
                         case Right((result, from_right)):
-                            data = ThenSpec(kind=ThenKind.BOTH, left=value, right=result)
-                            return Right((data, from_right.reduce(data)))
+                            data = ThenSpec(name=name, kind=kind, left=value, right=result)
+                            from_right = from_right.visit(other, result) 
+                            return Right((data, from_right.visit(this, data) if this is not None else from_right))
             raise SyncraftError("flat_map should always return a value or an error.", offending=self_result, expect=(Left, Right))
-        return self.__class__(then_run, name=self.name, cache=self.cache | other.cache) 
+        this = self.__class__(then_run, name=name, cache=self.cache | other.cache) 
+        return this
 
-    def then_left(self, other: Algebra[Any, WalkerState[SS]]) -> Algebra[Any, WalkerState[SS]]:
-        return self.then_both(other).map(lambda t: replace(t, kind=ThenKind.LEFT))
 
-    def then_right(self, other: Algebra[Any, WalkerState[SS]]) -> Algebra[Any, WalkerState[SS]]:
-        return self.then_both(other).map(lambda t: replace(t, kind=ThenKind.RIGHT))
 
+    def then_both(self, other: Algebra[Any, WalkerState]) -> Algebra[Any, WalkerState]:
+        return self.then_all(other, ThenKind.BOTH)
 
-    def many(self, *, at_least: int, at_most: Optional[int]) -> Algebra[Any, WalkerState[SS]]:
+    def then_left(self, other: Algebra[Any, WalkerState]) -> Algebra[Any, WalkerState]:
+        return self.then_all(other, ThenKind.LEFT)
+
+    def then_right(self, other: Algebra[Any, WalkerState]) -> Algebra[Any, WalkerState]:
+        return self.then_all(other, ThenKind.RIGHT)
+
+
+    def many(self, *, at_least: int, at_most: Optional[int]) -> Algebra[Any, WalkerState]:
         if at_least <=0 or (at_most is not None and at_most < at_least):
             raise SyncraftError(f"Invalid arguments for many: at_least={at_least}, at_most={at_most}", offending=(at_least, at_most), expect="at_least>0 and (at_most is None or at_most>=at_least)")
-        def many_run(input: WalkerState[SS], use_cache:bool) -> PyGenerator[Incomplete[WalkerState[SS]], WalkerState[SS], Either[Any, Tuple[Any, WalkerState[SS]]]]:
+        this: None | Algebra[Any, WalkerState] = None
+        def many_run(input: WalkerState, use_cache:bool) -> PyGenerator[Incomplete[WalkerState], WalkerState, Either[Any, Tuple[Any, WalkerState]]]:
             self_result = yield from self.run(input, use_cache)
             match self_result:
                 case Right((value, from_self)):
-                    data = ManySpec(value=value, at_least=at_least, at_most=at_most)
-                    return Right((data, from_self.reduce(data)))
+                    data = ManySpec(name=f"*({self.name})", value=value, at_least=at_least, at_most=at_most)
+                    from_self = from_self.visit(self, value)
+                    return Right((data, from_self.visit(this, data) if this is not None else from_self))
             raise SyncraftError("many should always return a value or an error.", offending=self_result, expect=(Left, Right))
-        return self.__class__(many_run, name=f"many({self.name})", cache=self.cache)  
+        this = self.__class__(many_run, name=self.name, cache=self.cache)  
+        return this
     
  
-    def or_else(self, other: Algebra[Any, WalkerState[SS]]) -> Algebra[Any, WalkerState[SS]]: 
-        def or_else_run(input: WalkerState[SS], use_cache:bool) -> PyGenerator[Incomplete[WalkerState[SS]], WalkerState[SS], Either[Any, Tuple[Any, WalkerState[SS]]]]:
+    def or_else(self, other: Algebra[Any, WalkerState]) -> Algebra[Any, WalkerState]: 
+        pattern = re.compile(r'\s')
+        self_name = self.name.strip() 
+        self_name = f"({self_name})" if bool(pattern.search(self_name)) else self_name
+        other_name = other.name.strip()
+        other_name = f"({other_name})" if bool(pattern.search(other_name)) else other_name
+        name = f"{self_name} | {other_name}"
+        this: None | Algebra[Any, WalkerState] = None
+        def or_else_run(input: WalkerState, use_cache:bool) -> PyGenerator[Incomplete[WalkerState], WalkerState, Either[Any, Tuple[Any, WalkerState]]]:
             self_result = yield from self.run(input, use_cache=use_cache)
             match self_result:
                 case Right((value, from_left)):
-                    other_result = yield from other.run(from_left, use_cache)
+                    other_result = yield from other.run(from_left.visit(self, value), use_cache)
                     match other_result:
                         case Right((result, from_right)):
-                            data = ChoiceSpec(left=value, right=result)
-                            return Right((data, from_right.reduce(data)))
+                            data = ChoiceSpec(name=name, left=value, right=result)
+                            from_right = from_right.visit(other, result) 
+                            return Right((data, from_right.visit(this, data) if this is not None else from_right))
             raise SyncraftError("", offending=self)
-        return self.__class__(or_else_run, name=f"or_else({self.name} | {other.name})", cache=self.cache | other.cache) 
+        this = self.__class__(or_else_run, name=name, cache=self.cache | other.cache) 
+        return this
 
 
 
-def walk(syntax: Syntax[Any, Any], reducer: Callable[[Any, Any], SS], init: SS)-> Tuple[Any, None | SS]:
+def walk(syntax: Syntax[Any, Any], reducer: Optional[Callable[[Any, Any], SS]] = None, init: Optional[SS] = None) -> Any:
     from syncraft.syntax import run
-    v, s = run(syntax=syntax, alg=Walker, use_cache=False, reducer=reducer, init=init)
-    return v, s
+    v, s = run(syntax=syntax, 
+               alg=Walker, 
+               use_cache=True, 
+               reducer=reducer or (lambda a, s: s), 
+               init=init)
+    if reducer is None:
+        return v
+    else:
+        if s is not None:
+            return s.acc
+        else:
+            return None

{syncraft-0.2.8.dist-info → syncraft-0.2.10.dist-info}/METADATA

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

syncraft-0.2.10.dist-info/RECORD

@@ -0,0 +1,20 @@
+syncraft/__init__.py,sha256=g1Rd3DwPJ-Z7dL0PBNyNkcLBmpkp8bIBDWabkeBCD48,1329
+syncraft/algebra.py,sha256=kgJWXxPX1ehdTmmc0nHUKXeC_58MyaUAZ-xBsQoisN8,20857
+syncraft/ast.py,sha256=IAPW4unDl8LWQp1I5BhNmgFUsMRjz1HuiHlor5Y0wBY,22191
+syncraft/cache.py,sha256=imp3LktzdYUaHfen4MELtJg_a5n-PW1Yx7rgfb51b0E,4839
+syncraft/constraint.py,sha256=a6j_VafRor8W7FBXh20DoVnIUO9nfn7eIValigCf9lU,16318
+syncraft/dev.py,sha256=v7jdb2aOVCGbio-Jw14tRhO09FkhWc0vrDdIkIKPu2Y,186
+syncraft/finder.py,sha256=Mv9BYrsDjjq62Z4NO3gElZAbkEgSBINhSbqFbKEQW4Q,4347
+syncraft/generator.py,sha256=2q_dRKZlPLdfyrwdZqL01KpNes00qLKm-D13OWzN79I,21232
+syncraft/lexer.py,sha256=npPHAEEbBRQYcFHPMHtXmiVLbCZAnjpTtj3cnVui4W0,3720
+syncraft/parser.py,sha256=bdCbbeJ5p-j8kJniqmKSRAE8N3pCWN-ltJIpALW0h54,9070
+syncraft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syncraft/sqlite3.py,sha256=Pq09IHZOwuWg5W82l9D1flzd36QV0TOHQpTJ5U02V8g,34701
+syncraft/syntax.py,sha256=YzugKKEttL7wFB3HrJc9IMOFQ3_MQcpHYnBivnB8Zo4,25321
+syncraft/utils.py,sha256=2V446Il2q4mR7bwwGX5_qruJPU0WXU2PniXEjl6EOPE,8746
+syncraft/walker.py,sha256=2aBcKHHcBAyyg_hvlDXkfqKqFjLjVbB_5RHG8Y_AYe4,9254
+syncraft-0.2.10.dist-info/licenses/LICENSE,sha256=wHSV424U5csa3339dy1AZbsz2xsd0hrkMx2QK48CcUk,1062
+syncraft-0.2.10.dist-info/METADATA,sha256=BcUwP1Fj4JuX2l0DuYYMiscpGsE4qvrci0RgsWbW4wY,1024
+syncraft-0.2.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+syncraft-0.2.10.dist-info/top_level.txt,sha256=Kq3t8ESXB2xW1Xt3uPmkENFc-c4f2pamNmaURBk7zc8,9
+syncraft-0.2.10.dist-info/RECORD,,

syncraft-0.2.8.dist-info/RECORD

@@ -1,20 +0,0 @@
-syncraft/__init__.py,sha256=g1Rd3DwPJ-Z7dL0PBNyNkcLBmpkp8bIBDWabkeBCD48,1329
-syncraft/algebra.py,sha256=RfI6IzVPflDMuONbajGmqDYo0gR2Yqt3GSaZ8M0N-cs,20709
-syncraft/ast.py,sha256=UZSByp1XZjaBMldc6AVL6bZcjTbPPi7qtlAM1HwY2Tk,20798
-syncraft/cache.py,sha256=oqF0E-jHFzYW36YqPRQm-wP_8_YhcB6VfGNdvgllE0w,4827
-syncraft/constraint.py,sha256=a6j_VafRor8W7FBXh20DoVnIUO9nfn7eIValigCf9lU,16318
-syncraft/dev.py,sha256=v7jdb2aOVCGbio-Jw14tRhO09FkhWc0vrDdIkIKPu2Y,186
-syncraft/finder.py,sha256=Mv9BYrsDjjq62Z4NO3gElZAbkEgSBINhSbqFbKEQW4Q,4347
-syncraft/generator.py,sha256=2q_dRKZlPLdfyrwdZqL01KpNes00qLKm-D13OWzN79I,21232
-syncraft/lexer.py,sha256=npPHAEEbBRQYcFHPMHtXmiVLbCZAnjpTtj3cnVui4W0,3720
-syncraft/parser.py,sha256=bdCbbeJ5p-j8kJniqmKSRAE8N3pCWN-ltJIpALW0h54,9070
-syncraft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-syncraft/sqlite3.py,sha256=Pq09IHZOwuWg5W82l9D1flzd36QV0TOHQpTJ5U02V8g,34701
-syncraft/syntax.py,sha256=ILIEK0GQp0_rpXJYEAX9E_wN7ouTUiFfyGqlQtaAJN4,24794
-syncraft/utils.py,sha256=2V446Il2q4mR7bwwGX5_qruJPU0WXU2PniXEjl6EOPE,8746
-syncraft/walker.py,sha256=-IFS8M_cL5qG2meJleo_AS2ejTis0bnLWu-6Yw-ILUk,6817
-syncraft-0.2.8.dist-info/licenses/LICENSE,sha256=wHSV424U5csa3339dy1AZbsz2xsd0hrkMx2QK48CcUk,1062
-syncraft-0.2.8.dist-info/METADATA,sha256=2QiTtmFXvxrquEPGn1eqBTSbsesiHavUf_KyQgxQtHk,1023
-syncraft-0.2.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-syncraft-0.2.8.dist-info/top_level.txt,sha256=Kq3t8ESXB2xW1Xt3uPmkENFc-c4f2pamNmaURBk7zc8,9
-syncraft-0.2.8.dist-info/RECORD,,