syncraft 0.1.19__tar.gz → 0.1.20__tar.gz

{syncraft-0.1.19 → syncraft-0.1.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncraft
-Version: 0.1.19
+Version: 0.1.20
 Summary: Parser combinator library
 Author-email: Michael Afmokt <michael@esacca.com>
 License-Expression: MIT
@@ -31,6 +31,7 @@ pip install syncraft
 
 
 ## TODO
-- [ ] Test Walker.get/set for bidirectional mapping between source code and data class
-- [ ] Annotate sqlite3 grammar with named nodes and data classes
-- [ ] 
+- [ ] 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.
+- [ ] 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.20/README.md

@@ -0,0 +1,22 @@
+# Syncraft
+
+Syncraft is a parser/generator combinator library with full round-trip support:
+
+- Parse source code into AST or dataclasses
+- Generate source code from dataclasses
+- Bidirectional transformations via lenses
+- Convenience combinators: `all`, `first`, `last`, `named`
+- SQLite syntax support included
+
+## Installation
+
+```bash
+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.
+- [ ] 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.19 → syncraft-0.1.20}/pyproject.toml

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

{syncraft-0.1.19 → syncraft-0.1.20}/syncraft/algebra.py

@@ -1,163 +1,120 @@
-"""
-We want to parse a token stream into an AST, and then generate a new token stream from that AST.
-The generation should be a dual to the parsing. By 'dual' we mean that the generation algebra should be 
-as close as possible to the parsing algebra. The closest algebra to the parsing algebra is the parsing 
-algebra itself. 
-
-Given:
-AST = Syntax(Parser)(ParserState([Token, ...]))
-AST =?= Syntax(Parser)(GenState(AST))
-
-where =?= means the LHS and RHS induce the same text output, e.g. the same token stream 
-inspite of the token metadata, token types, and/or potentially different structure of the AST.
-
-With the above setting, Generator as a dual to Parser, can reuse most of the parsing combinator, the 
-change needed is to introduce randomness in the generation process, e.g. to generate a random variable name, etc.
-
-[Token, ...] == Syntax(Generator)(GenState(AST))
-
-"""
-
-
 from __future__ import annotations
-
 from typing import (
     Optional, List, Any, TypeVar, Generic, Callable, Tuple, cast, 
-    Dict, Type, ClassVar, Hashable,
-    Mapping, Iterator
+    Dict, Type, ClassVar, Hashable
 )
 
 import traceback
-from dataclasses import dataclass, fields, replace, field
-from functools import cached_property
+from dataclasses import dataclass, replace
 from weakref import WeakKeyDictionary
-from abc import ABC, abstractmethod
+from abc import ABC
 from enum import Enum
+from functools import reduce
 
 
-
-
-class Insptectable(ABC):
-    @abstractmethod
-    def to_string(self, interested: Callable[[Any], bool]) -> Optional[str]:
-        raise NotImplementedError("Subclasses must implement to_string")
-    
-    @cached_property
-    def _string(self)->Optional[str]:
-        return self.to_string(lambda _: True)
-
-    def __repr__(self) -> str:
-        return self._string or self.__class__.__name__
-    def __str__(self) -> str:
-        return self._string or self.__class__.__name__
-
-
-A = TypeVar('A')  # Result type
-B = TypeVar('B')  # Result type for mapping
-
-S = TypeVar('S')  # State type for the Algebra
-
-    
-    
-class FrozenDict(Generic[A]):
-    def __init__(self, items: Mapping[str, A]):
-        for k, v in items.items():
-            if not isinstance(k, Hashable) or not isinstance(v, Hashable):
-                raise TypeError(f"Metadata key or value not hashable: {k} = {v}")
-        self._items = tuple(sorted(items.items()))
-
-    def __getitem__(self, key: str) -> A:
-        return dict(self._items)[key]
-
-    def __contains__(self, key: str) -> bool:
-        return key in dict(self._items)
-
-    def items(self) -> Iterator[tuple[str, A]]:
-        return iter(self._items)
-
-    def to_dict(self) -> dict[str, A]:
-        return dict(self._items)
-
-    def __hash__(self) -> int:
-        return hash(self._items)
-
-    def __eq__(self, other: object) -> bool:
-        return isinstance(other, FrozenDict) and self._items == other._items
-
-    def __repr__(self) -> str:
-        return f"FrozenDict({dict(self._items)})"
-
+A = TypeVar('A')  
+B = TypeVar('B')  
+C = TypeVar('C')  
+S = TypeVar('S')  
 
 
 @dataclass(frozen=True)
-class Lens(Generic[S, A]):
-    get: Callable[[S], A]
-    set: Callable[[S, A], S]    
-
-    def modify(self, source: S, f: Callable[[A], A]) -> S:
-        return self.set(source, f(self.get(source)))
-    
-    def bimap(self, ff: Callable[[A], B], bf: Callable[[B], A]) -> Lens[S, B]:
-        def getf(data: S) -> B:
-            return ff(self.get(data))
-
-        def setf(data: S, value: B) -> S:
-            return self.set(data, bf(value))
-
-        return Lens(get=getf, set=setf)
-
-    def __truediv__(self, other: Lens[A, B]) -> Lens[S, B]:
-        def get_composed(obj: S) -> B:
-            return other.get(self.get(obj))        
-        def set_composed(obj: S, value: B) -> S:
-            return self.set(obj, other.set(self.get(obj), value))
-        return Lens(get=get_composed, set=set_composed)
+class Bimap(Generic[S, A, B]):
+    forward: Callable[[S, A], Tuple[S, B]]
+    inverse: Callable[[S, B], Tuple[S, A]]
+    def __rshift__(self, other: Bimap[S, B, C]) -> Bimap[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 Bimap(
+            forward=fwd,
+            inverse=inv
+        )
+    @staticmethod
+    def identity()->Bimap[S, A, A]:
+        return Bimap(
+            forward=lambda s, x: (s, x),
+            inverse=lambda s, y: (s, y)
+        )
+    @staticmethod
+    def variable(value: A)->Bimap[S, A, A]:
+        return Bimap(
+            forward=lambda s, _: (s, value),
+            inverse=lambda s, y: (s, y)
+        )
+    @staticmethod
+    def const(state: S, value: A)->Bimap[Any, A, A]:
+        return Bimap(
+            forward=lambda s, _: (state, value),
+            inverse=lambda s, y: (state, value)
+        )
+    @staticmethod
+    def combine(*biarrows: Bimap[Any, Any, Any]) -> Bimap[Any, Any, Any]:
+        return reduce(lambda a, b: a >> b, biarrows, Bimap.identity()) 
+            
     
-    def __rtruediv__(self, other: Lens[B, S])->Lens[B, A]:
-        return other.__truediv__(self)
         
 class StructuralResult:
-    def bimap(self, ctx: Any)->Tuple[Any, Callable[[Any], StructuralResult]]:
-        return (self, lambda x: self)
-
+    def bimap(self, arr: Bimap[Any, Any, Any] = Bimap.identity()) -> Bimap[Any, Any, Any]:
+        return Bimap.identity()
         
 @dataclass(frozen=True)
 class NamedResult(Generic[A], StructuralResult):
     name: str
     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)
-        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
-
+    def bimap(self, arr: Bimap[Any, Any, Any] = Bimap.identity()) -> Bimap[Any, NamedResult[A], NamedResult[Any]]:
+        inner_b = self.value.bimap(arr) if isinstance(self.value, StructuralResult) else arr
+        def fwd(s: S, a: NamedResult[A])-> Tuple[S, NamedResult[Any]]:
+            assert a == self, f"Expected {self}, got {a}"
+            inner_s, inner_v = inner_b.forward(s, a.value)
+            return (inner_s, replace(a, value=inner_v)) if not isinstance(inner_v, NamedResult) else (inner_s, inner_v)
+        
+        def inv(s: S, a: NamedResult[Any]) -> Tuple[S, NamedResult[A]]:
+            assert isinstance(a, NamedResult), f"Expected NamedResult, got {type(a)}"
+            inner_s, inner_v = inner_b.inverse(s, a.value)
+            return (inner_s, replace(self, value=inner_v)) if not isinstance(inner_v, NamedResult) else (inner_s, replace(self, value=inner_v.value))
+        
+        return Bimap(
+            forward=fwd,
+            inverse=inv
+        )    
 @dataclass(eq=True, frozen=True)
 class ManyResult(Generic[A], StructuralResult):
     value: Tuple[A, ...]
-    def bimap(self, ctx: Any)->Tuple[List[Any], Callable[[List[Any]], StructuralResult]]:
-        transformed = [v.bimap(ctx) if isinstance(v, StructuralResult) else (v, lambda x: x) for v in self.value]
-        backmaps = [b for (_, b) in transformed]
-        ret = [a for (a, _) in transformed]
-        def backward(data: List[Any]) -> StructuralResult:
-            if len(data) != len(transformed):
-                raise ValueError("Incompatible data length")
-            return ManyResult(value=tuple([backmaps[i](x) for i, x in enumerate(data)]))
-        return ret, lambda data: backward(data)
-
-
-
+    def bimap(self, arr: Bimap[Any, Any, Any] = Bimap.identity()) -> Bimap[Any, ManyResult[A], List[A]]:
+        inner_b = [v.bimap(arr) if isinstance(v, StructuralResult) else arr for v in self.value]
+        def fwd(s: Any, a: ManyResult[A]) -> Tuple[Any, List[A]]:
+            assert a == self, f"Expected {self}, got {a}"
+            return s, [inner_b[i].forward(s, v)[1] for i, v in enumerate(a.value)]
+            
+        def inv(s: Any, a: List[A]) -> Tuple[Any, ManyResult[A]]:
+            assert isinstance(a, list), f"Expected list, got {type(a)}"
+            assert len(a) == len(inner_b), f"Expected {len(inner_b)} elements, got {len(a)}"
+            return s, ManyResult(value=tuple(inner_b[i].inverse(s, v)[1] for i, v in enumerate(a)))
+        return Bimap(
+            forward=fwd,
+            inverse=inv
+        )    
 @dataclass(eq=True, frozen=True)
 class OrResult(Generic[A], StructuralResult):
     value: A
-    def bimap(self, ctx: Any) -> Tuple[Any, Callable[[Any], StructuralResult]]:
-        value, backward = self.value.bimap(ctx) if isinstance(self.value, StructuralResult) else (self.value, lambda x: x)
-        return value, lambda data: OrResult(value=backward(data))
-
-
+    def bimap(self, arr: Bimap[Any, Any, Any] = Bimap.identity()) -> Bimap[Any, OrResult[A], Any]:
+        inner_b = self.value.bimap(arr) if isinstance(self.value, StructuralResult) else arr
+        def fwd(s: Any, a: OrResult[A]) -> Tuple[Any, Any]:
+            assert a == self, f"Expected {self}, got {a}"
+            return inner_b.forward(s, a.value)
+        
+        def inv(s: Any, a: Any) -> Tuple[Any, OrResult[A]]:
+            inner_s, inner_v = inner_b.inverse(s, a)
+            return inner_s, OrResult(value=inner_v) 
+        
+        return Bimap(
+            forward=fwd,
+            inverse=inv
+        )    
 class ThenKind(Enum):
     BOTH = '+'
     LEFT = '//'
@@ -168,49 +125,60 @@ class ThenResult(Generic[A, B], StructuralResult):
     kind: ThenKind
     left: A
     right: B
-    def bimap(self, ctx: Any) -> Tuple[Any, Callable[[Any], StructuralResult]]:
-        def branch(b: Any) -> Tuple[Any, Callable[[Any], StructuralResult]]:
-            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)
-                right_value, right_bmap = branch(self.right)
-                def backward(x: Tuple[Any, Any]) -> StructuralResult:
-                    return ThenResult(self.kind, left_bmap(x[0]), right_bmap(x[1]))
-                x, y = ThenResult.flat((left_value, right_value))
-                return x, lambda data: backward(y(data))
-            case ThenKind.LEFT:
-                left_value, left_bmap = branch(self.left)
-                return left_value, lambda data: ThenResult(self.kind, left_bmap(data), self.right)
-            case ThenKind.RIGHT:
-                right_value, right_bmap = branch(self.right)
-                return right_value, lambda data: ThenResult(self.kind, self.left, right_bmap(data))
-    @staticmethod
-    def flat(array: Tuple[Any, Any]) -> Tuple[Tuple[Any, ...], Callable[[Tuple[Any, ...]], Tuple[Any, Any]]]:
-        index: Dict[int, int] = {}
-        ret: List[Any] = []
-        for e in array:
-            if isinstance(e, tuple):
-                index[len(ret)] = len(e)
-                ret.extend(e)
-            else:
-                ret.append(e)
-        def backward(data: Tuple[Any, ...]) -> Tuple[Any, Any]:
-            tmp: List[Any] = []
-            skip: int = 0
-            for i, e in enumerate(data):
-                if skip <= 0:
-                    if i in index:
-                        tmp.append(tuple(data[i:i + index[i]]))
-                        skip = index[i] - 1
-                    else:
-                        tmp.append(e)
-                else:
-                    skip -= 1
-            return tuple(tmp)
-        return tuple(ret), backward
-
-
+    def arity(self)->int:
+        if self.kind == ThenKind.LEFT:
+            return self.left.arity() if isinstance(self.left, ThenResult) else 1
+        elif self.kind == ThenKind.RIGHT:
+            return self.right.arity() if isinstance(self.right, ThenResult) else 1
+        elif self.kind == ThenKind.BOTH:
+            left_arity = self.left.arity() if isinstance(self.left, ThenResult) else 1
+            right_arity = self.right.arity() if isinstance(self.right, ThenResult) else 1
+            return left_arity + right_arity
+        else:
+            return 1
+                
+    def bimap(self, arr: Bimap[Any, Any, Any] = Bimap.identity()) -> Bimap[Any, ThenResult[A, B], Tuple[Any, ...] | Any]:
+        kind = self.kind
+        lb = self.left.bimap(arr) if isinstance(self.left, StructuralResult) else arr
+        rb = self.right.bimap(arr) if isinstance(self.right, StructuralResult) else arr
+        left_size = self.left.arity() if isinstance(self.left, ThenResult) else 1
+        right_size = self.right.arity() if isinstance(self.right, ThenResult) else 1
+        def fwd(s : S, a : ThenResult[A, B]) -> Tuple[S, Tuple[Any, ...] | Any]:
+            assert a == self, f"Expected {self}, got {a}"
+            match kind:
+                case ThenKind.LEFT:
+                    return lb.forward(s, a.left)
+                case ThenKind.RIGHT:
+                    return rb.forward(s, a.right)
+                case ThenKind.BOTH:
+                    s1, left_v = lb.forward(s, a.left)
+                    s2, right_v = rb.forward(s1, a.right)
+                    left_v = (left_v,) if not isinstance(a.left, ThenResult) else left_v
+                    right_v = (right_v,) if not isinstance(a.right, ThenResult) else right_v
+                    return s2, left_v + right_v
+
+        def inv(s: S, b: Tuple[Any, ...] | Any) -> Tuple[S, ThenResult[A, B]]:
+            match kind:
+                case ThenKind.LEFT:
+                    s1, lv = lb.inverse(s, b)
+                    return s1, replace(self, left=lv)
+                case ThenKind.RIGHT:
+                    s1, rv = rb.inverse(s, b)
+                    return s1, replace(self, right=rv)
+                case ThenKind.BOTH:
+                    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
+                    s1, lv = lb.inverse(s, lraw)
+                    s2, rv = rb.inverse(s1, rraw)
+                    return s2, replace(self, left=lv, right=rv)
+            
+        return Bimap(
+            forward=fwd,
+            inverse=inv
+        )
+    
 InProgress = object()  # Marker for in-progress state, used to prevent re-entrance in recursive calls
 L = TypeVar('L')  # Left type for combined results
 R = TypeVar('R')  # Right type for combined results
@@ -233,7 +201,7 @@ class Right(Either[L, R]):
 
 
 @dataclass(frozen=True)
-class Error(Insptectable):
+class Error:
     this: Any
     message: Optional[str] = None
     error: Optional[Any] = None    
@@ -254,59 +222,9 @@ class Error(Insptectable):
             state=state,
             previous=self
         )
-    
-
 
 
-    def to_list(self, interested: Callable[[Any], bool]) -> List[Dict[str, str]]:
-
-        def to_dict() -> Dict[str, str]:
-            data: Dict[str, str] = {}
-            for f in fields(self):
-                value = getattr(self, f.name)
-                if isinstance(value, Error):
-                    # self.previous
-                    pass
-                elif isinstance(value, Insptectable):
-                    # self.this
-                    def inst(x: Any) -> bool:
-                        return x in self.algebras
-                    s = value.to_string(inst) 
-                    data[f.name] = s if s is not None else repr(value)
-                elif value is not None:
-                    # self.committed, self.message, self.expect, self.exception
-                    data[f.name] = repr(value)
-            return data
-        ret = []
-        tmp : None | Error = self
-        while tmp is not None:
-            ret.append(to_dict())
-            tmp = tmp.previous
-        return ret
-
-    def find(self, predicate: Callable[[Error], bool]) -> Optional[Error]:
-        if predicate(self):
-            return self
-        if self.previous is not None:
-            return self.previous.find(predicate)
-        return None
-    
-    def to_string(self, interested: Callable[[Any], bool])->str:
-        lst = self.to_list(interested)
-        root, leaf = lst[0], lst[-1]
-        root_fields = ',\n  '.join([f"{key}: {value}" for key, value in root.items() if value is not None])
-        leaf_fields = ',\n  '.join([f"{key}: {value}" for key, value in leaf.items() if value is not None])
-
-        return  f"{self.__class__.__name__}: ROOT\n"\
-                f"  {root_fields}\n"\
-                f"\u25cf \u25cf \u25cf  LEAF\n"\
-                f"  {leaf_fields}\n"
 
-
-    @cached_property
-    def algebras(self) -> List[Any]:
-        return [self.this] + (self.previous.algebras if self.previous is not None else [])
-        
 @dataclass(frozen=True)        
 class Algebra(ABC, Generic[A, S]):
 ######################################################## shared among all subclasses ########################################################

{syncraft-0.1.19 → syncraft-0.1.20}/syncraft/ast.py

@@ -3,12 +3,11 @@
 from __future__ import annotations
 import re
 from typing import (
-    Optional, Any, TypeVar, Tuple, runtime_checkable, Dict,
+    Optional, Any, TypeVar, Tuple, runtime_checkable, 
     Protocol, Generic, Callable, Union, cast
 )
 from syncraft.algebra import (
-    OrResult,ThenResult, ManyResult, ThenKind,NamedResult, StructuralResult,
-    Lens
+    OrResult,ThenResult, ManyResult, ThenKind,NamedResult, StructuralResult
 )
 from dataclasses import dataclass, replace, is_dataclass, asdict
 from enum import Enum
@@ -67,13 +66,17 @@ 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 bimap(self)->Tuple[Any, Callable[[Any], AST[T]]]:
+        if isinstance(self.focus, StructuralResult):
+            b = self.focus.bimap() 
+            s, v = b.forward(None, self.focus)
+            def inverse(data: Any) -> AST[T]:
+                s1, v1 = b.inverse(None, data)
+                return replace(self, focus=v1)
+            return v, inverse
+        else:
+            return self.focus, lambda x: replace(self, focus=x)
+        
     def wrapper(self)-> Callable[[Any], Any]:
         if isinstance(self.focus, NamedResult):
             focus = cast(NamedResult[Any], self.focus)

{syncraft-0.1.19 → syncraft-0.1.20}/syncraft/generator.py

@@ -7,7 +7,7 @@ from typing import (
 from functools import cached_property
 from dataclasses import dataclass, replace
 from syncraft.algebra import (
-    Algebra, ThenResult, Either, Left, Right, Error, Insptectable, 
+    Algebra, ThenResult, Either, Left, Right, Error, 
     OrResult, ManyResult, NamedResult
 )
 
@@ -31,7 +31,7 @@ GenResult = Union[
 ]
 
 @dataclass(frozen=True)
-class GenState(Generic[T], Insptectable):
+class GenState(Generic[T]):
     ast: Optional[AST[T]]
     seed: int
 

{syncraft-0.1.19 → syncraft-0.1.20}/syncraft/parser.py

@@ -6,7 +6,7 @@ from typing import (
     Generic, Callable
 )
 from syncraft.algebra import (
-    Either, Left, Right, Error, Insptectable, Algebra
+    Either, Left, Right, Error, Algebra
 )
 from dataclasses import dataclass, field, replace
 from enum import Enum
@@ -24,7 +24,7 @@ from syncraft.ast import Token, TokenSpec, AST, T
 
 
 @dataclass(frozen=True)
-class ParserState(Generic[T], Insptectable):
+class ParserState(Generic[T]):
     input: Tuple[T, ...] = field(default_factory=tuple)
     index: int = 0
     
@@ -40,13 +40,6 @@ class ParserState(Generic[T], Insptectable):
     def after(self, length: Optional[int] = 5)->str:
         length = min(length, len(self.input) - self.index) if length is not None else len(self.input) - self.index
         return " ".join(token.text for token in self.input[self.index:self.index + length])
- 
-    def to_string(self, interested: Callable[[Any], bool])->str:
-        return f"ParserState(\n"\
-               f"index={self.index}, \n"\
-               f"input({len(self.input)})=[{self.token_sample_string()}, ...]), \n"\
-               f"before=({self.before()}), \n"\
-               f"after=({self.after()})"  
 
 
     def current(self)->T:

{syncraft-0.1.19 → syncraft-0.1.20}/syncraft/syntax.py

@@ -6,7 +6,7 @@ from typing import (
 )
 from dataclasses import dataclass, field, replace
 from functools import reduce
-from syncraft.algebra import Algebra, Error, Either, Insptectable, ThenResult, ManyResult, ThenKind, NamedResult
+from syncraft.algebra import Algebra, Error, Either, ThenResult, ManyResult, ThenKind, NamedResult
 from types import MethodType, FunctionType
 
 
@@ -18,7 +18,7 @@ C = TypeVar('C')  # Result type for else branch
 S = TypeVar('S')  # State type
 
 @dataclass(frozen=True)
-class Description(Insptectable):
+class Description:
     name: Optional[str] = None
     newline: Optional[str] = None
     fixity: Literal['infix', 'prefix', 'postfix'] = 'infix'
@@ -67,7 +67,7 @@ class Description(Insptectable):
 
 
 @dataclass(frozen=True)
-class Syntax(Generic[A, S], Insptectable):
+class Syntax(Generic[A, S]):
     alg: Callable[[Type[Algebra[Any, Any]]], Algebra[A, S]]
     meta: Description = field(default_factory=Description, repr=False)
 

{syncraft-0.1.19 → syncraft-0.1.20}/syncraft.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncraft
-Version: 0.1.19
+Version: 0.1.20
 Summary: Parser combinator library
 Author-email: Michael Afmokt <michael@esacca.com>
 License-Expression: MIT
@@ -31,6 +31,7 @@ pip install syncraft
 
 
 ## TODO
-- [ ] Test Walker.get/set for bidirectional mapping between source code and data class
-- [ ] Annotate sqlite3 grammar with named nodes and data classes
-- [ ] 
+- [ ] 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.
+- [ ] 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.19 → syncraft-0.1.20}/tests/test_bimap.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
-from syncraft.algebra import NamedResult, Error, ManyResult, OrResult, ThenResult, ThenKind
+from typing import Any, List, Tuple
+from syncraft.algebra import NamedResult, Error, ManyResult, OrResult, ThenResult, ThenKind, Bimap
 from syncraft.parser import literal, parse
 import syncraft.generator as gen
 from syncraft.generator import TokenGen
@@ -17,7 +18,7 @@ def test1_simple_then() -> None:
     print("---" * 40)
     print(generated)
     assert ast == generated
-    value, bmap = generated.bimap(None)
+    value, bmap = generated.bimap()
     print(value)
     assert bmap(value) == generated
 
@@ -33,7 +34,7 @@ def test2_named_results() -> None:
     print("---" * 40)
     print(generated)
     assert ast == generated
-    value, bmap = generated.bimap(None)
+    value, bmap = generated.bimap()
     print(value)
     print(bmap(value))
     assert bmap(value) == generated
@@ -50,7 +51,7 @@ def test3_many_literals() -> None:
     print("---" * 40)
     print(generated)
     assert ast == generated
-    value, bmap = generated.bimap(None)
+    value, bmap = generated.bimap()
     print(value)
     assert bmap(value) == generated
 
@@ -67,7 +68,7 @@ def test4_mixed_many_named() -> None:
     print("---" * 40)
     print(generated)
     assert ast == generated
-    value, bmap = generated.bimap(None)
+    value, bmap = generated.bimap()
     print(value)
     assert bmap(value) == generated
 
@@ -83,7 +84,7 @@ def test5_nested_then_many() -> None:
     print("---" * 40)
     print(generated)
     # assert ast == generated
-    value, bmap = generated.bimap(None)
+    value, bmap = generated.bimap()
     print(value)
     assert bmap(value) == generated
 
@@ -97,7 +98,7 @@ def test_then_flatten():
     print(ast)
     generated = gen.generate(syntax, ast)
     assert ast == generated
-    value, bmap = ast.bimap(None)
+    value, bmap = ast.bimap()
     assert bmap(value) == ast    
 
 
@@ -112,7 +113,7 @@ def test_named_in_then():
     print(ast)
     generated = gen.generate(syntax, ast)
     assert ast == generated
-    value, bmap = ast.bimap(None)
+    value, bmap = ast.bimap()
     assert isinstance(value, tuple)
     print(value)
     assert set(x.name for x in value if isinstance(x, NamedResult)) == {"first", "second", "third"}
@@ -127,7 +128,7 @@ def test_named_in_many():
     print(ast)
     generated = gen.generate(syntax, ast)
     assert ast == generated
-    value, bmap = ast.bimap(None)
+    value, bmap = ast.bimap()
     assert isinstance(value, list)
     assert all(isinstance(v, NamedResult) for v in value if isinstance(v, NamedResult))
     assert bmap(value) == ast
@@ -142,7 +143,7 @@ def test_named_in_or():
     print(ast)
     generated = gen.generate(syntax, ast)
     assert ast == generated
-    value, bmap = ast.bimap(None)
+    value, bmap = ast.bimap()
     assert isinstance(value, NamedResult)
     assert value.name == "b"
     assert bmap(value) == ast    
@@ -163,7 +164,7 @@ def test_deep_mix():
     print('---' * 40)
     print(generated)
     assert ast == generated
-    value, bmap = ast.bimap(None)
+    value, bmap = ast.bimap()
     assert bmap(value) == ast
 
 
@@ -181,7 +182,7 @@ def test_backtracking_many() -> None:
     syntax = (A.many() + B)  # must not eat the final "a" needed for B
     sql = "a a a a b"
     ast = parse(syntax, sql, dialect="sqlite")
-    value, bmap = ast.bimap(None)
+    value, bmap = ast.bimap()
     assert value[-1] == TokenGen.from_string("b")
 
 def test_deep_nesting() -> None:
@@ -208,7 +209,7 @@ def test_named_many() -> None:
     sql = "a a"
     ast = parse(syntax, sql, dialect="sqlite")
     # Expect [NamedResult("alpha", "a"), NamedResult("alpha", "a")]
-    flattened, _ = ast.bimap(None)
+    flattened, _ = ast.bimap()
     assert all(isinstance(x, NamedResult) for x in flattened)
 
 
@@ -220,7 +221,7 @@ def test_or_named() -> None:
     ast = parse(syntax, sql, dialect="sqlite")
     # Either NamedResult("y", "b") or just "b", depending on your design
     assert isinstance(ast.focus, OrResult)
-    value, _ = ast.bimap(None)
+    value, _ = ast.bimap()
     assert value == NamedResult(name="y", value=TokenGen.from_string("b"))
 
 
@@ -264,10 +265,128 @@ def test_optional():
     A = literal("a").bind("a")
     syntax = A.optional()
     ast1 = parse(syntax, "", dialect="sqlite")
-    v1, _ = ast1.bimap(None)
+    v1, _ = ast1.bimap()
     assert v1 is None
     ast2 = parse(syntax, "a", dialect="sqlite")
-    v2, _ = ast2.bimap(None)
+    v2, _ = ast2.bimap()
     assert v2 == NamedResult(name='a', value=TokenGen.from_string('a'))
 
 
+def test_or()->None:
+    inc: Bimap[Any, int, int] = Bimap(
+        forward=lambda s, x: (s, x + 1),
+        inverse=lambda s, x: (s, x - 1),
+    )
+    data  = OrResult(value=1)
+    b = data.bimap()
+    b = b >> inc
+    s, x = b.forward(None, data)
+    assert x == 2
+    s, y = b.inverse(s, x)
+    assert y == data
+
+def test_named()->None:
+    inc: Bimap[Any, NamedResult[int], int] = Bimap(
+        forward=lambda s, x: (s, x.value + 1),
+        inverse=lambda s, y: (s, NamedResult(name="", value=y - 1)),
+    )
+    data  = NamedResult(name="test", value=1)
+    b = data.bimap()
+    c = b >> inc
+    s, x = c.forward(None, data)
+    assert x == 2
+    s, y = c.inverse(s, x)
+    assert y == data
+
+def test_many()->None:
+    inc: Bimap[Any, int, int] = Bimap(
+        forward=lambda s, x: (s, x + 1),
+        inverse=lambda s, y: (s, y - 1),
+    )
+
+    inc2: Bimap[Any, List[int], List[int]] = Bimap(
+        forward=lambda s, x: (s, [xx + 1 for xx in x]),
+        inverse=lambda s, y: (s, [yy - 1 for yy in y]),
+    )
+    data  = ManyResult(value=(1,2))
+    b = data.bimap(inc)
+    c = b >> inc2
+    s, x = c.forward(None, data)
+    assert x == [3,4]
+    s, y = c.inverse(s, x)
+    assert y == data
+
+def test_then()->None:
+    inc: Bimap[Any, int, int] = Bimap(
+        forward=lambda s, x: (s, x + 1),
+        inverse=lambda s, y: (s, y - 1),
+    )
+    inc2: Bimap[Any, Tuple[int, ...], Tuple[int, ...]] = Bimap(
+        forward=lambda s, x: (s, tuple(xx + 1 for xx in x)),
+        inverse=lambda s, y: (s, tuple(yy - 1 for yy in y)),
+    )
+
+    data  = ThenResult(kind=ThenKind.BOTH, left=1, right=2)
+    b = data.bimap(inc)
+    c = b >> inc2
+    s, x = c.forward(None, data)
+    assert x == (3, 4)
+    s, y = c.inverse(s, x)
+    assert y == data
+
+
+def test_left()->None:
+    inc: Bimap[Any, int, int] = Bimap(
+        forward=lambda s, x: (s, x + 1),
+        inverse=lambda s, y: (s, y - 1),
+    )
+    inc2: Bimap[Any, int, int] = Bimap(
+        forward=lambda s, x: (s, x + 1),
+        inverse=lambda s, y: (s, y - 1),
+    )
+
+    data  = ThenResult(kind=ThenKind.LEFT, left=1, right=2)
+    b = data.bimap(inc)
+    c = b >> inc2
+    s, x = c.forward(None, data)
+    assert x == 3
+    s, y = c.inverse(s, x)
+    assert y == data
+
+def test_right()->None:
+    inc: Bimap[Any, int, int] = Bimap(
+        forward=lambda s, x: (s, x + 1),
+        inverse=lambda s, y: (s, y - 1),
+    )
+    inc2: Bimap[Any, int, int] = Bimap(
+        forward=lambda s, x: (s, x + 1),
+        inverse=lambda s, y: (s, y - 1),
+    )
+
+    data  = ThenResult(kind=ThenKind.RIGHT, left=1, right=2)
+    b = data.bimap(inc)
+    c = b >> inc2
+    s, x = c.forward(None, data)
+    assert x == 4
+    s, y = c.inverse(s, x)
+    assert y == data
+
+def test_nested()->None:
+    inc: Bimap[Any, int, int] = Bimap(
+        forward=lambda s, x: (s, x + 1),
+        inverse=lambda s, y: (s, y - 1),
+    )
+    inc2: Bimap[Any, Tuple[int, ...], Tuple[int, ...]] = Bimap(
+        forward=lambda s, x: (s, tuple(xx + 1 for xx in x)),
+        inverse=lambda s, y: (s, tuple(yy - 1 for yy in y)),
+    )
+
+    data  = ThenResult(kind=ThenKind.BOTH, left=ThenResult(kind=ThenKind.BOTH, left=0, right=1), right=ThenResult(kind=ThenKind.BOTH, left=2, right=3))
+    b = data.bimap(inc)
+    c = b >> inc2
+    s, x = c.forward(None, data)
+    assert x == (2,3,4,5)
+    s, y = c.inverse(s, x)
+    assert y == data
+
+

syncraft-0.1.19/README.md

@@ -1,21 +0,0 @@
-# Syncraft
-
-Syncraft is a parser/generator combinator library with full round-trip support:
-
-- Parse source code into AST or dataclasses
-- Generate source code from dataclasses
-- Bidirectional transformations via lenses
-- Convenience combinators: `all`, `first`, `last`, `named`
-- SQLite syntax support included
-
-## Installation
-
-```bash
-pip install syncraft
-```
-
-
-## TODO
-- [ ] Test Walker.get/set for bidirectional mapping between source code and data class
-- [ ] Annotate sqlite3 grammar with named nodes and data classes
-- [ ]