syncraft 0.1.28__tar.gz → 0.1.29__tar.gz

{syncraft-0.1.28 → syncraft-0.1.29}/PKG-INFO

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

{syncraft-0.1.28 → syncraft-0.1.29}/pyproject.toml

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

{syncraft-0.1.28 → syncraft-0.1.29}/syncraft/algebra.py

@@ -8,7 +8,10 @@ import traceback
 from dataclasses import dataclass, replace, asdict
 from weakref import WeakKeyDictionary
 from abc import ABC
-from syncraft.ast import ThenKind, Then, S, Choice, Many, ChoiceKind
+from syncraft.ast import ThenKind, Then, Choice, Many, ChoiceKind
+from syncraft.constraint import Bindable
+
+S = TypeVar('S', bound=Bindable)
     
 A = TypeVar('A')  # Result type
 B = TypeVar('B')  # Mapped result type

{syncraft-0.1.28 → syncraft-0.1.29}/syncraft/ast.py

@@ -3,14 +3,14 @@
 from __future__ import annotations
 import re
 from typing import (
-    Optional, Any, TypeVar, Tuple, runtime_checkable, Self,
-    Dict, Generic, Callable, Union, Protocol, Type
+    Optional, Any, TypeVar, Tuple, runtime_checkable, cast,
+    Generic, Callable, Union, Protocol, Type, List, ClassVar
 )
 
 
-from dataclasses import dataclass
+from dataclasses import dataclass, replace, is_dataclass, asdict, fields
 from enum import Enum
-from syncraft.constraint import Bindable
+
 
 
 
@@ -18,7 +18,9 @@ A = TypeVar('A')
 B = TypeVar('B')  
 C = TypeVar('C')  
 D = TypeVar('D')
-S = TypeVar('S', bound=Bindable)  
+S = TypeVar('S')  
+S1 = TypeVar('S1')
+
 
 @dataclass(frozen=True)
 class Biarrow(Generic[A, B]):
@@ -79,20 +81,6 @@ class Lens(Generic[C, A]):
         return other.__truediv__(self)
     
 
-@dataclass(frozen=True)
-class Reducer(Generic[A, S]):
-    run_f: Callable[[A, S], S]
-    def __call__(self, a: A, s: S) -> S:
-        return self.run_f(a, s)
-    
-    def map(self, f: Callable[[B], A]) -> Reducer[B, S]:
-        def map_run(b: B, s: S) -> S:
-            return self(f(b), s)
-        return Reducer(map_run)
-    
-    def __rshift__(self, other: Reducer[A, S]) -> Reducer[A, S]:
-        return Reducer(lambda a, s: other(a, self(a, s)))
-    
 @dataclass(frozen=True)
 class Bimap(Generic[A, B]):
     run_f: Callable[[A], Tuple[B, Callable[[B], A]]]
@@ -161,14 +149,36 @@ class Bimap(Generic[A, B]):
             return abc, inv_f
         return Bimap(when_run)
     
-    
 
+@dataclass(frozen=True)
+class Reducer(Generic[A, S]):
+    run_f: Callable[[A, S], S]
+    def __call__(self, a: A, s: S) -> S:
+        return self.run_f(a, s)
     
+    def map(self, f: Callable[[B], A]) -> Reducer[B, S]:
+        def map_run(b: B, s: S) -> S:
+            return self(f(b), s)
+        return Reducer(map_run)
+    
+    def __rshift__(self, other: Reducer[A, S]) -> Reducer[A, S]:
+        return Reducer(lambda a, s: other(a, self(a, s)))
+    
+    def zip(self, other: Reducer[A, S1])-> Reducer[A, Tuple[S, S1]]:
+        return Reducer(lambda a, s: (self(a, s[0]), other(a, s[1])))
+    
+    def diff(self, other: Reducer[B, S]) -> Reducer[Tuple[A, B], S]:
+        return Reducer(lambda ab, s: other(ab[1], self(ab[0], s)))
+    
+    def filter(self, f: Callable[[A, S], bool]) -> Reducer[A, S]:
+        return Reducer(lambda a, s: self(a, s) if f(a, s) else s)
+
+
 
 @dataclass(frozen=True)    
 class AST:
-    def walk(self, r: Reducer[Any, S], s: S) -> S:
-        return s
+    def bimap(self, r: Bimap[Any, Any]=Bimap.identity()) -> Tuple[Any, Callable[[Any], Any]]:
+        return r(self)
 
 @dataclass(frozen=True)
 class Nothing(AST):
@@ -182,19 +192,10 @@ class Nothing(AST):
 class Marked(Generic[A], AST):
     name: str
     value: A
-    def walk(self, r: Reducer[A, S], s: S) -> S:
-        return self.value.walk(r, s) if isinstance(self.value, AST) else r(self.value, s)
-
-
-class DataclassProtocol(Protocol):
-    __dataclass_fields__: dict
-
-E = TypeVar("E")
-@dataclass(frozen=True)
-class Collect(Generic[A, E], AST): 
-    collector: Type[E]
-    value: A
-
+    def bimap(self, r: Bimap[A, B]=Bimap.identity()) -> Tuple[Marked[B], Callable[[Marked[B]], Marked[A]]]:
+        v, inner_f = self.value.bimap(r) if isinstance(self.value, AST) else r(self.value)
+        return Marked(name=self.name, value=v), lambda b: Marked(name = b.name, value=inner_f(b.value))
+    
 class ChoiceKind(Enum):
     LEFT = 'left'
     RIGHT = 'right'
@@ -203,49 +204,122 @@ class ChoiceKind(Enum):
 class Choice(Generic[A, B], AST):
     kind: Optional[ChoiceKind]
     value: Optional[A | B] = None
-    def walk(self, r: Reducer[A | B, S], s: S) -> S:
-        if self.value is not None:
-            if isinstance(self.value, AST):
-                return self.value.walk(r, s)
-            else:
-                return r(self.value, s)
-        return s
+    def bimap(self, r: Bimap[A | B, C]=Bimap.identity()) -> Tuple[Optional[C], Callable[[Optional[C]], Choice[A, B]]]:
+        if self.value is None:
+            return None, lambda c: replace(self, value=None, kind=None)
+        else:
+            v, inv = self.value.bimap(r) if isinstance(self.value, AST) else r(self.value)
+            return v, lambda c: replace(self, value=inv(c) if c is not None else None, kind=None)
 
 @dataclass(frozen=True)
 class Many(Generic[A], AST):
     value: Tuple[A, ...]
-    def walk(self, r: Reducer[A, S], s: S) -> S:
-        for item in self.value:
-            if isinstance(item, AST):
-                s = item.walk(r, s)
+    def bimap(self, r: Bimap[A, B]=Bimap.identity()) -> Tuple[List[B], Callable[[List[B]], Many[A]]]:
+        ret = [v.bimap(r) if isinstance(v, AST) else r(v) for v in self.value]
+        def inv(bs: List[B]) -> Many[A]:
+            if len(bs) <= len(ret):
+                return Many(value = tuple(ret[i][1](bs[i]) for i in range(len(bs)))) 
             else:
-                s = r(item, s)
-        return s
+                half = [ret[i][1](bs[i]) for i in range(len(bs))]
+                tmp = [ret[-1][1](bs[i]) for i in range(len(ret)-1, len(bs))]
+                return Many(value = tuple(half + tmp))
+        return [v[0] for v in ret], inv
 
 class ThenKind(Enum):
     BOTH = '+'
     LEFT = '//'
     RIGHT = '>>'
     
-FlatThen = Tuple[Any, ...]
-MarkedThen = Tuple[Dict[str, Any] | Any, FlatThen]
-
 @dataclass(eq=True, frozen=True)
 class Then(Generic[A, B], AST):
     kind: ThenKind
     left: A
     right: B
-    def walk(self, r: Reducer[A | B, S], s: S) -> S:
-        if isinstance(self.left, AST):
-            s = self.left.walk(r, s)
+    def arity(self)->int:
+        if self.kind == ThenKind.LEFT:
+            return self.left.arity() if isinstance(self.left, Then) else 1
+        elif self.kind == ThenKind.RIGHT:
+            return self.right.arity() if isinstance(self.right, Then) else 1
+        elif self.kind == ThenKind.BOTH:
+            left_arity = self.left.arity() if isinstance(self.left, Then) else 1
+            right_arity = self.right.arity() if isinstance(self.right, Then) else 1
+            return left_arity + right_arity
         else:
-            s = r(self.left, s)
-        if isinstance(self.right, AST):
-            s = self.right.walk(r, s)
+            return 1
+
+    def bimap(self, r: Bimap[A|B, Any]=Bimap.identity()) -> Tuple[Any | Tuple[Any, ...], Callable[[Any | Tuple[Any, ...]], Then[A, B]]]:
+        def need_wrap(x: Any) -> bool:
+            return not (isinstance(x, Then) and x.kind == ThenKind.BOTH)
+        match self.kind:
+            case ThenKind.LEFT:
+                lb, linv = self.left.bimap(r) if isinstance(self.left, AST) else r(self.left)
+                return lb, lambda c: replace(self, left=cast(A, linv(c)))
+            case ThenKind.RIGHT:
+                rb, rinv = self.right.bimap(r) if isinstance(self.right, AST) else r(self.right)
+                return rb, lambda c: replace(self, right=cast(B, rinv(c)))
+            case ThenKind.BOTH:
+                lb, linv = self.left.bimap(r) if isinstance(self.left, AST) else r(self.left)
+                rb, rinv = self.right.bimap(r) if isinstance(self.right, AST) else r(self.right)
+                left_v = (lb,) if need_wrap(self.left) else lb
+                right_v = (rb,) if need_wrap(self.right) else rb
+                def invf(b: Tuple[C, ...]) -> Then[A, B]:
+                    left_size = self.left.arity() if isinstance(self.left, Then) else 1
+                    right_size = self.right.arity() if isinstance(self.right, Then) else 1
+                    lraw: Tuple[Any, ...] = b[:left_size]
+                    rraw: Tuple[Any, ...] = 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=cast(A, la), right=cast(B, ra))
+                return left_v + right_v, invf
+
+
+class DataclassInstance(Protocol):
+    __dataclass_fields__: ClassVar[dict[str, Any]]
+
+
+E = TypeVar("E", bound=DataclassInstance)
+
+Collector = Type[E] | Callable[..., E]
+@dataclass(frozen=True)
+class Collect(Generic[A, E], AST): 
+    collector: Collector
+    value: A
+    def bimap(self, r: Bimap[A, B]=Bimap.identity()) -> Tuple[B | E, Callable[[B | E], Collect[A, E]]]:
+        b, inner_f = r(self.value)
+        if isinstance(self.value, Then) and self.value.kind == ThenKind.BOTH:
+            assert isinstance(b, tuple), f"Expected tuple from Then.BOTH combinator, got {type(b)}"
+            index: List[str | int] = []
+            named_count = 0
+            for i, v in enumerate(b):
+                if isinstance(v, Marked):
+                    index.append(v.name)
+                    named_count += 1
+                else:
+                    index.append(i - named_count)
+            named = {v.name: v.value for v in b if isinstance(v, Marked)}
+            unnamed = [v for v in b if not isinstance(v, Marked)]
+            ret: E = self.collector(*unnamed, **named)
+            def invf(e: E) -> Tuple[Any, ...]:
+                assert is_dataclass(e), f"Expected dataclass instance for collector inverse, got {type(e)}"
+                named_dict = asdict(e)     
+                unnamed = []           
+                for f in fields(e):
+                    if f.name not in named:
+                        unnamed.append(named_dict[f.name])
+                tmp = []
+                for x in index:
+                    if isinstance(x, str):
+                        tmp.append(Marked(name=x, value=named_dict[x]))
+                    else:
+                        tmp.append(unnamed[x])
+                return tuple(tmp)
+            return ret, lambda e: replace(self, value=inner_f(invf(e))) # type: ignore
         else:
-            s = r(self.right, s)
-        return s
+            return b, lambda e: replace(self, value=inner_f(e)) # type: ignore
 
+#########################################################################################################################
 @dataclass(frozen=True)
 class Token(AST):
     token_type: Enum
@@ -255,11 +329,7 @@ class Token(AST):
     
     def __repr__(self) -> str:
         return self.__str__()
-    
-    def walk(self, r: Reducer['Token', S], s: S) -> S:
-        return r(self, s)
-
-        
+            
 @runtime_checkable
 class TokenProtocol(Protocol):
     @property
@@ -290,89 +360,10 @@ ParseResult = Union[
     Marked['ParseResult[T]'],
     Choice['ParseResult[T]', 'ParseResult[T]'],
     Many['ParseResult[T]'],
+    Collect['ParseResult[T]', Any],
     Nothing,
     T,
 ]
 
 
 
-"""
-    @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, Marked):
-                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, Marked)}
-        unnamed = [v for v in a if not isinstance(v, Marked)]
-        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[FlatThen, Callable[[FlatThen], Then[A, B]]]:
-        match self.kind:
-            case ThenKind.LEFT:
-                lb, linv = self.left.bimap(f) if isinstance(self.left, AST) 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, AST) 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, AST) else f(self.left)
-                rb, rinv = self.right.bimap(f) if isinstance(self.right, AST) else f(self.right)
-                left_v = (lb,) if not isinstance(self.left, Then) else lb
-                right_v = (rb,) if not isinstance(self.right, Then) else rb
-                def invf(b: Tuple[Any, ...]) -> Then[A, B]:
-                    left_size = self.left.arity() if isinstance(self.left, Then) else 1
-                    right_size = self.right.arity() if isinstance(self.right, Then) 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
-            
-    def bimap_collected(self, f: Bimap[Any, Any]=Bimap.identity()) -> Tuple[MarkedThen, Callable[[MarkedThen], Then[A, B]]]:
-        data, invf = self.bimap(f)                
-        data, func = Then.collect_marked(data)
-        return data, lambda d: invf(func(d))
-
-
-    def arity(self)->int:
-        if self.kind == ThenKind.LEFT:
-            return self.left.arity() if isinstance(self.left, Then) else 1
-        elif self.kind == ThenKind.RIGHT:
-            return self.right.arity() if isinstance(self.right, Then) else 1
-        elif self.kind == ThenKind.BOTH:
-            left_arity = self.left.arity() if isinstance(self.left, Then) else 1
-            right_arity = self.right.arity() if isinstance(self.right, Then) else 1
-            return left_arity + right_arity
-        else:
-            return 1
-
-
-"""

{syncraft-0.1.28 → syncraft-0.1.29}/syncraft/finder.py

@@ -1,40 +1,40 @@
 from __future__ import annotations
 
 from typing import (
-    Any, Tuple, Generator as YieldGen
+    Any, Tuple, Generator as YieldGen, TypeVar
 )
 from dataclasses import dataclass
 from syncraft.algebra import (
     Algebra, Either, Right, 
 )
-from syncraft.ast import T, ParseResult, Choice, Many, Then, Marked
+from syncraft.ast import TokenProtocol, ParseResult, Choice, Many, Then, Marked, Collect
 
 from syncraft.generator import GenState, Generator
 
 from syncraft.syntax import Syntax
 
 
-
+T=TypeVar('T', bound=TokenProtocol)
 @dataclass(frozen=True)
 class Finder(Generator[T]):
     @classmethod
     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()')
+        return cls(anything_run, name=cls.__name__ + '.anything')
 
 
 
-anything = Syntax(lambda cls: cls.factory('anything')).describe(name="anything", fixity='infix') 
+anything = Syntax(lambda cls: cls.factory('anything')).describe(name="Anything", fixity='infix') 
 
-def matches(syntax: Syntax[Any, Any], data: ParseResult[T])-> bool:
+def matches(syntax: Syntax[Any, Any], data: ParseResult[Any])-> bool:
     gen = syntax(Finder)
-    state = GenState.from_ast(ast = data, restore_pruned=True)
+    state = GenState[Any].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: ParseResult[T]) -> YieldGen[ParseResult[T], None, None]:
+def find(syntax: Syntax[Any, Any], data: ParseResult[Any]) -> YieldGen[ParseResult[Any], None, None]:
     if matches(syntax, data):
         yield data
     match data:
@@ -48,10 +48,10 @@ def find(syntax: Syntax[Any, Any], data: ParseResult[T]) -> YieldGen[ParseResult
                 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 Choice(value=value):
+            if value is not None:
+                yield from find(syntax, value)
+        case Collect(value=value):
+            yield from find(syntax, value)
         case _:
             pass

{syncraft-0.1.28 → syncraft-0.1.29}/syncraft/generator.py

@@ -11,8 +11,8 @@ from syncraft.algebra import (
 )
 
 from syncraft.ast import (
-    T, ParseResult, AST, Token, TokenSpec, 
-    Bindable, Nothing,
+    ParseResult, AST, Token, TokenSpec, 
+    Nothing, TokenProtocol,
     Choice, Many, ChoiceKind,
     Then, ThenKind, Marked
 )
@@ -24,6 +24,14 @@ import rstr
 from functools import lru_cache
 import random
 from rich import print
+from syncraft.constraint import Bindable
+
+T = TypeVar('T', bound=TokenProtocol)  
+
+S = TypeVar('S', bound=Bindable)
+
+
+
 B = TypeVar('B')
 
 
@@ -63,9 +71,7 @@ class GenState(Bindable, Generic[T]):
         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        
@@ -76,19 +82,27 @@ class GenState(Bindable, Generic[T]):
                 raise TypeError(f"Invalid AST type({self.ast}) for down traversal")
     
     @classmethod
-    def from_ast(cls, *, ast: Optional[ParseResult[T]], seed: int = 0, restore_pruned:bool=False) -> GenState[T]:
+    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)
     
-
-
-
-
 @lru_cache(maxsize=None)
-def token_type_from_string(token_type: Optional[TokenType], text: str, case_sensitive:bool)-> TokenType:
+def token_type_from_string(token_type: Optional[TokenType], 
+                           text: str, 
+                           case_sensitive:bool = False)-> TokenType:
     if not isinstance(token_type, TokenType) or token_type == TokenType.VAR:
-        for t in TokenType:
-            if t.value == text or str(t.value).lower() == text.lower():
-                return t
+        if case_sensitive:
+            for t in TokenType:
+                if t.value == text:
+                    return t
+        else:
+            text = text.lower()
+            for t in TokenType:
+                if t.value == text or str(t.value).lower() == text:
+                    return t
         return TokenType.VAR
     return token_type
 
@@ -121,13 +135,10 @@ class TokenGen(TokenSpec):
         else:
             text = "VALUE"
 
-        return Token(token_type= token_type_from_string(self.token_type,
-                                                        text, 
-                                                        self.case_sensitive), 
-                     text=text)        
+        return Token(token_type=token_type_from_string(self.token_type, text, case_sensitive=False), text=text)        
 
     @staticmethod
-    def from_string(string: str)->Token:
+    def from_string(string: str) -> Token:
         return Token(token_type=token_type_from_string(None, string, case_sensitive=False), text=string)
 
 

{syncraft-0.1.28 → syncraft-0.1.29}/syncraft/parser.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 import re
 from sqlglot import tokenize, TokenType, Parser as GlotParser, exp
 from typing import (
-    Optional, List, Any, Tuple,
+    Optional, List, Any, Tuple, TypeVar,
     Generic
 )
 from syncraft.algebra import (
@@ -13,9 +13,11 @@ from enum import Enum
 from functools import reduce
 from syncraft.syntax import Syntax
 
-from syncraft.ast import Token, TokenSpec, AST, T, Bindable
+from syncraft.ast import Token, TokenSpec, AST, TokenProtocol
+from syncraft.constraint import Bindable
 
 
+T = TypeVar('T', bound=TokenProtocol)
 @dataclass(frozen=True)
 class ParserState(Bindable, Generic[T]):
     input: Tuple[T, ...] = field(default_factory=tuple)

{syncraft-0.1.28 → syncraft-0.1.29}/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 Then, ThenKind, Marked, Choice, Many, ChoiceKind, Nothing, Collect, E
+from syncraft.ast import Then, ThenKind, Marked, Choice, Many, ChoiceKind, Nothing, Collect, E, Collector
 from types import MethodType, FunctionType
 
 from rich import print
@@ -249,7 +249,7 @@ class Syntax(Generic[A, S]):
             ret = self.mark(var.name).map_all(bind_v) if var.name else self.map_all(bind_v)
         return ret.describe(name=f'bind({var.name})', fixity='postfix', parameter=(self,))
 
-    def to(self, f: Type[E])-> Syntax[Collect[A, E], S]:
+    def to(self, f: Collector[E])-> Syntax[Collect[A, E], S]:
         def to_f(v: A) -> Collect[A, E]:
             if isinstance(v, Collect):
                 return replace(v, collector=f)

{syncraft-0.1.28 → syncraft-0.1.29}/syncraft.egg-info/PKG-INFO

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