koatl 0.1.29__tar.gz → 0.1.31__tar.gz

{koatl-0.1.29 → koatl-0.1.31}/Cargo.lock

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

{koatl-0.1.29 → koatl-0.1.31}/PKG-INFO

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

{koatl-0.1.29 → koatl-0.1.31}/koatl/Cargo.toml

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

koatl-0.1.31/koatl/python/koatl/prelude/__init__.tl

@@ -0,0 +1,4 @@
+export import .functional.*
+
+export import .iterable.Iterable
+export import .io

koatl-0.1.31/koatl/python/koatl/prelude/functional/__init__.tl

@@ -0,0 +1,26 @@
+export import .algebra.*
+export import .result.*
+export import .async.*
+export import .env.*
+export import .memo.*
+export import .list.*
+
+export id = x => x
+
+export compose = (*args) =>
+    args match:
+        [] => raise ValueError("At least one function is required for composition")
+        [f] => f
+        [*fs] =>
+            let composed = (*args, **kwargs) =>
+                let value = fs[-1](*args, **kwargs)
+                for f in fs[..-1..-1]:
+                    value = f(value)
+                value
+
+            composed.__name__ = "<Fn.compose()>"
+            composed.__qualname__ = composed.__name__
+            composed.signature = fs[-1].signature
+
+            composed
+        default raise ValueError("Invalid arguments for Fn.compose()")

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

@@ -0,0 +1,72 @@
+export Monad = class(Trait):
+    """
+    Abstract base class for monads.
+
+    Subclasses must implement `bind` and `pure`.
+    Automatically provides (likely suboptimal) standard
+    functor operations: map, apply, lift.
+    """
+    __slots__ = ()
+
+    bind = Abstract& (self, f) => None
+
+    pure = staticmethod& Abstract& value => None
+
+    # Automatically generated implementations.
+    map = (self, f) => self.bind(x => self.pure(f(x)))
+    apply = (self, mf) => self.bind(x => mf.map(f => f(x)))
+
+
+export MonadOnce = class(Monad, Trait):
+    """
+    Abstract base class for monads that don't require branching.
+    In other words, a deterministic monad.
+
+    A MonadOnce only calls `f` in `bind_once` once, which is suitable for
+    use with Python generators that cannot be cloned or reused.
+
+    Subclasses must implement `bind_once` and `pure`.
+
+    Subclasses may also implement `bind_gen` for more efficient
+    handling of do-blocks.
+    """
+    __slots__ = ()
+
+    # The default implementation required for `@` syntax that should be overridden by subclasses.
+    bind_once = Abstract& (self, f) => 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)
+
+
+export Identity = class(MonadOnce):
+    """
+    A utility class for preventing `@` from wrapping the function output.
+
+    The semantics are unusual:
+        - pure returns the value directly, NOT wrapped in Identity.
+        - bind_once can be called on either Identity(value) or a bare value directly.
+    """
+
+    __slots__ = ("value",)
+    __match_args__ = ("value",)
+
+    __init__ = (self, value) => self.value = value
+
+    bind_once = (self, f) => self matches Identity(value) then f(value) else f(self)
+
+    pure = staticmethod& x => x
+
+
+export Traversable = class(Trait):
+    """
+    Abstract base class for traversable data structures.
+    Subclasses must implement `traverse`.
+    """
+    __slots__ = ()
+
+    traverse = Abstract& (self, f) => None

{koatl-0.1.29 → koatl-0.1.31}/koatl/python/koatl/prelude/functional/async.tl

@@ -24,7 +24,7 @@ export Async = class(MonadOnce):
         if hasattr(result, "__await__"):
             return yield from result.__await__()
 
-        return result
+        result
 
     bind_gen = (self, gen) => Async.from_generator_fn& () =>
         try:
@@ -39,5 +39,11 @@ export Async = class(MonadOnce):
 
     sleep = staticmethod& x => Async(asyncio.sleep(x))
 
-    # TODO: Why is asyncio.gather eager?
-    gather = staticmethod& (*args) => Async.from_generator_fn& () => yield from asyncio.gather(*args)
+    # These execute immediately, so we need to wrap them in a generator
+    # (otherwise, there might not be an event loop running)
+
+    gather = staticmethod& (*args) => Async.from_generator_fn& () =>
+        yield from asyncio.gather(*args)
+
+    from_sync = staticmethod& (f, *args, **kwargs) => Async.from_generator_fn& () =>
+        yield from asyncio.get_running_loop().run_in_executor(None, () => f(*args, **kwargs))

koatl-0.1.31/koatl/python/koatl/prelude/functional/env.tl

@@ -0,0 +1,42 @@
+import functools.wraps
+import .MonadOnce
+
+export Env = class(MonadOnce):
+    __slots__ = ("f",)
+
+    """
+    A monad that provides a *mutable* reference to the environment.
+    This means that it can behave like a State, without needing to
+    explicitly write updates to the context.
+
+    Structurally, it is identical to Reader.
+    """
+
+    __init__ = (self, f) => self.f = f
+
+    __repr__ = self => "Env(...)"
+
+    run = (self, ctx) => self.f(ctx)
+
+    pure = staticmethod& value => Env(ctx => value)
+
+    get = None # to be populated later
+
+    item = staticmethod& name => Env(ctx => ctx[name])
+
+    bind_once = (self, f) => Env& ctx =>
+        let v = f(self.f(ctx))
+        if v matches Env():
+            return v.f(ctx)
+        v
+
+    bind_gen = (self, gen) => Env& ctx =>
+        try:
+            while True:
+                self = gen.send(self.f(ctx))
+        except StopIteration(value=value):
+            return value
+
+    NoKey = object()
+
+Env.get = Env(ctx => ctx)

{koatl-0.1.29 → koatl-0.1.31/koatl}/python/koatl/prelude/functional/list.tl

@@ -1,9 +1,13 @@
 import itertools
 
 import .Monad
-import ..iterable.Iterable
 
 export List = class(Monad):
+    __new__ = (cls, *args, **kwargs) => raise ValueError(
+        "List cannot be instantiated directly. "
+            "Use [] or list()."
+    )
+
     bind_once = (self, f) =>
         raise NotImplementedError(
             "List may not be bound using @ "
@@ -15,7 +19,7 @@ export List = class(Monad):
 
     pure = staticmethod& x => [x]
 
-    traverse = Iterable.traverse
+    len = TraitProperty& self => len(self)
 
 
 for name, method in List.__dict__:

koatl-0.1.31/koatl/python/koatl/prelude/functional/memo.tl

@@ -0,0 +1,121 @@
+import collections.defaultdict
+import functools.wraps
+
+import .algebra.(MonadOnce, Identity)
+import .result.(Result, Ok, Err)
+import .env.Env
+
+export Memo = class(Env):
+    __slots__ = ("f",)
+
+    """
+    The Memo monad is a specialization of Env, where
+    the environment is a cache that stores previously computed values.
+    It is used to memoize computations, allowing for efficient reuse of results
+    without recomputing them.
+    """
+
+    Cache = class:
+        """
+        Basic implementation of a cache without any eviction policy.
+        """
+        __init__ = self =>
+            self.cache = defaultdict(dict)
+
+        __repr__ = self => f"Memo.Cache({self.cache})"
+
+        try_get = (self, name, deps) => try self.cache[name][deps] except KeyError()
+
+        update = (self, name, deps, value) =>
+            self.cache[name][deps] = value
+            value
+
+    NullCache = class:
+        """
+        A cache that does not store any values.
+        Useful for testing or when memoization is not needed.
+        """
+        __init__ = self => None
+
+        __repr__ = self => "Memo.NullCache()"
+
+        try_get = (self, name, deps) => Err()
+
+        update = (self, name, deps, value) => value
+
+    __init__ = (self, f) => self.f = f
+
+    __repr__ = self => f"Memo(...)"
+
+    # We need to handle
+    # memo @value
+    # separately, because we *don't* want to memoize the monad itself
+    # but rather the value it produces.
+    # Another way to think about it is that
+    # fused_value produces a Memo.T<MonadOnce<T>> value.
+    value = staticmethod& (id, deps, f) =>
+        Memo(ctx =>
+            if ctx.try_get(id, tuple(deps)) matches Ok((inner_type, value)):
+                if inner_type === None or inner_type === Memo:
+                    # Non-monadic cached values, or Memo cached values, shouldn't
+                    # wrap the output in a monadic type.
+
+                    # The issue is that the present do-block expects a value to be bound,
+                    # but we don't want to use @Memo.pure(value) because that would
+                    # produce a Memo<Memo<T>> value.
+                    # It's hacky, but it works for now.
+                    return @Identity(value)
+                else:
+                    # This gives us a Memo<MonadOnce<T>> value as normal.
+                    return @inner_type.pure(value)
+
+            let inner = f()
+            let inner_type = type(inner)
+
+            if isinstance(inner, Memo):
+                inner = @Identity(inner.f(ctx))
+            else if not hasattr(inner, "bind_once"):
+                inner_type = None
+                inner = @Identity(inner)
+            else:
+                inner = @inner
+
+            ctx.update(id, tuple(deps), (inner_type, inner))
+            inner
+        )
+
+    fn = staticmethod& f => wraps(f)& (*args, **kwargs) =>
+        let id = f"{f.__module__}.{f.__qualname__}"
+        let deps = (tuple(args), tuple(kwargs.items()))
+
+        # Same semantics as Memo.value above.
+        Memo.value(id, deps, () => f(*args, **kwargs))
+
+
+    run = (self, ctx=None) =>
+        if ctx === None:
+            ctx = Memo.Cache()
+        self.f(ctx)
+
+    pure = staticmethod& value => Memo(ctx => value)
+
+    bind_once = (self, f) => Memo(ctx =>
+        let value = f(self.f(ctx))
+        if value matches Memo():
+            return value.f(ctx)
+        value
+    )
+
+    bind_gen = (self, gen) => Memo(ctx =>
+        self = self.f(ctx)
+        try:
+            while True:
+                self = gen.send(self)
+                if self matches Memo():
+                    self = self.f(ctx)
+        except StopIteration(value=value):
+            return value
+    )
+
+
+__tl__.memo_value = Memo.value

{koatl-0.1.29 → koatl-0.1.31/koatl}/python/koatl/prelude/functional/result.tl

@@ -1,5 +1,5 @@
 import functools.wraps
-import .algebra.MonadOnce
+import .algebra.(Identity, MonadOnce)
 
 export Result = class(MonadOnce):
     __slots__ = ()
@@ -28,9 +28,7 @@ export Result = class(MonadOnce):
         if not self.ok:
             return self
 
-        let v = Result(f(self.value))
-
-    bind = bind_once
+        f(self.value)
 
     bind_gen = (self, gen) =>
         self = Result(self)
@@ -41,7 +39,7 @@ export Result = class(MonadOnce):
 
                 self = Result(gen.send(self.value))
         except StopIteration(value=value):
-            return Result.pure(value)
+            return Result(value)
 
     pure = staticmethod& x => Ok(x)
 
@@ -74,6 +72,29 @@ export Result = class(MonadOnce):
             return Err(f())
         return self
 
+    T = class(MonadOnce):
+        __slots__ = ("value",)
+        __init__ = (self, value) =>
+            if not hasattr(value, "bind_once"):
+                raise TypeError("Expected a MonadOnce value")
+
+            self.value = value
+
+        __repr__ = self => f"Result.T({repr(self.value)})"
+
+        pure = (self, x) => self.value.pure(Result.pure(x))
+
+        bind_once = (self, f) =>
+            self.value.bind_once(x =>
+                x = Result(x)
+
+                if not x.ok:
+                    return self.value.pure(x)
+
+                f(x.value)
+            )
+
+
 export Ok = class(Result):
     __slots__ = ("value",)
     ok = True
@@ -81,8 +102,8 @@ export Ok = class(Result):
     __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.
+            # since Python's Result.__new__ will call Ok.__init__ again,
+            # in the case we call Result(Ok(value))
             return None
         self.value = value
 
@@ -95,11 +116,12 @@ export Ok = class(Result):
     unwrap = self => self.value
     coalesce = (self, f) => self.value
 
+
 export Err = class(Result):
     __slots__ = ("value",)
     ok = False
-    __new__ = (cls, value) => object.__new__(cls)
-    __init__ = (self, value) =>
+    __new__ = (cls, value=None) => object.__new__(cls)
+    __init__ = (self, value=None) =>
         if hasattr(self, "value"):
             return None
         self.value = value
@@ -109,7 +131,7 @@ export Err = class(Result):
             return False
         return self.value == other.value
 
-    __repr__ = self => f"Err({repr(self.value)})"
+    __repr__ = self => f"Err({self.value === None then "" else repr(self.value)})"
     unwrap = self =>
         if self.value matches BaseException():
             raise self.value
@@ -123,11 +145,9 @@ ExtensionProperty(object, "ok")& _ => True
 
 ExtensionProperty(object, "result")& Result
 
-# Enables @ operator for bare objects.
-ExtensionMethod(object, "bind_gen")& Result.bind_gen
-
 __tl__.Ok = Ok
 __tl__.Err = Err
+__tl__.Result = Result
 
 __tl__.op_coal = (x, f) =>
     if x matches Result():

koatl-0.1.31/koatl/python/koatl/prelude/io.tl

@@ -0,0 +1,5 @@
+export read = (filename) =>
+    let desc = open(filename, "r")
+    let data = desc.read()
+    desc.close()
+    data

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

@@ -0,0 +1,194 @@
+import itertools
+import builtins
+import .functional.Traversable
+import .functional.(Ok, Err)
+
+export Iterable = ExtensionTrait& class(Traversable, Trait):
+    iter = Abstract
+
+    skip = (self, n) =>
+        let it = self.iter
+        for _ in ..n:
+            next(it, None)
+        it
+
+    take = (self, n) =>
+        let impl = () =>
+            let it = self.iter
+            for _ in ..n:
+                try:
+                    yield next(it)
+                except StopIteration(value=value):
+                    return value
+
+        impl.__name__ = f"take"
+        impl.__qualname__ = f"Iterable.take"
+
+        impl()
+
+    take_while = (self, f) =>
+        let impl = () =>
+            for i in self.iter:
+                if not f(i):
+                    return None
+                yield i
+
+        impl.__name__ = f"take_while"
+        impl.__qualname__ = f"Iterable.take_while"
+
+        impl()
+
+    chain = (self, *others) =>
+        itertools.chain(self.iter, *others.map($.iter))
+
+    zip = (self, *others) =>
+        zip(self.iter, *others.map($.iter))
+
+    enumerate = (self, start=0) =>
+        enumerate(self.iter, start)
+
+    map = (self, f) => builtins.map(f, self.iter)
+
+    filter = (self, f) => builtins.filter(f, self.iter)
+
+    flat_map = (self, f) => itertools.chain.from_iterable(self.map(f))
+
+    reverse = self => reversed(list(self.iter))
+
+    sort = (self, key=None, reverse=False) =>
+        sorted(self.iter, key=key, reverse=reverse)
+
+    copy = self => itertools.tee(self.iter)
+
+
+    count = self => len(self.iter)
+
+    fold = (self, init, f) =>
+        let acc = init
+        for i in self:
+            acc = f(acc, i)
+        acc
+
+    associate = (self, f) =>
+        let acc = dict() # Don't use Record here.
+        for i in self:
+            let value = f(i)
+            acc[i] = value
+        acc
+
+    group_by = (self, f) =>
+        let acc = dict()
+        for i in self:
+            let key = f(i)
+            if not acc.__contains__(key):
+                acc[key] = []
+            acc[key].append(i)
+        acc
+
+    count_by = (self, f) =>
+        let acc = dict()
+        for i in self:
+            let key = f(i)
+            if not acc.__contains__(key):
+                acc[key] = 0
+            acc[key] += 1
+        acc
+
+    all = (self, f) =>
+        for i in self:
+            if not f(i):
+                return False
+        return True
+
+    any = (self, f) =>
+        for i in self:
+            if f(i):
+                return True
+        return False
+
+    find = (self, f) =>
+        for i in self:
+            if f(i):
+                return Ok(i)
+        return Err()
+
+    first = self =>
+        (try next(self.iter)).map_err(_ => None)
+
+    last = (self, f) =>
+        let result = Err()
+        for i in self:
+            if f(i):
+                result = Ok(i)
+        return result
+
+    at = (self, index) =>
+        for i in self:
+            if i == index:
+                return Ok(i)
+        return Err()
+
+    sum = self =>
+        let acc = 0
+        for i in self:
+            acc = acc + i
+        acc
+
+    for_each = (self, f) =>
+        for i in self:
+            f(i)
+
+    list = self =>
+        list(self.iter)
+
+    dict = self =>
+        dict(self.iter)
+
+    record = self =>
+        Record(self.iter)
+
+    traverse = (self, f=None) =>
+        import .functional.(Async, Result)
+
+        if f === None:
+            f = x => x
+
+        let it = self.iter
+        let v
+        try:
+            v = next(it)
+        except StopIteration():
+            return []
+
+        let m = f(v)
+
+        # TODO: can special case traversals be generalized?
+
+        # The Result traversal of a list is short-circuiting.
+        # Fall back to Result semantics for bare types.
+        if m matches Result() or not hasattr(m, "apply"):
+            if not m.ok:
+                return m
+
+            let acc = [m]
+            for v in it:
+                let fv = f(v)
+                if not fv.ok:
+                    return fv
+                acc.append(fv)
+            return acc
+
+        # The Async traversal of a list is gather.
+        if m matches Async():
+            let acc = [m]
+            for v in it:
+                acc.append(f(v))
+            return Async.gather(*acc)
+
+        # Fall back to default applicative semantics.
+        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

{koatl-0.1.29 → koatl-0.1.31/koatl}/python/koatl/runtime/__init__.py

@@ -43,11 +43,11 @@ __tl__ = SimpleNamespace(
     # These require more complex logic and require the prelude.
     # The runtime provides dummy implementations that raise if used without the prelude.
     memo_value=dummy("memo"),
-    bind_memo_value=dummy("memo"),
     op_map=dummy("?"),
     op_coal=("??"),
     Ok=dummy("try-expr"),
     Err=dummy("try-expr"),
+    Result=dummy("Result"),
     **{name: helpers.__dict__[name] for name in helpers.__all__},
     **{name: record.__dict__[name] for name in record.__all__},
     **{name: virtual.__dict__[name] for name in virtual.__all__},