syncraft 0.1.14__tar.gz → 0.1.16__tar.gz

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

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

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

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

{syncraft-0.1.14 → 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.14 → 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.14 → syncraft-0.1.16}/syncraft.egg-info/PKG-INFO

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

{syncraft-0.1.14 → syncraft-0.1.16}/syncraft.egg-info/SOURCES.txt

@@ -16,5 +16,6 @@ syncraft.egg-info/SOURCES.txt
 syncraft.egg-info/dependency_links.txt
 syncraft.egg-info/requires.txt
 syncraft.egg-info/top_level.txt
+tests/test_bimap.py
 tests/test_parse.py
 tests/test_until.py

syncraft-0.1.16/tests/test_bimap.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+from syncraft.algebra import NamedResult
+from syncraft.parser import literal, parse, Parser
+import syncraft.generator as gen
+from rich import print
+
+
+def test1_simple_then() -> None:
+    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("---" * 40)
+    print(ast)
+    generated = gen.generate(syntax(gen.Generator), ast)
+    print("---" * 40)
+    print(generated)
+    assert ast == generated
+    value, bmap = generated.bimap(None)
+    print(value)
+    assert bmap(value) == generated
+
+
+def test2_named_results() -> None:
+    A, B = literal("a").bind("x").bind('z'), literal("b").bind("y")
+    syntax = A // B
+    sql = "a b"
+    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    print("---" * 40)
+    print(ast)
+    generated = gen.generate(syntax(gen.Generator), ast)
+    print("---" * 40)
+    print(generated)
+    assert ast == generated
+    value, bmap = generated.bimap(None)
+    print(value)
+    print(bmap(value))
+    assert bmap(value) == generated
+
+
+def test3_many_literals() -> None:
+    A = literal("a")
+    syntax = A.many()
+    sql = "a a a"
+    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    print("---" * 40)
+    print(ast)
+    generated = gen.generate(syntax(gen.Generator), ast)
+    print("---" * 40)
+    print(generated)
+    assert ast == generated
+    value, bmap = generated.bimap(None)
+    print(value)
+    assert bmap(value) == generated
+
+
+def test4_mixed_many_named() -> None:
+    A = literal("a").bind("x")
+    B = literal("b")
+    syntax = (A | B).many()
+    sql = "a b a"
+    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    print("---" * 40)
+    print(ast)
+    generated = gen.generate(syntax(gen.Generator), ast)
+    print("---" * 40)
+    print(generated)
+    assert ast == generated
+    value, bmap = generated.bimap(None)
+    print(value)
+    assert bmap(value) == generated
+
+
+def test5_nested_then_many() -> None:
+    IF, THEN, END = literal("if"), literal("then"), literal("end")
+    syntax = (IF.many() // THEN.many()).many() // END
+    sql = "if if then end"
+    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    print("---" * 40)
+    print(ast)
+    generated = gen.generate(syntax(gen.Generator), ast)
+    print("---" * 40)
+    print(generated)
+    # assert ast == generated
+    value, bmap = generated.bimap(None)
+    print(value)
+    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