syncraft 0.1.13__tar.gz → 0.1.14__tar.gz

{syncraft-0.1.13 → syncraft-0.1.14}/PKG-INFO

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

{syncraft-0.1.13 → syncraft-0.1.14}/pyproject.toml

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

{syncraft-0.1.13 → syncraft-0.1.14}/syncraft/algebra.py

@@ -127,7 +127,13 @@ class NamedResult(Generic[A], StructuralResult):
     value: A
     def bimap(self, ctx: Any)->Tuple[NamedResult[Any], Callable[[NamedResult[Any]], StructuralResult]]:
         value, backward = self.value.bimap(ctx) if isinstance(self.value, StructuralResult) else (self.value, lambda x: x)
-        return NamedResult(self.name, value), lambda data: NamedResult(self.name, backward(data))
+        def named_back(data: Any)->NamedResult[Any]:
+            v = backward(data)
+            if isinstance(v, NamedResult):
+                return replace(v, name=self.name)
+            else:
+                return NamedResult(name=self.name, value=v)
+        return NamedResult(self.name, value), named_back
 
 @dataclass(eq=True, frozen=True)
 class ManyResult(Generic[A], StructuralResult):
@@ -165,9 +171,12 @@ class ThenResult(Generic[A, B], StructuralResult):
     def bimap(self, ctx: Any) -> Tuple[Any, Callable[[Any], StructuralResult]]:
         def branch(b: Any) -> Tuple[Any, Callable[[Any], StructuralResult]]:
             if isinstance(b, ThenResult):
-               value, backward = b.bimap(ctx)
-               x, y = ThenResult.flat((value, backward))
-               return x, lambda data: ThenResult(self.kind, y(data), self.right)
+                value, backward = b.bimap(ctx)
+                if isinstance(value, tuple):
+                    x, y = ThenResult.flat(value)
+                    return x, lambda data: ThenResult(self.kind, y(data), self.right)
+                else:
+                    return value, backward
             elif isinstance(b, StructuralResult):
                 return b.bimap(ctx)
             else:

{syncraft-0.1.13 → syncraft-0.1.14}/syncraft/ast.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 import re
 from typing import (
     Optional, Any, TypeVar, Tuple, runtime_checkable, Dict,
-    Protocol, Generic, Callable, Union
+    Protocol, Generic, Callable, Union, cast
 )
 from syncraft.algebra import (
     OrResult,ThenResult, ManyResult, ThenKind,NamedResult, StructuralResult,
@@ -65,26 +65,32 @@ class AST(Generic[T]):
     pruned: bool = False
     parent: Optional[AST[T]] = None
 
+
     def bimap(self, ctx: Any) -> Tuple[Any, Callable[[Any], AST[T]]]:
         value, backward = self.focus.bimap(ctx) if isinstance(self.focus, StructuralResult) else (self.focus, lambda x: x)
         def back2ast(data: Any) -> AST[T]:
             return replace(self, focus=backward(data)) # type: ignore
         return value, back2ast
 
-    def up(self)->Optional[AST[T]]:
-        return self.parent
+    def wrapper(self)-> Callable[[Any], Any]:
+        if isinstance(self.focus, NamedResult):
+            focus = cast(NamedResult[Any], self.focus)
+            return lambda x: NamedResult(name = focus.name, value = x)
+        else:
+            return lambda x: x
+        
+    def is_named(self) -> bool: 
+        return isinstance(self.focus, NamedResult)
 
     def left(self) -> Optional[AST[T]]:
-        focus = self.focus.value if isinstance(self.focus, NamedResult) else self.focus
-        match focus:
+        match self.focus:
             case ThenResult(left=left, kind=kind):
                 return replace(self, focus=left, parent=self, pruned = self.pruned or kind == ThenKind.RIGHT)
             case _:
                 raise TypeError(f"Invalid focus type({self.focus}) for left traversal")
 
     def right(self) -> Optional[AST[T]]:
-        focus = self.focus.value if isinstance(self.focus, NamedResult) else self.focus
-        match focus:
+        match self.focus:
             case ThenResult(right=right, kind=kind):
                 return replace(self, focus=right, parent=self, pruned = self.pruned or kind == ThenKind.LEFT)
             case _:
@@ -92,8 +98,7 @@ class AST(Generic[T]):
 
 
     def down(self, index: int) -> Optional[AST[T]]:
-        focus = self.focus.value if isinstance(self.focus, NamedResult) else self.focus
-        match focus:
+        match self.focus:
             case ManyResult(value=children):
                 if 0 <= index < len(children):
                     return replace(self, focus=children[index], parent=self, pruned=self.pruned)
@@ -104,6 +109,8 @@ class AST(Generic[T]):
                     return replace(self, focus=value, parent=self, pruned=self.pruned)
                 else:
                     raise IndexError(f"Index {index} out of bounds for OrResult")
+            case NamedResult(value=value):
+                return replace(self, focus=value, parent=self, pruned=self.pruned)
             case _:
                 raise TypeError(f"Invalid focus type({self.focus}) for down traversal")
 

{syncraft-0.1.13 → syncraft-0.1.14}/syncraft/dsl.py

@@ -4,9 +4,9 @@ from typing import (
     Optional, List, Any, TypeVar, Generic, Callable, Tuple, cast,
     Type, Literal
 )
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from functools import reduce
-from syncraft.algebra import Algebra, Error, Either, Insptectable, ThenResult, ManyResult, ThenKind
+from syncraft.algebra import Algebra, Error, Either, Insptectable, ThenResult, ManyResult, ThenKind, NamedResult
 from types import MethodType, FunctionType
 
 
@@ -226,75 +226,14 @@ class DSL(Generic[A, S], Insptectable):
 
 
 ######################################################################## data processing combinators #########################################################
-
-    def _attach(self, 
-               name: str, 
-               *,
-               forward_map: Callable[[B], C] | None,
-               backward_map: Callable[[C], B] | None,
-               aggregator_f: Callable[..., Any] | None,
-               ) -> DSL[NamedResult[A, C], S]:
-        def attach_f(x: A | NamedResult[A, B]) -> NamedResult[A, C]:
-            if isinstance(x, NamedResult):
-                if x.backward_map is not None:
-                    b_f = x.backward_map
-                    def combined_bf(a: Any)->A:
-                        if backward_map is not None:
-                            return b_f(backward_map(a))
-                        else:
-                            return b_f(a)
-                if x.forward_map is not None:
-                    f_f = x.forward_map
-                    def combined_ff(a: Any)->Any:
-                        if forward_map is not None:
-                            return forward_map(f_f(a))
-                        else:
-                            return f_f(a)
-                if x.aggregator is not None:
-                    agg_f = x.aggregator
-                    def combined_agg(a: Any)->Any:
-                        if aggregator_f is not None:
-                            return aggregator_f(agg_f(a))
-                        else:
-                            return agg_f(a)
-                return NamedResult(
-                    name=name,
-                    value=x.value,
-                    forward_map=forward_map if x.forward_map is None else combined_ff, # type: ignore
-                    backward_map=backward_map if x.backward_map is None else combined_bf, # type: ignore
-                    aggregator=aggregator_f if x.aggregator is None else combined_agg
-                )
+    def bind(self, name: str) -> DSL[NamedResult[A], S]:
+        def bind_f(value: A) -> NamedResult[A]:
+            if isinstance(value, NamedResult):
+                return replace(value, name=name)    
             else:
-                return NamedResult(
-                    name=name,
-                    value=x,
-                    forward_map=forward_map, # type: ignore
-                    backward_map=backward_map, # type: ignore
-                    aggregator=aggregator_f,
-
-                )            
-            
-        return self.map(attach_f)
-
-    def bind(self, name: str) -> DSL[NamedResult[Any, Any], S]:
-        return self._attach(name, 
-                           forward_map=None, 
-                           backward_map=None, 
-                           aggregator_f=None,
-                           ).describe(name=f'bind("{name}")', fixity='postfix', parameter=[self])            
-
-    def bimap(self, name: str, *, forward_map: Callable[[Any], Any], backward_map: Callable[[Any], Any]) -> DSL[NamedResult[Any, Any], S]:
-        return self._attach(name, 
-                           forward_map=forward_map, 
-                           backward_map=backward_map, 
-                           aggregator_f=None,
-                           ).describe(name=f'bimap("{name}")', fixity='postfix', parameter=[self])            
-    def to(self, name: str, aggregator_f: Callable[..., Any]) -> DSL[NamedResult[A, Any], S]:
-        return self._attach(name, 
-                           forward_map=None, 
-                           backward_map=None, 
-                           aggregator_f=aggregator_f,
-                           ).describe(name=f'to("{name}")', fixity='postfix', parameter=[self])
+                return NamedResult(name=name, value=value)
+        return self.map(bind_f).describe(name=f'bind("{name}")', fixity='postfix', parameter=[self]) 
+
 
     def dump_error(self, formatter: Optional[Callable[[Error], None]] = None) -> DSL[A, S]:
         def dump_error_run(err: Any)->Any:

{syncraft-0.1.13 → syncraft-0.1.14}/syncraft/generator.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from typing import (
-    Any, TypeVar, Tuple, Optional,  Callable, Generic, Union, Iterable, 
+    Any, TypeVar, Tuple, Optional,  Callable, Generic, Union, 
     List
 )
 from functools import cached_property
@@ -24,7 +24,7 @@ GenResult = Union[
     ThenResult['GenResult[T]', 'GenResult[T]'], 
     ManyResult['GenResult[T]'],
     OrResult['GenResult[T]'],
-    Iterable[T],
+
     T
 ]
 
@@ -52,7 +52,16 @@ class GenState(Generic[T], Insptectable):
         if self.ast is None:
             return None
         return self.ast.focus
+
+    @property
+    def is_named(self)->bool:
+        return self.ast is not None and self.ast.is_named()
     
+    def wrapper(self)->Callable[[Any], Any]:
+        if self.ast is not None:
+            return self.ast.wrapper()
+        else:
+            return lambda x: x
 
     def left(self)-> GenState[T]:
         if self.ast is None:
@@ -64,10 +73,7 @@ class GenState(Generic[T], Insptectable):
             return self
         return replace(self, ast=self.ast.right())
     
-    def up(self)->GenState[T]:
-        if self.ast is None:
-            return self
-        return replace(self, ast=self.ast.up())
+
     
     def down(self, index: int) -> GenState[T]:
         if self.ast is None:
@@ -142,13 +148,19 @@ class TokenGen(TokenSpec):
 class Generator(Algebra[GenResult[T], GenState[T]]):  
     def flat_map(self, f: Callable[[GenResult[T]], Algebra[B, GenState[T]]]) -> Algebra[B, GenState[T]]: 
         def flat_map_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[B, GenState[T]]]:
-            lft = input.left()
+            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
+            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()
-                    return f(value).run(r, use_cache)
+                    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.")
         return Generator(run_f = flat_map_run, name=self.name) # type: ignore  
     
@@ -158,6 +170,8 @@ class Generator(Algebra[GenResult[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]]]:
+            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:
                 upper = at_most if at_most is not None else at_least + 2
                 count = input.rng("many").randint(at_least, upper)
@@ -169,7 +183,7 @@ class Generator(Algebra[GenResult[T], GenState[T]]):
                             ret.append(value)
                         case Left(_):
                             pass
-                return Right((ManyResult(tuple(ret)), input))
+                return Right((wrapper(ManyResult(tuple(ret))), input))
             else:
                 ret = []
                 for index in range(input.how_many): 
@@ -190,7 +204,7 @@ class Generator(Algebra[GenResult[T], GenState[T]]):
                         this=self,
                         state=input.down(index)
                     )) 
-                return Right((ManyResult(tuple(ret)), input))
+                return Right((wrapper(ManyResult(tuple(ret))), input))
         return self.__class__(many_run, name=f"many({self.name})")  # type: ignore
     
  
@@ -198,21 +212,23 @@ class Generator(Algebra[GenResult[T], GenState[T]]):
                 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]]]:
+            wrapper = input.wrapper()
+            input = input if not input.is_named else input.down(0)  # If the input is named, we need to go down to the first child
             if input.pruned:
                 forked_input = input.fork(tag="or_else")
                 match forked_input.rng("or_else").choice((self, other)).run(forked_input, use_cache):
                     case Right((value, next_input)):
-                        return Right((OrResult(value), next_input))
+                        return Right((wrapper(OrResult(value)), next_input))
                     case Left(error):
                         return Left(error)
             else:
                 match self.run(input.down(0), use_cache):
                     case Right((value, next_input)):
-                        return Right((OrResult(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((OrResult(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.")
@@ -228,6 +244,8 @@ class Generator(Algebra[GenResult[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]]]:
+            wrapper = input.wrapper()
+            input = input if not input.is_named else input.down(0)  # If the input is named, we need to go down to the first child
             if input.pruned:
                 return Right((gen.gen(), input))
             else:
@@ -236,7 +254,7 @@ class Generator(Algebra[GenResult[T], GenState[T]]):
                     return Left(Error(None, 
                                       message=f"Expected a Token, but got {type(current)}.", 
                                       state=input))
-                return Right((current, 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
 

{syncraft-0.1.13 → syncraft-0.1.14}/syncraft/parser.py

@@ -77,23 +77,23 @@ class ParserState(Generic[T], Insptectable):
 
     
 @dataclass(frozen=True)
-class Parser(Algebra[Tuple[T,...] | T, ParserState[T]]):
+class Parser(Algebra[T, ParserState[T]]):
     @classmethod
     def token(cls, 
               token_type: Optional[Enum] = None, 
               text: Optional[str] = None, 
               case_sensitive: bool = False,
               regex: Optional[re.Pattern[str]] = None
-              )-> Algebra[Tuple[T,...] | T, ParserState[T]]:
+              )-> Algebra[T, ParserState[T]]:
         spec = TokenSpec(token_type=token_type, text=text, case_sensitive=case_sensitive, regex=regex)
-        def token_run(state: ParserState[T], use_cache:bool) -> Either[Any, Tuple[Tuple[T,...] | T, ParserState[T]]]:
+        def token_run(state: ParserState[T], use_cache:bool) -> Either[Any, Tuple[T, ParserState[T]]]:
             if state.ended():
                 return Left(state)
             token = state.current()
             if token is None or not spec.is_valid(token):
                 return Left(state)
             return Right((Token(token_type = token.token_type, text=token.text), state.advance()))  # type: ignore
-        captured: Algebra[Tuple[T,...] | T, ParserState[T]] = cls(token_run, name=cls.__name__ + f'.token({token_type}, {text})')
+        captured: Algebra[T, ParserState[T]] = cls(token_run, name=cls.__name__ + f'.token({token_type}, {text})')
         def error_fn(err: Any) -> Error:
             if isinstance(err, ParserState):
                 return Error(message=f"Cannot match token at {err}", this=captured, state=err)            

{syncraft-0.1.13 → syncraft-0.1.14}/syncraft/sqlite3.py

@@ -280,7 +280,7 @@ HAVING = dsl.lift(TokenType.HAVING)
 HINT = dsl.lift(TokenType.HINT)
 IGNORE = dsl.lift(TokenType.IGNORE)
 ILIKE = dsl.lift(TokenType.ILIKE)
-ILIKE_ANY = dsl.lift(TokenType.ILIKE_ANY)
+
 IN = dsl.lift(TokenType.IN)
 INDEX = dsl.lift(TokenType.INDEX)
 INNER = dsl.lift(TokenType.INNER)
@@ -301,7 +301,7 @@ LANGUAGE = dsl.lift(TokenType.LANGUAGE)
 LATERAL = dsl.lift(TokenType.LATERAL)
 LEFT = dsl.lift(TokenType.LEFT)
 LIKE = dsl.lift(TokenType.LIKE)
-LIKE_ANY = dsl.lift(TokenType.LIKE_ANY)
+
 LIMIT = dsl.lift(TokenType.LIMIT)
 LIST = dsl.lift(TokenType.LIST)
 LOAD = dsl.lift(TokenType.LOAD)

{syncraft-0.1.13 → syncraft-0.1.14}/syncraft.egg-info/PKG-INFO

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