syncraft 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

syncraft/ast.py

@@ -0,0 +1,202 @@
+
+
+from __future__ import annotations
+import re
+from typing import (
+    Optional, Any, TypeVar, Tuple, runtime_checkable, Dict,
+    Protocol, Generic, Callable, Union
+)
+from syncraft.algebra import (
+    NamedResult, OrResult,ThenResult, ManyResult, ThenKind,
+    Lens
+)
+from dataclasses import dataclass, field, replace, is_dataclass, asdict
+from enum import Enum
+from functools import cached_property
+
+@runtime_checkable
+class TokenProtocol(Protocol):
+    @property
+    def token_type(self) -> Enum: ...
+    @property
+    def text(self) -> str: ...
+    
+
+@dataclass(frozen=True)
+class Token:
+    token_type: Enum
+    text: str
+    def __str__(self) -> str:
+        return f"{self.token_type.name}({self.text})"
+    
+    def __repr__(self) -> str:
+        return self.__str__()
+
+@dataclass(frozen=True)
+class TokenSpec:
+    token_type: Optional[Enum] = None
+    text: Optional[str] = None
+    case_sensitive: bool = False
+    regex: Optional[re.Pattern[str]] = None
+        
+    def is_valid(self, token: TokenProtocol) -> bool:
+        type_match = self.token_type is None or token.token_type == self.token_type
+        value_match = self.text is None or (token.text.strip() == self.text.strip() if self.case_sensitive else 
+                                                    token.text.strip().upper() == self.text.strip().upper())
+        value_match = value_match or (self.regex is not None and self.regex.fullmatch(token.text) is not None)
+        return type_match and value_match
+
+
+
+
+T = TypeVar('T', bound=TokenProtocol)  
+
+
+ParseResult = Union[
+    ThenResult['ParseResult[T]', 'ParseResult[T]'], 
+    NamedResult['ParseResult[T]', Any], 
+    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 up(self)->Optional[AST[T]]:
+        return self.parent
+
+    def left(self) -> Optional[AST[T]]:
+        match self.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:
+            case ThenResult(right=right, kind=kind):
+                return replace(self, focus=right, parent=self, pruned = self.pruned or kind == ThenKind.LEFT)
+            case _:
+                raise TypeError(f"Invalid focus type({self.focus}) for right traversal")
+
+
+    def down(self, index: int) -> Optional[AST[T]]:
+        match self.focus:
+            case ManyResult(value=children):
+                if 0 <= index < len(children):
+                    return replace(self, focus=children[index], parent=self, pruned=self.pruned)
+                else:
+                    raise IndexError(f"Index {index} out of bounds for ManyResult with {len(children)} children")
+            case OrResult(value=value):
+                if index == 0:
+                    return replace(self, focus=value, parent=self, pruned=self.pruned)
+                else:
+                    raise IndexError(f"Index {index} out of bounds for OrResult")
+            case _:
+                raise TypeError(f"Invalid focus type({self.focus}) for down traversal")
+
+    def how_many(self)->int:
+        match self.focus:
+            case ManyResult(value=children):
+                return len(children)
+            case _:
+                raise TypeError(f"Invalid focus type({self.focus}) for how_many")
+            
+    
+
+    @cached_property
+    def root(self) -> AST[T]:
+        while self.parent is not None:
+            self = self.parent  
+        return self
+    

syncraft/dsl.py

@@ -156,7 +156,7 @@ class DSL(Generic[A, S], Insptectable):
     def sep_by(self, sep: DSL[Any, S]) -> DSL[ThenResult[A, ManyResult[ThenResult[None, A]]], S]:
         return (self + (sep >> self).many()).describe(
             name='sep_by',
-            fixity='infix',
+            fixity='prefix',
             parameter=[self, sep]
         )
     

syncraft/generator.py

@@ -4,22 +4,19 @@ from typing import (
     Any, TypeVar, Tuple, Optional,  Callable, Generic, Union, Iterable, Hashable, 
     cast, 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
+    NamedResult, OrResult, ManyResult, ThenKind
 )
-from syncraft.parser import TokenProtocol, ParseResult, AST, Token, TokenSpec, Crumb
+from syncraft.ast import TokenProtocol, ParseResult, AST, Token, TokenSpec
 from sqlglot import TokenType
 import re
-from rich import print
 import rstr
 from functools import lru_cache
 import random
 
-
-A = TypeVar('A')
 B = TypeVar('B')
 T = TypeVar('T', bound=TokenProtocol)  
 
@@ -31,12 +28,6 @@ GenResult = Union[
     T
 ]
 
-
-
-
-E = TypeVar('E', bound=Hashable)
-F = TypeVar('F', bound=Hashable)
-
 @dataclass(frozen=True)
 class GenState(Generic[T], Insptectable):
     ast: Optional[AST[T]]
@@ -51,15 +42,9 @@ class GenState(Generic[T], Insptectable):
     def to_string(self, interested: Callable[[Any], bool]) -> str | None:
         return f"GenState(current={self.focus})"
 
-    @property
-    def is_freeform(self) -> bool:
-        if self.ast is None:
-            return True
-        return self.ast.is_pruned
-    
-    @property
-    def ended(self) -> bool:
-        return self.ast is None
+    @cached_property
+    def pruned(self)->bool:
+        return self.ast is None or self.ast.pruned
     
 
     @property
@@ -69,65 +54,35 @@ class GenState(Generic[T], Insptectable):
         return self.ast.focus
     
 
-    def leftmost(self)-> GenState[T]:
+    def left(self)-> GenState[T]:
         if self.ast is None:
             return self
-        return replace(self, ast=self.ast.leftmost)
+        return replace(self, ast=self.ast.left())
 
-    def down_left(self) -> GenState[T]:
-        if self.ast is None:
-            return self
-        return replace(self, ast=self.ast.down_left())
-        
     def right(self) -> GenState[T]:
         if self.ast is None:
-            return self    
+            return self
         return replace(self, ast=self.ast.right())
-
-    def advance(self, filter: Callable[[Any], bool]) -> GenState[T]:
-        if self.ast is None:
-            return self        
-        def filtered(z: GenState[T]) -> GenState[T]:
-            return z if z.ast is None or filter(z.ast.focus) else z.advance(filter=filter)
-        z = self.down_left()
-        if z.ast is not None:
-            return filtered(z)
-        z = self.right()
-        if z.ast is not None:
-            return filtered(z)
-        
-        zs = self.ast
-        while tmp_z := zs.up():
-            if next_z := tmp_z.right():
-                return filtered(replace(self, ast=next_z))
-            zs = tmp_z
-        return filtered(replace(self, ast=None))
-
-        
-        
-    @staticmethod
-    def only_terminal(node: Any) -> bool:
-        return not isinstance(node, (ManyResult, ThenResult, NamedResult, OrResult))
     
-    def copy(self) -> GenState[T]:
-        return self.__class__(ast=self.ast, seed=self.seed)
-
-    def delta(self, new_state: GenState[T]) -> Tuple[T, ...]:
-        return tuple()
-
-    def scoped(self) -> GenState[T]:
-        return ScopedState(ast=self.ast, 
-                           seed=self.seed,
-                           scope=self.ast.breadcrumbs[-1] if self.ast and self.ast.breadcrumbs else None)
-
-    def freeform(self) -> GenState[T]:
-        return FreeformState(ast=None, seed=self.seed)
+    def up(self)->GenState[T]:
+        if self.ast is None:
+            return self
+        return replace(self, ast=self.ast.up())
     
+    def down(self, index: int) -> GenState[T]:
+        if self.ast is None:
+            return self
+        return replace(self, ast=self.ast.down(index))
     
+    @cached_property
+    def how_many(self) -> int:
+        if self.ast is None:
+            return 0
+        return self.ast.how_many()
+
     @classmethod
     def from_ast(cls, ast: Optional[AST[T]], seed: int = 0) -> GenState[T]:
-        ret = cls(ast=ast, seed=seed)
-        return ret if ast is not None else ret.freeform()
+        return cls(ast=ast, seed=seed)
 
 
     @classmethod
@@ -135,32 +90,7 @@ class GenState(Generic[T], Insptectable):
         return cls.from_ast(AST(parse_result) if parse_result else None, seed)
 
 
-@dataclass(frozen=True)
-class ScopedState(GenState[T]):
-    scope: None | Crumb[T]
-    @property
-    def ended(self) -> bool:
-        return self.ast is None or self.scope in self.ast.closed
-    
-    def right(self)-> GenState[T]:
-        ret: ScopedState[T] = cast(ScopedState[T], super().right())
-        if ret.ast is not None and self.scope is not None:
-            if self.scope not in ret.ast.closed and self.scope not in ret.ast.breadcrumbs:
-                return replace(ret, scope=ret.ast.breadcrumbs[-1] if ret.ast.breadcrumbs else None)
-        return ret
-            
-
-@dataclass(frozen=True)
-class FreeformState(GenState[T]):
-    @property
-    def ended(self) -> bool:
-        return False
-
-    def scoped(self) -> GenState[T]:
-        return self
 
-    def advance(self, filter: Callable[[Any], bool]) -> GenState[T]:
-        return self
 
 
 @lru_cache(maxsize=None)
@@ -212,81 +142,81 @@ 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]]]:
-            left = input.down_left()
-            s = left.scoped()
-            match self.run(s, 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)):
-                    return f(value).run(left.right(), use_cache)
+                    r = input.right()
+                    return f(value).run(r, use_cache)
             raise ValueError("flat_map should always return a value or an error.")
         return Generator(run_f = flat_map_run, name=self.name) # type: ignore  
-
-    def gen(self, 
-            freeform: Algebra[Any, GenState[T]], 
-            default: Algebra[Any, GenState[T]]
-            ) -> Algebra[Any, GenState[T]]:
-        def gen_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[Any, GenState[T]]]:
-            if input.ended:
-                return Left(Error(this=self, 
-                                  message=f"{input.__class__.__name__} has ended, cannot run many.",
-                                  state=input))
-            elif input.is_freeform:            
-                return freeform.run(input, use_cache)
-            else:
-                return default.run(input, use_cache)
-        return self.__class__(gen_run, name=default.name) 
-
-    def gen_many(self, 
-                 at_least: int, 
-                 at_most: Optional[int] = None
-                 ) -> Algebra[ManyResult[GenResult[T]], GenState[T]]: 
-        def gen_many_run(input: GenState[T], 
-                         use_cache:bool
-                         ) -> Either[Any, Tuple[ManyResult[GenResult[T]], GenState[T]]]:
-            upper = at_most if at_most is not None else at_least + 2
-            count = input.rng("many").randint(at_least, upper)
-            ret: List[Any] = []
-            current_input: GenState[T] = input.freeform()
-            for _ in range(count):
-                forked_input = current_input.fork(tag=len(ret))
-                match self.run(forked_input, use_cache):
-                    case Right((value, next_input)):
-                        current_input = next_input
-                        ret.append(value)
-                    case Left(_):
-                        break
-            return Right((ManyResult(tuple(ret)), input))
-        return self.__class__(run_f=gen_many_run, name=f"free_many({self.name})")  # type: ignore
+    
         
 
     def many(self, *, at_least: int, at_most: Optional[int]) -> Algebra[ManyResult[GenResult[T]], GenState[T]]:
         assert at_least > 0, "at_least must be greater than 0"
         assert at_most is None or at_least <= at_most, "at_least must be less than or equal to at_most"
-        return self.gen(freeform=self.gen_many(at_least, at_most), 
-                        default=super().many(at_least=at_least, at_most=at_most)) 
+        def many_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[ManyResult[GenResult[T]], GenState[T]]]:
+            if input.pruned:
+                upper = at_most if at_most is not None else at_least + 2
+                count = input.rng("many").randint(at_least, upper)
+                ret: List[Any] = []
+                for i in range(count):
+                    forked_input = input.down(0).fork(tag=len(ret))
+                    match self.run(forked_input, use_cache):
+                        case Right((value, next_input)):
+                            ret.append(value)
+                        case Left(_):
+                            pass
+                return Right((ManyResult(tuple(ret)), input))
+            else:
+                ret = []
+                for index in range(input.how_many): 
+                    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
     
-    def gen_or_else(self, 
-                 other: Algebra[GenResult[T], GenState[T]]) -> Algebra[OrResult[GenResult[T]], GenState[T]]:
-        def gen_or_else_run(input: GenState[T], 
-                            use_cache:bool
-                            )->Either[Any, Tuple[OrResult[GenResult[T]], GenState[T]]]:
-            forked_input = input.fork(tag="or_else")
-            match forked_input.rng("or_else").choice((self, other)).run(forked_input.freeform(), use_cache):
-                case Right((value, next_input)):
-                    return Right((OrResult(value), next_input))
-                case Left(error):
-                    return Left(error)
-            raise TypeError(f"Unexpected result type from {self}")
-        return self.__class__(gen_or_else_run, name=f"free_or({self.name} | {other.name})") # type: ignore
  
-
     def or_else(self, # type: ignore
                 other: Algebra[GenResult[T], GenState[T]]
                 ) -> Algebra[OrResult[GenResult[T]], GenState[T]]: 
-        return self.gen(freeform=self.gen_or_else(other), 
-                        default=super().or_else(other))  
-
+        def or_else_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[OrResult[GenResult[T]], GenState[T]]]:
+            if input.pruned:
+                forked_input = input.fork(tag="or_else")
+                match forked_input.rng("or_else").choice((self, other)).run(forked_input, use_cache):
+                    case Right((value, next_input)):
+                        return Right((OrResult(value), next_input))
+                    case Left(error):
+                        return Left(error)
+            else:
+                match self.run(input.down(0), use_cache):
+                    case Right((value, next_input)):
+                        return Right((OrResult(value), next_input))
+                    case Left(error):
+                        match other.run(input.down(0), use_cache):
+                            case Right((value, next_input)):
+                                return Right((OrResult(value), next_input))
+                            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"or_else({self.name} | {other.name})") # type: ignore
 
     @classmethod
     def token(cls, 
@@ -298,20 +228,15 @@ class Generator(Algebra[GenResult[T], GenState[T]]):
         gen = TokenGen(token_type=token_type, text=text, case_sensitive=case_sensitive, regex=regex)  
         lazy_self: Algebra[GenResult[T], GenState[T]]
         def token_run(input: GenState[T], use_cache:bool) -> Either[Any, Tuple[GenResult[Token], GenState[T]]]:
-            if input.ended:
-                return Left(Error(None,
-                                  message=f"{input.__class__.__name__} has ended, cannot run token.", 
-                                  state=input))
-            elif input.is_freeform:
-                return Right((gen.gen(), input.advance(GenState.only_terminal)))  
+            if input.pruned:
+                return Right((gen.gen(), input))
             else:
-                input = input.leftmost()
                 current = input.focus
                 if not isinstance(current, Token) or not gen.is_valid(current):
                     return Left(Error(None, 
                                       message=f"Expected a Token, but got {type(current)}.", 
                                       state=input))
-                return Right((current, input.advance(GenState.only_terminal)))
+                return Right((current, input))
         lazy_self = cls(token_run, name=cls.__name__ + f'.token({token_type or text or regex})')  # type: ignore
         return lazy_self
 
@@ -322,6 +247,6 @@ def generate(gen: Algebra[Any, Any], data: Optional[AST[Any]] = None, seed: int
     result = gen.run(state, use_cache=False)
     if isinstance(result, Right):
         return AST(result.value[0])
-    assert isinstance(result, Left), "Parser must return Either[E, Tuple[A, S]]"
+    assert isinstance(result, Left), "Generator must return Either[Any, Tuple[Any, Any]]"
     return result.value
 

syncraft/parser.py

@@ -2,329 +2,23 @@ from __future__ import annotations
 import re
 from sqlglot import tokenize, TokenType, Parser as GlotParser, exp
 from typing import (
-    Optional, List, Any, TypeVar, Tuple, runtime_checkable, Dict,
-    Protocol, Generic, Callable, Union
+    Optional, List, Any, Tuple,
+    Generic, Callable
 )
 from syncraft.algebra import (
-    Either, Left, Right, Error, Insptectable, Algebra, NamedResult, OrResult,ThenResult, ManyResult, ThenKind,
-    Lens
+    Either, Left, Right, Error, Insptectable, Algebra
 )
-from dataclasses import dataclass, field, replace, is_dataclass, asdict
+from dataclasses import dataclass, field, replace
 from enum import Enum
-from functools import reduce, cached_property
+from functools import reduce
 from syncraft.dsl import DSL
 
+from syncraft.ast import Token, TokenSpec, AST, T
 
 
 
 
 
-@runtime_checkable
-class TokenProtocol(Protocol):
-    @property
-    def token_type(self) -> TokenType: ...
-    @property
-    def text(self) -> str: ...
-    
-
-@dataclass(frozen=True)
-class Token:
-    token_type: TokenType
-    text: str
-    def __str__(self) -> str:
-        return f"{self.token_type.name}({self.text})"
-    
-    def __repr__(self) -> str:
-        return self.__str__()
-
-@dataclass(frozen=True)
-class TokenSpec:
-    token_type: Optional[TokenType] = None
-    text: Optional[str] = None
-    case_sensitive: bool = False
-    regex: Optional[re.Pattern[str]] = None
-        
-    def is_valid(self, token: TokenProtocol) -> bool:
-        type_match = self.token_type is None or token.token_type == self.token_type
-        value_match = self.text is None or (token.text.strip() == self.text.strip() if self.case_sensitive else 
-                                                    token.text.strip().upper() == self.text.strip().upper())
-        value_match = value_match or (self.regex is not None and self.regex.fullmatch(token.text) is not None)
-        return type_match and value_match
-
-
-
-
-T = TypeVar('T', bound=TokenProtocol)  
-
-
-ParseResult = Union[
-    ThenResult['ParseResult[T]', 'ParseResult[T]'], 
-    NamedResult['ParseResult[T]', Any], 
-    ManyResult['ParseResult[T]'],
-    OrResult['ParseResult[T]'],
-    Tuple[T, ...],
-    T,
-] 
-
-
-
-@dataclass(frozen=True)
-class Crumb(Generic[T]):
-    entrance: str
-    id: int = field(init=False)
-    def __post_init__(self)-> None:
-        object.__setattr__(self, 'id', id(self))
-
-    
-
-@dataclass(frozen=True)
-class LeftCrumb(Crumb[T]):
-    right: ParseResult[T]
-    kind: ThenKind
-    
-
-@dataclass(frozen=True)
-class OrCrumb(Crumb[T]):
-    pass
-@dataclass(frozen=True)
-class RightCrumb(Crumb[T]):
-    left: ParseResult[T]
-    kind: ThenKind
-    
-    
-@dataclass(frozen=True)
-class NamedCrumb(Crumb[T]):
-    name: str
-    forward_map: Callable[[Any], Any] | None
-    backward_map: Callable[[Any], Any] | None
-    aggregator: Callable[..., Any] | None
-
-    
-@dataclass(frozen=True)
-class ManyCrumb(Crumb[T]):
-    before: Tuple[ParseResult[T], ...]
-    after: Tuple[ParseResult[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]
-    breadcrumbs: Tuple[Crumb[T], ...] = field(default_factory=tuple)
-    closed: frozenset[Crumb[T]] = field(default_factory=frozenset)
-
-    @cached_property
-    def is_pruned(self) -> bool:
-        for crumb in self.breadcrumbs:
-            match crumb:
-                case LeftCrumb(kind=ThenKind.RIGHT):
-                    return True  # you're in a left child of a then_right
-                case RightCrumb(kind=ThenKind.LEFT):
-                    return True  # you're in a right child of a then_left
-        return False
-
-
-    def up(self) -> Optional[AST[T]]:
-        if not self.breadcrumbs:
-            return None
-        *rest, last = self.breadcrumbs
-
-        match last:
-            case LeftCrumb(right=right, kind=kind):
-                parent: ParseResult[T] = ThenResult(kind=kind, left=self.focus, right=right)
-            case RightCrumb(left=left, kind=kind):
-                parent = ThenResult(kind=kind, left=left, right=self.focus)
-            case NamedCrumb(name=name, forward_map=forward_map, backward_map=backward_map, aggregator=aggregator):
-                parent = NamedResult(name=name, value=self.focus, forward_map=forward_map, backward_map=backward_map, aggregator=aggregator)
-            case ManyCrumb(before=before, after=after):
-                parent = ManyResult(value=before + (self.focus,) + after)
-            case OrCrumb():
-                parent = OrResult(value=self.focus)
-            case _:
-                raise ValueError(f"Unexpected crumb type: {last}")
-        return AST(focus=parent, breadcrumbs=tuple(rest), closed=frozenset(self.closed | {last}))
-
-    def down_left(self) -> Optional[AST[T]]:
-        match self.focus:
-            case ThenResult(left=left, right=_, kind=kind):
-                return AST(focus=left, 
-                           breadcrumbs=self.breadcrumbs + (LeftCrumb("\u2199", right=self.focus.right, kind=kind),), 
-                           closed=self.closed)
-            case NamedResult(name=name, 
-                             value=inner, 
-
-                             forward_map=forward_map, 
-                             backward_map=backward_map,
-                             aggregator=aggregator):
-                return AST(focus=inner, 
-                           breadcrumbs=self.breadcrumbs + (NamedCrumb("\u2199", 
-                                                                      name=name, 
-
-                                                                      forward_map=forward_map, 
-                                                                      backward_map=backward_map, 
-                                                                      aggregator=aggregator),),
-                           closed=self.closed)
-            case ManyResult(value=()):
-                return None
-            case ManyResult(value=(head, *tail)):
-                return AST(focus=head, 
-                           breadcrumbs=self.breadcrumbs + (ManyCrumb("\u2199", before=(), after=tuple(tail)),),
-                           closed=self.closed)
-            case OrResult(value=value):
-                return AST(focus=value, 
-                           breadcrumbs=self.breadcrumbs + (OrCrumb("\u2199"),),
-                           closed=self.closed)
-            case _:
-                return None        
-
-
-
-
-    def right(self) -> Optional[AST[T]]:
-        if not self.breadcrumbs:
-            return None
-        *rest, last = self.breadcrumbs
-        match last:
-            case ManyCrumb(before=before, after=(next_, *after)):
-                # If inside a ManyResult, and there are elements in after, return the next sibling and update before to include current focus
-                new_last = ManyCrumb("\u2192", before=before + (self.focus,), after=tuple(after))
-                return AST(focus=next_, 
-                           breadcrumbs=tuple(rest) + (new_last,),
-                           # don't add the ManyCrumb(last) to closed, because we only close one of its children
-                           # and the whole ManyCrumb can not be considered closed
-                           # so we only add the current focus to closed if it is a Crumb.
-                           # if the client code hold MnayCrumb(last) as a scope, it should check 
-                           # if the scope is in closed, and update the scope to the new ManyCrumb
-                           closed=frozenset(self.closed | {self.focus}) if isinstance(self.focus, Crumb) else frozenset(self.closed)
-                        )
-            case LeftCrumb(right=right, kind=kind):
-                return AST(focus=right, 
-                           breadcrumbs=tuple(rest) + (RightCrumb("\u2192", self.focus, kind),),
-                           closed=frozenset(self.closed | {last}))
-            case _:
-                return None
-    
-
-    def replace(self, new_focus: ParseResult[T]) -> AST[T]:
-        focus = new_focus
-        for crumb in reversed(self.breadcrumbs):
-            match crumb:
-                case LeftCrumb(right=right, kind=kind):
-                    focus = ThenResult(left=focus, right=right, kind=kind)
-                case RightCrumb(left=left, kind=kind):
-                    focus = ThenResult(left=left, right=focus, kind=kind)
-                case NamedCrumb(name=name, 
-                                
-                                forward_map=forward_map, 
-                                backward_map=backward_map,
-                                aggregator=aggregator):
-                    focus = NamedResult(name=name, 
-                                        value=focus, 
-
-                                        forward_map=forward_map, 
-                                        backward_map=backward_map,
-                                        aggregator=aggregator)
-                case ManyCrumb(before=before, after=after):
-                    focus = ManyResult(value=before + (focus,) + after)
-                case OrCrumb():
-                    focus = OrResult(value=focus)
-        return AST(focus=focus)
-    
-    @cached_property
-    def root(self) -> AST[T]:
-        z = self
-        while z.breadcrumbs:
-            z = z.up() # type: ignore
-            assert z is not None, "Zipper should not be None when breadcrumbs are present"
-        return z
-    
-    @cached_property
-    def leftmost(self) -> AST[T]:
-        z = self
-        while True:
-            next_z = z.down_left()
-            if next_z is None:
-                return z
-            z = next_z
-
 
 
 
@@ -386,7 +80,7 @@ class ParserState(Generic[T], Insptectable):
 class Parser(Algebra[Tuple[T,...] | T, ParserState[T]]):
     @classmethod
     def token(cls, 
-              token_type: Optional[TokenType] = None, 
+              token_type: Optional[Enum] = None, 
               text: Optional[str] = None, 
               case_sensitive: bool = False,
               regex: Optional[re.Pattern[str]] = None

{syncraft-0.1.10.dist-info → syncraft-0.1.12.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: syncraft
-Version: 0.1.10
+Version: 0.1.12
 Summary: Parser combinator library
 Author-email: Michael Afmokt <michael@esacca.com>
 License-Expression: MIT
 Keywords: parser,combinator,sql,sqlite,generator,printer
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: rich>=14.1.0

syncraft-0.1.12.dist-info/RECORD

@@ -0,0 +1,15 @@
+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=SD9CRWnJrllWlZeiZmyBEkQ_WOVMjWKgrcAGo-27o14,9970
+syncraft/parser.py,sha256=rk3YF8B0G8PG3JKYpeMQsYmHC5JxqrkCMXZAPfaqgME,10210
+syncraft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syncraft/sqlite3.py,sha256=2JNGDymSJti3mdc7hdeXIF78S6SsSLpKJwe6AzivskQ,34757
+syncraft-0.1.12.dist-info/licenses/LICENSE,sha256=wHSV424U5csa3339dy1AZbsz2xsd0hrkMx2QK48CcUk,1062
+syncraft-0.1.12.dist-info/METADATA,sha256=ObEtoVoxfp6uKYMU9ZW_ABAs6T-RH7TRu__Pjt9mwIA,946
+syncraft-0.1.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+syncraft-0.1.12.dist-info/top_level.txt,sha256=Kq3t8ESXB2xW1Xt3uPmkENFc-c4f2pamNmaURBk7zc8,9
+syncraft-0.1.12.dist-info/RECORD,,

syncraft-0.1.10.dist-info/RECORD

@@ -1,14 +0,0 @@
-syncraft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-syncraft/algebra.py,sha256=jiqdo1GbXVwi_7Uoh1zBLe-TparNaHp8jW2IFt8PzBc,24494
-syncraft/cmd.py,sha256=DzXgU8QLVOg0YTFKpmOyzbf02LKPphQ4EeKSLzqpJ_s,2012
-syncraft/diagnostic.py,sha256=_kLbl1LlU4Y2PtsLLZFA_OLqeZqq1f2rjT_LRXLnDaI,2813
-syncraft/dsl.py,sha256=cUBBB8upivOJDfZteTgwppoRg8Z_e5Bo4urDgdUG_QU,16503
-syncraft/generator.py,sha256=19FnFCi7yfq9dR4ePg7mzt06Kw--1mIRENHXDfPUGnk,12279
-syncraft/parser.py,sha256=wDiRJuNLsBsTBv0HZlGUGtkKMbDpIA8sTfsV3tA4BU0,22835
-syncraft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-syncraft/sqlite3.py,sha256=2JNGDymSJti3mdc7hdeXIF78S6SsSLpKJwe6AzivskQ,34757
-syncraft-0.1.10.dist-info/licenses/LICENSE,sha256=wHSV424U5csa3339dy1AZbsz2xsd0hrkMx2QK48CcUk,1062
-syncraft-0.1.10.dist-info/METADATA,sha256=cTJNXllZFFRL9Av8u_-iSgHrN92ZKO0HpgOYbKx6_fE,945
-syncraft-0.1.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-syncraft-0.1.10.dist-info/top_level.txt,sha256=Kq3t8ESXB2xW1Xt3uPmkENFc-c4f2pamNmaURBk7zc8,9
-syncraft-0.1.10.dist-info/RECORD,,