koatl 0.3.8__tar.gz → 0.3.10__tar.gz

{koatl-0.3.8 → koatl-0.3.10}/Cargo.lock

@@ -190,7 +190,7 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "koatl"
-version = "0.3.8"
+version = "0.3.10"
 dependencies = [
  "ariadne",
  "koatl-core",

{koatl-0.3.8 → koatl-0.3.10}/PKG-INFO

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

{koatl-0.3.8 → koatl-0.3.10}/koatl/Cargo.toml

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

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

@@ -0,0 +1,38 @@
+export import koatl.std.(
+    trait.*
+    ext.*
+    data.*
+    iter.*
+    control.(Result, Ok, Err, Env, Memo, Async, AsyncMemo, do)
+)
+
+import koatl.std.(
+    re.Pattern
+    lazy_module.(LazyModule, RootModulesProxy)
+)
+
+export std = LazyModule("koatl.std")
+export mod = RootModulesProxy()
+
+Extension.trait(Iterable)
+
+Extension.property(list, "len")! List.len.fget
+
+Extension.property(object, "result")! self => Result(self)
+
+Extension.method(str, "match")! (regex, str) => Pattern(regex).match(str)
+Extension.method(str, "matches")! (str, regex) => Pattern(regex).match(str)
+
+__tl__.do = koatl.std.control.do.do
+
+__tl__.op_map = koatl.std.control.result.op_map
+__tl__.op_coal = koatl.std.control.result.op_coal
+
+__tl__.Ok = koatl.std.control.result.Ok
+__tl__.Err = koatl.std.control.result.Err
+__tl__.Result = koatl.std.control.result.Result
+
+__tl__.MatchError = koatl.std.MatchError
+
+__tl__.memo_value = koatl.std.control.memo.Memo.value
+__tl__.async_memo_value = koatl.std.control.memo.AsyncMemo.value

{koatl-0.3.8 → koatl-0.3.10/koatl}/python/koatl/std/data/list.tl

@@ -1,6 +1,6 @@
 import itertools
 
-import koatl.std.alg.Monad
+import koatl.std.control.Monad
 
 export List = class(Monad):
     __new__ = (cls, *args, **kwargs) => raise ValueError(

{koatl-0.3.8 → koatl-0.3.10}/koatl/python/koatl/std/iter.tl

@@ -3,14 +3,14 @@ import builtins
 
 import koatl.std.data.Record
 import koatl.std.trait.Trait
-import .alg.(Traversable, Ok, Err, Memo, Async, AsyncMemo, Result)
+import .control.(Traversable, Ok, Err, Memo, Async, AsyncMemo, Result)
 
 export Iterable = class(Traversable, Trait):
     iter = Trait.abstract! self => None
 
     skip = (self, n) =>
         let it = self.iter
-        for _ in ..n:
+        for _ in..n:
             next(it, None)
         it
 
@@ -27,7 +27,7 @@ export Iterable = class(Traversable, Trait):
     take = (self, n) =>
         let impl = () =>
             let it = self.iter
-            for _ in ..n:
+            for _ in..n:
                 try:
                     yield next(it)
                 except StopIteration(value=value) =>

koatl-0.3.10/koatl/python/koatl/std/re.tl

@@ -0,0 +1,41 @@
+import re
+import collections
+import .control.Result
+
+export Pattern = class:
+    __slots__ = ("pattern",)
+
+    __init__ = (self, pattern) =>
+        pattern match:
+            re.Pattern() => self.pattern = pattern
+            str() => self.pattern = re.compile(pattern)
+            Pattern(pattern=pattern) => self.pattern = pattern
+            default => raise TypeError(
+                f"Expected a str or pattern, but got {type(pattern).__name__}"
+            )
+
+    __repr__ = self => f"Pattern({self.pattern})"
+
+    match = (self, string, flags=0) =>
+        if not isinstance(string, str):
+            raise TypeError(f"Expected a string, but got {type(string).__name__}")
+
+        self.pattern.match(string, flags).result.map(Match)
+
+export 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})"

{koatl-0.3.8 → koatl-0.3.10}/koatl-core/src/resolve_scopes.rs

@@ -1675,7 +1675,7 @@ impl<'src> SStmtExt<'src> for Indirect<SStmt<'src>> {
                         .collect::<Vec<_>>()
                         .join(".");
 
-                    let full_module = ".".repeat(tree.level) + &base_module;
+                    let full_module = ".".repeat(level) + &base_module;
 
                     match &tree.leaf.value {
                         ImportLeaf::Multi(branches) => {

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

@@ -0,0 +1,38 @@
+export import koatl.std.(
+    trait.*
+    ext.*
+    data.*
+    iter.*
+    control.(Result, Ok, Err, Env, Memo, Async, AsyncMemo, do)
+)
+
+import koatl.std.(
+    re.Pattern
+    lazy_module.(LazyModule, RootModulesProxy)
+)
+
+export std = LazyModule("koatl.std")
+export mod = RootModulesProxy()
+
+Extension.trait(Iterable)
+
+Extension.property(list, "len")! List.len.fget
+
+Extension.property(object, "result")! self => Result(self)
+
+Extension.method(str, "match")! (regex, str) => Pattern(regex).match(str)
+Extension.method(str, "matches")! (str, regex) => Pattern(regex).match(str)
+
+__tl__.do = koatl.std.control.do.do
+
+__tl__.op_map = koatl.std.control.result.op_map
+__tl__.op_coal = koatl.std.control.result.op_coal
+
+__tl__.Ok = koatl.std.control.result.Ok
+__tl__.Err = koatl.std.control.result.Err
+__tl__.Result = koatl.std.control.result.Result
+
+__tl__.MatchError = koatl.std.MatchError
+
+__tl__.memo_value = koatl.std.control.memo.Memo.value
+__tl__.async_memo_value = koatl.std.control.memo.AsyncMemo.value

{koatl-0.3.8/koatl → koatl-0.3.10}/python/koatl/std/data/list.tl

@@ -1,6 +1,6 @@
 import itertools
 
-import koatl.std.alg.Monad
+import koatl.std.control.Monad
 
 export List = class(Monad):
     __new__ = (cls, *args, **kwargs) => raise ValueError(

{koatl-0.3.8 → koatl-0.3.10}/python/koatl/std/iter.tl

@@ -3,14 +3,14 @@ import builtins
 
 import koatl.std.data.Record
 import koatl.std.trait.Trait
-import .alg.(Traversable, Ok, Err, Memo, Async, AsyncMemo, Result)
+import .control.(Traversable, Ok, Err, Memo, Async, AsyncMemo, Result)
 
 export Iterable = class(Traversable, Trait):
     iter = Trait.abstract! self => None
 
     skip = (self, n) =>
         let it = self.iter
-        for _ in ..n:
+        for _ in..n:
             next(it, None)
         it
 
@@ -27,7 +27,7 @@ export Iterable = class(Traversable, Trait):
     take = (self, n) =>
         let impl = () =>
             let it = self.iter
-            for _ in ..n:
+            for _ in..n:
                 try:
                     yield next(it)
                 except StopIteration(value=value) =>

koatl-0.3.10/python/koatl/std/re.tl

@@ -0,0 +1,41 @@
+import re
+import collections
+import .control.Result
+
+export Pattern = class:
+    __slots__ = ("pattern",)
+
+    __init__ = (self, pattern) =>
+        pattern match:
+            re.Pattern() => self.pattern = pattern
+            str() => self.pattern = re.compile(pattern)
+            Pattern(pattern=pattern) => self.pattern = pattern
+            default => raise TypeError(
+                f"Expected a str or pattern, but got {type(pattern).__name__}"
+            )
+
+    __repr__ = self => f"Pattern({self.pattern})"
+
+    match = (self, string, flags=0) =>
+        if not isinstance(string, str):
+            raise TypeError(f"Expected a string, but got {type(string).__name__}")
+
+        self.pattern.match(string, flags).result.map(Match)
+
+export 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})"

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

@@ -1,42 +0,0 @@
-export import koatl.std.(
-    trait.*
-    ext.*
-    data.*
-    iter.*
-    alg.(Result, Ok, Err, Env, Memo, Async, AsyncMemo)
-    alg.do
-)
-
-import koatl.std.(
-    re.Pattern
-    lazy_module.(LazyModule, RootModulesProxy)
-)
-
-export std = LazyModule("koatl.std")
-export mod = RootModulesProxy()
-
-Extension.trait(Iterable)
-
-Extension.property(list, "len")! List.len.fget
-
-Extension.property(object, "result")! self => Result(self)
-
-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)
-
-__tl__.do = koatl.std.alg.do.do
-
-__tl__.op_map = koatl.std.alg.result.op_map
-__tl__.op_coal = koatl.std.alg.result.op_coal
-
-__tl__.Ok = koatl.std.alg.result.Ok
-__tl__.Err = koatl.std.alg.result.Err
-__tl__.Result = koatl.std.alg.result.Result
-
-__tl__.MatchError = koatl.std.MatchError
-
-__tl__.memo_value = koatl.std.alg.memo.Memo.value
-__tl__.async_memo_value = koatl.std.alg.memo.AsyncMemo.value

koatl-0.3.8/koatl/python/koatl/std/re.tl

@@ -1,48 +0,0 @@
-import re
-import collections
-import .alg.Result
-
-export Pattern = 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})"

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

@@ -1,42 +0,0 @@
-export import koatl.std.(
-    trait.*
-    ext.*
-    data.*
-    iter.*
-    alg.(Result, Ok, Err, Env, Memo, Async, AsyncMemo)
-    alg.do
-)
-
-import koatl.std.(
-    re.Pattern
-    lazy_module.(LazyModule, RootModulesProxy)
-)
-
-export std = LazyModule("koatl.std")
-export mod = RootModulesProxy()
-
-Extension.trait(Iterable)
-
-Extension.property(list, "len")! List.len.fget
-
-Extension.property(object, "result")! self => Result(self)
-
-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)
-
-__tl__.do = koatl.std.alg.do.do
-
-__tl__.op_map = koatl.std.alg.result.op_map
-__tl__.op_coal = koatl.std.alg.result.op_coal
-
-__tl__.Ok = koatl.std.alg.result.Ok
-__tl__.Err = koatl.std.alg.result.Err
-__tl__.Result = koatl.std.alg.result.Result
-
-__tl__.MatchError = koatl.std.MatchError
-
-__tl__.memo_value = koatl.std.alg.memo.Memo.value
-__tl__.async_memo_value = koatl.std.alg.memo.AsyncMemo.value

koatl-0.3.8/python/koatl/std/re.tl

@@ -1,48 +0,0 @@
-import re
-import collections
-import .alg.Result
-
-export Pattern = 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})"