koatl 0.1.42__tar.gz → 0.2.2__tar.gz

{koatl-0.1.42 → koatl-0.2.2}/Cargo.lock

@@ -99,7 +99,7 @@ checksum = "f4c7245a08504955605670dbf141fceab975f15ca21570696aebe9d2e71576bd"
 
 [[package]]
 name = "koatl"
-version = "0.1.42"
+version = "0.2.2"
 dependencies = [
  "ariadne",
  "koatl-core",
@@ -112,11 +112,18 @@ name = "koatl-core"
 version = "0.1.0"
 dependencies = [
  "ariadne",
+ "koatl-parser",
  "once_cell",
- "parser",
  "slotmap",
 ]
 
+[[package]]
+name = "koatl-parser"
+version = "0.1.0"
+dependencies = [
+ "chumsky",
+]
+
 [[package]]
 name = "libc"
 version = "0.2.174"
@@ -144,13 +151,6 @@ version = "1.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
-[[package]]
-name = "parser"
-version = "0.1.0"
-dependencies = [
- "chumsky",
-]
-
 [[package]]
 name = "portable-atomic"
 version = "1.11.1"

koatl-0.2.2/Cargo.toml

@@ -0,0 +1,3 @@
+[workspace]
+members = ["koatl-parser", "koatl-core", "koatl"]
+resolver = "3"

{koatl-0.1.42 → koatl-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: koatl
-Version: 0.1.42
+Version: 0.2.2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{koatl-0.1.42 → koatl-0.2.2}/koatl/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "koatl"
-version = "0.1.42"
+version = "0.2.2"
 edition = "2021"
 
 [lib]

{koatl-0.1.42 → koatl-0.2.2/koatl}/python/koatl/cli.py

@@ -9,9 +9,23 @@ def transpile_from_source(source, mode="script", script_path="<string>"):
 
 def run_from_source(source, mode="script", script_path="<string>"):
     from koatl import transpile
+    import ast
 
     transpiled_code = transpile(source, mode=mode, filename=str(script_path))
-    code_obj = compile(transpiled_code, script_path, "exec")
+
+    try:
+        code_obj = compile(transpiled_code, script_path, "exec")
+    except Exception as e:
+
+        class Visitor(ast.NodeVisitor):
+            def generic_visit(self, node):
+                if hasattr(node, "lineno"):
+                    if node.lineno > node.end_lineno:
+                        print(f"Error: {node.lineno} > {node.end_lineno} for {node}")
+                super().generic_visit(node)
+
+        Visitor().visit(transpiled_code)
+        raise
 
     script_globals = {"__name__": "__main__"}
 

{koatl-0.1.42 → koatl-0.2.2/koatl}/python/koatl/std/alg/async.tl

@@ -31,7 +31,7 @@ export Async = class(MonadOnce):
                 self = gen.send(yield from self.__await__())
                 if not hasattr(self, "__await__"):
                     raise ValueError(f"Expected the binder to return an Awaitable, but got {type(self).__name__}")
-        except StopIteration(value=value):
+        except StopIteration(value=value) =>
             return value
 
     pure = staticmethod& x => Async.from_generator_fn& () =>

{koatl-0.1.42 → koatl-0.2.2/koatl}/python/koatl/std/alg/do.tl

@@ -7,10 +7,10 @@ export do = f => wraps(f)& (*args, **kwargs) =>
     let m
     try:
         m = gen.send(None)
-    except StopIteration() as e:
+    except StopIteration() as e =>
         raise ValueError(
             "Returning before `@` is not allowed. "
-                "Use `return @MonadType.pure(value)` instead."
+                + "Use `return @MonadType.pure(value)` instead."
         )
 
     try:
@@ -18,17 +18,17 @@ export do = f => wraps(f)& (*args, **kwargs) =>
         # is it possible to derive bind_gen directly from bind_once?
 
         return m.bind_gen(gen)
-    except AttributeError():
+    except AttributeError() =>
         None
 
     let recurse = v =>
         try:
             m = gen.send(v)
             return m.bind_once(recurse)
-        except StopIteration() as e:
+        except StopIteration() as e =>
             return m.pure(e.value)
 
     try:
         return m.bind_once(recurse)
-    except AttributeError():
+    except AttributeError() =>
         raise ValueError("@ can only be used with an object that has `bind_once`.")

{koatl-0.1.42 → koatl-0.2.2}/koatl/python/koatl/std/alg/env.tl

@@ -26,7 +26,7 @@ export Env = class(MonadOnce):
 
     bind_once = (self, f) => Env& ctx =>
         let v = f(self.f(ctx))
-        if v matches not Env():
+        if v not matches Env():
             raise ValueError(f"Expected the binder to return an Env, but got {type(v)}")
 
         v.f(ctx)
@@ -35,9 +35,9 @@ export Env = class(MonadOnce):
         try:
             while True:
                 self = gen.send(self.f(ctx))
-                if self matches not Env():
+                if self not matches Env():
                     raise ValueError(f"Expected the binder to return an Env, but got {type(self)}")
-        except StopIteration(value=value):
+        except StopIteration(value=value) =>
             return value
 
     NoKey = object()

{koatl-0.1.42 → koatl-0.2.2/koatl}/python/koatl/std/alg/memo.tl

@@ -24,7 +24,7 @@ export Memo = class(MonadOnce):
 
         __repr__ = self => f"Memo.Cache({self.cache})"
 
-        try_get = (self, name, deps) => try self.cache[name][deps] except KeyError()
+        try_get = (self, name, deps) => check self.cache[name][deps] except KeyError()
 
         update = (self, name, deps, value) =>
             self.cache[name][deps] = value
@@ -88,7 +88,7 @@ export Memo = class(MonadOnce):
     bind_once = (self, f) => Memo(ctx =>
         let value = f(self.f(ctx))
 
-        if value matches not Memo():
+        if value not matches Memo():
             raise ValueError(f"Expected the binder to return a Memo, but got {type(value)}")
 
         return value.f(ctx)
@@ -100,10 +100,9 @@ export Memo = class(MonadOnce):
                 let inner = self.f(ctx)
                 self = gen.send(inner)
 
-                if self matches not Memo():
+                if self not matches Memo():
                     raise ValueError(f"Expected the binder to return a Memo, but got {type(value)}")
-
-        except StopIteration(value=value):
+        except StopIteration(value=value) =>
             return value
     )
 
@@ -164,7 +163,7 @@ export AsyncMemo = class(MonadOnce):
     bind_once = (self, f) => AsyncMemo(ctx =>
         let value = f(@self.f(ctx))
 
-        if value matches not AsyncMemo():
+        if value not matches AsyncMemo():
             raise ValueError(f"Expected the binder to return a Memo, but got {type(value)}")
 
         return value.f(ctx)
@@ -176,9 +175,9 @@ export AsyncMemo = class(MonadOnce):
                 let inner = @self.f(ctx)
                 self = gen.send(inner)
 
-                if self matches not AsyncMemo():
+                if self not matches AsyncMemo():
                     raise ValueError(f"Expected the binder to return a Memo, but got {type(value)}")
 
-        except StopIteration(value=value):
+        except StopIteration(value=value) =>
             return value
     )

{koatl-0.1.42 → koatl-0.2.2}/koatl/python/koatl/std/alg/result.tl

@@ -5,7 +5,7 @@ infer_ok = x =>
     x match:
         None => False
         BaseException() => False
-        default True
+        _ => True
 
 op_coal = (x, f) =>
     if x matches Result():
@@ -42,7 +42,7 @@ export Result = class(MonadOnce):
         """
         try:
             return Ok(f())
-        except BaseException() as e:
+        except BaseException() as e =>
             return Err(e)
 
     bind_once = (self, f) =>
@@ -50,7 +50,7 @@ export Result = class(MonadOnce):
             return self
 
         let value = f(self.value)
-        if value matches not Result():
+        if value not matches Result():
             raise ValueError(f"Expected the binder to return a Result, but got {type(value)}")
         value
 
@@ -61,9 +61,9 @@ export Result = class(MonadOnce):
                     return self
 
                 self = gen.send(self.value)
-                if self matches not Result():
+                if self not matches Result():
                     raise ValueError(f"Expected the binder to return a Result, but got {type(self)}")
-        except StopIteration(value=value):
+        except StopIteration(value=value) =>
             return Result(value)
 
     pure = staticmethod& x => Ok(x)

{koatl-0.1.42 → koatl-0.2.2}/koatl/python/koatl/std/data/list.tl

@@ -5,14 +5,14 @@ import koatl.std.alg.Monad
 export List = class(Monad):
     __new__ = (cls, *args, **kwargs) => raise ValueError(
         "List cannot be instantiated directly. "
-            "Use [] or list()."
+            + "Use [] or list()."
     )
 
     bind_once = (self, f) =>
         raise NotImplementedError(
             "List may not be bound using @ "
-                "due to generator limitations. "
-                "Wrap in Ok to use the Result monad."
+                + "due to generator limitations. "
+                + "Wrap in Ok to use the Result monad."
         )
 
     bind = (self, f) => List(self.flat_map(f))

{koatl-0.1.42 → koatl-0.2.2}/koatl/python/koatl/std/iter.tl

@@ -21,7 +21,7 @@ export Iterable = class(Traversable, Trait):
                 let value = next(it)
                 if not f(value):
                     return Iterable.chain([value], it)
-            except StopIteration():
+            except StopIteration() =>
                 return it
 
     take = (self, n) =>
@@ -30,7 +30,7 @@ export Iterable = class(Traversable, Trait):
             for _ in ..n:
                 try:
                     yield next(it)
-                except StopIteration(value=value):
+                except StopIteration(value=value) =>
                     return value
 
         impl.__name__ = f"take"
@@ -152,7 +152,7 @@ export Iterable = class(Traversable, Trait):
         return Err()
 
     first = self =>
-        (try next(self.iter)).map_err(_ => None)
+        (check next(self.iter)).map_err(_ => None)
 
     last = (self, f) =>
         let result = Err()
@@ -212,7 +212,7 @@ export Iterable = class(Traversable, Trait):
                 m = v
             else:
                 m = key(v)
-        except StopIteration(value=value):
+        except StopIteration(value=value) =>
             raise ValueError("max of empty iterable")
 
 
@@ -239,7 +239,7 @@ export Iterable = class(Traversable, Trait):
                 m = v
             else:
                 m = key(v)
-        except StopIteration(value=value):
+        except StopIteration(value=value) =>
             raise ValueError("min of empty iterable")
 
         if key === None:
@@ -272,7 +272,7 @@ export Iterable = class(Traversable, Trait):
         let v
         try:
             v = next(it)
-        except StopIteration():
+        except StopIteration() =>
             return []
 
         let m = f(v)

{koatl-0.1.42 → koatl-0.2.2}/koatl/python/koatl/std/lazy_module.tl

@@ -25,7 +25,7 @@ export LazyModule = class:
 
             if hasattr(self._module, attr):
                 return getattr(self._module, attr)
-        except e:
+        except e =>
             raise ValueError(str(e))
 
         raise AttributeError(f"Module '{self._name}' has no attribute '{attr}'")

{koatl-0.1.42 → koatl-0.2.2}/koatl/src/emit_py.rs

@@ -1,4 +1,4 @@
-use koatl_core::{parser::ast::*, py::ast::*, util::LineColCache};
+use koatl_core::{py::ast::*, util::LineColCache, Span};
 
 use pyo3::{
     call::PyCallArgs,

{koatl-0.1.42 → koatl-0.2.2}/koatl/tests/e2e/base/match.tl

@@ -1,28 +1,36 @@
 import util.assert_eq
 
 # parsing test
-1 match 1 if False => 2 default 3
+1 match:
+    1 if False => 2
+    _ => 3
 
 assert_eq(
-    1 match 1 if False => 2 default 3,
+    1 match:
+        1 if False => 2
+        _ => 3
     3
 )
 
 assert_eq(
-    1 match 1 if False => 2 else _ => 3,
+    1 match:
+        1 if False => 2
+        _ => 3
     3
 )
 
 x = 1
 assert_eq(
-    1 match .x => 2 default 3,
+    1 match:
+        .x => 2
+        _ => 3
     2
 )
 
 assert_eq(
     1 match:
         .x => 2
-        default 3
+        _ => 3
     2
 )
 
@@ -34,7 +42,7 @@ assert_eq(
 )
 
 assert_eq(
-    match 1:
+    1 match:
         .x => 2
         _ => 3
     2
@@ -42,29 +50,36 @@ assert_eq(
 
 x = 1
 assert_eq(
-    2 match .x => 2 default 3
+    2 match:
+        .x => 2
+        _ => 3
     3
 )
 
 assert_eq(
-    2 match x => 2
+    2 match:
+        x => 2
     2
 )
 
 assert_eq(
-    [1, 2, 3] match [3, *x] => x default 123
+    [1, 2, 3] match:
+        [3, *x] => x
+        _ => 123
     123
 )
 
 assert_eq(
-    [1, 2, 3] match [1, *x] => x default 123
+    [1, 2, 3] match:
+        [1, *x] => x
+        _ => 123
     [2, 3] | list
 )
 
 assert_eq(
     [1, 2, 3] match:
         [1, *x] => x
-        default:
+        _ =>
             123
     [2, 3] | list
 )
@@ -79,7 +94,7 @@ f = () =>
     else:
         raise
 
-    if [1, 2, 3] matches not [1, 2, x]:
+    if [1, 2, 3] not matches [1, 2, x]:
         raise
     else:
         assert_eq(x, 3)

koatl-0.2.2/koatl/tests/e2e/prelude/try.tl

@@ -0,0 +1,28 @@
+import util.assert_eq
+
+# precedence
+assert_eq(check 1 ?? 2, 1)
+assert_eq(check z ?? 2, 2)
+assert_eq(check z matches Err(NameError()), True)
+assert_eq(check z ?? check 1 ?? 2, 1)
+assert_eq(check z ?? check None ?? 2, None)
+assert_eq(check z ?? Err(None) ?? 2, 2)
+
+err_type = NameError
+assert_eq(check a except err_type() matches Err(), True)
+
+# handlers
+assert_eq(check 1 except ValueError() ?? 2, 1)
+assert_eq(check a except NameError() ?? 2, 2)
+assert_eq(check a except (ValueError() | NameError()) ?? 2, 2)
+
+try:
+    check a except (ValueError() | StopIteration())
+    raise
+except _ =>
+    None
+
+assert_eq(check 1 matches Ok(1), True)
+
+assert_eq((check 5)?.($+1), Ok(6))
+assert_eq((check x)?.($+1) matches Err(), True)

{koatl-0.1.42 → koatl-0.2.2}/koatl/tests/e2e/prelude/virtual.tl

@@ -28,5 +28,5 @@ assert_eq(None.some_global_prop, ())
 assert_eq({required_method: Record.method& self => 42}.derived_method(), 42)
 assert_eq({required_method: Record.method& self => 42}.derived_property, 42)
 
-assert_eq((try "asdf".derived_method).ok, False)
-assert_eq((try "asdf".derived_prop).ok, False)
+assert_eq((check "asdf".derived_method).ok, False)
+assert_eq((check "asdf".derived_prop).ok, False)

koatl-0.2.2/koatl/tests/parse/matches.tl

@@ -0,0 +1,2 @@
+1 matches 1
+1 not matches 1

{koatl-0.1.42 → koatl-0.2.2}/koatl-core/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2024"
 
 [dependencies]
 ariadne = "0.5.1"
-parser = { path = "parser" }
+koatl-parser = { path = "../koatl-parser" }
 once_cell = "1.19.0"
 slotmap = "1.0.7"
 

{koatl-0.1.42/koatl-core/parser → koatl-0.2.2/koatl-core}/src/ast.rs

@@ -1,6 +1,7 @@
 use std::{borrow::Cow, fmt::Display};
 
-use chumsky::span::SimpleSpan;
+pub use koatl_parser::cst::{BinaryOp, Spannable, Spanned, UnaryOp};
+pub use koatl_parser::lexer::Span;
 
 pub type Indirect<T> = Box<T>;
 
@@ -30,45 +31,6 @@ impl<T> IntoIndirect<T> for T {
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum BinaryOp {
-    Add,
-    Sub,
-    Mul,
-    MatMul,
-    Div,
-    Exp,
-
-    FloorDiv,
-    Mod,
-
-    In,
-    Nin,
-    Lt,
-    Leq,
-    Gt,
-    Geq,
-    Eq,
-    Neq,
-    Is,
-    Nis,
-
-    And,
-    Or,
-
-    Coalesce,
-    Pipe,
-}
-
-#[derive(Debug, Copy, Clone)]
-pub enum UnaryOp {
-    Inv,
-    Pos,
-    Neg,
-    Not,
-    Bind,
-}
-
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub struct Ident<'a>(pub Cow<'a, str>);
 
@@ -133,7 +95,6 @@ pub enum Stmt<'a, TTree: Tree> {
     While(TTree::Expr, TTree::Expr),
     For(TTree::Pattern, TTree::Expr, TTree::Expr),
     Import(ImportTree<'a>, bool),
-    Try(TTree::Expr, Vec<MatchCase<TTree>>, Option<TTree::Expr>),
     Raise(Option<TTree::Expr>),
 
     Break,
@@ -176,7 +137,7 @@ pub enum ArgDefItem<'a, TTree: Tree> {
 
 #[derive(Debug, Clone)]
 pub struct MatchCase<TTree: Tree> {
-    pub pattern: Option<TTree::Pattern>,
+    pub pattern: TTree::Pattern,
     pub guard: Option<TTree::Expr>,
     pub body: TTree::Expr,
 }
@@ -227,6 +188,7 @@ pub enum Expr<'a, TTree: Tree> {
     MappedScopedAttribute(TTree::Expr, TTree::Expr),
     MappedAttribute(TTree::Expr, SIdent<'a>),
 
+    Try(TTree::Expr, Vec<MatchCase<TTree>>, Option<TTree::Expr>),
     Checked(TTree::Expr, Option<TTree::Pattern>),
 
     Block(Vec<TTree::Stmt>),
@@ -264,7 +226,7 @@ pub enum PatternClassItem<'a, TTree: Tree> {
 pub enum Pattern<'a, TTree: Tree> {
     Capture(Option<SIdent<'a>>),
     Value(TTree::Expr),
-    As(TTree::Pattern, SIdent<'a>),
+    As(TTree::Pattern, Option<SIdent<'a>>),
     Or(Vec<TTree::Pattern>),
     Literal(SLiteral<'a>),
     Sequence(Vec<PatternSequenceItem<'a, TTree>>),
@@ -285,24 +247,6 @@ impl<'src> Tree for STree<'src> {
     type Stmt = Indirect<SStmt<'src>>;
 }
 
-pub type Span = SimpleSpan<usize, ()>;
-
-#[derive(Debug, Clone)]
-pub struct Spanned<T> {
-    pub span: Span,
-    pub value: T,
-}
-
-pub trait Spannable<T> {
-    fn spanned(self, span: Span) -> Spanned<T>;
-}
-
-impl<T> Spannable<T> for T {
-    fn spanned(self, span: Span) -> Spanned<T> {
-        Spanned { span, value: self }
-    }
-}
-
 pub type SPatternInner<'a> = Pattern<'a, STree<'a>>;
 
 #[derive(Debug, Clone)]

koatl-0.1.42/koatl-core/parser/src/util.rs → koatl-0.2.2/koatl-core/src/ast_builder.rs

@@ -68,8 +68,8 @@ impl AstBuilder {
         body: impl IntoIndirect<SExpr<'src>>,
         handlers: Vec<SMatchCase<'src>>,
         orelse: Option<impl IntoIndirect<SExpr<'src>>>,
-    ) -> SStmt<'src> {
-        Stmt::Try(body.indirect(), handlers, orelse.map(|o| o.indirect())).spanned(self.span)
+    ) -> SExpr<'src> {
+        Expr::Try(body.indirect(), handlers, orelse.map(|o| o.indirect())).spanned(self.span)
     }
 
     pub fn raise<'src>(&self, expr: Option<impl IntoIndirect<SExpr<'src>>>) -> SStmt<'src> {
@@ -172,10 +172,17 @@ impl AstBuilder {
 
     pub fn fstring<'src>(
         &self,
-        prefix: Spanned<String>,
-        parts: Vec<(SFmtExpr<'src>, Spanned<String>)>,
+        prefix: impl Into<String>,
+        parts: Vec<(SFmtExpr<'src>, impl Into<String>)>,
     ) -> SExpr<'src> {
-        Expr::Fstr(prefix, parts).spanned(self.span)
+        Expr::Fstr(
+            prefix.into().spanned(self.span),
+            parts
+                .into_iter()
+                .map(|(x, s)| (x, s.into().spanned(self.span)))
+                .collect(),
+        )
+        .spanned(self.span)
     }
 
     pub fn block_expr<'src>(&self, block: Vec<impl IntoIndirect<SStmt<'src>>>) -> SExpr<'src> {