koatl 0.1.12__tar.gz → 0.1.14__tar.gz

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

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

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

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

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

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

{koatl-0.1.12 → 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.12 → 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.12 → 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.12 → 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.12 → 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.12 → 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.12 → koatl-0.1.14}/koatl/tests/e2e/base/coal.tl

@@ -12,7 +12,7 @@ obj = (class:
 assert_eq((x => x)?(1), 1)
 assert_eq([1]?[0], 1)
 assert_eq(obj?.a, 1)
-assert_eq(1?.($ + 1), 2)
+assert_eq(1?.($ + 1)(), 2)
 
 assert_eq(None ?? 1, 1)
 assert_eq(int(5) ?? 1, 5)
@@ -26,5 +26,5 @@ assert_eq(type(try [0][5]), IndexError)
 assert_eq(try 5, 5)
 
 
-assert_eq((try 5)?.($+1), 6)
-assert_eq(type((try x)?.($+1)), NameError)
+assert_eq((try 5)?.($+1)?(), 6)
+assert_eq(type((try x)?.($+1)?()), NameError)

koatl-0.1.14/koatl/tests/e2e/base/placeholder.tl

@@ -0,0 +1,37 @@
+import util.assert_eq
+
+# basic usage
+
+call_with_five = f => f(5)
+
+assert_eq(call_with_five($ + 1), 6)
+
+res = call_with_five($)
+assert_eq(callable(res), True)
+
+assert_eq(callable([1, 2, $]), True)
+
+
+# weird cases
+
+assert_eq((x => x)($ + 1)(1), 2)
+
+assert_eq(1
+    | $ + 1
+    | $ * 2
+    | $ * 5, 20)
+
+f = $ + 1
+
+assert_eq(f(2), 3)
+
+f = x => x * 2
+g = f($)
+
+assert_eq(g(3), 6)
+
+assert_eq(3 | f($), 6)
+
+assert_eq(3 | [$, 2, 3], [3, 2, 3])
+f = [$, 2, 3]
+assert_eq(f(3), [3, 2, 3])

koatl-0.1.12/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.12 → koatl-0.1.14}/koatl-core/parser/src/ast.rs

@@ -174,22 +174,22 @@ pub enum Expr<'a> {
 
     Call(Box<SExpr<'a>>, Vec<SCallItem<'a>>),
     Subscript(Box<SExpr<'a>>, Vec<ListItem<'a>>),
+    RawAttribute(Box<SExpr<'a>>, SIdent<'a>),
+    ScopedAttribute(Box<SExpr<'a>>, Box<SExpr<'a>>),
     Attribute(Box<SExpr<'a>>, SIdent<'a>),
-    ScopedExtension(Box<SExpr<'a>>, Box<SExpr<'a>>),
-    Extension(Box<SExpr<'a>>, SIdent<'a>),
 
     MappedCall(Box<SExpr<'a>>, Vec<SCallItem<'a>>),
     MappedSubscript(Box<SExpr<'a>>, Vec<ListItem<'a>>),
+    MappedRawAttribute(Box<SExpr<'a>>, SIdent<'a>),
+    MappedScopedAttribute(Box<SExpr<'a>>, Box<SExpr<'a>>),
     MappedAttribute(Box<SExpr<'a>>, SIdent<'a>),
-    MappedThen(Box<SExpr<'a>>, Box<SExpr<'a>>),
-    MappedExtension(Box<SExpr<'a>>, SIdent<'a>),
 
     Checked(Box<SExpr<'a>>, Option<Box<SPattern<'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.12 → koatl-0.1.14}/koatl-core/parser/src/parser.rs

@@ -121,7 +121,7 @@ where
         .or_not()
         .then(qualified_ident.clone())
         .try_map(|(q, value), _e| {
-            Ok(if let Expr::Attribute(..) = value.0 {
+            Ok(if let Expr::RawAttribute(..) = value.0 {
                 Pattern::Value(value)
             } else if q.is_some() {
                 Pattern::Value(value)
@@ -588,7 +588,7 @@ where
         .clone()
         .foldl_with(
             symbol(".").ignore_then(ident.clone()).repeated(),
-            |lhs, rhs, e| (Expr::Attribute(Box::new(lhs), rhs), e.span()),
+            |lhs, rhs, e| (Expr::RawAttribute(Box::new(lhs), rhs), e.span()),
         )
         .boxed();
 
@@ -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,
@@ -687,10 +673,10 @@ where
     enum Postfix<'a> {
         Call(Vec<SCallItem<'a>>),
         Subscript(Vec<ListItem<'a>>),
-        Extension(SIdent<'a>),
-        Then(SExpr<'a>),
-        ThenCall(SExpr<'a>, Vec<SCallItem<'a>>),
         Attribute(SIdent<'a>),
+        ScopedAttribute(SExpr<'a>),
+        ScopedAttributeCall(SExpr<'a>, Vec<SCallItem<'a>>),
+        RawAttribute(SIdent<'a>),
     }
 
     let call_args = enumeration(
@@ -735,7 +721,7 @@ where
 
     let attribute = symbol(".")
         .ignore_then(ident.clone())
-        .map(Postfix::Extension)
+        .map(Postfix::Attribute)
         .labelled("extension-attribute");
 
     let then = symbol(".")
@@ -743,18 +729,18 @@ where
         .then(call_args.or_not())
         .map(|(rhs, args)| {
             if let Some(args) = args {
-                Postfix::ThenCall(rhs, args)
+                Postfix::ScopedAttributeCall(rhs, args)
             } else {
-                Postfix::Then(rhs)
+                Postfix::ScopedAttribute(rhs)
             }
         })
         .labelled("then-attribute")
         .boxed();
 
-    let extension = symbol("!")
+    let raw_attr = symbol("!")
         .ignore_then(ident.clone())
-        .map(Postfix::Attribute)
-        .labelled("native-attribute")
+        .map(Postfix::RawAttribute)
+        .labelled("raw-attribute")
         .boxed();
 
     let postfix = atom
@@ -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 {
                 (
@@ -771,34 +757,38 @@ where
                         match op {
                             Postfix::Call(args) => Expr::Call(Box::new(expr), args),
                             Postfix::Subscript(args) => Expr::Subscript(Box::new(expr), args),
-                            Postfix::Attribute(attr) => Expr::Attribute(Box::new(expr), attr),
-                            Postfix::Then(rhs) => {
-                                Expr::ScopedExtension(Box::new(expr), Box::new(rhs))
+                            Postfix::RawAttribute(attr) => Expr::RawAttribute(Box::new(expr), attr),
+                            Postfix::ScopedAttribute(rhs) => {
+                                Expr::ScopedAttribute(Box::new(expr), Box::new(rhs))
                             }
-                            Postfix::ThenCall(rhs, args) => Expr::Call(
+                            Postfix::ScopedAttributeCall(rhs, args) => Expr::Call(
                                 // TODO optimize this case in the AST by skipping partial application
                                 Box::new((
-                                    Expr::ScopedExtension(Box::new(expr), Box::new(rhs)),
+                                    Expr::ScopedAttribute(Box::new(expr), Box::new(rhs)),
                                     e.span(),
                                 )),
                                 args,
                             ),
-                            Postfix::Extension(rhs) => Expr::Extension(Box::new(expr), rhs),
+                            Postfix::Attribute(rhs) => Expr::Attribute(Box::new(expr), rhs),
                         }
                     } else {
                         match op {
                             Postfix::Call(args) => Expr::MappedCall(Box::new(expr), args),
                             Postfix::Subscript(args) => Expr::MappedSubscript(Box::new(expr), args),
-                            Postfix::Attribute(attr) => Expr::MappedAttribute(Box::new(expr), attr),
-                            Postfix::Then(rhs) => Expr::MappedThen(Box::new(expr), Box::new(rhs)),
-                            Postfix::ThenCall(rhs, args) => Expr::Call(
+                            Postfix::RawAttribute(attr) => {
+                                Expr::MappedRawAttribute(Box::new(expr), attr)
+                            }
+                            Postfix::ScopedAttribute(rhs) => {
+                                Expr::MappedScopedAttribute(Box::new(expr), Box::new(rhs))
+                            }
+                            Postfix::ScopedAttributeCall(rhs, args) => Expr::Call(
                                 Box::new((
-                                    Expr::MappedThen(Box::new(expr), Box::new(rhs)),
+                                    Expr::MappedScopedAttribute(Box::new(expr), Box::new(rhs)),
                                     e.span(),
                                 )),
                                 args,
                             ),
-                            Postfix::Extension(rhs) => Expr::MappedExtension(Box::new(expr), rhs),
+                            Postfix::Attribute(rhs) => Expr::MappedAttribute(Box::new(expr), rhs),
                         }
                     },
                     e.span(),
@@ -808,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(
@@ -819,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.12 → koatl-0.1.14}/koatl-core/parser/src/util.rs

@@ -147,14 +147,14 @@ impl AstBuilder {
         attr: impl Into<Cow<'src, str>>,
     ) -> SExpr<'src> {
         (
-            Expr::Attribute(Box::new(value), (attr.into(), self.span)),
+            Expr::RawAttribute(Box::new(value), (attr.into(), self.span)),
             self.span,
         )
     }
 
     pub fn then<'src>(&self, left: SExpr<'src>, right: SExpr<'src>) -> SExpr<'src> {
         (
-            Expr::ScopedExtension(Box::new(left), Box::new(right)),
+            Expr::ScopedAttribute(Box::new(left), Box::new(right)),
             self.span,
         )
     }