koatl 0.1.13__tar.gz → 0.1.14__tar.gz

{koatl-0.1.13 → koatl-0.1.14}/Cargo.lock

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

{koatl-0.1.13 → koatl-0.1.14}/PKG-INFO

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

{koatl-0.1.13 → koatl-0.1.14}/koatl/Cargo.toml

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

{koatl-0.1.13 → koatl-0.1.14/koatl}/python/koatl/cli.py

@@ -2,7 +2,7 @@ def transpile_from_source(source, mode="script", script_path="<string>"):
     from koatl import transpile
     import ast
 
-    transpiled_code = transpile(source, mode=mode)
+    transpiled_code = transpile(source, mode=mode, filename=str(script_path))
 
     return ast.unparse(transpiled_code)
 
@@ -10,7 +10,7 @@ def transpile_from_source(source, mode="script", script_path="<string>"):
 def run_from_source(source, mode="script", script_path="<string>"):
     from koatl import transpile
 
-    transpiled_code = transpile(source, mode=mode)
+    transpiled_code = transpile(source, mode=mode, filename=str(script_path))
     code_obj = compile(transpiled_code, script_path, "exec")
 
     script_globals = {"__name__": "__main__"}

{koatl-0.1.13 → koatl-0.1.14/koatl}/python/koatl/prelude/functional/__init__.tl

@@ -1,9 +1,10 @@
-export import .ok.*
+export import .monad.*
+export import .result.*
 export import .async.*
 export import .reader.*
 
 export Fn = class:
-    compose = &[staticmethod] (*args) =>
+    compose = staticmethod& (*args) =>
         args match:
             [] => raise ValueError("At least one function is required for composition")
             [f] => f

koatl-0.1.14/koatl/python/koatl/prelude/functional/async.tl

@@ -0,0 +1,42 @@
+import functools.wraps
+import asyncio
+import .async_util
+
+export Async = class:
+    __init__ = (self, awaitable) => self.generator = awaitable.__await__()
+
+    __await__ = self => self.generator
+
+    __repr__ = self => "Async(...)"
+
+    from_generator_fn = staticmethod& (generator_fn, *args, **kwargs) =>
+        m = object.__new__(Async)
+        m.generator = generator_fn(*args, **kwargs)
+        return m
+
+    run = self => asyncio.run(async_util.to_coro(self))
+
+    bind_once = (self, f) => Async.from_generator_fn& () =>
+        result = f(yield from self.__await__())
+
+        if hasattr(result, "__await__"):
+            return yield from result.__await__()
+
+        return result
+
+    bind_gen = (self, gen) => Async.from_generator_fn& () =>
+        nonlocal self = self
+        try:
+            while True:
+                self = gen.send(yield from self.__await__())
+        except StopIteration(value=value):
+            return value
+
+    pure = staticmethod& x => Async.from_generator_fn& () =>
+        return x
+        yield None
+
+    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)

koatl-0.1.14/koatl/python/koatl/prelude/functional/monad.tl

@@ -0,0 +1,12 @@
+import abc
+
+export Monad = class(abc.ABC):
+    bind = (self, f) => self.bind_once(f)
+
+    # An optional, optimized implementation of `bind` that skips deep recursion.
+    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

koatl-0.1.14/koatl/python/koatl/prelude/functional/reader.tl

@@ -0,0 +1,33 @@
+import functools.wraps
+
+export Reader = class:
+    __init__ = (self, fn) => self.fn = fn
+
+    __repr__ = self => "Reader(...)"
+
+    run = (self, ctx) => self.fn(ctx)
+
+    bind_once = (self, f) => Reader& ctx =>
+        v = f(self.fn(ctx))
+        if v matches Reader():
+            v.fn(ctx)
+        else:
+            v
+
+    # TODO: this is a workaround to avoid recursion.
+    # how to get bind_gen directly from bind_once?
+    bind_gen = (self, gen) => Reader& ctx =>
+        nonlocal self = self
+        try:
+            while True:
+                self = gen.send(self.fn(ctx))
+        except StopIteration(value=value):
+            return value
+
+    NoKey = object()
+
+    ask = staticmethod& (key=NoKey) => Reader(
+        key === Reader.NoKey then ctx => ctx else ctx => ctx[key]
+    )
+
+    pure = staticmethod& value => Reader(ctx => value)

koatl-0.1.14/koatl/python/koatl/prelude/functional/result.tl

@@ -0,0 +1,80 @@
+import functools.wraps
+import .monad.Monad
+import koatl.runtime.virtual.register_global_attr
+
+export Result = class(Monad):
+    bind_once = (self, f) => self match:
+        Ok(value) => f(value)
+        Ok() => f(self)
+        default => self
+
+    bind_gen = (self, gen) =>
+        try:
+            while True:
+                if not __tl__.ok(self):
+                    return self
+
+                if self matches Ok(value):
+                    self = value
+
+                self = gen.send(self)
+        except StopIteration(value=value):
+            if value === None:
+                return Ok(None)
+            return value
+
+    map_err = (self, f) =>
+        if self matches Err():
+            return f(self)
+        else:
+            return self
+
+OkMeta = class(type):
+    __instancecheck__ = (cls, instance) => __tl__.ok(instance)
+
+export Ok = class(metaclass=OkMeta):
+    __match_args__ = ("value",)
+
+    __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
+    bind_once = Result.bind_once
+    bind_gen = Result.bind_gen
+    map_err = Result.map_err
+
+    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,
+    "bind",
+    Result.bind_once
+)
+
+register_global_attr(
+    object,
+    "bind_once",
+    Result.bind_once
+)
+
+register_global_attr(
+    object,
+    "bind_gen",
+    Result.bind_gen
+)

{koatl-0.1.13 → koatl-0.1.14/koatl}/python/koatl/runtime/__init__.py

@@ -22,10 +22,11 @@ from .helpers import *
 
 
 __tl__ = SimpleNamespace(
+    vget=virtual.vget,
+    vhas=virtual.vhas,
     unpack_record=helpers.unpack_record,
     set_exports=helpers.set_exports,
     do=helpers.do,
-    vget=helpers.vget,
     ok=helpers.ok,
     partial=functools.partial,
     **{name: helpers.__dict__[name] for name in helpers.__all__},

{koatl-0.1.13 → koatl-0.1.14/koatl}/python/koatl/runtime/helpers.py

@@ -56,17 +56,17 @@ def ok(obj):
 def do(f):
     @wraps(f)
     def impl(*args, **kwargs):
-        coro = f(*args, **kwargs)
+        gen = f(*args, **kwargs)
 
         try:
-            m = coro.send(None)
+            m = gen.send(None)
         except StopIteration as e:
             return e.value
 
         def recurse(v):
             nonlocal m
             try:
-                m = coro.send(v)
+                m = gen.send(v)
                 return vget(m, "bind_once")(recurse)
             except StopIteration as e:
                 try:
@@ -74,6 +74,10 @@ def do(f):
                 except AttributeError:
                     return e.value
 
-        return vget(m, "bind_once")(recurse)
+        try:
+            print(m, gen)
+            return vget(m, "bind_gen")(gen)
+        except (NotImplementedError, AttributeError):
+            return vget(m, "bind_once")(recurse)
 
     return impl

{koatl-0.1.13 → koatl-0.1.14}/koatl/python/koatl/runtime/meta_finder.py

@@ -53,9 +53,13 @@ class TlLoader(Loader):
         )
 
         if module.__name__.startswith("koatl.prelude"):
-            transpiled_code = transpile(source_code, mode="prelude")
+            transpiled_code = transpile(
+                source_code, mode="prelude", filename=self.filepath
+            )
         else:
-            transpiled_code = transpile(source_code, mode="module")
+            transpiled_code = transpile(
+                source_code, mode="module", filename=self.filepath
+            )
 
         code = compile(transpiled_code, self.filepath, "exec")
 

{koatl-0.1.13 → koatl-0.1.14/koatl}/python/koatl/runtime/virtual.py

@@ -46,6 +46,33 @@ def vget(obj, name):
         ) from None
 
 
+def vhas(obj, name):
+    if hasattr(obj, name):
+        return True
+
+    if name == "iter":
+        if isinstance(obj, slice):
+            return True
+
+        try:
+            obj.items()
+            return True
+        except AttributeError:
+            pass
+
+        try:
+            iter(obj)
+            return True
+        except TypeError:
+            pass
+
+    v = fast_vget(obj, name)
+    if v is not None:
+        return True
+
+    return False
+
+
 def Trait(module, name, methods, *, requires=[]):
     def fix_methods(type_name, methods):
         import inspect

koatl-0.1.13/koatl/tests/e2e/prelude/ok.tl → koatl-0.1.14/koatl/tests/e2e/prelude/result.tl

@@ -16,4 +16,14 @@ fn = () =>
     v.append(@321)
 fn()
 
-assert_eq(v, [123, 222, 321])
+assert_eq(v, [123, 222, 321])
+
+v = []
+fn = () =>
+    v.append(@123)
+    v.append(@Ok(None))
+    v.append(@ValueError())
+    v.append(@321)
+fn()
+
+assert_eq(v, [123, None])

koatl-0.1.14/koatl/tests/parse/deco.tl

@@ -0,0 +1,2 @@
+wraps(f)& x => x
+y = wraps(f)& x => x

{koatl-0.1.13 → koatl-0.1.14}/koatl-core/parser/src/ast.rs

@@ -189,7 +189,7 @@ pub enum Expr<'a> {
     Fn(Vec<ArgDefItem<'a>>, Box<SExpr<'a>>),
     Fstr(Spanned<String>, Vec<(SFmtExpr<'a>, Spanned<String>)>),
 
-    Decorated(Vec<SExpr<'a>>, Box<SExpr<'a>>),
+    Decorated(Box<SExpr<'a>>, Box<SExpr<'a>>),
 
     Block(Vec<SStmt<'a>>),
 }

{koatl-0.1.13 → koatl-0.1.14}/koatl-core/parser/src/parser.rs

@@ -620,19 +620,6 @@ where
     ))
     .boxed();
 
-    let deco_list = enumeration(expr.clone(), symbol(","))
-        .delimited_by_with_eol(just(Token::Symbol("[")), just(Token::Symbol("]")))
-        .labelled("decorators")
-        .boxed();
-
-    let decorators = symbol("&").ignore_then(deco_list.clone());
-
-    let decorated = decorators
-        .then(below_pipe.clone())
-        .map(|(decorators, expr)| Expr::Decorated(decorators, Box::new(expr)))
-        .spanned()
-        .labelled("fn");
-
     enum ControlKw {
         Await,
         Yield,
@@ -665,7 +652,6 @@ where
 
     atom.define(
         choice((
-            decorated,
             ident_expr.clone(),
             classic_if,
             classic_match,
@@ -751,7 +737,7 @@ where
         .labelled("then-attribute")
         .boxed();
 
-    let extension = symbol("!")
+    let raw_attr = symbol("!")
         .ignore_then(ident.clone())
         .map(Postfix::RawAttribute)
         .labelled("raw-attribute")
@@ -763,7 +749,7 @@ where
             symbol("?")
                 .to(1)
                 .or_not()
-                .then(choice((call, subscript, attribute, then, extension)))
+                .then(choice((call, subscript, attribute, then, raw_attr)))
                 .repeated(),
             |expr, (coal, op), e| -> SExpr {
                 (
@@ -812,6 +798,19 @@ where
         .labelled("postfix")
         .boxed();
 
+    let decorator = postfix
+        .clone()
+        .then(symbol("&").ignore_then(expr.clone()).or_not())
+        .map_with(|(lhs, rhs), e| {
+            if let Some(rhs) = rhs {
+                (Expr::Decorated(Box::new(lhs), Box::new(rhs)), e.span())
+            } else {
+                lhs
+            }
+        })
+        .labelled("decorator")
+        .boxed();
+
     let mut checked = Recursive::<Indirect<TInput, SExpr, TExtra>>::declare();
 
     unary.define(
@@ -823,7 +822,7 @@ where
         }
         .repeated()
         .foldr_with(
-            choice((postfix, checked.clone())),
+            choice((decorator, checked.clone())),
             |op: UnaryOp, rhs: SExpr, e| (Expr::Unary(op, Box::new(rhs)), e.span()),
         )
         .labelled("unary-expression")

{koatl-0.1.13 → koatl-0.1.14}/koatl-core/src/transform.rs

@@ -663,7 +663,7 @@ fn transform_assignment<'src, 'ast>(
                 }
                 Expr::Decorated(deco, right) => {
                     cur_node = &right.0;
-                    decorators.extend(deco);
+                    decorators.push(deco);
                 }
                 Expr::Call(left, right) => {
                     if right.len() != 1 {
@@ -2285,20 +2285,18 @@ impl<'src> SExprExt<'src> for SExpr<'src> {
                     pre: aux_stmts,
                 })
             }
-            Expr::Decorated(decorators, expr) => {
+            Expr::Decorated(deco, expr) => {
                 let mut pre = PyBlock::new();
                 let mut node = bind_pre(&mut pre, expr.transform(ctx)?);
 
-                for item in decorators.iter().rev() {
-                    node = (
-                        PyExpr::Call(
-                            Box::new(bind_pre(&mut pre, item.transform(ctx)?)),
-                            vec![PyCallItem::Arg(node)],
-                        ),
-                        item.1,
-                    )
-                        .into();
-                }
+                node = (
+                    PyExpr::Call(
+                        Box::new(bind_pre(&mut pre, deco.transform(ctx)?)),
+                        vec![PyCallItem::Arg(node)],
+                    ),
+                    *span,
+                )
+                    .into();
 
                 Ok(SPyExprWithPre { value: node, pre })
             }

{koatl-0.1.13/koatl → koatl-0.1.14}/python/koatl/cli.py

@@ -2,7 +2,7 @@ def transpile_from_source(source, mode="script", script_path="<string>"):
     from koatl import transpile
     import ast
 
-    transpiled_code = transpile(source, mode=mode)
+    transpiled_code = transpile(source, mode=mode, filename=str(script_path))
 
     return ast.unparse(transpiled_code)
 
@@ -10,7 +10,7 @@ def transpile_from_source(source, mode="script", script_path="<string>"):
 def run_from_source(source, mode="script", script_path="<string>"):
     from koatl import transpile
 
-    transpiled_code = transpile(source, mode=mode)
+    transpiled_code = transpile(source, mode=mode, filename=str(script_path))
     code_obj = compile(transpiled_code, script_path, "exec")
 
     script_globals = {"__name__": "__main__"}

{koatl-0.1.13/koatl → koatl-0.1.14}/python/koatl/prelude/functional/__init__.tl

@@ -1,9 +1,10 @@
-export import .ok.*
+export import .monad.*
+export import .result.*
 export import .async.*
 export import .reader.*
 
 export Fn = class:
-    compose = &[staticmethod] (*args) =>
+    compose = staticmethod& (*args) =>
         args match:
             [] => raise ValueError("At least one function is required for composition")
             [f] => f

koatl-0.1.14/python/koatl/prelude/functional/async.tl

@@ -0,0 +1,42 @@
+import functools.wraps
+import asyncio
+import .async_util
+
+export Async = class:
+    __init__ = (self, awaitable) => self.generator = awaitable.__await__()
+
+    __await__ = self => self.generator
+
+    __repr__ = self => "Async(...)"
+
+    from_generator_fn = staticmethod& (generator_fn, *args, **kwargs) =>
+        m = object.__new__(Async)
+        m.generator = generator_fn(*args, **kwargs)
+        return m
+
+    run = self => asyncio.run(async_util.to_coro(self))
+
+    bind_once = (self, f) => Async.from_generator_fn& () =>
+        result = f(yield from self.__await__())
+
+        if hasattr(result, "__await__"):
+            return yield from result.__await__()
+
+        return result
+
+    bind_gen = (self, gen) => Async.from_generator_fn& () =>
+        nonlocal self = self
+        try:
+            while True:
+                self = gen.send(yield from self.__await__())
+        except StopIteration(value=value):
+            return value
+
+    pure = staticmethod& x => Async.from_generator_fn& () =>
+        return x
+        yield None
+
+    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)

koatl-0.1.14/python/koatl/prelude/functional/monad.tl

@@ -0,0 +1,12 @@
+import abc
+
+export Monad = class(abc.ABC):
+    bind = (self, f) => self.bind_once(f)
+
+    # An optional, optimized implementation of `bind` that skips deep recursion.
+    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

koatl-0.1.14/python/koatl/prelude/functional/reader.tl

@@ -0,0 +1,33 @@
+import functools.wraps
+
+export Reader = class:
+    __init__ = (self, fn) => self.fn = fn
+
+    __repr__ = self => "Reader(...)"
+
+    run = (self, ctx) => self.fn(ctx)
+
+    bind_once = (self, f) => Reader& ctx =>
+        v = f(self.fn(ctx))
+        if v matches Reader():
+            v.fn(ctx)
+        else:
+            v
+
+    # TODO: this is a workaround to avoid recursion.
+    # how to get bind_gen directly from bind_once?
+    bind_gen = (self, gen) => Reader& ctx =>
+        nonlocal self = self
+        try:
+            while True:
+                self = gen.send(self.fn(ctx))
+        except StopIteration(value=value):
+            return value
+
+    NoKey = object()
+
+    ask = staticmethod& (key=NoKey) => Reader(
+        key === Reader.NoKey then ctx => ctx else ctx => ctx[key]
+    )
+
+    pure = staticmethod& value => Reader(ctx => value)

koatl-0.1.14/python/koatl/prelude/functional/result.tl

@@ -0,0 +1,80 @@
+import functools.wraps
+import .monad.Monad
+import koatl.runtime.virtual.register_global_attr
+
+export Result = class(Monad):
+    bind_once = (self, f) => self match:
+        Ok(value) => f(value)
+        Ok() => f(self)
+        default => self
+
+    bind_gen = (self, gen) =>
+        try:
+            while True:
+                if not __tl__.ok(self):
+                    return self
+
+                if self matches Ok(value):
+                    self = value
+
+                self = gen.send(self)
+        except StopIteration(value=value):
+            if value === None:
+                return Ok(None)
+            return value
+
+    map_err = (self, f) =>
+        if self matches Err():
+            return f(self)
+        else:
+            return self
+
+OkMeta = class(type):
+    __instancecheck__ = (cls, instance) => __tl__.ok(instance)
+
+export Ok = class(metaclass=OkMeta):
+    __match_args__ = ("value",)
+
+    __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
+    bind_once = Result.bind_once
+    bind_gen = Result.bind_gen
+    map_err = Result.map_err
+
+    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,
+    "bind",
+    Result.bind_once
+)
+
+register_global_attr(
+    object,
+    "bind_once",
+    Result.bind_once
+)
+
+register_global_attr(
+    object,
+    "bind_gen",
+    Result.bind_gen
+)