koatl 0.1.35__tar.gz → 0.1.37__tar.gz

{koatl-0.1.35 → koatl-0.1.37}/Cargo.lock

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

{koatl-0.1.35 → koatl-0.1.37}/PKG-INFO

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

{koatl-0.1.35 → koatl-0.1.37}/koatl/Cargo.toml

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

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

@@ -0,0 +1,60 @@
+import koatl.std.iter.Iterable
+
+Extension.trait(Iterable)
+
+import koatl.std.data.List
+
+Extension.property(list, "len")& List.len.fget
+
+import koatl.std.alg.*
+
+Extension.property(object, "result")& self => Result(self)
+
+__tl__.Ok = Ok
+__tl__.Err = Err
+__tl__.Result = Result
+
+__tl__.op_coal = (x, f) =>
+    if x matches Result():
+        return x.coalesce(f)
+
+    if not koatl.std.alg.result.infer_ok(x):
+        return f()
+    return x
+
+__tl__.op_map = (x, f) =>
+    if x matches Result():
+        return x.map(f)
+
+    if koatl.std.alg.result.infer_ok(x):
+        return f(x)
+    return x
+
+__tl__.memo_value = Memo.value
+__tl__.async_memo_value = AsyncMemo.value
+
+import koatl.std.re.Pattern
+
+Extension.method(str, "match")& (regex, str) => Pattern(regex).match(str)
+
+# Note: the below methods have arguments in reverse order to Python's re module.
+Extension.method(str, "matches")& (str, regex) => Pattern(regex).match(str)
+Extension.method(str, "search")& (str, regex) => Pattern(regex).search(str)
+
+import koatl.std.lazy_module.LazyModule
+
+export Result, Ok, Err, Env, Memo, Async, AsyncMemo
+export std = LazyModule("koatl.std")
+
+ModuleProxy = class:
+    __init__ = (self) =>
+        self._modules = {}
+
+    __getattr__ = (self, attr) =>
+        if attr not in self._modules:
+            self._modules[attr] = LazyModule(attr)
+        return self._modules[attr]
+
+    __repr__ = self => f"ModuleProxy({self._modules})"
+
+export mod = ModuleProxy()

{koatl-0.1.35 → koatl-0.1.37}/koatl/python/koatl/runtime/virtual.py

@@ -1,14 +1,14 @@
 from functools import partial
 from itertools import count
 from types import SimpleNamespace
-from .._rs import fast_vget, fast_vset, fast_vset_trait
+from koatl._rs import fast_vget, fast_vset, fast_vset_trait
 
 
 def vget(obj, name, ignore_traits=False):
     try:
         return getattr(obj, name)
-    except AttributeError:
-        pass
+    except AttributeError as e:
+        orig_err = e
 
     # special case for iter - this could be implemented using types and trait vtbls
     # but this is simpler and probably faster
@@ -38,7 +38,7 @@ def vget(obj, name, ignore_traits=False):
 
         return partial(v, obj)
 
-    raise AttributeError(f"'{type(obj).__name__}' object has no v-attribute '{name}'")
+    raise orig_err
 
 
 def vhas(obj, name, ignore_traits=False):

koatl-0.1.37/koatl/python/koatl/std/alg/__init__.tl

@@ -0,0 +1,5 @@
+export import .base.*
+export import .async.*
+export import .env.*
+export import .memo.*
+export import .result.*

{koatl-0.1.35/koatl/python/koatl/prelude/functional → koatl-0.1.37/koatl/python/koatl/std/alg}/async.tl

@@ -1,7 +1,7 @@
 import functools.wraps
 import asyncio
 
-import .MonadOnce
+import .base.MonadOnce
 
 export Async = class(MonadOnce):
     __init__ = (self, awaitable) => self.generator = awaitable.__await__()

{koatl-0.1.35/python/koatl/prelude/functional → koatl-0.1.37/koatl/python/koatl/std/alg}/env.tl

@@ -1,5 +1,5 @@
 import functools.wraps
-import .MonadOnce
+import .base.MonadOnce
 
 export Env = class(MonadOnce):
     __slots__ = ("f",)

{koatl-0.1.35/python/koatl/prelude/functional → koatl-0.1.37/koatl/python/koatl/std/alg}/memo.tl

@@ -1,7 +1,7 @@
 import collections.defaultdict
 import functools.wraps
 
-import .algebra.(MonadOnce, Identity)
+import .base.(MonadOnce, Identity)
 import .result.(Result, Ok, Err)
 import .async.(Async)
 
@@ -181,7 +181,4 @@ export AsyncMemo = class(MonadOnce):
 
         except StopIteration(value=value):
             return value
-    )
-
-__tl__.memo_value = Memo.value
-__tl__.async_memo_value = AsyncMemo.value
+    )

{koatl-0.1.35/koatl/python/koatl/prelude/functional → koatl-0.1.37/koatl/python/koatl/std/alg}/result.tl

@@ -1,5 +1,5 @@
 import functools.wraps
-import .algebra.(Identity, MonadOnce)
+import .base.(Identity, MonadOnce)
 
 infer_ok = x =>
     x match:
@@ -158,26 +158,4 @@ export Err = class(Result):
         if self.value matches BaseException():
             raise self.value
         raise ValueError(f"Expected Ok, got {repr(self)}")
-    coalesce = (self, f) => f()
-
-Extension.property(object, "result")& self => Result
-
-__tl__.Ok = Ok
-__tl__.Err = Err
-__tl__.Result = Result
-
-__tl__.op_coal = (x, f) =>
-    if x matches Result():
-        return x.coalesce(f)
-
-    if not infer_ok(x):
-        return f()
-    return x
-
-__tl__.op_map = (x, f) =>
-    if x matches Result():
-        return x.map(f)
-
-    if infer_ok(x):
-        return f(x)
-    return x
+    coalesce = (self, f) => f()

koatl-0.1.37/koatl/python/koatl/std/data/__init__.tl

@@ -0,0 +1 @@
+export import .list.List

{koatl-0.1.35/python/koatl/prelude/functional → koatl-0.1.37/koatl/python/koatl/std/data}/list.tl

@@ -1,6 +1,6 @@
 import itertools
 
-import .Monad
+import koatl.std.alg.Monad
 
 export List = class(Monad):
     __new__ = (cls, *args, **kwargs) => raise ValueError(
@@ -19,7 +19,4 @@ export List = class(Monad):
 
     pure = staticmethod& x => [x]
 
-    len = property& self => len(self)
-
-
-Extension.property(list, "len")& List.len.fget
+    len = property& self => len(self)

koatl-0.1.37/koatl/python/koatl/std/io.tl

@@ -0,0 +1,3 @@
+export read_file = (filename) =>
+    with desc = open(filename, "r"):
+        desc.read()

koatl-0.1.35/python/koatl/prelude/iterable.tl → koatl-0.1.37/koatl/python/koatl/std/iter.tl

@@ -1,8 +1,9 @@
 import itertools
 import builtins
-import .functional.(Traversable, Ok, Err, Memo, Async, AsyncMemo, Result)
+import .alg.(Traversable, Ok, Err, Memo, Async, AsyncMemo, Result)
 
-export Iterable = Extension.trait& class(Traversable, Trait):
+
+export Iterable = class(Traversable, Trait):
     iter = Trait.abstract& self => None
 
     skip = (self, n) =>
@@ -11,6 +12,16 @@ export Iterable = Extension.trait& class(Traversable, Trait):
             next(it, None)
         it
 
+    skip_while = (self, f) =>
+        let it = self.iter
+        while True:
+            try:
+                let value = next(it)
+                if not f(value):
+                    return Iterable.chain([value], it)
+            except StopIteration():
+                return it
+
     take = (self, n) =>
         let impl = () =>
             let it = self.iter
@@ -70,7 +81,7 @@ export Iterable = Extension.trait& class(Traversable, Trait):
 
     reverse = self => reversed(list(self.iter))
 
-    sort = (self, key=None, reverse=False) =>
+    sorted = (self, key=None, reverse=False) =>
         sorted(self.iter, key=key, reverse=reverse)
 
     copy = self => itertools.tee(self.iter)
@@ -99,19 +110,19 @@ export Iterable = Extension.trait& class(Traversable, Trait):
             acc[i] = value
         acc
 
-    group_by = (self, f) =>
+    group_by = (self, f=None) =>
         let acc = dict()
         for i in self:
-            let key = f(i)
+            let key = f === None then i else f(i)
             if not acc.__contains__(key):
                 acc[key] = []
             acc[key].append(i)
         acc
 
-    count_by = (self, f) =>
+    count_by = (self, f=None) =>
         let acc = dict()
         for i in self:
-            let key = f(i)
+            let key = f === None then i else f(i)
             if not acc.__contains__(key):
                 acc[key] = 0
             acc[key] += 1
@@ -249,8 +260,6 @@ export Iterable = Extension.trait& class(Traversable, Trait):
         Record(self.iter)
 
     traverse = (self, f=None) =>
-        import .functional.(Async, Result)
-
         if f === None:
             f = x => x
 

koatl-0.1.37/koatl/python/koatl/std/lazy_module.tl

@@ -0,0 +1,33 @@
+import importlib
+import collections
+
+export LazyModule = class:
+    __init__ = (self, name) =>
+        self._name = name
+        self._module = None
+        self._submodules = {}
+
+    __getattr__ = (self, attr) =>
+        try:
+            if self._module === None:
+                self._module = importlib.import_module(self._name)
+
+            if hasattr(self._module, "__path__"):
+                if attr not in self._submodules:
+                    self._submodules[attr] =
+                        if importlib.util.find_spec(f"{self._name}.{attr}", self._module.__path__):
+                            LazyModule(f"{self._name}.{attr}")
+                        else:
+                            None
+
+                if self._submodules[attr] <=> None:
+                    return self._submodules[attr]
+
+            if hasattr(self._module, attr):
+                return getattr(self._module, attr)
+        except e:
+            raise ValueError(str(e))
+
+        raise AttributeError(f"Module '{self._name}' has no attribute '{attr}'")
+
+    __repr__ = self => f"LazyModule({self._name})"

koatl-0.1.35/koatl/python/koatl/prelude/regex.tl → koatl-0.1.37/koatl/python/koatl/std/re.tl

@@ -1,8 +1,8 @@
 import re
 import collections
-import .functional.Result
+import .alg.Result
 
-export Regex = class:
+export Pattern = class:
     __slots__ = ("pattern",)
 
     __init__ = (self, pattern) =>
@@ -45,16 +45,4 @@ export Regex = class:
 
         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)
+        __repr__ = self => f"Match({self._match})"

{koatl-0.1.35 → koatl-0.1.37}/koatl-core/parser/src/ast.rs

@@ -97,21 +97,20 @@ pub enum Literal<'a> {
 pub type SLiteral<'a> = Spanned<Literal<'a>>;
 
 #[derive(Debug, Clone)]
-pub enum ImportList<'a> {
-    // ident, alias
-    Leaves(Vec<(SIdent<'a>, Option<SIdent<'a>>)>),
+pub enum ImportLeaf<'a> {
+    Multi(Vec<ImportTree<'a>>),
+    Single(SIdent<'a>, Option<SIdent<'a>>),
+    This(Option<SIdent<'a>>),
     Star,
 }
 
 #[derive(Debug, Clone)]
-pub struct ImportStmt<'a> {
+pub struct ImportTree<'a> {
     pub trunk: Vec<SIdent<'a>>,
-    pub imports: ImportList<'a>,
+    pub leaf: Spanned<ImportLeaf<'a>>,
 
     // number of dots prepending the trunk
     pub level: usize,
-
-    pub reexport: bool,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ -133,7 +132,7 @@ pub enum Stmt<'a, TTree: Tree> {
     Return(TTree::Expr),
     While(TTree::Expr, TTree::Expr),
     For(TTree::Pattern, TTree::Expr, TTree::Expr),
-    Import(ImportStmt<'a>),
+    Import(ImportTree<'a>, bool),
     Try(TTree::Expr, Vec<MatchCase<TTree>>, Option<TTree::Expr>),
     Raise(Option<TTree::Expr>),
 

{koatl-0.1.35 → koatl-0.1.37}/koatl-core/parser/src/parser.rs

@@ -646,55 +646,62 @@ where
         .labelled("continue statement")
         .boxed();
 
+    let import_item = recursive(|import_item| {
+        // TODO this looks extremely cursed
+        let level = symbol("..")
+            .to(2)
+            .repeated()
+            .foldr(
+                symbol(".")
+                    .or_not()
+                    .map(|x| if x.is_some() { 1 } else { 0 }),
+                |acc, sum| acc + sum,
+            )
+            .boxed();
+
+        let prefix = ident
+            .clone()
+            .then_ignore(symbol("."))
+            .repeated()
+            .collect()
+            .boxed();
+
+        choice((
+            group((
+                level,
+                prefix,
+                choice((
+                    enumeration(import_item.clone(), symbol(","))
+                        .delimited_by_with_eol(symbol("("), symbol(")"))
+                        .map(ImportLeaf::Multi),
+                    ident
+                        .clone()
+                        .then(just(Token::Kw("as")).ignore_then(ident.clone()).or_not())
+                        .map(|(item, name)| ImportLeaf::Single(item, name)),
+                    symbol("*").map(|_| ImportLeaf::Star),
+                )),
+            ))
+            .map_with(|(level, prefix, choice), e| ImportTree {
+                trunk: prefix,
+                level: level,
+                leaf: choice.spanned(e.span()),
+            }),
+            symbol(".")
+                .ignore_then(just(Token::Kw("as")).ignore_then(ident.clone()).or_not())
+                .map_with(|alias, e| ImportTree {
+                    trunk: vec![],
+                    level: 0,
+                    leaf: ImportLeaf::This(alias).spanned(e.span()),
+                }),
+        ))
+    });
+
     let import_stmt = just(Token::Kw("export"))
         .to(1)
         .or_not()
         .then_ignore(just(Token::Kw("import")))
-        .then(group((
-            // TODO this looks extremely cursed
-            symbol("..")
-                .to(2)
-                .repeated()
-                .foldr(
-                    symbol(".")
-                        .or_not()
-                        .map(|x| if x.is_some() { 1 } else { 0 }),
-                    |acc, sum| acc + sum,
-                )
-                .boxed(),
-            ident
-                .clone()
-                .then_ignore(symbol("."))
-                .repeated()
-                .collect()
-                .boxed(),
-            choice((
-                enumeration(
-                    ident
-                        .clone()
-                        .then(just(Token::Kw("as")).ignore_then(ident.clone()).or_not()),
-                    symbol(","),
-                )
-                .delimited_by_with_eol(symbol("("), symbol(")"))
-                .map(ImportList::Leaves)
-                .boxed(),
-                just(Token::Symbol("*")).map(|_| ImportList::Star),
-                ident
-                    .clone()
-                    .then(just(Token::Kw("as")).ignore_then(ident.clone()).or_not())
-                    .map(|x| ImportList::Leaves(vec![x]))
-                    .boxed(),
-            ))
-            .boxed(),
-        )))
-        .map(|(reexport, (level, trunk, import_list))| {
-            SStmtInner::Import(ImportStmt {
-                trunk,
-                imports: import_list,
-                level,
-                reexport: reexport.is_some(),
-            })
-        })
+        .then(import_item)
+        .map(|(reexport, tree)| SStmtInner::Import(tree, reexport.is_some()))
         .labelled("import statement")
         .boxed();
 
@@ -745,8 +752,7 @@ where
     let mut expr = Recursive::<chumsky::recursive::Indirect<TInput, SExpr, TExtra>>::declare();
     let mut unary = Recursive::<chumsky::recursive::Indirect<TInput, SExpr, TExtra>>::declare();
     let mut cases = Recursive::<chumsky::recursive::Indirect<TInput, _, TExtra>>::declare();
-    let mut below_pipe =
-        Recursive::<chumsky::recursive::Indirect<TInput, SExpr, TExtra>>::declare();
+    let mut below_fn = Recursive::<chumsky::recursive::Indirect<TInput, SExpr, TExtra>>::declare();
 
     let stmts = stmt
         .clone()
@@ -1134,6 +1140,7 @@ where
 
     enum Postfix<'a> {
         Call(Vec<CallItem<'a, STree<'a>>>),
+        MethodCall(SIdent<'a>, Vec<CallItem<'a, STree<'a>>>),
         Subscript(Vec<ListItem<STree<'a>>>),
         Attribute(SIdent<'a>),
         ScopedAttribute(SExpr<'a>),
@@ -1181,6 +1188,12 @@ where
     .labelled("subscript")
     .boxed();
 
+    let method_call = symbol(".")
+        .ignore_then(ident.clone())
+        .then(call_args.clone())
+        .map(|(ident, args)| Postfix::MethodCall(ident, args))
+        .labelled("method-call");
+
     let attribute = symbol(".")
         .ignore_then(ident.clone())
         .map(Postfix::Attribute)
@@ -1204,12 +1217,25 @@ where
             symbol("?")
                 .to(1)
                 .or_not()
-                .then(choice((call, subscript, attribute, then, raw_attr)))
+                .then(choice((
+                    call,
+                    subscript,
+                    method_call,
+                    attribute,
+                    then,
+                    raw_attr,
+                )))
                 .repeated(),
             |expr, (coal, op), e| -> SExpr {
                 if coal.is_none() {
                     match op {
                         Postfix::Call(args) => Expr::Call(expr.indirect(), args),
+                        Postfix::MethodCall(name, args) => Expr::Call(
+                            Expr::Attribute(expr.indirect(), name)
+                                .spanned(e.span())
+                                .indirect(),
+                            args,
+                        ),
                         Postfix::Subscript(args) => Expr::Subscript(expr.indirect(), args),
                         Postfix::RawAttribute(attr) => Expr::RawAttribute(expr.indirect(), attr),
                         Postfix::ScopedAttribute(rhs) => {
@@ -1220,6 +1246,12 @@ where
                 } else {
                     match op {
                         Postfix::Call(args) => Expr::MappedCall(expr.indirect(), args),
+                        Postfix::MethodCall(name, args) => Expr::MappedCall(
+                            Expr::MappedAttribute(expr.indirect(), name)
+                                .spanned(e.span())
+                                .indirect(),
+                            args,
+                        ),
                         Postfix::Subscript(args) => Expr::MappedSubscript(expr.indirect(), args),
                         Postfix::RawAttribute(attr) => {
                             Expr::MappedRawAttribute(expr.indirect(), attr)
@@ -1374,17 +1406,10 @@ where
             .boxed(),
     );
 
-    let fn_ = function(
-        expr_or_inline_stmt_or_block.clone(),
-        ident.clone(),
-        expr.clone(),
-        closed_pattern.clone(),
-    );
-
     not_or_try.define(choice((not, checked, binary3.clone())));
 
     let binary4 = make_binary_op(
-        choice((fn_, not_or_try)),
+        not_or_try,
         select! {
             Token::Symbol("??") => BinaryOp::Coalesce,
         },
@@ -1429,7 +1454,7 @@ where
 
     let (match_, cases_) = match_expr(
         slices,
-        binary3,
+        below_fn.clone(),
         nary_pattern.clone(),
         expr_or_inline_stmt_or_block.clone(),
     );
@@ -1465,12 +1490,19 @@ where
         matches,
         select! {
             Token::Kw("and") => BinaryOp::And,
+        },
+        false,
+    );
+
+    let binary6 = make_binary_op(
+        binary5,
+        select! {
             Token::Kw("or") => BinaryOp::Or,
         },
         false,
     );
 
-    let if_ = binary5
+    let if_ = binary6
         .then(
             group((
                 just(Token::Kw("then"))
@@ -1494,10 +1526,17 @@ where
             }
         });
 
-    below_pipe.define(if_);
+    below_fn.define(if_);
+
+    let fn_ = function(
+        expr_or_inline_stmt_or_block.clone(),
+        ident.clone(),
+        expr.clone(),
+        closed_pattern.clone(),
+    );
 
     let binary6 = make_binary_op(
-        below_pipe.clone(),
+        choice((fn_, below_fn)),
         select! {
             Token::Symbol("|") => BinaryOp::Pipe,
         },