koatl 0.1.25__tar.gz → 0.1.26__tar.gz

{koatl-0.1.25 → koatl-0.1.26}/Cargo.lock

@@ -99,7 +99,7 @@ checksum = "f4c7245a08504955605670dbf141fceab975f15ca21570696aebe9d2e71576bd"
 
 [[package]]
 name = "koatl"
-version = "0.1.25"
+version = "0.1.26"
 dependencies = [
  "ariadne",
  "koatl-core",

{koatl-0.1.25 → koatl-0.1.26}/PKG-INFO

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

{koatl-0.1.25 → koatl-0.1.26}/koatl/Cargo.toml

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

{koatl-0.1.25 → koatl-0.1.26}/koatl/python/koatl/prelude/functional/__init__.tl

@@ -1,4 +1,4 @@
-export import .monad.*
+export import .algebra.*
 export import .result.*
 export import .async.*
 export import .reader.*

koatl-0.1.26/koatl/python/koatl/prelude/functional/algebra.tl

@@ -0,0 +1,46 @@
+import abc
+
+export Monad = class(abc.ABC):
+    """
+    Abstract base class for monads.
+
+    Subclasses must implement `bind` and `pure`.
+    Automatically provides standard monadic operations: bind_once, map, and apply.
+    """
+    __slots__ = ()
+
+    bind = abc.abstractmethod& (self, f) => None
+
+    pure = staticmethod& abc.abstractmethod& value => None
+
+    # Automatically generated implementations.
+    map = (self, f) => self.bind(x => self.pure(f(x)))
+    apply = (self, f) => self.bind(x => f.map(fn => fn(x)))
+
+
+# TODO: should this inherit from Monad?
+export MonadOnce = class(abc.ABC):
+    """
+    Abstract base class for single-use monads.
+
+    A MonadOnce can only be bound once, which is suitable for
+    use with Python generators that cannot be cloned or reused.
+
+    Subclasses must implement `bind_once` and `pure`.
+    Automatically provides (likely suboptimal) standard monadic operations: bind, map, and apply.
+    """
+    __slots__ = ()
+
+    # The default implementation required for `@` syntax that should be overridden by subclasses.
+    bind_once = abc.abstractmethod& (self, f) => None
+
+    pure = staticmethod& abc.abstractmethod& value => None
+
+    # An optional, optimized implementation of `bind` that skips deep recursion.
+    # TODO: can this be automatically generated from bind_once?
+    # bind_gen = (self, gen) => ...
+
+    # Automatically generated implementations.
+    bind = (self, f) => self.bind_once(f)
+    map = (self, f) => self.bind(x => self.pure(f(x)))
+    apply = (self, f) => self.bind(x => f.map(fn => fn(x)))

{koatl-0.1.25 → koatl-0.1.26}/koatl/python/koatl/prelude/functional/async.tl

@@ -2,9 +2,9 @@ import functools.wraps
 import asyncio
 
 import .async_util
-import .monad.Monad
+import .MonadOnce
 
-export Async = class(Monad):
+export Async = class(MonadOnce):
     __init__ = (self, awaitable) => self.generator = awaitable.__await__()
 
     __await__ = self => self.generator
@@ -39,5 +39,5 @@ export Async = class(Monad):
 
     sleep = staticmethod& x => Async(asyncio.sleep(x))
 
-    #- TODO: Why is asyncio.gather eager? -#
+    # TODO: Why is asyncio.gather eager?
     gather = staticmethod& (*args) => Async.from_generator_fn& () => yield from asyncio.gather(*args)

{koatl-0.1.25 → koatl-0.1.26/koatl}/python/koatl/prelude/functional/list.tl

@@ -1,7 +1,7 @@
 import collections.UserList
 import itertools
 
-import .monad.Monad
+import .Monad
 import ..iterable.Iterable
 
 export List = class(UserList, Monad):

{koatl-0.1.25 → koatl-0.1.26}/koatl/python/koatl/prelude/functional/memo.tl

@@ -1,18 +1,16 @@
 import collections.defaultdict
 import functools.wraps
 import .result.(Result, Ok)
-import .Monad
+import .MonadOnce
 
-export Memo = class(Monad):
+export Memo = class(MonadOnce):
     Cache = class:
         __init__ = self =>
             self.cache = defaultdict(dict)
 
         __repr__ = self => f"Memo.Cache({self.cache})"
 
-        try_get = (self, name, deps) =>
-            # TODO should try operator return a Result directly?
-            Result(try self.cache[name][deps] except KeyError())
+        try_get = (self, name, deps) => try self.cache[name][deps] except KeyError()
 
         update = (self, name, deps, value) =>
             self.cache[name][deps] = value

{koatl-0.1.25 → koatl-0.1.26/koatl}/python/koatl/prelude/functional/reader.tl

@@ -1,7 +1,7 @@
 import functools.wraps
-import .monad.Monad
+import .MonadOnce
 
-export Reader = class(Monad):
+export Reader = class(MonadOnce):
     __init__ = (self, fn) => self.fn = fn
 
     __repr__ = self => "Reader(...)"

{koatl-0.1.25 → koatl-0.1.26/koatl}/python/koatl/prelude/functional/result.tl

@@ -1,8 +1,8 @@
 import functools.wraps
-import .monad.Monad
 import koatl.runtime.virtual.register_global_attr
+import .algebra.MonadOnce
 
-export Result = class:
+export Result = class(MonadOnce):
     __slots__ = ()
     __match_args__ = ("value",)
 

{koatl-0.1.25 → koatl-0.1.26/koatl}/python/koatl/runtime/virtual.py

@@ -1,3 +1,4 @@
+import abc
 from functools import partial
 from itertools import count
 from types import new_class
@@ -105,7 +106,7 @@ def Trait(module, name, methods, *, requires=[]):
 
     meta = type(
         f"{name}Meta",
-        (type,),
+        (abc.ABCMeta,),
         {"__instancecheck__": instancecheck, "__module__": "types"},
     )
 

{koatl-0.1.25 → koatl-0.1.26}/koatl-core/parser/src/parser.rs

@@ -210,7 +210,6 @@ where
             if items.len() == 1 && last_comma.is_none() {
                 let item = items.into_iter().next().unwrap();
                 if let PatternSequenceItem::Item(inner) = item {
-                    // TODO ???
                     inner.extract()
                 } else {
                     Pattern::Sequence(vec![item]).spanned(e.span())

{koatl-0.1.25 → koatl-0.1.26}/koatl-core/src/py/emit.rs

@@ -456,21 +456,18 @@ impl SPyExpr<'_> {
                 ctx.emit("]");
             }
             PyExpr::Yield(expr) => {
-                set_prec(-0.5);
                 ctx.emit("(");
                 ctx.emit("yield ");
                 expr.emit_to(ctx, LOW_PREC)?;
                 ctx.emit(")");
             }
             PyExpr::Await(expr) => {
-                set_prec(-0.5);
-                ctx.emit_indent();
+                ctx.emit("(");
                 ctx.emit("await ");
                 expr.emit_to(ctx, LOW_PREC)?;
-                ctx.emit_endl();
+                ctx.emit(")");
             }
             PyExpr::YieldFrom(expr) => {
-                set_prec(-0.5); // TODO is this precedence correct?
                 ctx.emit("(");
                 ctx.emit("yield from ");
                 expr.emit_to(ctx, LOW_PREC)?;
@@ -511,7 +508,6 @@ impl SPyExpr<'_> {
                 }
             }
             PyExpr::IfExpr(cond, if_, else_) => {
-                // TODO precedence here?
                 ctx.emit("(");
                 if_.emit_to(ctx, LOW_PREC)?;
                 ctx.emit(" if ");

{koatl-0.1.25 → koatl-0.1.26}/koatl-core/src/resolve_scopes.rs

@@ -2,7 +2,6 @@ use std::collections::HashMap;
 use std::collections::HashSet;
 use std::fmt::Display;
 
-use slotmap::Key;
 use slotmap::SlotMap;
 use slotmap::new_key_type;
 
@@ -82,10 +81,10 @@ fn top_scope_and_key<'src, 'state>(
 #[allow(dead_code)]
 impl<'src> ResolveState<'src> {
     fn new(source: &'src str) -> Self {
-        let mut root_scope = Scope::new(ScopeKey::null());
+        let mut root_scope = Scope::new(None);
         root_scope.is_global = true;
 
-        let err_scope = Scope::new(ScopeKey::null());
+        let err_scope = Scope::new(None);
 
         let mut scopes = SlotMap::with_key();
         let root_scope_key = scopes.insert(root_scope);
@@ -203,7 +202,7 @@ impl<'src> ResolveState<'src> {
     where
         F: FnOnce(&mut ResolveState<'src>) -> Indirect<SExpr<'src>>,
     {
-        let mut dummy_scope = Scope::new(ScopeKey::null());
+        let mut dummy_scope = Scope::new(None);
         dummy_scope.is_fn = true;
 
         let temp_scope_key = self.scopes.insert(dummy_scope);
@@ -480,8 +479,7 @@ impl Display for Declaration<'_> {
 
 #[derive(Debug)]
 pub struct Scope {
-    // TODO make this option
-    pub parent: ScopeKey,
+    pub parent: Option<ScopeKey>,
 
     pub locals: Vec<DeclarationKey>,
 
@@ -511,7 +509,7 @@ impl Display for Scope {
 }
 
 impl Scope {
-    fn new(parent: ScopeKey) -> Scope {
+    fn new(parent: Option<ScopeKey>) -> Scope {
         Self {
             parent,
             locals: Vec::new(),
@@ -821,7 +819,7 @@ fn pattern_scoped<'src>(
     state: &mut ResolveState<'src>,
     pattern: Indirect<SPattern<'src>>,
 ) -> (Indirect<SPattern<'src>>, ScopeKey, PatternMeta<'src>) {
-    let scope = Scope::new(state.top_scope_key());
+    let scope = Scope::new(Some(state.top_scope_key()));
     let scope_key = state.scopes.insert(scope);
 
     let (pattern, meta) = pattern.traverse(state);
@@ -996,7 +994,7 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
                     new_stmts
                 } else {
                     let parent = state.top_scope_key();
-                    let scope = state.scopes.insert(Scope::new(parent));
+                    let scope = state.scopes.insert(Scope::new(Some(parent)));
                     state
                         .scoped(scope, |state| {
                             let mut new_stmts = Vec::new();
@@ -1091,7 +1089,7 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
                             (Some(pattern), scope)
                         } else {
                             let parent = state.top_scope_key();
-                            (None, state.scopes.insert(Scope::new(parent)))
+                            (None, state.scopes.insert(Scope::new(Some(parent))))
                         };
 
                         SMatchCase {
@@ -1109,7 +1107,7 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
             Expr::Class(bases, body) => {
                 let bases = traverse_call_items(state, bases);
 
-                let mut scope = Scope::new(state.top_scope_key());
+                let mut scope = Scope::new(Some(state.top_scope_key()));
                 scope.is_class = true;
                 let scope = state.scopes.insert(scope);
 
@@ -1122,7 +1120,7 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
             Expr::Fn(arg_def_items, body) => {
                 let mut decls = vec![];
 
-                let mut scope = Scope::new(state.top_scope_key());
+                let mut scope = Scope::new(Some(state.top_scope_key()));
                 scope.is_fn = true;
                 let scope = state.scopes.insert(scope);
 
@@ -1402,7 +1400,7 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
             Expr::Memo(inner) => {
                 state.set_do(span);
 
-                let mut scope = Scope::new(state.top_scope_key());
+                let mut scope = Scope::new(Some(state.top_scope_key()));
                 // TODO it's confusing that we need to
                 // set scope.is_fn = true all the time in order
                 // for captures to be found properly.
@@ -1574,7 +1572,7 @@ impl<'src> SStmtExt<'src> for Indirect<SStmt<'src>> {
                             (Some(pattern), scope)
                         } else {
                             let parent = state.top_scope_key();
-                            (None, state.scopes.insert(Scope::new(parent)))
+                            (None, state.scopes.insert(Scope::new(Some(parent))))
                         };
 
                         let body = state
@@ -1612,7 +1610,8 @@ impl<'src> SStmtExt<'src> for Indirect<SStmt<'src>> {
 
                 match &import_stmt.imports {
                     ImportList::Star => {
-                        // TODO
+                        // TODO can this be improved?
+
                         let base_module = import_stmt
                             .trunk
                             .iter()

{koatl-0.1.25 → koatl-0.1.26}/koatl-core/src/transform.rs

@@ -14,7 +14,7 @@ use crate::{
 };
 use once_cell::sync::Lazy;
 use parser::ast::*;
-use slotmap::{Key, SlotMap};
+use slotmap::SlotMap;
 use std::hash::{Hash, Hasher};
 
 static PY_KWS: &[&str] = &[
@@ -845,9 +845,6 @@ impl<'src, 'ast> SPatternExt<'src, 'ast> for SPattern<'src> {
         ctx: &mut TlCtx<'src, 'ast>,
         info: &PatternInfo,
     ) -> TlResult<WithPre<'src, SPyPattern<'src>>> {
-        // TODO avoid python syntaxerror by verifying that all branches in Or bind the same name
-        // also check for no patterns after default pattern
-
         let mut pre = PyBlock::new();
 
         let pattern = &self.value;
@@ -2322,7 +2319,6 @@ impl<'src, 'ast> SExprExt<'src, 'ast> for SExpr<'src> {
 
                 let memo_call = a.call(
                     if memo_captures.is_do {
-                        // TODO is there any better solution?
                         a.tl_builtin("bind_memo_value")
                     } else {
                         a.tl_builtin("memo_value")
@@ -2478,14 +2474,15 @@ fn py_fn_bindings<'src, 'ast>(
     for capture in memo_captures.captures.iter() {
         let mut scope = &ctx.scopes[ctx.declarations[*capture].scope];
         loop {
-            if scope.parent.is_null() {
+            let Some(parent) = scope.parent else {
                 break;
-            }
+            };
 
             if scope.is_fn || scope.is_class || scope.is_global {
                 break;
             }
-            scope = &ctx.scopes[scope.parent];
+
+            scope = &ctx.scopes[parent];
         }
 
         if scope.is_global || scope.is_class {

{koatl-0.1.25 → koatl-0.1.26}/python/koatl/prelude/functional/__init__.tl

@@ -1,4 +1,4 @@
-export import .monad.*
+export import .algebra.*
 export import .result.*
 export import .async.*
 export import .reader.*

koatl-0.1.26/python/koatl/prelude/functional/algebra.tl

@@ -0,0 +1,46 @@
+import abc
+
+export Monad = class(abc.ABC):
+    """
+    Abstract base class for monads.
+
+    Subclasses must implement `bind` and `pure`.
+    Automatically provides standard monadic operations: bind_once, map, and apply.
+    """
+    __slots__ = ()
+
+    bind = abc.abstractmethod& (self, f) => None
+
+    pure = staticmethod& abc.abstractmethod& value => None
+
+    # Automatically generated implementations.
+    map = (self, f) => self.bind(x => self.pure(f(x)))
+    apply = (self, f) => self.bind(x => f.map(fn => fn(x)))
+
+
+# TODO: should this inherit from Monad?
+export MonadOnce = class(abc.ABC):
+    """
+    Abstract base class for single-use monads.
+
+    A MonadOnce can only be bound once, which is suitable for
+    use with Python generators that cannot be cloned or reused.
+
+    Subclasses must implement `bind_once` and `pure`.
+    Automatically provides (likely suboptimal) standard monadic operations: bind, map, and apply.
+    """
+    __slots__ = ()
+
+    # The default implementation required for `@` syntax that should be overridden by subclasses.
+    bind_once = abc.abstractmethod& (self, f) => None
+
+    pure = staticmethod& abc.abstractmethod& value => None
+
+    # An optional, optimized implementation of `bind` that skips deep recursion.
+    # TODO: can this be automatically generated from bind_once?
+    # bind_gen = (self, gen) => ...
+
+    # Automatically generated implementations.
+    bind = (self, f) => self.bind_once(f)
+    map = (self, f) => self.bind(x => self.pure(f(x)))
+    apply = (self, f) => self.bind(x => f.map(fn => fn(x)))

{koatl-0.1.25 → koatl-0.1.26}/python/koatl/prelude/functional/async.tl

@@ -2,9 +2,9 @@ import functools.wraps
 import asyncio
 
 import .async_util
-import .monad.Monad
+import .MonadOnce
 
-export Async = class(Monad):
+export Async = class(MonadOnce):
     __init__ = (self, awaitable) => self.generator = awaitable.__await__()
 
     __await__ = self => self.generator
@@ -39,5 +39,5 @@ export Async = class(Monad):
 
     sleep = staticmethod& x => Async(asyncio.sleep(x))
 
-    #- TODO: Why is asyncio.gather eager? -#
+    # TODO: Why is asyncio.gather eager?
     gather = staticmethod& (*args) => Async.from_generator_fn& () => yield from asyncio.gather(*args)

{koatl-0.1.25/koatl → koatl-0.1.26}/python/koatl/prelude/functional/list.tl

@@ -1,7 +1,7 @@
 import collections.UserList
 import itertools
 
-import .monad.Monad
+import .Monad
 import ..iterable.Iterable
 
 export List = class(UserList, Monad):

{koatl-0.1.25 → koatl-0.1.26}/python/koatl/prelude/functional/memo.tl

@@ -1,18 +1,16 @@
 import collections.defaultdict
 import functools.wraps
 import .result.(Result, Ok)
-import .Monad
+import .MonadOnce
 
-export Memo = class(Monad):
+export Memo = class(MonadOnce):
     Cache = class:
         __init__ = self =>
             self.cache = defaultdict(dict)
 
         __repr__ = self => f"Memo.Cache({self.cache})"
 
-        try_get = (self, name, deps) =>
-            # TODO should try operator return a Result directly?
-            Result(try self.cache[name][deps] except KeyError())
+        try_get = (self, name, deps) => try self.cache[name][deps] except KeyError()
 
         update = (self, name, deps, value) =>
             self.cache[name][deps] = value

{koatl-0.1.25/koatl → koatl-0.1.26}/python/koatl/prelude/functional/reader.tl

@@ -1,7 +1,7 @@
 import functools.wraps
-import .monad.Monad
+import .MonadOnce
 
-export Reader = class(Monad):
+export Reader = class(MonadOnce):
     __init__ = (self, fn) => self.fn = fn
 
     __repr__ = self => "Reader(...)"

{koatl-0.1.25/koatl → koatl-0.1.26}/python/koatl/prelude/functional/result.tl

@@ -1,8 +1,8 @@
 import functools.wraps
-import .monad.Monad
 import koatl.runtime.virtual.register_global_attr
+import .algebra.MonadOnce
 
-export Result = class:
+export Result = class(MonadOnce):
     __slots__ = ()
     __match_args__ = ("value",)
 

{koatl-0.1.25/koatl → koatl-0.1.26}/python/koatl/runtime/virtual.py

@@ -1,3 +1,4 @@
+import abc
 from functools import partial
 from itertools import count
 from types import new_class
@@ -105,7 +106,7 @@ def Trait(module, name, methods, *, requires=[]):
 
     meta = type(
         f"{name}Meta",
-        (type,),
+        (abc.ABCMeta,),
         {"__instancecheck__": instancecheck, "__module__": "types"},
     )
 

koatl-0.1.25/koatl/python/koatl/prelude/functional/monad.tl

@@ -1,21 +0,0 @@
-import abc
-
-# TODO: this should be really called MonadOnce.
-export Monad = class(abc.ABC):
-    __slots__ = ()
-
-    # The default implementation required for `@` syntax that should be overridden by subclasses.
-    bind_once = abc.abstractmethod& (self, f) => None
-
-    pure = staticmethod& abc.abstractmethod& value => None
-
-    # Automatically given by bind_once.
-    bind = (self, f) => self.bind_once(f)
-
-    # An optional, optimized implementation of `bind` that skips deep recursion.
-    # TODO: can this be automatically generated?
-    # bind_gen = (self, gen) => ...
-
-    # Automatically generated implementations.
-    map = (self, f) => self.bind(x => self.pure(f(x)))
-    apply = (self, f) => self.bind(x => f.map(fn => fn(x)))

koatl-0.1.25/python/koatl/prelude/functional/monad.tl

@@ -1,21 +0,0 @@
-import abc
-
-# TODO: this should be really called MonadOnce.
-export Monad = class(abc.ABC):
-    __slots__ = ()
-
-    # The default implementation required for `@` syntax that should be overridden by subclasses.
-    bind_once = abc.abstractmethod& (self, f) => None
-
-    pure = staticmethod& abc.abstractmethod& value => None
-
-    # Automatically given by bind_once.
-    bind = (self, f) => self.bind_once(f)
-
-    # An optional, optimized implementation of `bind` that skips deep recursion.
-    # TODO: can this be automatically generated?
-    # bind_gen = (self, gen) => ...
-
-    # Automatically generated implementations.
-    map = (self, f) => self.bind(x => self.pure(f(x)))
-    apply = (self, f) => self.bind(x => f.map(fn => fn(x)))