syncraft 0.1.17__tar.gz → 0.1.19__tar.gz

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

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

{syncraft-0.1.17 → syncraft-0.1.19}/pyproject.toml

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

{syncraft-0.1.17 → syncraft-0.1.19}/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-0.1.17 → syncraft-0.1.19}/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
+    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
@@ -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-0.1.17 → syncraft-0.1.19}/syncraft/parser.py

@@ -11,7 +11,7 @@ from syncraft.algebra import (
 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
 
@@ -187,15 +187,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 +213,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 +248,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-0.1.17 → syncraft-0.1.19}/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-0.1.17/syncraft/dsl.py → syncraft-0.1.19/syncraft/syntax.py

@@ -67,11 +67,11 @@ class Description(Insptectable):
 
 
 @dataclass(frozen=True)
-class DSL(Generic[A, S], Insptectable):
+class Syntax(Generic[A, S], Insptectable):
     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.17 → syncraft-0.1.19}/syncraft.egg-info/PKG-INFO

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

{syncraft-0.1.17 → syncraft-0.1.19}/syncraft.egg-info/SOURCES.txt

@@ -6,11 +6,11 @@ syncraft/algebra.py
 syncraft/ast.py
 syncraft/cmd.py
 syncraft/diagnostic.py
-syncraft/dsl.py
 syncraft/generator.py
 syncraft/parser.py
 syncraft/py.typed
 syncraft/sqlite3.py
+syncraft/syntax.py
 syncraft.egg-info/PKG-INFO
 syncraft.egg-info/SOURCES.txt
 syncraft.egg-info/dependency_links.txt

{syncraft-0.1.17 → syncraft-0.1.19}/tests/test_bimap.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 from syncraft.algebra import NamedResult, Error, ManyResult, OrResult, ThenResult, ThenKind
-from syncraft.parser import literal, parse, Parser
+from syncraft.parser import literal, parse
 import syncraft.generator as gen
 from syncraft.generator import TokenGen
 from rich import print
@@ -10,10 +10,10 @@ def test1_simple_then() -> None:
     A, B, C = literal("a"), literal("b"), literal("c")
     syntax = A // B // C
     sql = "a b c"
-    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    ast = parse(syntax, sql, dialect="sqlite")
     print("---" * 40)
     print(ast)
-    generated = gen.generate(syntax(gen.Generator), ast)
+    generated = gen.generate(syntax, ast)
     print("---" * 40)
     print(generated)
     assert ast == generated
@@ -26,10 +26,10 @@ def test2_named_results() -> None:
     A, B = literal("a").bind("x").bind('z'), literal("b").bind("y")
     syntax = A // B
     sql = "a b"
-    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    ast = parse(syntax, sql, dialect="sqlite")
     print("---" * 40)
     print(ast)
-    generated = gen.generate(syntax(gen.Generator), ast)
+    generated = gen.generate(syntax, ast)
     print("---" * 40)
     print(generated)
     assert ast == generated
@@ -43,10 +43,10 @@ def test3_many_literals() -> None:
     A = literal("a")
     syntax = A.many()
     sql = "a a a"
-    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    ast = parse(syntax, sql, dialect="sqlite")
     print("---" * 40)
     print(ast)
-    generated = gen.generate(syntax(gen.Generator), ast)
+    generated = gen.generate(syntax, ast)
     print("---" * 40)
     print(generated)
     assert ast == generated
@@ -60,10 +60,10 @@ def test4_mixed_many_named() -> None:
     B = literal("b")
     syntax = (A | B).many()
     sql = "a b a"
-    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    ast = parse(syntax, sql, dialect="sqlite")
     print("---" * 40)
     print(ast)
-    generated = gen.generate(syntax(gen.Generator), ast)
+    generated = gen.generate(syntax, ast)
     print("---" * 40)
     print(generated)
     assert ast == generated
@@ -76,10 +76,10 @@ def test5_nested_then_many() -> None:
     IF, THEN, END = literal("if"), literal("then"), literal("end")
     syntax = (IF.many() // THEN.many()).many() // END
     sql = "if if then end"
-    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    ast = parse(syntax, sql, dialect="sqlite")
     print("---" * 40)
     print(ast)
-    generated = gen.generate(syntax(gen.Generator), ast)
+    generated = gen.generate(syntax, ast)
     print("---" * 40)
     print(generated)
     # assert ast == generated
@@ -93,9 +93,9 @@ def test_then_flatten():
     A, B, C = literal("a"), literal("b"), literal("c")
     syntax = A + (B + C)
     sql = "a b c"
-    ast = parse(syntax(Parser), sql, dialect='sqlite')
+    ast = parse(syntax, sql, dialect='sqlite')
     print(ast)
-    generated = gen.generate(syntax(gen.Generator), ast)
+    generated = gen.generate(syntax, ast)
     assert ast == generated
     value, bmap = ast.bimap(None)
     assert bmap(value) == ast    
@@ -108,9 +108,9 @@ def test_named_in_then():
     C = literal("c").bind("third")
     syntax = A + B + C
     sql = "a b c"
-    ast = parse(syntax(Parser), sql, dialect='sqlite')
+    ast = parse(syntax, sql, dialect='sqlite')
     print(ast)
-    generated = gen.generate(syntax(gen.Generator), ast)
+    generated = gen.generate(syntax, ast)
     assert ast == generated
     value, bmap = ast.bimap(None)
     assert isinstance(value, tuple)
@@ -123,9 +123,9 @@ def test_named_in_many():
     A = literal("x").bind("x")
     syntax = A.many()
     sql = "x x x"
-    ast = parse(syntax(Parser), sql, dialect='sqlite')
+    ast = parse(syntax, sql, dialect='sqlite')
     print(ast)
-    generated = gen.generate(syntax(gen.Generator), ast)
+    generated = gen.generate(syntax, ast)
     assert ast == generated
     value, bmap = ast.bimap(None)
     assert isinstance(value, list)
@@ -138,9 +138,9 @@ def test_named_in_or():
     B = literal("b").bind("b")
     syntax = A | B
     sql = "b"
-    ast = parse(syntax(Parser), sql, dialect='sqlite')
+    ast = parse(syntax, sql, dialect='sqlite')
     print(ast)
-    generated = gen.generate(syntax(gen.Generator), ast)
+    generated = gen.generate(syntax, ast)
     assert ast == generated
     value, bmap = ast.bimap(None)
     assert isinstance(value, NamedResult)
@@ -157,9 +157,9 @@ def test_deep_mix():
     C = literal("c").bind("c")
     syntax = ((A + B) | C).many() + B
     sql = "a b a b c b"
-    ast = parse(syntax(Parser), sql, dialect='sqlite')
+    ast = parse(syntax, sql, dialect='sqlite')
     print(ast)
-    generated = gen.generate(syntax(gen.Generator), ast)
+    generated = gen.generate(syntax, ast)
     print('---' * 40)
     print(generated)
     assert ast == generated
@@ -171,7 +171,7 @@ def test_empty_many() -> None:
     A = literal("a")
     syntax = A.many()  # This should allow empty matches
     sql = ""
-    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    ast = parse(syntax, sql, dialect="sqlite")
     assert isinstance(ast, Error)
 
 
@@ -180,7 +180,7 @@ def test_backtracking_many() -> None:
     B = literal("b")
     syntax = (A.many() + B)  # must not eat the final "a" needed for B
     sql = "a a a a b"
-    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    ast = parse(syntax, sql, dialect="sqlite")
     value, bmap = ast.bimap(None)
     assert value[-1] == TokenGen.from_string("b")
 
@@ -190,7 +190,7 @@ def test_deep_nesting() -> None:
     for _ in range(100):
         syntax = syntax + A
     sql = " " .join("a" for _ in range(101))
-    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    ast = parse(syntax, sql, dialect="sqlite")
     assert ast is not None
 
 
@@ -198,7 +198,7 @@ def test_nested_many() -> None:
     A = literal("a")
     syntax = (A.many().many())  # groups of groups of "a"
     sql = "a a a"
-    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    ast = parse(syntax, sql, dialect="sqlite")
     assert isinstance(ast.focus, ManyResult)
 
 
@@ -206,7 +206,7 @@ def test_named_many() -> None:
     A = literal("a").bind("alpha")
     syntax = A.many()
     sql = "a a"
-    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    ast = parse(syntax, sql, dialect="sqlite")
     # Expect [NamedResult("alpha", "a"), NamedResult("alpha", "a")]
     flattened, _ = ast.bimap(None)
     assert all(isinstance(x, NamedResult) for x in flattened)
@@ -217,7 +217,7 @@ def test_or_named() -> None:
     B = literal("b").bind("y")
     syntax = A | B
     sql = "b"
-    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    ast = parse(syntax, sql, dialect="sqlite")
     # Either NamedResult("y", "b") or just "b", depending on your design
     assert isinstance(ast.focus, OrResult)
     value, _ = ast.bimap(None)
@@ -230,7 +230,7 @@ def test_then_associativity() -> None:
     C = literal("c")
     syntax = A + B + C
     sql = "a b c"
-    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    ast = parse(syntax, sql, dialect="sqlite")
     # Should be ThenResult(ThenResult(A,B),C)
     assert ast.focus == ThenResult(kind=ThenKind.BOTH, 
                                    left=ThenResult(kind=ThenKind.BOTH, 
@@ -244,7 +244,7 @@ def test_ambiguous() -> None:
     B = literal("a") + literal("b")
     syntax = A | B
     sql = "a"
-    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    ast = parse(syntax, sql, dialect="sqlite")
     # Does it prefer A (shorter) or B (fails)? Depends on design.
     assert ast.focus == OrResult(TokenGen.from_string("a"))
 
@@ -256,6 +256,18 @@ def test_combo() -> None:
     syntax = ((A + B).many() | C) + B
     sql = "a b a b c b"
     # Should fail, as we discussed earlier
-    ast = parse(syntax(Parser), sql, dialect="sqlite")
+    ast = parse(syntax, sql, dialect="sqlite")
     assert isinstance(ast, Error)
 
+
+def test_optional():
+    A = literal("a").bind("a")
+    syntax = A.optional()
+    ast1 = parse(syntax, "", dialect="sqlite")
+    v1, _ = ast1.bimap(None)
+    assert v1 is None
+    ast2 = parse(syntax, "a", dialect="sqlite")
+    v2, _ = ast2.bimap(None)
+    assert v2 == NamedResult(name='a', value=TokenGen.from_string('a'))
+
+

{syncraft-0.1.17 → syncraft-0.1.19}/tests/test_parse.py

@@ -1,4 +1,4 @@
-from syncraft.parser import AST, literal, variable, parse, Parser
+from syncraft.parser import AST, literal, variable, parse
 import syncraft.generator as gen
 from typing import Any
 
@@ -12,16 +12,16 @@ var = variable()
 def test_between()->None:
     sql = "then if then"
     syntax = IF.between(THEN, THEN)
-    ast:AST[Any] = parse(syntax(Parser), sql, dialect='sqlite')    
-    generated = gen.generate(syntax(gen.Generator), ast)
+    ast:AST[Any] = parse(syntax, sql, dialect='sqlite')    
+    generated = gen.generate(syntax, ast)
     assert ast == generated, "Parsed and generated results do not match."
 
 
 def test_sep_by()->None:
     sql = "if then if then if then if"
     syntax = IF.sep_by(THEN)
-    ast:AST[Any] = parse(syntax(Parser), sql, dialect='sqlite')    
-    generated = gen.generate(syntax(gen.Generator), ast)
+    ast:AST[Any] = parse(syntax, sql, dialect='sqlite')    
+    generated = gen.generate(syntax, ast)
     assert ast == generated, "Parsed and generated results do not match."
 
 def test_many_or()->None:
@@ -30,6 +30,6 @@ def test_many_or()->None:
     END = literal("end")
     syntax = (IF.many() | THEN.many()).many() // END
     sql = "if if then end"
-    ast:AST[Any] = parse(syntax(Parser), sql, dialect='sqlite')
-    generated = gen.generate(syntax(gen.Generator), ast)
+    ast:AST[Any] = parse(syntax, sql, dialect='sqlite')
+    generated = gen.generate(syntax, ast)
     assert ast == generated, "Parsed and generated results do not match."

{syncraft-0.1.17 → syncraft-0.1.19}/tests/test_until.py

@@ -10,7 +10,7 @@ LB, RB = literal("["), literal("]")
 def test_until_accepts_proper_nesting() -> None:
     sql = "([])"
     syntax = until((LP, RP), (LB, RB))
-    ast: AST[Any] | Any = parse(syntax(Parser), sql, dialect="sqlite")
+    ast: AST[Any] | Any = parse(syntax, sql, dialect="sqlite")
     assert isinstance(ast, AST), f"Expected AST for proper nesting, got {ast}"
 
 
@@ -18,7 +18,7 @@ def test_until_rejects_mismatched_pairs() -> None:
     # Mismatched: ( ] should fail immediately
     sql = "(]"
     syntax = until((LP, RP), (LB, RB))
-    res = parse(syntax(Parser), sql, dialect="sqlite")
+    res = parse(syntax, sql, dialect="sqlite")
     from syncraft.algebra import Error
     assert isinstance(res, Error), "Mismatched pairs should be rejected with an Error"
 
@@ -26,7 +26,7 @@ def test_until_rejects_unterminated_group() -> None:
     # Unterminated: ( ... EOF
     sql = "("
     syntax = until((LP, RP))
-    res = parse(syntax(Parser), sql, dialect="sqlite")
+    res = parse(syntax, sql, dialect="sqlite")
     from syncraft.algebra import Error
     assert isinstance(res, Error), "Unterminated group should be rejected with an Error"
 
@@ -35,6 +35,6 @@ def test_until_rejects_crossing_pairs() -> None:
     sql = "([)]"
     syntax = until((LP, RP), (LB, RB))
     # Use postgres dialect so [ and ] are tokenized distinctly (not as bracketed identifier)
-    res = parse(syntax(Parser), sql, dialect="postgres")
+    res = parse(syntax, sql, dialect="postgres")
     from syncraft.algebra import Error
     assert isinstance(res, Error), "Crossing pairs should be rejected with an Error"