koatl 0.1.21__tar.gz → 0.1.23__tar.gz

{koatl-0.1.21 → koatl-0.1.23}/Cargo.lock

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

{koatl-0.1.21 → koatl-0.1.23}/PKG-INFO

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

{koatl-0.1.21 → koatl-0.1.23}/koatl/Cargo.toml

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

{koatl-0.1.21 → koatl-0.1.23}/koatl/python/koatl/prelude/functional/__init__.tl

@@ -3,9 +3,17 @@ export import .result.*
 export import .async.*
 export import .reader.*
 export import .memo.*
+export import .list.*
 
-export Fn = class:
-    compose = staticmethod& (*args) =>
+named = name => fn =>
+    fn.__name__ = name
+    fn.__qualname__ = name
+    fn
+
+methods = {
+    id: named("id")& x => x
+
+    compose: named("compose")& (*args) =>
         args match:
             [] => raise ValueError("At least one function is required for composition")
             [f] => f
@@ -21,4 +29,9 @@ export Fn = class:
                 composed.signature = fs[-1].signature
 
                 composed
-            default raise ValueError("Invalid arguments for Fn.compose()")
+            default raise ValueError("Invalid arguments for Fn.compose()")
+}
+
+globals().update(methods)
+
+__all__ = methods.keys() | tuple

koatl-0.1.23/koatl/python/koatl/prelude/functional/list.tl

@@ -0,0 +1,26 @@
+import collections.UserList
+import itertools
+
+import .monad.Monad
+import ..iterable.Iterable
+
+export List = class(UserList, Monad):
+    bind_once = (self, f) =>
+        raise NotImplementedError(
+            "Binding List in a do-block doesn't work in Koatl " +
+                "due to generator limitations. " +
+                "Wrap in Ok to use the regular Result monad."
+        )
+
+    bind = (self, f) => List(self.flat_map(f))
+
+    pure = staticmethod& x => [x]
+
+    traverse = Iterable.traverse
+
+
+for name, method in List.__dict__:
+    if name.startswith("_"):
+        continue
+
+    register_global_attr(list, name, method)

{koatl-0.1.21 → koatl-0.1.23}/koatl/python/koatl/prelude/functional/monad.tl

@@ -1,12 +1,18 @@
 import abc
 
 export Monad = class(abc.ABC):
+    # 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) => raise NotImplementedError()
 
-    # 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 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.21 → koatl-0.1.23/koatl}/python/koatl/prelude/functional/result.tl

@@ -8,6 +8,8 @@ export Result = class(Monad):
         Ok() => f(self)
         default => self
 
+    bind = bind_once
+
     bind_gen = (self, gen) =>
         try:
             while True:
@@ -23,6 +25,28 @@ export Result = class(Monad):
                 return Ok(None)
             return value
 
+    pure = staticmethod& x => Ok(x)
+
+    apply = (self, f) =>
+        if not __tl__.ok(self):
+            return self
+        if not __tl__.ok(f):
+            return f
+
+        # unwrap the Oks - this is a bit weird
+        # but it allows bare types to be Results
+        if self matches Ok(value):
+            self = self.value
+        if f matches Ok(value):
+            f = f.value
+
+        f(self)
+
+    # Map must not be defined since it will override any special map
+    # implementation for traits, specifically for Iterable -
+    # is there a better way around this (in the vtable implementation)?
+    # map = ...
+
     map_err = (self, f) =>
         if self matches Err():
             return f(self)
@@ -44,50 +68,23 @@ export Ok = class(metaclass=OkMeta):
     __init__ = (self, value) =>
         self.value = value
 
-    # Since we are using a custom metaclass, we can't derive from Result
-    # so need to copy the methods over manually from Result
-
-    # We could just use the object fallback methods, but this avoids
-    # the manual __tl__.vget so is slightly faster
-    bind_once = Result.bind_once
-    bind_gen = Result.bind_gen
-    map_err = Result.map_err
-    map_none = Result.map_none
-
     assert = staticmethod& value =>
         value match:
             BaseException() as e => raise e
             None => raise ValueError("Expected a value, got None")
             default value
 
-export Err = BaseException
-
-register_global_attr(
-    object,
-    "map_err",
-    Result.map_err
-)
-
-register_global_attr(
-    object,
-    "map_none",
-    Result.map_none
-)
-
-register_global_attr(
-    object,
-    "bind",
-    Result.bind_once
-)
-
-register_global_attr(
-    object,
-    "bind_once",
-    Result.bind_once
-)
-
-register_global_attr(
-    object,
-    "bind_gen",
-    Result.bind_gen
-)
+
+# Since we are using a custom metaclass, we can't derive from Result
+# so need to copy the methods over manually from Result
+
+# We could just use the object fallback methods, but this avoids
+# the vget so is slightly faster
+for name, method in Result.__dict__:
+    if name.startswith("_"):
+        continue
+
+    setattr(Ok, name, method)
+    register_global_attr(object, name, method)
+
+export Err = BaseException

koatl-0.1.23/koatl/python/koatl/prelude/iterable.tl

@@ -0,0 +1,83 @@
+import itertools
+import builtins
+
+methods = {
+    map: (x, f) => builtins.map(f, x.iter)
+
+    filter: (x, f) => builtins.filter(f, x.iter)
+
+    flat_map: (x, f) => itertools.chain.from_iterable(x.map(f))
+
+    traverse: (x, f) =>
+        let it = x.iter
+        let v
+        try:
+            v = next(it)
+        except StopIteration():
+            return []
+
+        let m = f(v)
+
+        if not hasattr(m, "apply"):
+            # special case for bare types - slightly more efficient
+            # ...also required since bare types don't have .map
+            if not __tl__.ok(m):
+                return m
+
+            let acc = [m]
+            for v in it:
+                let fv = f(v)
+                if not __tl__.ok(fv):
+                    return fv
+                acc.append(fv)
+            return acc
+
+        let acc = m.map([$])
+        for v in it:
+            m = f(v)
+            # acc = liftA2((list, value) => [*list, value])(acc, f(v))
+            acc = acc.apply(m.map(x => acc => [*acc, x]))
+        acc
+
+    fold: (x, init, f) =>
+        let acc = init
+        for i in x:
+            acc = f(acc, i)
+        acc
+
+    first: (x, f) =>
+        for i in x:
+            if f(i):
+                return i
+        return None
+
+    last: (x, f) =>
+        let result = None
+        for i in x:
+            if f(i):
+                result = i
+        return result
+
+    at: (x, index) =>
+        for i in x:
+            if i == index:
+                return i
+        raise IndexError("Index out of range")
+
+    sum: x =>
+        let acc = 0
+        for i in x:
+            acc = acc + i
+        acc
+
+    list: x =>
+        list(x.iter)
+
+    record: x =>
+        Record(x.iter)
+}
+
+# TODO merge this with typing.Iterable?
+
+export Iterable = Trait(__name__, "Iterable", methods, requires=["iter"])
+register_global_trait(Iterable)

{koatl-0.1.21 → koatl-0.1.23}/koatl/python/koatl/runtime/helpers.py

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

{koatl-0.1.21 → koatl-0.1.23}/koatl/python/koatl/runtime/virtual.py

@@ -9,7 +9,7 @@ def ExtensionProperty(f):
     return f
 
 
-def vget(obj, name):
+def vget(obj, name, ignore_traits=False):
     try:
         return getattr(obj, name)
     except:
@@ -34,7 +34,7 @@ def vget(obj, name):
             except TypeError:
                 pass
 
-        v = fast_vget(obj, name)
+        v = fast_vget(obj, name, ignore_traits)
         if v is not None:
             if hasattr(v, "ext_prop"):
                 return v(obj)

{koatl-0.1.21 → koatl-0.1.23}/koatl/src/lib.rs

@@ -79,27 +79,42 @@ struct TraitAttr {
 static VTBL2: Lazy<Mutex<HashMap<String, Vec<TraitAttr>>>> =
     Lazy::new(|| Mutex::new(HashMap::new()));
 
-#[pyfunction(signature=(obj, name))]
+#[pyfunction(signature=(obj, name, ignore_traits))]
 fn fast_vget<'py, 'ptr>(
     obj: &'ptr Bound<'py, PyAny>,
     name: &'ptr Bound<'py, PyString>,
+    ignore_traits: bool,
 ) -> PyResult<PyObject> {
     let name = name.to_string();
 
     let py = obj.py();
 
-    let vtbl = VTBL.lock().unwrap();
+    {
+        // This block is necessary to ensure the lock is released
+        // before we possibly re-enter fast_vget through __tl__.vget below.
 
-    if let Some(types) = vtbl.get(&name) {
-        let mro = obj.get_type().mro();
+        let vtbl = VTBL.lock().unwrap();
 
-        for typ in mro {
-            if let Some(attr) = types.get(&(typ.as_ptr() as usize)) {
-                return Ok((*attr).clone_ref(py));
+        if let Some(types) = vtbl.get(&name) {
+            let mro = obj.get_type().mro();
+
+            for typ in mro {
+                if let Some(attr) = types.get(&(typ.as_ptr() as usize)) {
+                    return Ok((*attr).clone_ref(py));
+                }
             }
         }
     }
 
+    if ignore_traits {
+        // This prevents a deadlock from fast_vget being called
+        // *again* from inside __tl_.vget while vtbl2 is locked.
+
+        // Also, prevents a trait from being dependent on other traits,
+        // which might cause an infinite loop sometimes.
+        return Ok(py.None().into_any());
+    }
+
     let vtbl2 = VTBL2.lock().unwrap();
 
     if let Some(traits) = vtbl2.get(&name) {
@@ -109,7 +124,7 @@ fn fast_vget<'py, 'ptr>(
         for t in traits {
             let mut ok = true;
             for r in t.requirements.iter() {
-                if vget.call1((obj, r)).is_err() {
+                if vget.call1((obj, r, true)).is_err() {
                     ok = false;
                     break;
                 }

koatl-0.1.23/koatl/tests/e2e/prelude/list.tl

@@ -0,0 +1,18 @@
+import util.assert_eq
+
+# Traverse makes sure that apply and map implementations are correct.
+
+assert_eq(
+    [1, 2, 3].traverse(x => @Async.pure(x)).run() # run in a new event loop
+    [1, 2, 3]
+)
+
+assert_eq(
+    [1, 2, 3].traverse(x => x + 1)
+    [2, 3, 4]
+)
+
+assert_eq(
+    [1, 2, 3].traverse(x => None)
+    None
+)

{koatl-0.1.21 → koatl-0.1.23}/koatl-core/parser/src/parser.rs

@@ -640,7 +640,17 @@ where
         .or_not()
         .then_ignore(just(Token::Kw("import")))
         .then(group((
-            symbol(".").repeated().count(),
+            // TODO this looks extremely cursed
+            symbol("..")
+                .to(2)
+                .repeated()
+                .foldr(
+                    symbol(".")
+                        .or_not()
+                        .map(|x| if x.is_some() { 1 } else { 0 }),
+                    |acc, sum| acc + sum,
+                )
+                .boxed(),
             ident
                 .clone()
                 .then_ignore(symbol("."))

{koatl-0.1.21 → koatl-0.1.23}/koatl-core/src/resolve_scopes.rs

@@ -213,13 +213,6 @@ impl<'src> ResolveState<'src> {
         let placeholder_ctx = self.placeholder_stack.pop().unwrap();
 
         if placeholder_ctx.activated {
-            if ph_fn_ctx.is_async || ph_fn_ctx.is_generator || ph_fn_ctx.is_do {
-                self.errors.extend(simple_err(
-                    "Await, bind, and yield are not allowed in placeholder functions",
-                    placeholder_ctx.span,
-                ));
-            }
-
             ph_fn_ctx.is_placeholder = true;
 
             ph_fn_ctx.arg_names.push(placeholder_ctx.arg_decl);
@@ -1323,13 +1316,6 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
 
                 let fn_ctx = state.fn_stack.pop().unwrap();
 
-                if fn_ctx.is_async || fn_ctx.is_generator || fn_ctx.is_do {
-                    state.errors.extend(simple_err(
-                        "Memo expressions cannot be async, generator, or do",
-                        span,
-                    ));
-                }
-
                 state.memo_captures.insert(inner.as_ref().into(), fn_ctx);
 
                 Expr::Memo(inner)

{koatl-0.1.21 → koatl-0.1.23}/koatl-core/src/transform.rs

@@ -15,6 +15,7 @@ use crate::{
 use once_cell::sync::Lazy;
 use parser::ast::*;
 use slotmap::SlotMap;
+use std::hash::{Hash, Hasher};
 
 static PY_KWS: &[&str] = &[
     "and", "as", "assert", "break", "class", "continue", "def", "del", "elif", "else", "except",
@@ -2279,20 +2280,26 @@ impl<'src, 'ast> SExprExt<'src, 'ast> for SExpr<'src> {
 
                 let callback = pre.bind(make_fn_exp(
                     ctx,
-                    FnDef::PyFnDef(vec![], py_body, false, false),
+                    FnDef::PyFnDef(vec![], py_body, memo_captures.is_do, memo_captures.is_async),
                     &span,
                 )?);
 
                 let linecol = ctx.line_cache.linecol(span.start);
 
-                a.yield_(a.call(
+                let memo_call = a.call(
                     a.tl_builtin("memo"),
                     vec![
-                        PyCallItem::Arg(
-                            a.str(
-                                format!("{}:{}:{}", ctx.filename, linecol.0, linecol.1)
-                            )
-                        ),
+                        PyCallItem::Arg(a.str(format!(
+                            "{}:{}:{}:{:08x}",
+                            ctx.filename,
+                            linecol.0,
+                            linecol.1,
+                            {
+                                let mut hasher = std::collections::hash_map::DefaultHasher::new();
+                                ctx.source[span.start..span.end].hash(&mut hasher);
+                                hasher.finish() as u32
+                            }
+                        ))),
                         PyCallItem::Arg(
                             a.tuple(
                                 nonlocals
@@ -2304,7 +2311,14 @@ impl<'src, 'ast> SExprExt<'src, 'ast> for SExpr<'src> {
                         ),
                         PyCallItem::Arg(callback),
                     ],
-                ))
+                );
+
+                if memo_captures.is_do {
+                    // TODO should we really automatically bind a monadic expression for convenience?
+                    a.yield_(a.yield_(memo_call))
+                } else {
+                    a.yield_(memo_call)
+                }
             }
             Expr::Await(expr) => a.await_(pre.bind(expr.transform(ctx)?)),
             Expr::Yield(expr) => a.yield_(pre.bind(expr.transform(ctx)?)),

{koatl-0.1.21 → koatl-0.1.23}/python/koatl/prelude/functional/__init__.tl

@@ -3,9 +3,17 @@ export import .result.*
 export import .async.*
 export import .reader.*
 export import .memo.*
+export import .list.*
 
-export Fn = class:
-    compose = staticmethod& (*args) =>
+named = name => fn =>
+    fn.__name__ = name
+    fn.__qualname__ = name
+    fn
+
+methods = {
+    id: named("id")& x => x
+
+    compose: named("compose")& (*args) =>
         args match:
             [] => raise ValueError("At least one function is required for composition")
             [f] => f
@@ -21,4 +29,9 @@ export Fn = class:
                 composed.signature = fs[-1].signature
 
                 composed
-            default raise ValueError("Invalid arguments for Fn.compose()")
+            default raise ValueError("Invalid arguments for Fn.compose()")
+}
+
+globals().update(methods)
+
+__all__ = methods.keys() | tuple

koatl-0.1.23/python/koatl/prelude/functional/list.tl

@@ -0,0 +1,26 @@
+import collections.UserList
+import itertools
+
+import .monad.Monad
+import ..iterable.Iterable
+
+export List = class(UserList, Monad):
+    bind_once = (self, f) =>
+        raise NotImplementedError(
+            "Binding List in a do-block doesn't work in Koatl " +
+                "due to generator limitations. " +
+                "Wrap in Ok to use the regular Result monad."
+        )
+
+    bind = (self, f) => List(self.flat_map(f))
+
+    pure = staticmethod& x => [x]
+
+    traverse = Iterable.traverse
+
+
+for name, method in List.__dict__:
+    if name.startswith("_"):
+        continue
+
+    register_global_attr(list, name, method)

{koatl-0.1.21 → koatl-0.1.23}/python/koatl/prelude/functional/monad.tl

@@ -1,12 +1,18 @@
 import abc
 
 export Monad = class(abc.ABC):
+    # 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) => raise NotImplementedError()
 
-    # 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 generated implementations.
+    map = (self, f) => self.bind(x => self.pure(f(x)))
+    apply = (self, f) => self.bind(x => f.map(fn => fn(x)))