syncraft 0.1.25__tar.gz → 0.1.26__tar.gz

{syncraft-0.1.25 → syncraft-0.1.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncraft
-Version: 0.1.25
+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.25 → syncraft-0.1.26}/README.md

@@ -16,7 +16,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.25 → syncraft-0.1.26}/pyproject.toml

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

{syncraft-0.1.25 → syncraft-0.1.26}/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-0.1.26/syncraft/ast.py

@@ -0,0 +1,187 @@
+
+
+from __future__ import annotations
+import re
+from typing import (
+    Optional, Any, TypeVar, Tuple, runtime_checkable, 
+    Dict, Generic, Callable, Union, cast, List, Protocol, Type
+)
+
+
+from dataclasses import dataclass, replace, is_dataclass, asdict
+from enum import Enum
+
+from syncraft.constraint import Binding, Variable, Bindable
+
+
+
+A = TypeVar('A')
+B = TypeVar('B')  
+C = TypeVar('C')  
+S = TypeVar('S', bound=Bindable)  
+
+@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)
+    
+
+    
+@dataclass(frozen=True)
+class Bimap(Generic[A, B]):
+    run_f: Callable[[A], Tuple[B, Callable[[B], A]]]
+    def __call__(self, a: A) -> Tuple[B, Callable[[B], A]]:
+        return self.run_f(a)    
+    def __rshift__(self, other: Bimap[B, C]) -> Bimap[A, C]:
+        def then_run(a: A) -> Tuple[C, Callable[[C], A]]:
+            b, inv1 = self(a)
+            c, inv2 = other(b)
+            def inv(c2: C) -> A:
+                return inv1(inv2(c2))
+            return c, inv
+        return Bimap(then_run)
+    @staticmethod
+    def const(a: B)->Bimap[B, B]:
+        return Bimap(lambda _: (a, lambda b: b))
+
+    @staticmethod
+    def identity()->Bimap[Any, Any]:
+        return Bimap(lambda a: (a, lambda b: b))
+
+    @staticmethod
+    def when(cond: Callable[[A], bool],
+             then: Bimap[A, B],
+             otherwise: Optional[Bimap[A, C]] = None) -> Bimap[A, A | B | C]:
+        def when_run(a:A) -> Tuple[A | B | C, Callable[[A | B | C], A]]:
+            bimap = then if cond(a) else (otherwise if otherwise is not None else Bimap.identity())
+            abc, inv = bimap(a)
+            def inv_f(b: Any) -> A:
+                return inv(b)
+            return abc, inv_f
+        return Bimap(when_run)
+    
+    
+
+@dataclass(frozen=True)
+class Biarrow(Generic[S, A, B]):
+    forward: Callable[[S, A], Tuple[S, B]]
+    inverse: Callable[[S, B], Tuple[S, A]]
+    def __rshift__(self, other: Biarrow[S, B, C]) -> Biarrow[S, A, C]:
+        def fwd(s: S, a: A) -> Tuple[S, C]:
+            s1, b = self.forward(s, a)
+            return other.forward(s1, b)
+        def inv(s: S, c: C) -> Tuple[S, A]:
+            s1, b = other.inverse(s, c)
+            return self.inverse(s1, b)
+        return Biarrow(
+            forward=fwd,
+            inverse=inv
+        )
+    @staticmethod
+    def identity()->Biarrow[S, A, A]:
+        return Biarrow(
+            forward=lambda s, x: (s, x),
+            inverse=lambda s, y: (s, y)
+        )
+            
+    @staticmethod
+    def when(condition: Callable[..., bool], 
+             then: Biarrow[S, A, B], 
+             otherwise: Optional[Biarrow[S, A, B]] = None) -> Callable[..., Biarrow[S, A, B]]:
+        def _when(*args:Any, **kwargs:Any) -> Biarrow[S, A, B]:
+            return then if condition(*args, **kwargs) else (otherwise or Biarrow.identity())
+        return _when
+    
+
+@dataclass(frozen=True)    
+class AST:
+    pass
+
+class ChoiceKind(Enum):
+    LEFT = 'left'
+    RIGHT = 'right'
+@dataclass(frozen=True)
+class Choice(Generic[A, B], AST):
+    kind: ChoiceKind
+    left: Optional[A] 
+    right: Optional[B] 
+
+
+@dataclass(frozen=True)
+class Many(Generic[A], AST):
+    value: Tuple[A, ...]
+
+@dataclass(frozen=True)
+class Marked(Generic[A], AST):
+    name: str
+    value: A
+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: Optional[A]
+    right: Optional[B]
+        
+@runtime_checkable
+class TokenProtocol(Protocol):
+    @property
+    def token_type(self) -> Enum: ...
+    @property
+    def text(self) -> str: ...
+    
+
+@dataclass(frozen=True)
+class Token:
+    token_type: Enum
+    text: str
+    def __str__(self) -> str:
+        return f"{self.token_type.name}({self.text})"
+    
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    
+
+@dataclass(frozen=True)
+class TokenSpec:
+    token_type: Optional[Enum] = None
+    text: Optional[str] = None
+    case_sensitive: bool = False
+    regex: Optional[re.Pattern[str]] = None
+        
+    def is_valid(self, token: TokenProtocol) -> bool:
+        type_match = self.token_type is None or token.token_type == self.token_type
+        value_match = self.text is None or (token.text.strip() == self.text.strip() if self.case_sensitive else 
+                                                    token.text.strip().upper() == self.text.strip().upper())
+        value_match = value_match or (self.regex is not None and self.regex.fullmatch(token.text) is not None)
+        return type_match and value_match
+
+
+
+
+T = TypeVar('T', bound=TokenProtocol)  
+
+
+ParseResult = Union[
+    Then['ParseResult[T]', 'ParseResult[T]'], 
+    Marked['ParseResult[T]'],
+    Choice['ParseResult[T]', 'ParseResult[T]'],
+    Many['ParseResult[T]'],
+    T,
+]
+
+
+

{syncraft-0.1.25 → syncraft-0.1.26}/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-0.1.26/syncraft/finder.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from typing import (
+    Any, Tuple, Optional, Generator as YieldGen
+)
+from dataclasses import dataclass, replace
+from syncraft.algebra import (
+    Algebra, Either, Right, 
+)
+from syncraft.ast import T, ParseResult, Choice, Many, Then, Marked
+
+from syncraft.generator import GenState, Generator
+from sqlglot import TokenType
+from syncraft.syntax import Syntax
+import re
+
+
+@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()')
+
+
+
+anything = Syntax(lambda cls: cls.factory('anything')).describe(name="anything", fixity='infix') 
+
+def matches(syntax: Syntax[Any, Any], data: ParseResult[T])-> bool:
+    gen = syntax(Finder)
+    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: ParseResult[T]) -> YieldGen[ParseResult[T], None, None]:
+    if matches(syntax, data):
+        yield data
+    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, 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