koatl 0.1.31__tar.gz → 0.1.33__tar.gz

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

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

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

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

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

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

{koatl-0.1.31 → koatl-0.1.33/koatl}/python/koatl/prelude/__init__.tl

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

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

@@ -1,7 +1,6 @@
 import functools.wraps
 import asyncio
 
-import .async_util
 import .MonadOnce
 
 export Async = class(MonadOnce):
@@ -16,20 +15,22 @@ export Async = class(MonadOnce):
         m.generator = generator_fn(*args, **kwargs)
         return m
 
-    run = self => asyncio.run(async_util.to_coro(self))
+    run = self => asyncio.run((() => await self)())
 
     bind_once = (self, f) => Async.from_generator_fn& () =>
         let result = f(yield from self.__await__())
 
-        if hasattr(result, "__await__"):
-            return yield from result.__await__()
+        if not hasattr(result, "__await__"):
+            raise ValueError(f"Expected the binder to return an Awaitable, but got {type(result).__name__}")
 
-        result
+        yield from result.__await__()
 
     bind_gen = (self, gen) => Async.from_generator_fn& () =>
         try:
             while True:
                 self = gen.send(yield from self.__await__())
+                if not hasattr(self, "__await__"):
+                    raise ValueError(f"Expected the binder to return an Awaitable, but got {type(self).__name__}")
         except StopIteration(value=value):
             return value
 

{koatl-0.1.31 → koatl-0.1.33/koatl}/python/koatl/prelude/functional/env.tl

@@ -26,14 +26,17 @@ export Env = class(MonadOnce):
 
     bind_once = (self, f) => Env& ctx =>
         let v = f(self.f(ctx))
-        if v matches Env():
-            return v.f(ctx)
-        v
+        if v matches not Env():
+            raise ValueError(f"Expected the binder to return an Env, but got {type(v)}")
+
+        v.f(ctx)
 
     bind_gen = (self, gen) => Env& ctx =>
         try:
             while True:
                 self = gen.send(self.f(ctx))
+                if self matches not Env():
+                    raise ValueError(f"Expected the binder to return an Env, but got {type(self)}")
         except StopIteration(value=value):
             return value
 

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

@@ -19,11 +19,7 @@ export List = class(Monad):
 
     pure = staticmethod& x => [x]
 
-    len = TraitProperty& self => len(self)
+    len = property& self => len(self)
 
 
-for name, method in List.__dict__:
-    if name.startswith("_"):
-        continue
-
-    ExtensionMethod(list, name)& method
+Extension.property(list, "len")& List.len.fget

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

@@ -0,0 +1,187 @@
+import collections.defaultdict
+import functools.wraps
+
+import .algebra.(MonadOnce, Identity)
+import .result.(Result, Ok, Err)
+import .async.(Async)
+
+export Memo = class(MonadOnce):
+    __slots__ = ("f",)
+
+    """
+    The Memo monad is like a 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(...)"
+
+    value = staticmethod& (id, deps, f) =>
+        """
+        Create a memoized value with the given id and dependencies.
+        f should be a function taking no arguments that returns the value to be memoized.
+        The id is a unique identifier for the memoized value, and deps are the dependencies
+        that determine when the value should be recomputed.
+        If the value is already cached, it will return the cached value.
+        If the value is not cached, it will compute the value using f and cache it.
+        """
+        Memo(ctx =>
+            if ctx.try_get(id, tuple(deps)) matches Ok(value):
+                return value
+
+            let inner = f()
+            let inner_type
+
+            if isinstance(inner, Memo):
+                # Collapse Memo<Memo<T>> into Memo<T>.
+                # Usually, this should only happen inside .flat(),
+                # but since we don't have type inference,
+                # we need to do it here to nesting memo inside memo.
+                inner = inner.f(ctx)
+
+            ctx.update(id, tuple(deps), inner)
+        )
+
+    fn = staticmethod& f => wraps(f)& (*args, **kwargs) =>
+        let id = f"{f.__module__}.{f.__qualname__}"
+        let deps = (tuple(args), tuple(kwargs.items()))
+        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 not Memo():
+            raise ValueError(f"Expected the binder to return a Memo, but got {type(value)}")
+
+        return value.f(ctx)
+    )
+
+    bind_gen = (self, gen) => Memo(ctx =>
+        try:
+            while True:
+                let inner = self.f(ctx)
+                self = gen.send(inner)
+
+                if self matches not Memo():
+                    raise ValueError(f"Expected the binder to return a Memo, but got {type(value)}")
+
+        except StopIteration(value=value):
+            return value
+    )
+
+
+
+export AsyncMemo = class(MonadOnce):
+    """
+    Like Memo, but fuses Async computations with the Memo itself.
+    """
+
+    __slots__ = ("f",)
+
+    __init__ = (self, f) => self.f = f
+
+    __repr__ = self => f"AsyncMemo(...)"
+
+    value = staticmethod& (id, deps, f) =>
+        """
+        Like Memo.value, but we need to cache the result of the Async.
+        """
+        AsyncMemo(ctx =>
+            # This pauses the generator to wait for an Async context.
+            # This allows with_ctx to work a little bit better with memoization,
+            # deferring the cache lookup until we are in an async context.
+            @Async.pure(None)
+
+            if ctx.try_get(id, tuple(deps)) matches Ok(value):
+                return value
+
+            let inner = f()
+            let inner_type
+
+            if isinstance(inner, Memo):
+                inner = inner.f(ctx)
+
+            if not isinstance(inner, Async):
+                raise ValueError(f"Expected the inner computation to be Async, but got {type(inner)}")
+
+            inner = @inner
+
+            ctx.update(id, tuple(deps), inner)
+        )
+
+    fn = staticmethod& f => wraps(f)& (*args, **kwargs) =>
+        let id = f"{f.__module__}.{f.__qualname__}"
+        let deps = (tuple(args), tuple(kwargs.items()))
+        AsyncMemo.value(id, deps, () => f(*args, **kwargs))
+
+    run = (self, ctx=None) =>
+        if ctx === None:
+            ctx = Memo.Cache()
+        self.f(ctx).run()
+
+    with_ctx = (self, ctx) => self.f(ctx)
+
+    pure = staticmethod& value => AsyncMemo(ctx => Async.pure(value))
+
+    bind_once = (self, f) => AsyncMemo(ctx =>
+        let value = f(@self.f(ctx))
+
+        if value matches not AsyncMemo():
+            raise ValueError(f"Expected the binder to return a Memo, but got {type(value)}")
+
+        return value.f(ctx)
+    )
+
+    bind_gen = (self, gen) => AsyncMemo(ctx =>
+        try:
+            while True:
+                let inner = @self.f(ctx)
+                self = gen.send(inner)
+
+                if self matches not AsyncMemo():
+                    raise ValueError(f"Expected the binder to return a Memo, but got {type(value)}")
+
+        except StopIteration(value=value):
+            return value
+    )
+
+__tl__.memo_value = Memo.value
+__tl__.async_memo_value = AsyncMemo.value

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

@@ -1,6 +1,12 @@
 import functools.wraps
 import .algebra.(Identity, MonadOnce)
 
+infer_ok = x =>
+    x match:
+        None => False
+        BaseException() => False
+        default True
+
 export Result = class(MonadOnce):
     __slots__ = ()
     __match_args__ = ("value",)
@@ -8,7 +14,7 @@ export Result = class(MonadOnce):
     __new__ = (cls, value) =>
         if isinstance(value, Result):
             return value
-        value.ok then Ok(value) else Err(value)
+        infer_ok(value) then Ok(value) else Err(value)
 
     __init__ = (self, *args, **kwargs) =>
         raise ValueError("Result should not be instantiated directly, use Ok or Err")
@@ -24,29 +30,29 @@ export Result = class(MonadOnce):
             return Err(e)
 
     bind_once = (self, f) =>
-        self = Result(self)
         if not self.ok:
             return self
 
-        f(self.value)
+        let value = f(self.value)
+        if value matches not Result():
+            raise ValueError(f"Expected the binder to return a Result, but got {type(value)}")
+        value
 
     bind_gen = (self, gen) =>
-        self = Result(self)
         try:
             while True:
                 if not self.ok:
                     return self
 
-                self = Result(gen.send(self.value))
+                self = gen.send(self.value)
+                if self matches not Result():
+                    raise ValueError(f"Expected the binder to return a Result, but got {type(self)}")
         except StopIteration(value=value):
             return Result(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:
@@ -55,44 +61,60 @@ export Result = class(MonadOnce):
         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
 
-    T = class(MonadOnce):
-        __slots__ = ("value",)
-        __init__ = (self, value) =>
-            if not hasattr(value, "bind_once"):
-                raise TypeError("Expected a MonadOnce value")
+    T = (typ) =>
+        """
+        TODO: cache the Result.T class to avoid creating it every time?
+        """
+        if not isinstance(typ, type):
+            raise ValueError(f"Expected a type, but got {type(typ).__name__}")
+
+        let cls = class(MonadOnce):
+            __slots__ = ("value",)
+            __init__ = (self, value) =>
+                if not isinstance(value, typ):
+                    raise ValueError(f"Expected a {typ}, but got {type(value).__name__}")
 
-            self.value = value
+                self.value = value
 
-        __repr__ = self => f"Result.T({repr(self.value)})"
+            __repr__ = self => f"Result.T({typ.__name__})({repr(self.value)})"
 
-        pure = (self, x) => self.value.pure(Result.pure(x))
+            pure = (self, x) => cls(typ.pure(Result.pure(x)))
 
-        bind_once = (self, f) =>
-            self.value.bind_once(x =>
-                x = Result(x)
+            bind_once = (self, f) =>
+                cls(self.value.bind_once(x =>
+                    if not isinstance(x, Result):
+                        raise ValueError(f"Expected the inner type to be a Result, but got {type(x).__name__}")
 
-                if not x.ok:
-                    return self.value.pure(x)
+                    if not x.ok:
+                        return typ.pure(x)
 
-                f(x.value)
-            )
+                    let value = f(x.value)
+                    if not hasattr(value, "value"):
+                        raise ValueError(
+                            f"Expected the binder to return a {cls.__name__}, " +
+                                f"but got a {type(value).__name__}"
+                        )
+
+                    value.value
+                ))
+
+        cls.__name__ = f"Result.T({typ.__name__})"
+        cls.__qualname__ = f"Result.T({typ.__name__})"
+        cls
 
 
 export Ok = class(Result):
@@ -135,15 +157,10 @@ export Err = class(Result):
     unwrap = self =>
         if self.value matches BaseException():
             raise self.value
-        raise ValueError(f"Expected Ok, got {repr(self.value)}")
+        raise ValueError(f"Expected Ok, got {repr(self)}")
     coalesce = (self, f) => f()
 
-
-ExtensionProperty(type(None), "ok")& _ => False
-ExtensionProperty(BaseException, "ok")& _ => False
-ExtensionProperty(object, "ok")& _ => True
-
-ExtensionProperty(object, "result")& Result
+Extension.property(object, "result")& Result
 
 __tl__.Ok = Ok
 __tl__.Err = Err
@@ -153,7 +170,7 @@ __tl__.op_coal = (x, f) =>
     if x matches Result():
         return x.coalesce(f)
 
-    if not x.ok:
+    if not infer_ok(x):
         return f()
     return x
 
@@ -161,6 +178,6 @@ __tl__.op_map = (x, f) =>
     if x matches Result():
         return x.map(f)
 
-    if x.ok:
+    if infer_ok(x):
         return f(x)
     return x

{koatl-0.1.31 → koatl-0.1.33}/koatl/python/koatl/prelude/iterable.tl

@@ -1,9 +1,8 @@
 import itertools
 import builtins
-import .functional.Traversable
-import .functional.(Ok, Err)
+import .functional.(Traversable, Ok, Err, Memo, Async, AsyncMemo)
 
-export Iterable = ExtensionTrait& class(Traversable, Trait):
+export Iterable = Extension.trait& class(Traversable, Trait):
     iter = Abstract
 
     skip = (self, n) =>
@@ -128,15 +127,67 @@ export Iterable = ExtensionTrait& class(Traversable, Trait):
                 return Ok(i)
         return Err()
 
+    for_each = (self, f) =>
+        for i in self:
+            f(i)
+
+    unique = self =>
+        let seen = set()
+        let impl = () =>
+            for i in self:
+                if not seen.__contains__(i):
+                    seen.add(i)
+                    yield i
+
+        impl.__name__ = f"unique"
+        impl.__qualname__ = f"Iterable.unique"
+
+        impl()
+
+    join_str = (self, sep="") =>
+        sep.join(self.map(str))
+
     sum = self =>
         let acc = 0
         for i in self:
             acc = acc + i
         acc
 
-    for_each = (self, f) =>
+    mean = self =>
+        let acc = 0
+        let count = 0
         for i in self:
-            f(i)
+            acc = acc + i
+            count = count + 1
+        if count == 0:
+            raise ValueError("mean of empty iterable")
+        acc / count
+
+    max = self =>
+        let it = self.iter
+        let v
+        try:
+            v = next(it)
+        except StopIteration(value=value):
+            raise ValueError("max of empty iterable")
+
+        for i in it:
+            if i > v:
+                v = i
+        v
+
+    min = self =>
+        let it = self.iter
+        let v
+        try:
+            v = next(it)
+        except StopIteration(value=value):
+            raise ValueError("min of empty iterable")
+
+        for i in it:
+            if i < v:
+                v = i
+        v
 
     list = self =>
         list(self.iter)
@@ -164,9 +215,11 @@ export Iterable = ExtensionTrait& class(Traversable, Trait):
 
         # TODO: can special case traversals be generalized?
 
+        if not hasattr(m, "apply"):
+            raise ValueError(f"Can only traverse with an Applicative type.")
+
         # 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 m matches Result():
             if not m.ok:
                 return m
 
@@ -185,6 +238,16 @@ export Iterable = ExtensionTrait& class(Traversable, Trait):
                 acc.append(f(v))
             return Async.gather(*acc)
 
+        if m matches AsyncMemo():
+            return AsyncMemo(ctx =>
+                let acc = [m.f(ctx)]
+
+                for v in it:
+                    acc.append(f(v).f(ctx))
+
+                return Async.gather(*acc)
+            )
+
         # Fall back to default applicative semantics.
         let acc = m.map([$])
         for v in it:

koatl-0.1.33/koatl/python/koatl/prelude/regex.tl

@@ -0,0 +1,60 @@
+import re
+import collections
+import .functional.Result
+
+export Regex = class:
+    __slots__ = ("pattern",)
+
+    __init__ = (self, pattern) =>
+        pattern match:
+            re.Pattern() => self.pattern = pattern
+            str() => self.pattern = re.compile(pattern)
+            Regex(pattern=pattern) => self.pattern = pattern
+            default => raise TypeError(
+                f"Expected a str or pattern, but got {type(pattern).__name__}"
+            )
+
+    __repr__ = self => f"Regex({self.pattern})"
+
+    match = (self, string) =>
+        if not isinstance(string, str):
+            raise TypeError(f"Expected a string, but got {type(string).__name__}")
+
+        self.pattern.match(string).result.map(Regex.Match)
+
+    search = (self, string) =>
+        if not isinstance(string, str):
+            raise TypeError(f"Expected a string, but got {type(string).__name__}")
+
+        self.pattern.search(string).result.map(Regex.Match)
+
+
+    Match = collections.abc.Sequence.register& class:
+        __slots__ = ("_match",)
+        __match_args__ = ("match",)
+
+        __init__ = (self, match) =>
+            if not isinstance(match, re.Match):
+                raise TypeError(f"Expected a re.Match, but got {type(match).__name__}")
+
+            self._match = match
+
+        __iter__ = self => iter(self._match.groups())
+        __len__ = self => len(self._match.groups())
+        __getitem__ = (self, index) => self._match[index]
+
+        match = property& self => self._match.group(0)
+
+        __repr__ = self => f"Match({self._match})"
+
+
+Extension.method(str, "match")& (regex, str) => Regex(regex).match(str)
+
+
+# Note: the below methods have arguments in reverse order to Python's re module.
+
+Extension.method(str, "matches")& (str, regex) =>
+    Regex(regex).match(str)
+
+Extension.method(str, "search")& (str, regex) =>
+    Regex(regex).search(str)

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

@@ -43,6 +43,7 @@ __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"),
+    async_memo_value=dummy("memo"),
     op_map=dummy("?"),
     op_coal=("??"),
     Ok=dummy("try-expr"),