syncraft 0.1.18__py3-none-any.whl → 0.1.20__py3-none-any.whl

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/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/diagnostic.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 from rich import print
 from rich.table import Table as RichTable
 from typing import Tuple, Any, Set
-from syncraft.dsl import DSL
+from syncraft.syntax import Syntax
 from syncraft.algebra import  Left, Right, Error, Either, Algebra
 
 from syncraft.parser import ParserState, Token
@@ -44,7 +44,7 @@ def rich_debug(this: Algebra[Any, ParserState[Any]],
                 return prefix + value.sql()
             elif isinstance(value, Token):
                 return prefix + f"{value.token_type.name}({value.text})"
-            elif isinstance(value, (Error, ParserState, DSL)):
+            elif isinstance(value, (Error, ParserState, Syntax)):
                 return prefix + (value._string or 'N/A')
             else:
                 return prefix + str(value)

syncraft/generator.py

@@ -2,15 +2,17 @@ from __future__ import annotations
 
 from typing import (
     Any, TypeVar, Tuple, Optional,  Callable, Generic, Union, 
-    List
+    List, Generator as YieldGen
 )
 from functools import cached_property
 from dataclasses import dataclass, replace
 from syncraft.algebra import (
-    Algebra, ThenResult, Either, Left, Right, Error, Insptectable, 
-    OrResult, ManyResult
+    Algebra, ThenResult, Either, Left, Right, Error, 
+    OrResult, ManyResult, NamedResult
 )
+
 from syncraft.ast import TokenProtocol, ParseResult, AST, Token, TokenSpec
+from syncraft.syntax import Syntax
 from sqlglot import TokenType
 import re
 import rstr
@@ -29,7 +31,7 @@ GenResult = Union[
 ]
 
 @dataclass(frozen=True)
-class GenState(Generic[T], Insptectable):
+class GenState(Generic[T]):
     ast: Optional[AST[T]]
     seed: int
 
@@ -270,7 +272,8 @@ class Generator(Algebra[GenResult[T], GenState[T]]):
 
 
 
-def generate(gen: Algebra[Any, Any], data: Optional[AST[Any]] = None, seed: int = 0) -> AST[Any] | Any:
+def generate(syntax: Syntax[Any, Any], data: Optional[AST[Any]] = None, seed: int = 0) -> AST[Any] | Any:
+    gen = syntax(Generator)
     state = GenState.from_ast(data, seed)
     result = gen.run(state, use_cache=False)
     if isinstance(result, Right):
@@ -278,3 +281,28 @@ def generate(gen: Algebra[Any, Any], data: Optional[AST[Any]] = None, seed: int
     assert isinstance(result, Left), "Generator must return Either[Any, Tuple[Any, Any]]"
     return result.value
 
+
+def matches(syntax: Syntax[Any, Any], data: AST[Any])-> bool:
+    gen = syntax(Generator)
+    state = GenState.from_ast(data)
+    result = gen.run(state, use_cache=True)
+    return isinstance(result, Right)
+
+
+def search(syntax: Syntax[Any, Any], data: AST[Any]) -> YieldGen[AST[Any], None, None]:
+    if matches(syntax, data):
+        yield data
+    match data.focus:
+        case ThenResult(left = left, right=right):
+            yield from search(syntax, AST(left))
+            yield from search(syntax, AST(right))
+        case ManyResult(value = value):
+            for e in value:
+                yield from search(syntax, AST(e))
+        case NamedResult(value=value):
+            yield from search(syntax, AST(value))
+        case OrResult(value=value):
+            yield from search(syntax, AST(value))
+        case _:
+            pass
+    

syncraft/parser.py

@@ -6,12 +6,12 @@ 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
 from functools import reduce
-from syncraft.dsl import DSL
+from syncraft.syntax import Syntax
 
 from syncraft.ast import Token, TokenSpec, AST, T
 
@@ -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:
@@ -187,15 +180,16 @@ class Parser(Algebra[T, ParserState[T]]):
             return Right((tuple(tokens), tmp_state))
         return cls(until_run, name=cls.__name__ + '.until')
 
-def sqlglot(parser: DSL[Any, Any], 
-            dialect: str) -> DSL[List[exp.Expression], ParserState[Any]]:
+def sqlglot(parser: Syntax[Any, Any], 
+            dialect: str) -> Syntax[List[exp.Expression], ParserState[Any]]:
     gp = GlotParser(dialect=dialect)
     return parser.map(lambda tokens: [e for e in gp.parse(raw_tokens=tokens) if e is not None])
 
 
-def parse(parser: Algebra[Any, ParserState[Token]], 
+def parse(syntax: Syntax[Any, Any], 
           sql: str, 
           dialect: str) -> AST[Any] | Any:
+    parser = syntax(Parser)
     input: ParserState[Token] = token_state(sql, dialect=dialect)
     result = parser.run(input, True)
     if isinstance(result, Right):
@@ -212,34 +206,34 @@ def token(token_type: Optional[Enum] = None,
           text: Optional[str] = None, 
           case_sensitive: bool = False,
           regex: Optional[re.Pattern[str]] = None
-          ) -> DSL[Any, Any]:
+          ) -> Syntax[Any, Any]:
     token_type_txt = token_type.name if token_type is not None else None
     token_value_txt = text if text is not None else None
     msg = 'token(' + ','.join([x for x in [token_type_txt, token_value_txt, str(regex)] if x is not None]) + ')'
-    return DSL(
+    return Syntax(
         lambda cls: cls.factory('token', token_type=token_type, text=text, case_sensitive=case_sensitive, regex=regex)
         ).describe(name=msg, fixity='prefix') 
 
     
-def identifier(value: str | None = None) -> DSL[Any, Any]:
+def identifier(value: str | None = None) -> Syntax[Any, Any]:
     if value is None:
         return token(TokenType.IDENTIFIER)
     else:
         return token(TokenType.IDENTIFIER, text=value)
 
-def variable(value: str | None = None) -> DSL[Any, Any]:
+def variable(value: str | None = None) -> Syntax[Any, Any]:
     if value is None:
         return token(TokenType.VAR)
     else:
         return token(TokenType.VAR, text=value)
 
-def literal(lit: str) -> DSL[Any, Any]:
+def literal(lit: str) -> Syntax[Any, Any]:
     return token(token_type=None, text=lit, case_sensitive=True)
 
-def regex(regex: re.Pattern[str]) -> DSL[Any, Any]:
+def regex(regex: re.Pattern[str]) -> Syntax[Any, Any]:
     return token(token_type=None, regex=regex, case_sensitive=True)
 
-def lift(value: Any)-> DSL[Any, Any]:
+def lift(value: Any)-> Syntax[Any, Any]:
     if isinstance(value, str):
         return literal(value)
     elif isinstance(value, re.Pattern):
@@ -247,22 +241,22 @@ def lift(value: Any)-> DSL[Any, Any]:
     elif isinstance(value, Enum):
         return token(value)
     else:
-        return DSL(lambda cls: cls.success(value))
+        return Syntax(lambda cls: cls.success(value))
 
-def number() -> DSL[Any, Any]:
+def number() -> Syntax[Any, Any]:
     return token(TokenType.NUMBER)
 
 
-def string() -> DSL[Any, Any]:
+def string() -> Syntax[Any, Any]:
     return token(TokenType.STRING)
 
 
 
-def until(*open_close: Tuple[DSL[Tuple[T, ...] | T, ParserState[T]], DSL[Tuple[T, ...] | T, ParserState[T]]],
-          terminator: Optional[DSL[Tuple[T, ...] | T, ParserState[T]]] = None,
+def until(*open_close: Tuple[Syntax[Tuple[T, ...] | T, ParserState[T]], Syntax[Tuple[T, ...] | T, ParserState[T]]],
+          terminator: Optional[Syntax[Tuple[T, ...] | T, ParserState[T]]] = None,
           inclusive: bool = True, 
-          strict: bool = True) -> DSL[Any, Any]:
-    return DSL(
+          strict: bool = True) -> Syntax[Any, Any]:
+    return Syntax(
         lambda cls: cls.factory('until', 
                            *[(left.alg(cls), right.alg(cls)) for left, right in open_close], 
                            terminator=terminator.alg(cls) if terminator else None, 

syncraft/sqlite3.py

@@ -4,7 +4,7 @@ https://www.sqlite.org/syntaxdiagrams.html
 """
 from __future__ import annotations
 from typing import Any
-from syncraft.dsl import DSL, lazy, choice
+from syncraft.syntax import Syntax, lazy, choice
 import syncraft.parser as dsl
 from syncraft.diagnostic import rich_error, rich_debug, rich_parser
 from sqlglot import TokenType
@@ -607,16 +607,16 @@ update_stmt_limited = (
     )
 
 
-def table_or_subquery()->DSL[Any, Any]:
+def table_or_subquery()->Syntax[Any, Any]:
     t1 = ~schema_name >> table_as_alias >> ~((INDEXED >> BY >> index_name)|(NOT >> INDEXED))
     t2 = ~schema_name >> table_function_name >> expr.parens(COMMA, L_PAREN, R_PAREN) >> ~(~AS >> var)
     t3 = select_stmt.between(L_PAREN, R_PAREN) >> ~(~AS >> var)
     t4 = table_subquery.parens(COMMA, L_PAREN, R_PAREN)
     t5 = join_clause.between(L_PAREN, R_PAREN) 
-    return (t1 | t2 | t3 | t4 | t5).as_(DSL[Any, Any])
+    return (t1 | t2 | t3 | t4 | t5).as_(Syntax[Any, Any])
 
 
-def expression() -> DSL[Any, Any]:
+def expression() -> Syntax[Any, Any]:
     return choice(
         literal_value,
         bind_parameter,
@@ -639,9 +639,9 @@ def expression() -> DSL[Any, Any]:
         expr >> ~NOT >> IN >> ~schema_name >> (table_name | (function_name >> expr.parens(COMMA, L_PAREN, R_PAREN))),
         ~NOT >> ~EXISTS >> select_stmt.between(L_PAREN, R_PAREN),
         CASE >> ~expr >> (WHEN >> expr >> THEN >> expr).many() >> ~(ELSE >> expr) // END,
-    ).as_(DSL[Any, Any])
+    ).as_(Syntax[Any, Any])
 
-def select_statement() -> DSL[Any, Any]:
+def select_statement() -> Syntax[Any, Any]:
     select_clause = SELECT >> ~(DISTINCT | ALL) >> result_columns.sep_by(COMMA)
     from_clause = FROM >> (table_subquery.sep_by(COMMA) | join_clause)
     where_clause = WHERE >> expr
@@ -657,7 +657,7 @@ def select_statement() -> DSL[Any, Any]:
          >> select_core.sep_by(compound_operator)
          >> ~(ordering_clause >> ~limit_clause)
          >> ~SEMICOLON
-    ).as_(DSL[Any, Any])
+    ).as_(Syntax[Any, Any])
 
 column_constraint = ~(CONSTRAINT >> constraint_name) >> (
     (PRIMARY >> KEY >> ~(ASC | DESC) >> ~conflict_clause >> AUTO_INCREMENT)

syncraft/{dsl.py → 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,11 +67,11 @@ class Description(Insptectable):
 
 
 @dataclass(frozen=True)
-class DSL(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)
 
-    def algebra(self, name: str | MethodType | FunctionType, *args: Any, **kwargs: Any)-> DSL[A, S]:
+    def algebra(self, name: str | MethodType | FunctionType, *args: Any, **kwargs: Any)-> Syntax[A, S]:
         def algebra_run(cls: Type[Algebra[Any, S]]) -> Algebra[Any, S]:
             a = self.alg(cls)
             if isinstance(name, str):
@@ -115,33 +115,33 @@ class DSL(Generic[A, S], Insptectable):
                  newline: Optional[str] = None,
                  name: Optional[str] = None, 
                  fixity: Optional[Literal['infix', 'prefix', 'postfix']] = None, 
-                 parameter: Optional[List[DSL[Any, S]]] = None) -> DSL[A, S]:
+                 parameter: Optional[List[Syntax[Any, S]]] = None) -> Syntax[A, S]:
         return self.__class__(alg=self.alg,
                               meta=self.meta.update(name=name,
                                     newline=newline,
                                     fixity=fixity,
                                     parameter=parameter))
     
-    def newline(self, info: str='')-> DSL[A, S]:
+    def newline(self, info: str='')-> Syntax[A, S]:
         return self.describe(newline=info)
 
-    def terminal(self, name: str)->DSL[A, S]:
+    def terminal(self, name: str)->Syntax[A, S]:
         return self.describe(name=name, fixity='prefix', parameter=[])
 
 ######################################################## value transformation ########################################################
-    def map(self, f: Callable[[A], B]) -> DSL[B, S]:
+    def map(self, f: Callable[[A], B]) -> Syntax[B, S]:
         return self.__class__(lambda cls: self.alg(cls).map(f), meta = self.meta) # type: ignore
 
-    def map_error(self, f: Callable[[Optional[Any]], Any]) -> DSL[A, S]:
+    def map_error(self, f: Callable[[Optional[Any]], Any]) -> Syntax[A, S]:
         return self.__class__(lambda cls: self.alg(cls).map_error(f), meta=self.meta)
     
-    def map_state(self, f: Callable[[S], S]) -> DSL[A, S]:
+    def map_state(self, f: Callable[[S], S]) -> Syntax[A, S]:
         return self.__class__(lambda cls: self.alg(cls).map_state(f), meta=self.meta)
 
-    def flat_map(self, f: Callable[[A], Algebra[B, S]]) -> DSL[B, S]:
+    def flat_map(self, f: Callable[[A], Algebra[B, S]]) -> Syntax[B, S]:
         return self.__class__(lambda cls: self.alg(cls).flat_map(f)) # type: ignore
 
-    def many(self, *, at_least: int = 1, at_most: Optional[int] = None) -> DSL[ManyResult[A], S]:
+    def many(self, *, at_least: int = 1, at_most: Optional[int] = None) -> Syntax[ManyResult[A], S]:
         return self.__class__(lambda cls:self.alg(cls).many(at_least=at_least, at_most=at_most)).describe(name='*', # type: ignore
                                                  fixity='prefix', 
                                                  parameter=[self])  
@@ -150,83 +150,83 @@ class DSL(Generic[A, S], Insptectable):
 
 
 
-    def between(self, left: DSL[Any, S], right: DSL[Any, S]) -> DSL[ThenResult[None, ThenResult[A, None]], S]:
+    def between(self, left: Syntax[Any, S], right: Syntax[Any, S]) -> Syntax[ThenResult[None, ThenResult[A, None]], S]:
         return left >> self // right
 
-    def sep_by(self, sep: DSL[Any, S]) -> DSL[ThenResult[A, ManyResult[ThenResult[None, A]]], S]:
+    def sep_by(self, sep: Syntax[Any, S]) -> Syntax[ThenResult[A, ManyResult[ThenResult[None, A]]], S]:
         return (self + (sep >> self).many()).describe(
             name='sep_by',
             fixity='prefix',
             parameter=[self, sep]
         )
     
-    def parens(self, sep: DSL[Any, S], open: DSL[Any, S], close: DSL[Any, S]) -> DSL[Any, S]:
+    def parens(self, sep: Syntax[Any, S], open: Syntax[Any, S], close: Syntax[Any, S]) -> Syntax[Any, S]:
         return self.sep_by(sep=sep).between(left=open, right=close)
             
-    def optional(self, default: Optional[B] = None) -> DSL[Optional[A | B], S]:
+    def optional(self, default: Optional[B] = None) -> Syntax[Optional[A | B], S]:
         return (self | success(default)).describe(name='~', fixity='prefix', parameter=[self])
 
 
-    def cut(self) -> DSL[A, S]:
+    def cut(self) -> Syntax[A, S]:
         return self.__class__(lambda cls:self.alg(cls).cut())
 
 
 ####################################################### operator overloading #############################################
-    def __ge__(self, f: Callable[[A], Algebra[B, S]]) -> DSL[B, S]:
+    def __ge__(self, f: Callable[[A], Algebra[B, S]]) -> Syntax[B, S]:
         return self.flat_map(f).describe(name='>=', fixity='infix', parameter=[self])
 
 
-    def __gt__(self, other: Callable[[A], B])->DSL[B, S]:
+    def __gt__(self, other: Callable[[A], B])->Syntax[B, S]:
         return self.map(other)
 
 
-    def __floordiv__(self, other: DSL[B, S]) -> DSL[ThenResult[A, None], S]:
-        other = other if isinstance(other, DSL) else self.lift(other).as_(DSL[B, S])
+    def __floordiv__(self, other: Syntax[B, S]) -> Syntax[ThenResult[A, None], S]:
+        other = other if isinstance(other, Syntax) else self.lift(other).as_(Syntax[B, S])
         return self.__class__(
             lambda cls: self.alg(cls).then_left(other.alg(cls))   # type: ignore
-            ).describe(name=ThenKind.LEFT.value, fixity='infix', parameter=[self, other]).as_(DSL[ThenResult[A, None], S]) 
+            ).describe(name=ThenKind.LEFT.value, fixity='infix', parameter=[self, other]).as_(Syntax[ThenResult[A, None], S]) 
 
-    def __rfloordiv__(self, other: DSL[B, S]) -> DSL[ThenResult[B, None], S]:
-        other = other if isinstance(other, DSL) else self.lift(other).as_(DSL[B, S])
+    def __rfloordiv__(self, other: Syntax[B, S]) -> Syntax[ThenResult[B, None], S]:
+        other = other if isinstance(other, Syntax) else self.lift(other).as_(Syntax[B, S])
         return other.__floordiv__(self)
 
-    def __invert__(self) -> DSL[A | None, S]:
+    def __invert__(self) -> Syntax[A | None, S]:
         return self.optional()
 
-    def __radd__(self, other: DSL[B, S]) -> DSL[ThenResult[B, A], S]:
-        other = other if isinstance(other, DSL) else self.lift(other).as_(DSL[B, S])
+    def __radd__(self, other: Syntax[B, S]) -> Syntax[ThenResult[B, A], S]:
+        other = other if isinstance(other, Syntax) else self.lift(other).as_(Syntax[B, S])
         return other.__add__(self)
 
-    def __add__(self, other: DSL[B, S]) -> DSL[ThenResult[A, B], S]:
-        other = other if isinstance(other, DSL) else self.lift(other).as_(DSL[B, S])
+    def __add__(self, other: Syntax[B, S]) -> Syntax[ThenResult[A, B], S]:
+        other = other if isinstance(other, Syntax) else self.lift(other).as_(Syntax[B, S])
         return self.__class__( 
             lambda cls: self.alg(cls).then_both(other.alg(cls)) # type: ignore
             ).describe(name=ThenKind.BOTH.value, fixity='infix', parameter=[self, other])
 
-    def __rshift__(self, other: DSL[B, S]) -> DSL[ThenResult[None, B], S]:
-        other = other if isinstance(other, DSL) else self.lift(other).as_(DSL[B, S])
+    def __rshift__(self, other: Syntax[B, S]) -> Syntax[ThenResult[None, B], S]:
+        other = other if isinstance(other, Syntax) else self.lift(other).as_(Syntax[B, S])
         return self.__class__(
             lambda cls: self.alg(cls).then_right(other.alg(cls))   # type: ignore
-            ).describe(name=ThenKind.RIGHT.value, fixity='infix', parameter=[self, other]).as_(DSL[ThenResult[None, B], S])   
+            ).describe(name=ThenKind.RIGHT.value, fixity='infix', parameter=[self, other]).as_(Syntax[ThenResult[None, B], S])   
 
 
-    def __rrshift__(self, other: DSL[B, S]) -> DSL[ThenResult[None, A], S]:
-        other = other if isinstance(other, DSL) else self.lift(other).as_(DSL[B, S])
+    def __rrshift__(self, other: Syntax[B, S]) -> Syntax[ThenResult[None, A], S]:
+        other = other if isinstance(other, Syntax) else self.lift(other).as_(Syntax[B, S])
         return other.__rshift__(self)  
 
 
-    def __or__(self, other: DSL[B, S]) -> DSL[A | B, S]:
-        other = other if isinstance(other, DSL) else self.lift(other).as_(DSL[B, S])
+    def __or__(self, other: Syntax[B, S]) -> Syntax[A | B, S]:
+        other = other if isinstance(other, Syntax) else self.lift(other).as_(Syntax[B, S])
         return self.__class__(lambda cls: self.alg(cls).or_else(other.alg(cls))).describe(name='|', fixity='infix', parameter=[self, other]) # type: ignore
 
 
-    def __ror__(self, other: DSL[B, S]) -> DSL[A | B, S]:
-        other = other if isinstance(other, DSL) else self.lift(other).as_(DSL[B, S])
-        return other.__or__(self).as_(DSL[A | B, S]) 
+    def __ror__(self, other: Syntax[B, S]) -> Syntax[A | B, S]:
+        other = other if isinstance(other, Syntax) else self.lift(other).as_(Syntax[B, S])
+        return other.__or__(self).as_(Syntax[A | B, S]) 
 
 
 ######################################################################## data processing combinators #########################################################
-    def bind(self, name: str) -> DSL[NamedResult[A], S]:
+    def bind(self, name: str) -> Syntax[NamedResult[A], S]:
         def bind_f(value: A) -> NamedResult[A]:
             if isinstance(value, NamedResult):
                 return replace(value, name=name)    
@@ -235,7 +235,7 @@ class DSL(Generic[A, S], Insptectable):
         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(self, formatter: Optional[Callable[[Error], None]] = None) -> Syntax[A, S]:
         def dump_error_run(err: Any)->Any:
             if isinstance(err, Error) and formatter is not None:
                 formatter(err) 
@@ -245,21 +245,21 @@ class DSL(Generic[A, S], Insptectable):
 
     def debug(self, 
               label: str, 
-              formatter: Optional[Callable[[Algebra[Any, S], S, Either[Any, Tuple[Any, S]]], None]] = None) -> DSL[A, S]:
+              formatter: Optional[Callable[[Algebra[Any, S], S, Either[Any, Tuple[Any, S]]], None]] = None) -> Syntax[A, S]:
         return self.__class__(lambda cls:self.alg(cls).debug(label, formatter), meta=self.meta)
 
 
     
-def lazy(thunk: Callable[[], DSL[A, S]]) -> DSL[A, S]:
-    return DSL(lambda cls: cls.lazy(lambda: thunk()(cls))).describe(name='lazy(?)', fixity='postfix') 
+def lazy(thunk: Callable[[], Syntax[A, S]]) -> Syntax[A, S]:
+    return Syntax(lambda cls: cls.lazy(lambda: thunk()(cls))).describe(name='lazy(?)', fixity='postfix') 
 
-def fail(error: Any) -> DSL[Any, Any]:
-    return DSL(lambda alg: alg.fail(error)).describe(name=f'fail({error})', fixity='prefix')
+def fail(error: Any) -> Syntax[Any, Any]:
+    return Syntax(lambda alg: alg.fail(error)).describe(name=f'fail({error})', fixity='prefix')
 
-def success(value: Any) -> DSL[Any, Any]:
-    return DSL(lambda alg: alg.success(value)).describe(name=f'success({value})', fixity='prefix')
+def success(value: Any) -> Syntax[Any, Any]:
+    return Syntax(lambda alg: alg.success(value)).describe(name=f'success({value})', fixity='prefix')
 
-def choice(*parsers: DSL[Any, S]) -> DSL[Any, S]:
+def choice(*parsers: Syntax[Any, S]) -> Syntax[Any, S]:
     return reduce(lambda a, b: a | b, parsers) if len(parsers) > 0 else success(None)
 
 
@@ -269,27 +269,27 @@ def choice(*parsers: DSL[Any, S]) -> DSL[Any, S]:
 
 
 
-def all(*parsers: DSL[Any, S]) -> DSL[ThenResult[Any, Any], S]:
+def all(*parsers: Syntax[Any, S]) -> Syntax[ThenResult[Any, Any], S]:
     return reduce(lambda a, b: a + b, parsers) if len(parsers) > 0 else success(None)
 
-def first(*parsers: DSL[Any, S]) -> DSL[Any, S]:
+def first(*parsers: Syntax[Any, S]) -> Syntax[Any, S]:
     return reduce(lambda a, b: a // b, parsers) if len(parsers) > 0 else success(None)
 
-def last(*parsers: DSL[Any, S]) -> DSL[Any, S]:
+def last(*parsers: Syntax[Any, S]) -> Syntax[Any, S]:
     return reduce(lambda a, b: a >> b, parsers) if len(parsers) > 0 else success(None)
 
-def named(* parsers: DSL[Any, S] | Tuple[str, DSL[Any, S]]) -> DSL[Any, S]:
+def named(* parsers: Syntax[Any, S] | Tuple[str, Syntax[Any, S]]) -> Syntax[Any, S]:
     def is_named_parser(x: Any) -> bool:
-        return isinstance(x, tuple) and len(x) == 2 and isinstance(x[0], str) and isinstance(x[1], DSL)
+        return isinstance(x, tuple) and len(x) == 2 and isinstance(x[0], str) and isinstance(x[1], Syntax)
     
-    def to_parser(x: DSL[Any, S] | Tuple[str, DSL[Any, S]])->DSL[Any, S]:
-        if isinstance(x, tuple) and len(x) == 2 and isinstance(x[0], str) and isinstance(x[1], DSL):
+    def to_parser(x: Syntax[Any, S] | Tuple[str, Syntax[Any, S]])->Syntax[Any, S]:
+        if isinstance(x, tuple) and len(x) == 2 and isinstance(x[0], str) and isinstance(x[1], Syntax):
             return x[1].bind(x[0])
-        elif isinstance(x, DSL):
+        elif isinstance(x, Syntax):
             return x
         else:
             raise ValueError(f"Invalid parser or tuple: {x}", x)
-    ret: Optional[DSL[Any, S]] = None
+    ret: Optional[Syntax[Any, S]] = None
     has_data = False
     for p in parsers:
         just_parser = to_parser(p)

{syncraft-0.1.18.dist-info → syncraft-0.1.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncraft
-Version: 0.1.18
+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.dist-info/RECORD

@@ -0,0 +1,15 @@
+syncraft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syncraft/algebra.py,sha256=utnhCbrF5GFG6P2Oef_Ru6YVgVCgsGccMh6wx80ok5E,20519
+syncraft/ast.py,sha256=Hn88_xOqSzrHYtPjNFKREJuE6yISmNI-VVTcU6PJKI0,4737
+syncraft/cmd.py,sha256=DzXgU8QLVOg0YTFKpmOyzbf02LKPphQ4EeKSLzqpJ_s,2012
+syncraft/diagnostic.py,sha256=mnzzceE9HpN2jVa7ztecZCz3sbCD79JxgkdLhJRBsvY,2822
+syncraft/generator.py,sha256=ygt5HXfKG5z1LcTxhU8adqEePegqmokLjbP6pi34hGA,12355
+syncraft/parser.py,sha256=hk67kvOTBToOB2GhAh4weJQHR9xv73YPNQnqrW_qYv8,11295
+syncraft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syncraft/sqlite3.py,sha256=Pq09IHZOwuWg5W82l9D1flzd36QV0TOHQpTJ5U02V8g,34701
+syncraft/syntax.py,sha256=NtxkfPvSNsmpbRcESxEgRAW9d04ZHukWQoSJqIHsHNk,13842
+syncraft-0.1.20.dist-info/licenses/LICENSE,sha256=wHSV424U5csa3339dy1AZbsz2xsd0hrkMx2QK48CcUk,1062
+syncraft-0.1.20.dist-info/METADATA,sha256=j3Ylao4YeT_HxO4Gv95chaRvpoZLBallacoeoaoLQjk,1381
+syncraft-0.1.20.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+syncraft-0.1.20.dist-info/top_level.txt,sha256=Kq3t8ESXB2xW1Xt3uPmkENFc-c4f2pamNmaURBk7zc8,9
+syncraft-0.1.20.dist-info/RECORD,,

syncraft-0.1.18.dist-info/RECORD

@@ -1,15 +0,0 @@
-syncraft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-syncraft/algebra.py,sha256=l_ptzSkXbRGSLzu46GXixcNQPdXAi1s5R9nRDI86JkY,22785
-syncraft/ast.py,sha256=9CuHqXRiw_7UMDLd4x2def3kHgTVQ0hnPxyIbBlx1Zc,4640
-syncraft/cmd.py,sha256=DzXgU8QLVOg0YTFKpmOyzbf02LKPphQ4EeKSLzqpJ_s,2012
-syncraft/diagnostic.py,sha256=_kLbl1LlU4Y2PtsLLZFA_OLqeZqq1f2rjT_LRXLnDaI,2813
-syncraft/dsl.py,sha256=AxAZKu6MBfaG7Wzss3UISbQsrFaigc1L-hS3p_CAXWQ,13620
-syncraft/generator.py,sha256=FpKfRPYvA0Wu-eKy7GUj_Xahz3e58sD0fZ3bXoTVIzY,11432
-syncraft/parser.py,sha256=c1cCCW0RNw2y4XlNIUkrMf7q5lkm8wes4v5xbjLAUGg,11573
-syncraft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-syncraft/sqlite3.py,sha256=WR4wFf2CraRkb7C5rph3wsu6sGbG_7EjEZDUsPH8xqU,34677
-syncraft-0.1.18.dist-info/licenses/LICENSE,sha256=wHSV424U5csa3339dy1AZbsz2xsd0hrkMx2QK48CcUk,1062
-syncraft-0.1.18.dist-info/METADATA,sha256=Ga4qLGYK64owCQOyGXgQocU-e4FXtK2jNv5RQT3eDS0,946
-syncraft-0.1.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-syncraft-0.1.18.dist-info/top_level.txt,sha256=Kq3t8ESXB2xW1Xt3uPmkENFc-c4f2pamNmaURBk7zc8,9
-syncraft-0.1.18.dist-info/RECORD,,