koatl 0.1.22__tar.gz → 0.1.24__tar.gz

{koatl-0.1.22 → koatl-0.1.24}/Cargo.lock

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

{koatl-0.1.22 → koatl-0.1.24}/PKG-INFO

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

{koatl-0.1.22 → koatl-0.1.24}/koatl/Cargo.toml

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

{koatl-0.1.22 → koatl-0.1.24}/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.24/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.22 → koatl-0.1.24/koatl}/python/koatl/prelude/functional/memo.tl

@@ -1,6 +1,6 @@
 import collections.defaultdict
 import functools.wraps
-import .result.Ok
+import .result.(Result, Ok)
 import .Monad
 
 export Memo = class(Monad):
@@ -11,7 +11,8 @@ export Memo = class(Monad):
         __repr__ = self => f"Memo.Cache({self.cache})"
 
         try_get = (self, name, deps) =>
-            try self.cache[name][deps] except KeyError()
+            # TODO should try operator return a Result directly?
+            Result(try self.cache[name][deps] except KeyError())
 
         update = (self, name, deps, value) =>
             self.cache[name][deps] = value
@@ -23,7 +24,7 @@ export Memo = class(Monad):
 
     value = staticmethod& (id, deps, f) =>
         Memo(ctx =>
-            if ctx.try_get(id, tuple(deps)) matches Ok() as value:
+            if ctx.try_get(id, tuple(deps)) matches Ok(value):
                 return value
 
             ctx.update(id, tuple(deps), f())
@@ -34,7 +35,7 @@ export Memo = class(Monad):
         let deps = (tuple(args), tuple(kwargs.items()))
 
         Memo(ctx =>
-            if ctx.try_get(id, deps) matches Ok() as value:
+            if ctx.try_get(id, deps) matches Ok(value):
                 return value
 
             let v = f(*args, **kwargs)

{koatl-0.1.22 → koatl-0.1.24/koatl}/python/koatl/prelude/functional/monad.tl

@@ -1,12 +1,20 @@
 import abc
 
 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) => 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.24/koatl/python/koatl/prelude/functional/result.tl

@@ -0,0 +1,131 @@
+import functools.wraps
+import .monad.Monad
+import koatl.runtime.virtual.register_global_attr
+
+export Result = class:
+    __slots__ = ()
+    __match_args__ = ("value",)
+
+    __new__ = (cls, value) =>
+        if isinstance(value, Result):
+            return value
+        value.ok then Ok(value) else Err(value)
+
+    __init__ = (self, *args, **kwargs) =>
+        raise ValueError("Result should not be instantiated directly, use Ok or Err")
+
+    raw = self =>
+        """
+        Unwraps the value from a Result, making it look like
+        a non-monadic Python value.
+        """
+        if self matches not Result():
+            return self
+
+        if self.ok:
+            if self.value.ok:
+                return self.value
+            else:
+                return self
+        else:
+            if self.value.ok:
+                return self
+            else:
+                return self.value
+
+    bind_once = (self, f) =>
+        self = Result(self)
+        if not self.ok:
+            return self
+
+        let v = Result(f(self.value))
+
+    bind = bind_once
+
+    bind_gen = (self, gen) =>
+        self = Result(self)
+        try:
+            while True:
+                if not self.ok:
+                    return self
+
+                self = Result(gen.send(self.value))
+        except StopIteration(value=value):
+            return Result.pure(value)
+
+    pure = staticmethod& x => Ok(x)
+
+    apply = (self, f) =>
+        self = Result(self)
+        f = Result(f)
+
+        if not self.ok:
+            return self
+        if not f.ok:
+            return f
+
+        Ok(f(self))
+
+    map = (self, f) =>
+        self = Result(self)
+        if self.ok:
+            return Ok(f(self.value))
+        return self
+
+    map_err = (self, f) =>
+        self = Result(self)
+        if not self.ok:
+            return Err(f(self.value))
+        return self
+
+    map_none = (self, f) =>
+        self = Result(self)
+        if not self.ok and self.value === None:
+            return Err(f())
+        return self
+
+export Ok = class(Result):
+    __slots__ = ("value",)
+    ok = True
+    __new__ = (cls, value) => object.__new__(cls)
+    __init__ = (self, value) =>
+        if hasattr(self, "value"):
+            # This is necessary to prevent overwriting the value
+            # since Python's Result.__new__ will call Ok.__init__ again
+            # if the object is already created.
+            return None
+        self.value = value
+
+    __repr__ = self => f"Ok({repr(self.value)})"
+    unwrap = self => self.value
+
+export Err = class(Result):
+    __slots__ = ("value",)
+    ok = False
+    __new__ = (cls, value) => object.__new__(cls)
+    __init__ = (self, value) =>
+        if hasattr(self, "value"):
+            return None
+        self.value = value
+
+    __repr__ = self => f"Err({repr(self.value)})"
+    unwrap = self =>
+        if self.value matches BaseException():
+            raise self.value
+        raise ValueError(f"Expected Ok, got {repr(self.value)}")
+
+
+# Provide a default implementation for *most* Result methods
+# ...we shouldn't provide a default for `map` since that
+# would prevent virtual trait lookup. TODO: fix this?
+for name, method in Result.__dict__:
+    if name.startswith("_"):
+        continue
+    if name == "map":
+        continue
+
+    let make_closure = method => (self, *args, **kwargs) => Result.raw(method(self, *args, **kwargs))
+
+    register_global_attr(object, name, make_closure(method))
+
+register_global_attr(object, "ok", ExtensionProperty(__tl__.ok))

koatl-0.1.24/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.22 → koatl-0.1.24}/koatl/python/koatl/runtime/helpers.py

@@ -46,6 +46,11 @@ def unpack_record(obj):
 
 
 def ok(obj):
+    try:
+        return obj.ok
+    except AttributeError:
+        pass
+
     if obj is None:
         return False
     if isinstance(obj, BaseException):

{koatl-0.1.22 → koatl-0.1.24}/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.22 → koatl-0.1.24}/koatl/src/emit_py.rs

@@ -502,7 +502,7 @@ impl<'src> PyExprExt<'src> for SPyExpr<'src> {
                 ctx.ast_node("Name", (ident, c.emit_py(ctx)?), &self.tl_span)?
             }
             PyExpr::Binary(op, left, right) => {
-                let py_op_str = match op {
+                let py_bin_op = match op {
                     PyBinaryOp::Add => Some("Add"),
                     PyBinaryOp::Sub => Some("Sub"),
                     PyBinaryOp::Mult => Some("Mult"),
@@ -512,18 +512,35 @@ impl<'src> PyExprExt<'src> for SPyExpr<'src> {
                     _ => None,
                 };
 
-                if let Some(py_op_str) = py_op_str {
+                if let Some(py_bin_op) = py_bin_op {
                     return ctx.ast_node(
                         "BinOp",
                         (
                             left.emit_py(ctx)?,
-                            ctx.ast_cls(py_op_str, ())?,
+                            ctx.ast_cls(py_bin_op, ())?,
                             right.emit_py(ctx)?,
                         ),
                         &self.tl_span,
                     );
                 }
 
+                let py_bool_op = match op {
+                    PyBinaryOp::And => Some("And"),
+                    PyBinaryOp::Or => Some("Or"),
+                    _ => None,
+                };
+
+                if let Some(py_bool_op) = py_bool_op {
+                    return ctx.ast_node(
+                        "BoolOp",
+                        (
+                            ctx.ast_cls(py_bool_op, ())?,
+                            [left.emit_py(ctx)?, right.emit_py(ctx)?],
+                        ),
+                        &self.tl_span,
+                    );
+                }
+
                 let py_cmp_op = match op {
                     PyBinaryOp::Lt => Some("Lt"),
                     PyBinaryOp::Gt => Some("Gt"),

{koatl-0.1.22 → koatl-0.1.24}/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.24/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.22 → koatl-0.1.24}/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.22 → koatl-0.1.24}/koatl-core/src/resolve_scopes.rs

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 use std::collections::HashSet;
 use std::fmt::Display;
 
+use slotmap::Key;
 use slotmap::SlotMap;
 use slotmap::new_key_type;
 
@@ -70,10 +71,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();
+        let mut root_scope = Scope::new(ScopeKey::null());
         root_scope.is_global = true;
 
-        let err_scope = Scope::new();
+        let err_scope = Scope::new(ScopeKey::null());
 
         let mut scopes = SlotMap::with_key();
         let root_scope_key = scopes.insert(root_scope);
@@ -107,6 +108,10 @@ impl<'src> ResolveState<'src> {
         top_scope(&self.scope_stack, &mut self.scopes)
     }
 
+    fn top_scope_key(&mut self) -> ScopeKey {
+        *self.scope_stack.last_mut().unwrap()
+    }
+
     fn top_scope_and_key(&mut self) -> (&mut Scope, ScopeKey) {
         top_scope_and_key(&self.scope_stack, &mut self.scopes)
     }
@@ -185,10 +190,10 @@ impl<'src> ResolveState<'src> {
     where
         F: FnOnce(&mut ResolveState<'src>) -> Indirect<SExpr<'src>>,
     {
-        let mut temp_scope = Scope::new();
-        temp_scope.is_fn = true;
+        let mut dummy_scope = Scope::new(ScopeKey::null());
+        dummy_scope.is_fn = true;
 
-        let temp_scope_key = self.scopes.insert(temp_scope);
+        let temp_scope_key = self.scopes.insert(dummy_scope);
 
         let ph_decl = self.declarations.insert_declaration(
             Ident("x".into()).spanned(span),
@@ -460,6 +465,9 @@ impl Display for Declaration<'_> {
 
 #[derive(Debug)]
 pub struct Scope {
+    // TODO make this option
+    pub parent: ScopeKey,
+
     pub locals: Vec<DeclarationKey>,
 
     pub is_class: bool,
@@ -488,8 +496,9 @@ impl Display for Scope {
 }
 
 impl Scope {
-    fn new() -> Scope {
+    fn new(parent: ScopeKey) -> Scope {
         Self {
+            parent,
             locals: Vec::new(),
             lifted_decls: Vec::new(),
 
@@ -797,7 +806,7 @@ fn pattern_scoped<'src>(
     state: &mut ResolveState<'src>,
     pattern: Indirect<SPattern<'src>>,
 ) -> (Indirect<SPattern<'src>>, ScopeKey, PatternMeta<'src>) {
-    let scope = Scope::new();
+    let scope = Scope::new(state.top_scope_key());
     let scope_key = state.scopes.insert(scope);
 
     let (pattern, meta) = pattern.traverse(state);
@@ -946,7 +955,8 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
                     }
                     new_stmts
                 } else {
-                    let scope = state.scopes.insert(Scope::new());
+                    let parent = state.top_scope_key();
+                    let scope = state.scopes.insert(Scope::new(parent));
                     state
                         .scoped(scope, |state| {
                             let mut new_stmts = Vec::new();
@@ -1040,7 +1050,8 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
                             let (pattern, scope, _meta) = pattern_scoped(state, pattern);
                             (Some(pattern), scope)
                         } else {
-                            (None, state.scopes.insert(Scope::new()))
+                            let parent = state.top_scope_key();
+                            (None, state.scopes.insert(Scope::new(parent)))
                         };
 
                         SMatchCase {
@@ -1058,7 +1069,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();
+                let mut scope = Scope::new(state.top_scope_key());
                 scope.is_class = true;
                 let scope = state.scopes.insert(scope);
 
@@ -1071,7 +1082,7 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
             Expr::Fn(arg_def_items, body) => {
                 let mut decls = vec![];
 
-                let mut scope = Scope::new();
+                let mut scope = Scope::new(state.top_scope_key());
                 scope.is_fn = true;
                 let scope = state.scopes.insert(scope);
 
@@ -1297,7 +1308,7 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
                 let mut fn_ctx = FnInfo::new();
                 fn_ctx.is_memo = true;
 
-                let mut scope = Scope::new();
+                let mut scope = Scope::new(state.top_scope_key());
                 scope.is_fn = true;
 
                 // TODO it's confusing that we need to
@@ -1467,7 +1478,8 @@ impl<'src> SStmtExt<'src> for Indirect<SStmt<'src>> {
                             let (pattern, scope, _meta) = pattern_scoped(state, pattern);
                             (Some(pattern), scope)
                         } else {
-                            (None, state.scopes.insert(Scope::new()))
+                            let parent = state.top_scope_key();
+                            (None, state.scopes.insert(Scope::new(parent)))
                         };
 
                         let body = state