syncraft 0.1.15__tar.gz → 0.1.16__tar.gz

{syncraft-0.1.15 → syncraft-0.1.16}/PKG-INFO

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

{syncraft-0.1.15 → syncraft-0.1.16}/pyproject.toml

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

{syncraft-0.1.15 → syncraft-0.1.16}/syncraft/algebra.py

@@ -170,17 +170,7 @@ class ThenResult(Generic[A, B], StructuralResult):
     right: B
     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)
-                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:
-                return b, lambda x: x
+            return b.bimap(ctx) if isinstance(b, StructuralResult) else (b, lambda x: x)
         match self.kind:
             case ThenKind.BOTH:
                 left_value, left_bmap = branch(self.left)

{syncraft-0.1.15 → syncraft-0.1.16}/syncraft/generator.py

@@ -147,24 +147,31 @@ 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]]: 
-        def flat_map_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[B, 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
-            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.")
-        return Generator(run_f = flat_map_run, name=self.name) # type: ignore  
-    
-        
+        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 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]]:
         assert at_least > 0, "at_least must be greater than 0"

{syncraft-0.1.15 → syncraft-0.1.16}/syncraft.egg-info/PKG-INFO

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

{syncraft-0.1.15 → syncraft-0.1.16}/tests/test_bimap.py

@@ -1,8 +1,7 @@
 from __future__ import annotations
-from syncraft.parser import literal, variable, parse, Parser
-from syncraft.ast import AST
+from syncraft.algebra import NamedResult
+from syncraft.parser import literal, parse, Parser
 import syncraft.generator as gen
-from typing import Any
 from rich import print
 
 
@@ -85,4 +84,83 @@ def test5_nested_then_many() -> None:
     # assert ast == generated
     value, bmap = generated.bimap(None)
     print(value)
-    assert bmap(value) == generated
+    assert bmap(value) == generated
+
+
+
+def test_then_flatten():
+    A, B, C = literal("a"), literal("b"), literal("c")
+    syntax = A + (B + C)
+    sql = "a b c"
+    ast = parse(syntax(Parser), sql, dialect='sqlite')
+    print(ast)
+    generated = gen.generate(syntax(gen.Generator), ast)
+    assert ast == generated
+    value, bmap = ast.bimap(None)
+    assert bmap(value) == ast    
+
+
+
+def test_named_in_then():
+    A = literal("a").bind("first")
+    B = literal("b").bind("second")
+    C = literal("c").bind("third")
+    syntax = A + B + C
+    sql = "a b c"
+    ast = parse(syntax(Parser), sql, dialect='sqlite')
+    print(ast)
+    generated = gen.generate(syntax(gen.Generator), ast)
+    assert ast == generated
+    value, bmap = ast.bimap(None)
+    assert isinstance(value, tuple)
+    print(value)
+    assert set(x.name for x in value if isinstance(x, NamedResult)) == {"first", "second", "third"}
+    assert bmap(value) == ast
+
+
+def test_named_in_many():
+    A = literal("x").bind("x")
+    syntax = A.many()
+    sql = "x x x"
+    ast = parse(syntax(Parser), sql, dialect='sqlite')
+    print(ast)
+    generated = gen.generate(syntax(gen.Generator), ast)
+    assert ast == generated
+    value, bmap = ast.bimap(None)
+    assert isinstance(value, list)
+    assert all(isinstance(v, NamedResult) for v in value if isinstance(v, NamedResult))
+    assert bmap(value) == ast
+
+
+def test_named_in_or():
+    A = literal("a").bind("a")
+    B = literal("b").bind("b")
+    syntax = A | B
+    sql = "b"
+    ast = parse(syntax(Parser), sql, dialect='sqlite')
+    print(ast)
+    generated = gen.generate(syntax(gen.Generator), ast)
+    assert ast == generated
+    value, bmap = ast.bimap(None)
+    assert isinstance(value, NamedResult)
+    assert value.name == "b"
+    assert bmap(value) == ast    
+
+
+
+
+
+def test_deep_mix():
+    A = literal("a").bind("a")
+    B = literal("b")
+    C = literal("c").bind("c")
+    syntax = ((A + B) | C).many() + B
+    sql = "a b a b c b"
+    ast = parse(syntax(Parser), sql, dialect='sqlite')
+    print(ast)
+    generated = gen.generate(syntax(gen.Generator), ast)
+    print('---' * 40)
+    print(generated)
+    assert ast == generated
+    value, bmap = ast.bimap(None)
+    assert bmap(value) == ast