koatl 0.1.30__tar.gz → 0.1.31__tar.gz

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

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

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

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

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

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

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.30 → koatl-0.1.31}/koatl/python/koatl/prelude/functional/algebra.tl

@@ -20,6 +20,7 @@ export Monad = class(Trait):
 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.
@@ -43,11 +44,20 @@ export MonadOnce = class(Monad, Trait):
 
 
 export Identity = class(MonadOnce):
-    __init__ = (self, *args, **kwargs) => raise ValueError(
-        "Identity should not be instantiated directly. "
-    )
+    """
+    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) => f(self)
+    bind_once = (self, f) => self matches Identity(value) then f(value) else f(self)
 
     pure = staticmethod& x => x
 

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.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.30 → koatl-0.1.31/koatl}/python/koatl/prelude/functional/result.tl

@@ -102,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
 

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

@@ -43,12 +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("do"),
+    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__},

koatl-0.1.31/koatl/tests/e2e/prelude/env.tl

@@ -0,0 +1,9 @@
+import util.assert_eq
+
+g = () =>
+    @Env.item("c")
+
+f = () =>
+    @Env.item("a"), @Env.item("b"), @g()
+
+assert_eq(f().run({ a: 1, b: 2, c: 3 }), (1, 2, 3))

{koatl-0.1.30 → koatl-0.1.31}/koatl/tests/e2e/prelude/memo.tl

@@ -1,4 +1,5 @@
 import util.assert_eq
+import time
 
 counts = 0
 
@@ -46,3 +47,31 @@ assert_eq(f(10, 20).run(ctx), 200)
 assert_eq(f(10, 30).run(ctx), 300)
 assert_eq(f(10, 30).run(ctx), 300)
 assert_eq(counts, 2)
+
+fib = x => x < 2 then @Memo.pure(1) else memo @fib(x - 1) + @fib(x - 2)
+
+now = time.time()
+fib(35).run()
+
+# Improperly memoized fib will take much longer to run.
+assert_eq(time.time() - now < 0.1, True)
+
+
+# Memo.fn with nested monad
+
+f = Memo.fn& () =>
+    @Async.sleep(0.1)
+    123
+
+now = time.time()
+ctx = Memo.Cache()
+assert_eq(f().run(ctx).run(), 123)
+assert_eq(f().run(ctx).run(), 123)
+assert_eq(time.time() - now < 0.12, True)
+
+
+now = time.time()
+ctx = Memo.NullCache()
+assert_eq(f().run(ctx).run(), 123)
+assert_eq(f().run(ctx).run(), 123)
+assert_eq(time.time() - now > 0.19, True)

{koatl-0.1.30 → koatl-0.1.31}/koatl-core/src/transform.rs

@@ -2031,11 +2031,7 @@ impl<'src, 'ast> SExprExt<'src, 'ast> for SExpr<'src> {
                 let linecol = ctx.line_cache.linecol(span.start);
 
                 let memo_call = a.call(
-                    if memo_captures.is_do {
-                        a.tl_builtin("bind_memo_value")
-                    } else {
-                        a.tl_builtin("memo_value")
-                    },
+                    a.tl_builtin("memo_value"),
                     vec![
                         PyCallItem::Arg(a.str(format!(
                             "{}:{}:{}:{:08x}",

koatl-0.1.31/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.30 → koatl-0.1.31}/python/koatl/prelude/functional/algebra.tl

@@ -20,6 +20,7 @@ export Monad = class(Trait):
 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.
@@ -43,11 +44,20 @@ export MonadOnce = class(Monad, Trait):
 
 
 export Identity = class(MonadOnce):
-    __init__ = (self, *args, **kwargs) => raise ValueError(
-        "Identity should not be instantiated directly. "
-    )
+    """
+    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) => f(self)
+    bind_once = (self, f) => self matches Identity(value) then f(value) else f(self)
 
     pure = staticmethod& x => x
 

koatl-0.1.31/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.31/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.30/koatl → koatl-0.1.31}/python/koatl/prelude/functional/result.tl

@@ -102,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
 

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

@@ -43,12 +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("do"),
+    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__},

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

@@ -1,37 +0,0 @@
-export import .algebra.*
-export import .result.*
-export import .async.*
-export import .reader.*
-export import .memo.*
-export import .list.*
-
-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
-            [*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()")
-}
-
-globals().update(methods)
-
-__all__ = methods.keys() | tuple