syncraft 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

syncraft/algebra.py

@@ -28,7 +28,7 @@ from typing import (
 )
 
 import traceback
-from dataclasses import dataclass, fields, replace
+from dataclasses import dataclass, fields, replace, field
 from functools import cached_property
 from weakref import WeakKeyDictionary
 from abc import ABC, abstractmethod
@@ -54,15 +54,11 @@ class Insptectable(ABC):
 
 A = TypeVar('A')  # Result type
 B = TypeVar('B')  # Result type for mapping
-C = TypeVar('C')  # Result type for composing lenses
+
 S = TypeVar('S')  # State type for the Algebra
 
     
     
-
-class StructuralResult:
-    pass    
-
 class FrozenDict(Generic[A]):
     def __init__(self, items: Mapping[str, A]):
         for k, v in items.items():
@@ -119,63 +115,41 @@ class Lens(Generic[S, A]):
     
     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)
 
-@dataclass(eq=True, frozen=True)
-class NamedResult(Generic[A, B], StructuralResult):
-    value: A
+        
+@dataclass(frozen=True)
+class NamedResult(Generic[A], StructuralResult):
     name: str
-    forward_map: Callable[[A], B] | None = None
-    backward_map: Callable[[B], A] | None = None
-    aggregator: Callable[..., Any] | None = None
-
-    def __post_init__(self)->None:
-        if (self.forward_map or self.backward_map) and self.aggregator is not None:
-            raise ValueError("NamedResult can have either bimap or aggregator, never both.")
-
-    @staticmethod
-    def lens() -> Lens[NamedResult[A, B], A]:
-        def get(data: NamedResult[A, B]) -> A:
-            return data.value
-
-        def set(data: NamedResult[A, B], value: A) -> NamedResult[A, B]:
-            return replace(data, value = value)
-
-        return Lens(get=get, set=set)
-    
-
+    value: A
+    def bimap(self, ctx: Any)->Tuple[NamedResult[Any], Callable[[NamedResult[Any]], StructuralResult]]:
+        value, backward = self.value.bimap(ctx) if isinstance(self.value, StructuralResult) else (self.value, lambda x: x)
+        return NamedResult(self.name, value), lambda data: NamedResult(self.name, backward(data))
 
 @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)
 
-    @staticmethod
-    def lens(index: int) -> Lens[ManyResult[A], A]:
-        def get(data: ManyResult[A]) -> A:
-            return data.value[index]
-
-        def set(data: ManyResult[A], value: A) -> ManyResult[A]:
-            new_value = list(data.value)
-            new_value[index] = value
-            return ManyResult(value=tuple(new_value))
-
-        return Lens(get=get, set=set)
 
 
 @dataclass(eq=True, frozen=True)
 class OrResult(Generic[A], StructuralResult):
     value: A
-
-    @staticmethod
-    def lens() -> Lens[OrResult[A], A]:
-        def get(data: OrResult[A]) -> A:
-            return data.value
-
-        def set(data: OrResult[A], value: A) -> OrResult[A]:
-            return OrResult(value=value)
-
-        return Lens(get=get, set=set)
+    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))
 
 
 class ThenKind(Enum):
@@ -188,89 +162,54 @@ class ThenResult(Generic[A, B], StructuralResult):
     kind: ThenKind
     left: A
     right: B
-    @cached_property
-    def flatten(self)-> Tuple[Any, ...]:
-        def _flatten_side(side: Any)->Tuple[Any, ...]:
-            return side.flatten if isinstance(side, ThenResult) else (side,)
+    def bimap(self, ctx: Any) -> Tuple[Any, Callable[[Any], StructuralResult]]:
+        def branch(b: Any) -> Tuple[Any, Callable[[Any], StructuralResult]]:
+            if isinstance(b, ThenResult):
+               value, backward = b.bimap(ctx)
+               x, y = ThenResult.flat((value, backward))
+               return x, lambda data: ThenResult(self.kind, y(data), self.right)
+            elif isinstance(b, StructuralResult):
+                return b.bimap(ctx)
+            else:
+                return b, lambda x: x
         match self.kind:
             case ThenKind.BOTH:
-                return _flatten_side(self.left) + _flatten_side(self.right)
+                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:
-                return _flatten_side(self.left)
+                left_value, left_bmap = branch(self.left)
+                return left_value, lambda data: ThenResult(self.kind, left_bmap(data), self.right)
             case ThenKind.RIGHT:
-                return _flatten_side(self.right)
-            
+                right_value, right_bmap = branch(self.right)
+                return right_value, lambda data: ThenResult(self.kind, self.left, right_bmap(data))
     @staticmethod
-    def lens(kind: ThenKind) -> Lens[ThenResult[A, B], Tuple[A, B]] | Lens[ThenResult[A, B], A] | Lens[ThenResult[A, B], B]:
-        def both_lens() -> Lens[ThenResult[A, B], Tuple[A, B]]:
-            def get(data: ThenResult[A, B]) -> Tuple[A, B]:
-                match data:
-                    case ThenResult(left=left, right=right, kind=ThenKind.BOTH):
-                        return left, right
-                    case _:
-                        raise ValueError(f"Unexpected ThenResult type: {type(data)}")
-
-            def set(data: ThenResult[A, B], value: Tuple[A, B] | ThenResult[A, B]) -> ThenResult[A, B]:
-                match data:
-                    case ThenResult(left=_, right=_, kind=ThenKind.BOTH):
-                        if isinstance(value, tuple) and len(value) == 2:
-                            return ThenResult(left=value[0], right=value[1], kind=ThenKind.BOTH)
-                        elif isinstance(value, ThenResult):
-                            return ThenResult(left=value.left, right=value.right, kind=ThenKind.BOTH)
-                        else:
-                            raise ValueError(f"Expected a tuple or ThenResult, got: {type(value)}")
-                    case _:
-                        raise ValueError(f"Unexpected ThenResult type: {type(data)}")
-            return Lens(get=get, set=set)
-
-        def left_lens()-> Lens[ThenResult[A, B], A]:
-            def left_get(data: ThenResult[A, B]) -> A:
-                match data:
-                    case ThenResult(left=left, right=_, kind=ThenKind.LEFT):
-                        return left
-                    case _:
-                        raise ValueError(f"Unexpected ParseResult type: {type(data)}")
-
-            def left_set(data: ThenResult[A, B], v: A) -> ThenResult[A, B]:
-                match data:
-                    case ThenResult(kind=ThenKind.LEFT):
-                        return replace(data, left=v)
-                    case _:
-                        raise ValueError(f"Unexpected ParseResult type: {type(data)}")
-                return 
-            return Lens(
-                get=left_get, 
-                set=left_set
-            )
-    
-        def right_lens()-> Lens[ThenResult[A, B], B]:
-            def right_get(data: ThenResult[A, B]) -> B:
-                match data:
-                    case ThenResult(left=_, right=right, kind=ThenKind.RIGHT):
-                        return right
-                    case _:
-                        raise ValueError(f"Unexpected ParseResult type: {type(data)}")
-
-            def right_set(data: ThenResult[A, B], v: B) -> ThenResult[A, B]:
-                match data:
-                    case ThenResult(kind=ThenKind.RIGHT):
-                        return replace(data, right=v)
-                    case _:
-                        raise ValueError(f"Unexpected ParseResult type: {type(data)}")
-                return
-            return Lens(
-                get=right_get,
-                set=right_set
-            )
-        match kind:
-            case ThenKind.BOTH:
-                return both_lens()
-            case ThenKind.LEFT:
-                return left_lens()
-            case ThenKind.RIGHT:
-                return right_lens()
-            case _:
-                raise ValueError(f"Unknown ThenKind: {kind}")
+    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
 
 
 InProgress = object()  # Marker for in-progress state, used to prevent re-entrance in recursive calls

syncraft/ast.py

@@ -7,10 +7,10 @@ from typing import (
     Protocol, Generic, Callable, Union
 )
 from syncraft.algebra import (
-    NamedResult, OrResult,ThenResult, ManyResult, ThenKind,
+    OrResult,ThenResult, ManyResult, ThenKind,NamedResult, StructuralResult,
     Lens
 )
-from dataclasses import dataclass, field, replace, is_dataclass, asdict
+from dataclasses import dataclass, replace, is_dataclass, asdict
 from enum import Enum
 from functools import cached_property
 
@@ -54,116 +54,37 @@ T = TypeVar('T', bound=TokenProtocol)
 
 ParseResult = Union[
     ThenResult['ParseResult[T]', 'ParseResult[T]'], 
-    NamedResult['ParseResult[T]', Any], 
+    NamedResult['ParseResult[T]'],
     ManyResult['ParseResult[T]'],
     OrResult['ParseResult[T]'],
-    Tuple[T, ...],
     T,
-] 
-
-
-
-
-    
-
-
-@dataclass(frozen=True)
-class NamedRecord:
-    lens: Lens[Any, Any]
-    value: Any
-
-@dataclass(frozen=True)
-class Walker:
-    lens: Optional[Lens[Any, Any]] = None
-    def get(self, root: ParseResult[Any]) -> Dict[str, NamedRecord]:
-        match root:
-            case ManyResult(value=children):
-                new_named: Dict[str, NamedRecord] = {}
-                for i, child in enumerate(children):
-                    new_walker = replace(self, lens=(self.lens / ManyResult.lens(i)) if self.lens else ManyResult.lens(i))
-                    new_named |= new_walker.get(child)
-                return new_named
-            case OrResult(value=value):
-                new_walker = replace(self, lens=(self.lens / OrResult.lens()) if self.lens else OrResult.lens())
-                return new_walker.get(value)
-            case ThenResult(left=left, 
-                            right=right, 
-                            kind=kind):
-                new_walker = replace(self, lens=(self.lens / ThenResult.lens(kind)) if self.lens else ThenResult.lens(kind))
-                return new_walker.get(left) | new_walker.get(right)
-            case NamedResult(name=name, 
-                             value=value, 
-                             forward_map=forward_map,
-                             backward_map=backward_map,
-                             aggregator=aggregator):
-                this_lens = (self.lens / NamedResult.lens()) if self.lens else NamedResult.lens()
-                if callable(forward_map) and callable(backward_map):
-                    this_lens = this_lens.bimap(forward_map, backward_map) 
-                elif callable(forward_map):
-                    this_lens = this_lens.bimap(forward_map, lambda _: value)
-                elif callable(backward_map):
-                    raise ValueError("backward_map provided without forward_map")
-                new_walker = replace(self, lens=this_lens)
-                child_named = new_walker.get(value)
-                if aggregator is not None:
-                    return child_named | {name: NamedRecord(lens=this_lens, 
-                                                            value=aggregator(child_named))}
-                else:
-                    return child_named
-        return {}
-
-    def set(self, root: ParseResult[Any], updated_values: Dict[str, Any]) -> ParseResult[Any]:
-        named_records = self.get(root)
-        def apply_update(name: str, value: Any, root: ParseResult[Any]) -> ParseResult[Any]:
-            if name not in named_records:
-                # Skip unknown names safely
-                return root
-            record = named_records[name]
-            target_named: NamedResult[Any, Any] = record.lens.get(root)
-            assert isinstance(target_named, NamedResult)
-
-            if target_named.aggregator is not None:
-                # Break apart dataclass/dict into child fields
-                if isinstance(value, dict):
-                    child_updates = value
-                elif is_dataclass(value) and not isinstance(value, type):
-                    child_updates = asdict(value)
-                else:
-                    raise TypeError(f"Unsupported aggregator value for '{name}': {type(value)}")
-
-                # Recursively apply each child update
-                for child_name, child_value in child_updates.items():
-                    root = apply_update(child_name, child_value, root)
-                return root
-
-            else:
-                # Leaf: just replace the value
-                updated_named = replace(target_named, value=value)
-                return record.lens.set(root, updated_named)
-
-        for name, value in updated_values.items():
-            root = apply_update(name, value, root)
-
-        return root
-
+]
 @dataclass(frozen=True)
 class AST(Generic[T]):
     focus: ParseResult[T]
     pruned: bool = False
     parent: Optional[AST[T]] = None
 
+    def bimap(self, ctx: Any) -> Tuple[Any, Callable[[Any], AST[T]]]:
+        value, backward = self.focus.bimap(ctx) if isinstance(self.focus, StructuralResult) else (self.focus, lambda x: x)
+        def back2ast(data: Any) -> AST[T]:
+            return replace(self, focus=backward(data)) # type: ignore
+        return value, back2ast
+
     def up(self)->Optional[AST[T]]:
         return self.parent
 
     def left(self) -> Optional[AST[T]]:
-        match self.focus:
+        focus = self.focus.value if isinstance(self.focus, NamedResult) else self.focus
+        match focus:
             case ThenResult(left=left, kind=kind):
                 return replace(self, focus=left, parent=self, pruned = self.pruned or kind == ThenKind.RIGHT)
             case _:
                 raise TypeError(f"Invalid focus type({self.focus}) for left traversal")
 
     def right(self) -> Optional[AST[T]]:
-        match self.focus:
+        focus = self.focus.value if isinstance(self.focus, NamedResult) else self.focus
+        match focus:
             case ThenResult(right=right, kind=kind):
                 return replace(self, focus=right, parent=self, pruned = self.pruned or kind == ThenKind.LEFT)
             case _:
@@ -171,7 +92,8 @@ class AST(Generic[T]):
 
 
     def down(self, index: int) -> Optional[AST[T]]:
-        match self.focus:
+        focus = self.focus.value if isinstance(self.focus, NamedResult) else self.focus
+        match focus:
             case ManyResult(value=children):
                 if 0 <= index < len(children):
                     return replace(self, focus=children[index], parent=self, pruned=self.pruned)
@@ -186,7 +108,8 @@ class AST(Generic[T]):
                 raise TypeError(f"Invalid focus type({self.focus}) for down traversal")
 
     def how_many(self)->int:
-        match self.focus:
+        focus = self.focus.value if isinstance(self.focus, NamedResult) else self.focus
+        match focus:
             case ManyResult(value=children):
                 return len(children)
             case _:

syncraft/dsl.py

@@ -6,7 +6,7 @@ from typing import (
 )
 from dataclasses import dataclass, field
 from functools import reduce
-from syncraft.algebra import Algebra, Error, Either, Insptectable, NamedResult, ThenResult, ManyResult, ThenKind
+from syncraft.algebra import Algebra, Error, Either, Insptectable, ThenResult, ManyResult, ThenKind
 from types import MethodType, FunctionType
 
 

syncraft/generator.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 
 from typing import (
-    Any, TypeVar, Tuple, Optional,  Callable, Generic, Union, Iterable, Hashable, 
-    cast, List
+    Any, TypeVar, Tuple, Optional,  Callable, Generic, Union, Iterable, 
+    List
 )
 from functools import cached_property
 from dataclasses import dataclass, replace
 from syncraft.algebra import (
     Algebra, ThenResult, Either, Left, Right, Error, Insptectable, 
-    NamedResult, OrResult, ManyResult, ThenKind
+    OrResult, ManyResult
 )
 from syncraft.ast import TokenProtocol, ParseResult, AST, Token, TokenSpec
 from sqlglot import TokenType
@@ -142,7 +142,8 @@ class TokenGen(TokenSpec):
 class Generator(Algebra[GenResult[T], GenState[T]]):  
     def flat_map(self, f: Callable[[GenResult[T]], Algebra[B, GenState[T]]]) -> Algebra[B, GenState[T]]: 
         def flat_map_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[B, GenState[T]]]:
-            match self.run(input.left(), use_cache=use_cache):
+            lft = input.left()
+            match self.run(lft, use_cache=use_cache):
                 case Left(error):
                     return Left(error)
                 case Right((value, next_input)):
@@ -175,8 +176,20 @@ class Generator(Algebra[GenResult[T], GenState[T]]):
                     match self.run(input.down(index), use_cache):
                         case Right((value, next_input)):
                             ret.append(value)
+                            if at_most is not None and len(ret) > at_most:
+                                return Left(Error(
+                                        message=f"Expected at most {at_most} matches, got {len(ret)}",
+                                        this=self,
+                                        state=input.down(index)
+                                    ))                             
                         case Left(_):
                             pass
+                if len(ret) < at_least:
+                    return Left(Error(
+                        message=f"Expected at least {at_least} matches, got {len(ret)}",
+                        this=self,
+                        state=input.down(index)
+                    )) 
                 return Right((ManyResult(tuple(ret)), input))
         return self.__class__(many_run, name=f"many({self.name})")  # type: ignore
     
@@ -203,7 +216,7 @@ class Generator(Algebra[GenResult[T], GenState[T]]):
                             case Left(error):
                                 return Left(error)
             raise ValueError("or_else should always return a value or an error.")
-        return self.__class__(or_else_run, name=f"free_or({self.name} | {other.name})") # type: ignore
+        return self.__class__(or_else_run, name=f"or_else({self.name} | {other.name})") # type: ignore
 
     @classmethod
     def token(cls, 

syncraft/parser.py

@@ -111,52 +111,79 @@ class Parser(Algebra[Tuple[T,...] | T, ParserState[T]]):
               inclusive: bool = True, 
               strict: bool = True) -> Algebra[Any, ParserState[T]]:
         def until_run(state: ParserState[T], use_cache:bool) -> Either[Any, Tuple[Any, ParserState[T]]]:
-            counters = [0] * len(open_close)
+            # Use a stack to enforce proper nesting across multiple open/close pairs.
             tokens: List[Any] = []
             if not terminator and len(open_close) == 0:
-                return Left(Error(this=until_run, message="No terminator and no open/close parsers, nothing to parse", state=state))  
-            def run_oc(s: ParserState[T], 
-                       sign: int, 
-                       *oc: Algebra[Any, ParserState[T]])->Tuple[bool, ParserState[T]]:
-                matched = False
-                for i, p in enumerate(oc):
-                    new = p.run(s, use_cache)
-                    if isinstance(new, Right):
-                        matched = True
-                        counters[i] += sign
-                        if inclusive:
-                            tokens.append(new.value[0])
-                        s = new.value[1]
-                return matched, s
+                return Left(Error(this=until_run, message="No terminator and no open/close parsers, nothing to parse", state=state))
+
+            # Helper to try matching any of the parsers once, returning early on first match
+            def try_match(s: ParserState[T], *parsers: Algebra[Any, ParserState[T]]) -> Tuple[bool, Optional[int], Optional[Any], ParserState[T]]:
+                for i, p in enumerate(parsers):
+                    res = p.run(s, use_cache)
+                    if isinstance(res, Right):
+                        val, ns = res.value
+                        return True, i, val, ns
+                return False, None, None, s
+
             opens, closes = zip(*open_close) if len(open_close) > 0 else ((), ())
             tmp_state: ParserState[T] = state.copy()
-            if strict:
-                c = reduce(lambda a, b: a.or_else(b), opens).run(tmp_state)
+            stack: List[int] = []  # indices into open_close indicating expected closer
+
+            # If strict, require the very next token to be an opener of any kind
+            if strict and len(opens) > 0:
+                c = reduce(lambda a, b: a.or_else(b), opens).run(tmp_state, use_cache)
                 if c.is_left():
-                    return Left(Error(
-                        this=until_run,
-                        message="No opening parser matched",
-                        state=tmp_state
-                    ))
+                    return Left(Error(this=until_run, message="No opening parser matched", state=tmp_state))
+
             while not tmp_state.ended():
-                mopen, tmp_state = run_oc(tmp_state, 1, *opens)
-                mclose, tmp_state = run_oc(tmp_state, -1, *closes)
-                matched = mopen or mclose
-                if all(c == 0 for c in counters):
-                    if terminator :
-                        new = terminator.run(tmp_state, use_cache)
-                        if isinstance(new, Right):
-                            matched = True
+                # Try to open
+                o_matched, o_idx, o_tok, o_state = try_match(tmp_state, *opens)
+                if o_matched and o_idx is not None:
+                    stack.append(o_idx)
+                    if inclusive:
+                        tokens.append(o_tok)
+                    tmp_state = o_state
+                    continue
+
+                # Try to close
+                c_matched, c_idx, c_tok, c_state = try_match(tmp_state, *closes)
+                if c_matched and c_idx is not None:
+                    if not stack or stack[-1] != c_idx:
+                        return Left(Error(this=until_run, message="Mismatched closing parser", state=tmp_state))
+                    stack.pop()
+                    if inclusive:
+                        tokens.append(c_tok)
+                    tmp_state = c_state
+                    # After closing, if stack empty, we may terminate on a terminator
+                    if len(stack) == 0:
+                        if terminator:
+                            term = terminator.run(tmp_state, use_cache)
+                            if isinstance(term, Right):
+                                if inclusive:
+                                    tokens.append(term.value[0])
+                                return Right((tuple(tokens), term.value[1]))
+                        else:
+                            return Right((tuple(tokens), tmp_state))
+                    continue
+
+                # If nothing structural matched, check termination when not nested
+                if len(stack) == 0:
+                    if terminator:
+                        term2 = terminator.run(tmp_state, use_cache)
+                        if isinstance(term2, Right):
                             if inclusive:
-                                tokens.append(new.value[0])
-                            return Right((tuple(tokens), new.value[1]))
+                                tokens.append(term2.value[0])
+                            return Right((tuple(tokens), term2.value[1]))
                     else:
                         return Right((tuple(tokens), tmp_state))
-                elif any(c < 0 for c in counters):
-                    return Left(Error(this=until_run, message="Unmatched closing parser", state=tmp_state))
-                if not matched:
-                    tokens.append(tmp_state.current())
-                    tmp_state = tmp_state.advance()
+
+                # Otherwise, consume one token as payload and continue
+                tokens.append(tmp_state.current())
+                tmp_state = tmp_state.advance()
+
+            # Reached end of input
+            if len(stack) != 0:
+                return Left(Error(this=until_run, message="Unterminated group", state=tmp_state))
             return Right((tuple(tokens), tmp_state))
         return cls(until_run, name=cls.__name__ + '.until')
 

{syncraft-0.1.11.dist-info → syncraft-0.1.13.dist-info}/METADATA

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

syncraft-0.1.13.dist-info/RECORD

@@ -0,0 +1,15 @@
+syncraft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syncraft/algebra.py,sha256=mXKqPsjBJFD05oq_qT33qgxUhid63PXkcRNAVwOjwA4,22850
+syncraft/ast.py,sha256=dnTvFRBoMqzfjf1gpNoez_OIjVRIl_V2UB1agXV87XQ,4455
+syncraft/cmd.py,sha256=DzXgU8QLVOg0YTFKpmOyzbf02LKPphQ4EeKSLzqpJ_s,2012
+syncraft/diagnostic.py,sha256=_kLbl1LlU4Y2PtsLLZFA_OLqeZqq1f2rjT_LRXLnDaI,2813
+syncraft/dsl.py,sha256=eakeYo4noqUV9wGUj929uOpaKqfrQjh6P4UCDB4pIGc,16491
+syncraft/generator.py,sha256=hRiYinoeFc2Um59CP3qijSY9ls0wBqqZc16MyrwDUlE,9931
+syncraft/parser.py,sha256=Gx1zSF1Ob5lLAlgfkzx72pz9Dqhh4MO0tG0xaYO0aGQ,11633
+syncraft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syncraft/sqlite3.py,sha256=2JNGDymSJti3mdc7hdeXIF78S6SsSLpKJwe6AzivskQ,34757
+syncraft-0.1.13.dist-info/licenses/LICENSE,sha256=wHSV424U5csa3339dy1AZbsz2xsd0hrkMx2QK48CcUk,1062
+syncraft-0.1.13.dist-info/METADATA,sha256=das9gn34gO4cGtC4ln3hlcCBBfvu8lPy-3CBwnEanYs,946
+syncraft-0.1.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+syncraft-0.1.13.dist-info/top_level.txt,sha256=Kq3t8ESXB2xW1Xt3uPmkENFc-c4f2pamNmaURBk7zc8,9
+syncraft-0.1.13.dist-info/RECORD,,

syncraft-0.1.11.dist-info/RECORD

@@ -1,15 +0,0 @@
-syncraft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-syncraft/algebra.py,sha256=jiqdo1GbXVwi_7Uoh1zBLe-TparNaHp8jW2IFt8PzBc,24494
-syncraft/ast.py,sha256=y48DKYO-rSzmrObxsLXq2k_DfAplMnXjJBURY4Gv30U,7582
-syncraft/cmd.py,sha256=DzXgU8QLVOg0YTFKpmOyzbf02LKPphQ4EeKSLzqpJ_s,2012
-syncraft/diagnostic.py,sha256=_kLbl1LlU4Y2PtsLLZFA_OLqeZqq1f2rjT_LRXLnDaI,2813
-syncraft/dsl.py,sha256=T89zkcE6xKvQSP4PJDHaWp9TsygXCTAzgx6r91KysFc,16504
-syncraft/generator.py,sha256=56LbqoasPk7zFlGqYAKaXkZND0MfA-8V-F0xTrWKaUA,9261
-syncraft/parser.py,sha256=rk3YF8B0G8PG3JKYpeMQsYmHC5JxqrkCMXZAPfaqgME,10210
-syncraft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-syncraft/sqlite3.py,sha256=2JNGDymSJti3mdc7hdeXIF78S6SsSLpKJwe6AzivskQ,34757
-syncraft-0.1.11.dist-info/licenses/LICENSE,sha256=wHSV424U5csa3339dy1AZbsz2xsd0hrkMx2QK48CcUk,1062
-syncraft-0.1.11.dist-info/METADATA,sha256=AII8S8yjjEW45-3YeCsK9bhWH1EJSJKqe5byW3AkHNM,946
-syncraft-0.1.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-syncraft-0.1.11.dist-info/top_level.txt,sha256=Kq3t8ESXB2xW1Xt3uPmkENFc-c4f2pamNmaURBk7zc8,9
-syncraft-0.1.11.dist-info/RECORD,,