koatl 0.1.14__tar.gz → 0.1.15__tar.gz

{koatl-0.1.14 → koatl-0.1.15}/Cargo.lock

@@ -99,7 +99,7 @@ checksum = "f4c7245a08504955605670dbf141fceab975f15ca21570696aebe9d2e71576bd"
 
 [[package]]
 name = "koatl"
-version = "0.1.14"
+version = "0.1.15"
 dependencies = [
  "ariadne",
  "koatl-core",
@@ -112,6 +112,7 @@ name = "koatl-core"
 version = "0.1.0"
 dependencies = [
  "ariadne",
+ "once_cell",
  "parser",
 ]
 

{koatl-0.1.14 → koatl-0.1.15}/PKG-INFO

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

{koatl-0.1.14 → koatl-0.1.15}/koatl/Cargo.toml

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

{koatl-0.1.14 → koatl-0.1.15}/koatl/python/koatl/notebook/__init__.py

@@ -21,14 +21,23 @@ def source_code_transformer(lines):
     return lines
 
 
-def import_prelude(namespace):
-    exec("from koatl.runtime import *", namespace)
-    exec("from koatl.prelude import *", namespace)
+def try_import_prelude(namespace):
+    try:
+        exec("from koatl.runtime import *", namespace)
+        exec("from koatl.prelude import *", namespace)
+    except Exception as e:
+        import traceback
+
+        print(
+            "There was an error importing the Koatl prelude. Some features may not work."
+        )
+        traceback.print_exc()
 
 
 def load_ipython_extension(ipython):
-    import_prelude(ipython.user_ns)
-    print("koatl enabled")
+    print("Switched notebook to Koatl.")
+
+    try_import_prelude(ipython.user_ns)
 
     ttm = ipython.input_transformer_manager
 

{koatl-0.1.14 → koatl-0.1.15/koatl}/python/koatl/prelude/functional/__init__.tl

@@ -9,8 +9,8 @@ export Fn = class:
             [] => raise ValueError("At least one function is required for composition")
             [f] => f
             [*fs] =>
-                composed = (*args, **kwargs) =>
-                    value = fs[-1](*args, **kwargs)
+                let composed = (*args, **kwargs) =>
+                    let value = fs[-1](*args, **kwargs)
                     for f in fs[..-1..-1]:
                         value = f(value)
                     value

{koatl-0.1.14 → koatl-0.1.15/koatl}/python/koatl/prelude/functional/async.tl

@@ -1,8 +1,10 @@
 import functools.wraps
 import asyncio
+
 import .async_util
+import .monad.Monad
 
-export Async = class:
+export Async = class(Monad):
     __init__ = (self, awaitable) => self.generator = awaitable.__await__()
 
     __await__ = self => self.generator
@@ -10,14 +12,14 @@ export Async = class:
     __repr__ = self => "Async(...)"
 
     from_generator_fn = staticmethod& (generator_fn, *args, **kwargs) =>
-        m = object.__new__(Async)
+        let m = object.__new__(Async)
         m.generator = generator_fn(*args, **kwargs)
         return m
 
     run = self => asyncio.run(async_util.to_coro(self))
 
     bind_once = (self, f) => Async.from_generator_fn& () =>
-        result = f(yield from self.__await__())
+        let result = f(yield from self.__await__())
 
         if hasattr(result, "__await__"):
             return yield from result.__await__()
@@ -25,7 +27,6 @@ export Async = class:
         return result
 
     bind_gen = (self, gen) => Async.from_generator_fn& () =>
-        nonlocal self = self
         try:
             while True:
                 self = gen.send(yield from self.__await__())

{koatl-0.1.14 → koatl-0.1.15}/koatl/python/koatl/prelude/functional/reader.tl

@@ -1,6 +1,7 @@
 import functools.wraps
+import .monad.Monad
 
-export Reader = class:
+export Reader = class(Monad):
     __init__ = (self, fn) => self.fn = fn
 
     __repr__ = self => "Reader(...)"
@@ -8,16 +9,13 @@ export Reader = class:
     run = (self, ctx) => self.fn(ctx)
 
     bind_once = (self, f) => Reader& ctx =>
-        v = f(self.fn(ctx))
+        let v = f(self.fn(ctx))
         if v matches Reader():
             v.fn(ctx)
         else:
             v
 
-    # TODO: this is a workaround to avoid recursion.
-    # how to get bind_gen directly from bind_once?
     bind_gen = (self, gen) => Reader& ctx =>
-        nonlocal self = self
         try:
             while True:
                 self = gen.send(self.fn(ctx))

{koatl-0.1.14 → koatl-0.1.15}/koatl/python/koatl/prelude/iterable.tl

@@ -13,7 +13,7 @@ methods = {
             yield from f(i)
 
     fold: (x, init, f) =>
-        acc = init
+        let acc = init
         for i in x:
             acc = f(acc, i)
         acc
@@ -25,7 +25,7 @@ methods = {
         return None
 
     last: (x, f) =>
-        result = None
+        let result = None
         for i in x:
             if f(i):
                 result = i
@@ -38,7 +38,7 @@ methods = {
         raise IndexError("Index out of range")
 
     sum: x =>
-        acc = 0
+        let acc = 0
         for i in x:
             acc = acc + i
         acc

{koatl-0.1.14 → koatl-0.1.15}/koatl/python/koatl/runtime/__init__.py

@@ -22,6 +22,7 @@ from .helpers import *
 
 
 __tl__ = SimpleNamespace(
+    slice=slice,
     vget=virtual.vget,
     vhas=virtual.vhas,
     unpack_record=helpers.unpack_record,

{koatl-0.1.14 → koatl-0.1.15/koatl}/python/koatl/runtime/helpers.py

@@ -75,7 +75,9 @@ def do(f):
                     return e.value
 
         try:
-            print(m, gen)
+            # TODO: this is a workaround to avoid recursion.
+            # is it possible to get bind_gen directly from bind_once?
+
             return vget(m, "bind_gen")(gen)
         except (NotImplementedError, AttributeError):
             return vget(m, "bind_once")(recurse)

{koatl-0.1.14 → koatl-0.1.15}/koatl/python/koatl/runtime/meta_finder.py

@@ -54,7 +54,7 @@ class TlLoader(Loader):
 
         if module.__name__.startswith("koatl.prelude"):
             transpiled_code = transpile(
-                source_code, mode="prelude", filename=self.filepath
+                source_code, mode="no_prelude", filename=self.filepath
             )
         else:
             transpiled_code = transpile(

{koatl-0.1.14 → koatl-0.1.15}/koatl/src/emit_py.rs

@@ -333,18 +333,31 @@ impl<'src> PyStmtExt<'src> for SPyStmt<'src> {
                     &self.tl_span,
                 )
             }
-            PyStmt::FnDef(name, args, body, decorators) => {
-                let arguments = args.emit_py(ctx)?;
-                let body_ast = body.emit_py(ctx)?;
-                let decorators = decorators.emit_py(ctx)?;
-
-                ctx.ast_node(
-                    "FunctionDef",
-                    (name.as_ref(), arguments, body_ast, decorators),
-                    &self.tl_span,
-                )
+            PyStmt::FnDef(fndef) => {
+                let arguments = fndef.args.emit_py(ctx)?;
+                let body_ast = fndef.body.emit_py(ctx)?;
+                let decorators = fndef.decorators.emit_py(ctx)?;
+
+                if fndef.async_ {
+                    ctx.ast_node(
+                        "AsyncFunctionDef",
+                        (fndef.name.as_ref(), arguments, body_ast, decorators),
+                        &self.tl_span,
+                    )
+                } else {
+                    ctx.ast_node(
+                        "FunctionDef",
+                        (fndef.name.as_ref(), arguments, body_ast, decorators),
+                        &self.tl_span,
+                    )
+                }
             }
-            PyStmt::ClassDef(name, bases, body, decorators) => {
+            PyStmt::ClassDef(PyClassDef {
+                name,
+                bases,
+                body,
+                decorators,
+            }) => {
                 let mut bases_ast = Vec::new();
                 let mut keywords_ast = Vec::new();
 

{koatl-0.1.14 → koatl-0.1.15}/koatl/src/lib.rs

@@ -14,7 +14,7 @@ use pyo3::{
 fn get_option(mode: &str) -> PyResult<TranspileOptions> {
     Ok(match mode {
         "module" => TranspileOptions::module(),
-        "prelude" => TranspileOptions::prelude(),
+        "no_prelude" => TranspileOptions::no_prelude(),
         "interactive" => TranspileOptions::interactive(),
         "script" => TranspileOptions::script(),
         _ => {

{koatl-0.1.14 → koatl-0.1.15}/koatl/tests/e2e/base/coal.tl

@@ -1,9 +1,10 @@
 import util.assert_eq
 
-assert_eq(None?(1)?(2), None)
-assert_eq(None?[1]?.a, None)
-assert_eq(None?.a, None)
-assert_eq(None?.(a), None)
+none = None
+assert_eq(none?(1)?(2), None)
+assert_eq(none?[1]?.a, None)
+assert_eq(none?.a, None)
+assert_eq(none?.(a), None)
 
 obj = (class:
     a = 1

{koatl-0.1.14 → koatl-0.1.15}/koatl/tests/e2e/base/if_expr.tl

@@ -10,7 +10,7 @@ assert_eq(a, 1)
 a = if False:
     2 * 4
 else:
-    x = 4 * 8
+    let x = 4 * 8
     x * 2
 
 assert_eq(a, 4 * 8 * 2)

koatl-0.1.15/koatl/tests/e2e/base/scopes.tl

@@ -0,0 +1,49 @@
+import util.assert_eq
+
+test = 1
+if True:
+    test = 2
+    assert_eq(test, 2)
+
+    let test = 3
+    assert_eq(test, 3)
+
+    test = 4
+    assert_eq(test, 4)
+
+assert_eq(test, 2)
+
+f = () =>
+    let test = 5
+    assert_eq(test, 5)
+
+f()
+assert_eq(test, 2)
+
+f = () =>
+    test = 5
+    let g = () =>
+        test = 6
+    g()
+    assert_eq(test, 6)
+
+f()
+
+
+f = () =>
+    test = 5
+    let g = () =>
+        let test = 6
+    g()
+    assert_eq(test, 5)
+
+f()
+
+test = 0
+
+f = test =>
+    test = 1
+    assert_eq(test, 1)
+
+f(1)
+assert_eq(test, 0)

{koatl-0.1.14 → koatl-0.1.15}/koatl/tests/e2e/base/semantic_whitespace.tl

@@ -64,7 +64,7 @@ assert_eq([
 apply = (x, y) => x(y)
 assert_eq(apply(
     x =>
-        y = x * 2
+        let y = x * 2
         y * 2
     8
 ), 8 * 2 * 2)
@@ -72,7 +72,7 @@ assert_eq(apply(
 assert_eq(
     apply(
         x =>
-            y = x * 2
+            let y = x * 2
             y * 2
         8
     )

{koatl-0.1.14 → koatl-0.1.15}/koatl/tests/test_e2e.py

@@ -6,10 +6,9 @@ from pathlib import Path
 sys.path.append(str(Path(__file__).parent / "e2e"))
 
 
-def get_test_data():
+def get_test_data(dirs):
     data_dirs = [
-        Path(__file__).parent / "e2e" / "base",
-        Path(__file__).parent / "e2e" / "prelude",
+        Path(__file__).parent / "e2e" / dirs,
     ]
 
     test_cases = []
@@ -20,13 +19,32 @@ def get_test_data():
     return test_cases
 
 
-@pytest.mark.parametrize("test_file", get_test_data())
-def test_e2e_native_emit(test_file):
+@pytest.mark.parametrize("test_file", get_test_data("base"))
+def test_e2e_native_emit_base(test_file):
+    e2e_native_emit(test_file, "no_prelude")
+
+
+@pytest.mark.parametrize("test_file", get_test_data("prelude"))
+def test_e2e_native_emit_prelude(test_file):
+    e2e_native_emit(test_file, "script")
+
+
+@pytest.mark.parametrize("test_file", get_test_data("base"))
+def test_e2e_base(test_file):
+    e2e(test_file, "no_prelude")
+
+
+@pytest.mark.parametrize("test_file", get_test_data("prelude"))
+def test_e2e_prelude(test_file):
+    e2e(test_file, "script")
+
+
+def e2e_native_emit(test_file, mode):
     import linecache
 
     with open(test_file, "r") as f:
         source = f.read()
-    source, source_map = koatl.transpile_raw(source, mode="script")
+    source, source_map = koatl.transpile_raw(source, mode=mode)
 
     global_dict = {}
 
@@ -46,6 +64,5 @@ def test_e2e_native_emit(test_file):
     print("end", test_file)
 
 
-@pytest.mark.parametrize("test_file", get_test_data())
-def test_e2e(test_file):
-    koatl.cli.run_from_path(test_file, mode="script")
+def e2e(test_file, mode):
+    koatl.cli.run_from_path(test_file, mode=mode)

{koatl-0.1.14 → koatl-0.1.15}/koatl-core/Cargo.toml

@@ -6,3 +6,4 @@ edition = "2024"
 [dependencies]
 ariadne = "0.5.1"
 parser = { path = "parser" }
+once_cell = "1.19.0"

{koatl-0.1.14 → koatl-0.1.15}/koatl-core/parser/Cargo.toml

@@ -4,4 +4,4 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-chumsky = "0.10.1"
+chumsky = { version="0.10.1", features=["memoization"] }

{koatl-0.1.14 → koatl-0.1.15}/koatl-core/parser/src/ast.rs

@@ -1,9 +1,10 @@
-use std::borrow::Cow;
+use std::{borrow::Cow, rc::Rc};
 
 use chumsky::span::SimpleSpan;
 
 pub type Span = SimpleSpan<usize, ()>;
 pub type Spanned<T> = (T, Span);
+pub type Indirect<T> = Rc<T>;
 
 #[derive(Debug, Copy, Clone)]
 pub enum BinaryOp {
@@ -40,7 +41,15 @@ pub enum UnaryOp {
     Bind,
 }
 
-pub type Ident<'a> = Cow<'a, str>;
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+pub struct Ident<'a>(pub Cow<'a, str>);
+
+impl<'a> From<Cow<'a, str>> for Ident<'a> {
+    fn from(value: Cow<'a, str>) -> Self {
+        Ident(value)
+    }
+}
+
 pub type SIdent<'a> = Spanned<Ident<'a>>;
 
 #[derive(Debug, Clone)]
@@ -62,24 +71,26 @@ pub struct ImportStmt<'a> {
 }
 
 #[derive(Debug, Clone, Copy, PartialEq)]
-pub enum AssignModifier {
+pub enum DeclType {
     Export,
     Global,
-    Nonlocal,
+    Let,
+    Const,
 }
 
 // TODO should these be cows
 #[derive(Debug, Clone)]
 pub enum Stmt<'a> {
     Module,
-    Assign(SExpr<'a>, SExpr<'a>, Vec<AssignModifier>),
+    Decl(Vec<SIdent<'a>>, DeclType),
+    Assign(SExpr<'a>, SExpr<'a>, Option<DeclType>),
     Expr(SExpr<'a>),
 
     Return(SExpr<'a>),
     While(SExpr<'a>, SExpr<'a>),
     For(SPattern<'a>, SExpr<'a>, SExpr<'a>),
     Import(ImportStmt<'a>),
-    Try(SExpr<'a>, Vec<MatchCase<'a>>, Option<SExpr<'a>>),
+    Try(SExpr<'a>, Vec<Indirect<MatchCase<'a>>>, Option<SExpr<'a>>),
     Assert(SExpr<'a>, Option<SExpr<'a>>),
     Raise(Option<SExpr<'a>>),
     Break,
@@ -101,7 +112,7 @@ pub type SLiteral<'a> = Spanned<Literal<'a>>;
 
 #[derive(Debug, Clone)]
 pub struct FmtExpr<'a> {
-    pub block: SExpr<'a>,
+    pub expr: SExpr<'a>,
     pub fmt: Option<Ident<'a>>,
 }
 
@@ -132,7 +143,7 @@ pub type SCallItem<'a> = Spanned<CallItem<'a>>;
 
 #[derive(Debug, Clone)]
 pub enum ArgDefItem<'a> {
-    Arg(SPattern<'a>, Option<SExpr<'a>>),
+    Arg(ISPattern<'a>, Option<SExpr<'a>>),
     ArgSpread(SIdent<'a>),
     KwargSpread(SIdent<'a>),
 }
@@ -141,7 +152,7 @@ pub type SArgItem<'a> = Spanned<ArgDefItem<'a>>;
 
 #[derive(Debug, Clone)]
 pub struct MatchCase<'src> {
-    pub pattern: Option<SPattern<'src>>,
+    pub pattern: Option<Indirect<SPattern<'src>>>,
     pub guard: Option<SExpr<'src>>,
     pub body: SExpr<'src>,
 }
@@ -155,41 +166,45 @@ pub enum Expr<'a> {
     List(Vec<ListItem<'a>>),
     Mapping(Vec<MappingItem<'a>>),
     Slice(
-        Option<Box<SExpr<'a>>>,
-        Option<Box<SExpr<'a>>>,
-        Option<Box<SExpr<'a>>>,
+        Option<Indirect<SExpr<'a>>>,
+        Option<Indirect<SExpr<'a>>>,
+        Option<Indirect<SExpr<'a>>>,
     ),
 
-    Unary(UnaryOp, Box<SExpr<'a>>),
-    Binary(BinaryOp, Box<SExpr<'a>>, Box<SExpr<'a>>),
+    Unary(UnaryOp, Indirect<SExpr<'a>>),
+    Binary(BinaryOp, Indirect<SExpr<'a>>, Indirect<SExpr<'a>>),
 
-    Await(Box<SExpr<'a>>),
-    Yield(Box<SExpr<'a>>),
-    YieldFrom(Box<SExpr<'a>>),
+    Await(Indirect<SExpr<'a>>),
+    Yield(Indirect<SExpr<'a>>),
+    YieldFrom(Indirect<SExpr<'a>>),
 
-    If(Box<SExpr<'a>>, Box<SExpr<'a>>, Option<Box<SExpr<'a>>>),
-    Match(Box<SExpr<'a>>, Vec<MatchCase<'a>>),
-    Matches(Box<SExpr<'a>>, Box<SPattern<'a>>),
-    Class(Vec<SCallItem<'a>>, Box<SExpr<'a>>),
+    If(
+        Indirect<SExpr<'a>>,
+        Indirect<SExpr<'a>>,
+        Option<Indirect<SExpr<'a>>>,
+    ),
+    Match(Indirect<SExpr<'a>>, Vec<Indirect<MatchCase<'a>>>),
+    Matches(Indirect<SExpr<'a>>, ISPattern<'a>),
+    Class(Vec<SCallItem<'a>>, Indirect<SExpr<'a>>),
 
-    Call(Box<SExpr<'a>>, Vec<SCallItem<'a>>),
-    Subscript(Box<SExpr<'a>>, Vec<ListItem<'a>>),
-    RawAttribute(Box<SExpr<'a>>, SIdent<'a>),
-    ScopedAttribute(Box<SExpr<'a>>, Box<SExpr<'a>>),
-    Attribute(Box<SExpr<'a>>, SIdent<'a>),
+    Call(Indirect<SExpr<'a>>, Vec<SCallItem<'a>>),
+    Subscript(Indirect<SExpr<'a>>, Vec<ListItem<'a>>),
+    RawAttribute(Indirect<SExpr<'a>>, SIdent<'a>),
+    ScopedAttribute(Indirect<SExpr<'a>>, Indirect<SExpr<'a>>),
+    Attribute(Indirect<SExpr<'a>>, SIdent<'a>),
 
-    MappedCall(Box<SExpr<'a>>, Vec<SCallItem<'a>>),
-    MappedSubscript(Box<SExpr<'a>>, Vec<ListItem<'a>>),
-    MappedRawAttribute(Box<SExpr<'a>>, SIdent<'a>),
-    MappedScopedAttribute(Box<SExpr<'a>>, Box<SExpr<'a>>),
-    MappedAttribute(Box<SExpr<'a>>, SIdent<'a>),
+    MappedCall(Indirect<SExpr<'a>>, Vec<SCallItem<'a>>),
+    MappedSubscript(Indirect<SExpr<'a>>, Vec<ListItem<'a>>),
+    MappedRawAttribute(Indirect<SExpr<'a>>, SIdent<'a>),
+    MappedScopedAttribute(Indirect<SExpr<'a>>, Indirect<SExpr<'a>>),
+    MappedAttribute(Indirect<SExpr<'a>>, SIdent<'a>),
 
-    Checked(Box<SExpr<'a>>, Option<Box<SPattern<'a>>>),
+    Checked(Indirect<SExpr<'a>>, Option<ISPattern<'a>>),
 
-    Fn(Vec<ArgDefItem<'a>>, Box<SExpr<'a>>),
+    Fn(Vec<ArgDefItem<'a>>, Indirect<SExpr<'a>>),
     Fstr(Spanned<String>, Vec<(SFmtExpr<'a>, Spanned<String>)>),
 
-    Decorated(Box<SExpr<'a>>, Box<SExpr<'a>>),
+    Decorated(Indirect<SExpr<'a>>, Indirect<SExpr<'a>>),
 
     Block(Vec<SStmt<'a>>),
 }
@@ -198,29 +213,29 @@ pub type SExpr<'a> = Spanned<Expr<'a>>;
 
 #[derive(Debug, Clone)]
 pub enum PatternSequenceItem<'a> {
-    Item(SPattern<'a>),
+    Item(ISPattern<'a>),
     Spread(Option<SIdent<'a>>),
 }
 
 #[derive(Debug, Clone)]
 pub enum PatternMappingItem<'a> {
     Ident(SIdent<'a>),
-    Item(SExpr<'a>, SPattern<'a>),
+    Item(SExpr<'a>, ISPattern<'a>),
     Spread(Option<SIdent<'a>>),
 }
 
 #[derive(Debug, Clone)]
 pub enum PatternClassItem<'a> {
-    Item(SPattern<'a>),
-    Kw(SIdent<'a>, SPattern<'a>),
+    Item(ISPattern<'a>),
+    Kw(SIdent<'a>, ISPattern<'a>),
 }
 
 #[derive(Debug, Clone)]
 pub enum Pattern<'a> {
     Capture(Option<SIdent<'a>>),
     Value(SExpr<'a>),
-    As(Box<SPattern<'a>>, SIdent<'a>),
-    Or(Vec<SPattern<'a>>),
+    As(ISPattern<'a>, SIdent<'a>),
+    Or(Vec<ISPattern<'a>>),
     Literal(SLiteral<'a>),
     Sequence(Vec<PatternSequenceItem<'a>>),
     Mapping(Vec<PatternMappingItem<'a>>),
@@ -228,3 +243,4 @@ pub enum Pattern<'a> {
 }
 
 pub type SPattern<'a> = Spanned<Pattern<'a>>;
+pub type ISPattern<'a> = Indirect<SPattern<'a>>;

{koatl-0.1.14 → koatl-0.1.15}/koatl-core/parser/src/lexer.rs

@@ -139,8 +139,8 @@ where
     fn new(input: &'input mut InputRef<'src, 'parse, TInput, TExtra<'src>>) -> Self {
         static KEYWORDS: &[&str] = &[
             "match", "if", "then", "else", "import", "export", "as", "class", "while", "for", "in",
-            "break", "continue", "with", "yield", "global", "nonlocal", "return", "raise", "try",
-            "except", "finally", "and", "or", "not", "await",
+            "break", "continue", "with", "yield", "global", "return", "raise", "try", "except",
+            "finally", "and", "or", "not", "await", "let", "const",
         ];
 
         let keywords = HashSet::<String>::from_iter(KEYWORDS.iter().map(|s| s.to_string()));