koatl 0.1.22__tar.gz → 0.1.23__tar.gz

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

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

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

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

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

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

{koatl-0.1.22 → 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.22 → 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.22 → 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.22 → 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.22 → 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.22 → 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.22 → 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.22 → 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)))

{koatl-0.1.22/koatl → koatl-0.1.23}/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/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.23}/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/python/koatl/prelude/iterable.tl

@@ -1,56 +0,0 @@
-methods = {
-    map: (x, f) =>
-        for i in x:
-            yield f(i)
-
-    filter: (x, f) =>
-        for i in x:
-            if f(i):
-                yield i
-
-    flat_map: (x, f) =>
-        for i in x:
-            yield from f(i)
-
-    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/python/koatl/prelude/iterable.tl

@@ -1,56 +0,0 @@
-methods = {
-    map: (x, f) =>
-        for i in x:
-            yield f(i)
-
-    filter: (x, f) =>
-        for i in x:
-            if f(i):
-                yield i
-
-    flat_map: (x, f) =>
-        for i in x:
-            yield from f(i)
-
-    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)