koatl 0.1.36__tar.gz → 0.1.38__tar.gz

{koatl-0.1.36 → koatl-0.1.38}/Cargo.lock

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

{koatl-0.1.36 → koatl-0.1.38}/PKG-INFO

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

{koatl-0.1.36 → koatl-0.1.38}/koatl/Cargo.toml

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

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

@@ -0,0 +1,61 @@
+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 import koatl.std.trait.*
+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.36 → koatl-0.1.38/koatl}/python/koatl/runtime/__init__.py

@@ -19,7 +19,6 @@ meta_finder.install_hook()
 from .virtual import *
 from .record import *
 from .helpers import *
-from .classes import *
 
 
 def dummy(name):
@@ -52,7 +51,6 @@ __tl__ = SimpleNamespace(
     **{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__},
-    **{name: classes.__dict__[name] for name in classes.__all__},
 )
 
 
@@ -61,5 +59,4 @@ __all__ = [
     *helpers.__all__,
     *record.__all__,
     *virtual.__all__,
-    *classes.__all__,
 ]

{koatl-0.1.36 → koatl-0.1.38}/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.38/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.36/koatl/python/koatl/prelude/functional → koatl-0.1.38/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.36/koatl/python/koatl/prelude/functional/algebra.tl → koatl-0.1.38/koatl/python/koatl/std/alg/base.tl

@@ -1,3 +1,5 @@
+import koatl.std.trait.Trait
+
 export Monad = class(Trait):
     """
     Abstract base class for monads.

{koatl-0.1.36/python/koatl/prelude/functional → koatl-0.1.38/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.36/python/koatl/prelude/functional → koatl-0.1.38/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.36/koatl/python/koatl/prelude/functional → koatl-0.1.38/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.38/koatl/python/koatl/std/data/__init__.tl

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

{koatl-0.1.36/python/koatl/prelude/functional → koatl-0.1.38/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.38/koatl/python/koatl/std/io.tl

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

koatl-0.1.36/python/koatl/prelude/iterable.tl → koatl-0.1.38/koatl/python/koatl/std/iter.tl

@@ -1,8 +1,10 @@
 import itertools
 import builtins
-import .functional.(Traversable, Ok, Err, Memo, Async, AsyncMemo, Result)
 
-export Iterable = Extension.trait& class(Traversable, Trait):
+import koatl.std.trait.Trait
+import .alg.(Traversable, Ok, Err, Memo, Async, AsyncMemo, Result)
+
+export Iterable = class(Traversable, Trait):
     iter = Trait.abstract& self => None
 
     skip = (self, n) =>
@@ -259,8 +261,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.38/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.36/koatl/python/koatl/prelude/regex.tl → koatl-0.1.38/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.36/koatl/python/koatl/runtime/classes.py → koatl-0.1.38/koatl/python/koatl/std/trait.py

@@ -40,7 +40,7 @@ class MappingMeta(type):
         return [(k, v) for k, v in inspect.getmembers(self) if not k.startswith("_")]
 
 
-# A utility base class to inherit from to enable __getitem__ method lookup on types and thus destructuring.
+# A utility base class to inherit from that implements Mapping on the type and thus destructuring.
 class Class(metaclass=MappingMeta):
     pass
 

{koatl-0.1.36 → koatl-0.1.38}/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>),