koatl 0.3.7__tar.gz → 0.3.9__tar.gz

{koatl-0.3.7 → koatl-0.3.9}/Cargo.lock

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

{koatl-0.3.7 → koatl-0.3.9}/PKG-INFO

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

{koatl-0.3.7 → koatl-0.3.9}/koatl/Cargo.toml

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

{koatl-0.3.7 → koatl-0.3.9}/koatl/python/koatl/notebook/magic.py

@@ -36,8 +36,7 @@ def _make_help_call(target, esc):
 
 
 def crepr(s):
-    assert isinstance(s, str)
-    return '"' + repr(s)[1:-1] + '"'
+    return repr(s)
 
 
 def _tr_help(content):

koatl-0.3.9/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.7 → koatl-0.3.9/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.7 → koatl-0.3.9}/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.9/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.7 → koatl-0.3.9}/koatl/tests/e2e/prelude/coal.tl

@@ -4,7 +4,7 @@ none = None
 assert_eq(none?(1)?(2), None)
 assert_eq(none?[1]?.a, None)
 assert_eq(none?.a, None)
-assert_eq(none?.(a), None)
+assert_eq(none?. (a), None)
 
 obj = (class:
     a = 1
@@ -13,7 +13,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)
@@ -25,4 +25,7 @@ f = () =>
 f() ?? 1
 
 # should only call once
-assert_eq(counts, 1)
+assert_eq(counts, 1)
+
+assert_eq((1).?f, None)
+assert_eq(None.?f, None)

{koatl-0.3.7 → koatl-0.3.9}/koatl-core/src/ast.rs

@@ -186,12 +186,14 @@ pub enum Expr<'a, TTree: Tree> {
     RawAttribute(TTree::Expr, SIdent<'a>),
     ScopedAttribute(TTree::Expr, TTree::Expr),
     Attribute(TTree::Expr, SIdent<'a>),
+    MaybeAttribute(TTree::Expr, SIdent<'a>),
 
     MappedCall(TTree::Expr, Vec<CallItem<'a, TTree>>),
     MappedSubscript(TTree::Expr, Vec<ListItem<TTree>>),
     MappedRawAttribute(TTree::Expr, SIdent<'a>),
     MappedScopedAttribute(TTree::Expr, TTree::Expr),
     MappedAttribute(TTree::Expr, SIdent<'a>),
+    MappedMaybeAttribute(TTree::Expr, SIdent<'a>),
 
     Try(TTree::Expr, Vec<MatchCase<TTree>>, Option<TTree::Expr>),
     Checked(TTree::Expr, Option<TTree::Pattern>),

{koatl-0.3.7 → koatl-0.3.9}/koatl-core/src/inference.rs

@@ -229,7 +229,9 @@ impl<'src, 'ast> SExprExt<'src, 'ast> for Indirect<SExpr<'src>> {
             Expr::RawAttribute(expr, _)
             | Expr::MappedRawAttribute(expr, _)
             | Expr::Attribute(expr, _)
-            | Expr::MappedAttribute(expr, _) => {
+            | Expr::MappedAttribute(expr, _)
+            | Expr::MaybeAttribute(expr, _)
+            | Expr::MappedMaybeAttribute(expr, _) => {
                 expr.traverse(ctx);
                 Type::Any
             }

{koatl-0.3.7 → koatl-0.3.9}/koatl-core/src/lift_cst.rs

@@ -317,6 +317,18 @@ impl<'src, 'tok> Lift<Indirect<ast::SExpr<'src>>> for cst::SExpr<'src, 'tok> {
                     ast::Expr::Attribute(expr.lift(), attr.lift_as_ident())
                 }
             }
+            cst::Expr::MaybeAttribute {
+                expr,
+                attr,
+                question,
+                ..
+            } => {
+                if question.is_some() {
+                    ast::Expr::MappedMaybeAttribute(expr.lift(), attr.lift_as_ident())
+                } else {
+                    ast::Expr::MaybeAttribute(expr.lift(), attr.lift_as_ident())
+                }
+            }
             cst::Expr::Call {
                 expr,
                 args,

{koatl-0.3.7 → koatl-0.3.9}/koatl-core/src/resolve_scopes.rs

@@ -1410,6 +1410,20 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
 
                 return traversed;
             }
+            Expr::MaybeAttribute(expr, attr) => {
+                Expr::MaybeAttribute(expr.traverse(state), attr.clone())
+            }
+            Expr::MappedMaybeAttribute(expr, attr) => {
+                let traversed = Expr::MappedMaybeAttribute(expr.traverse(state), attr)
+                    .spanned(span)
+                    .indirect();
+
+                state
+                    .mapped_fninfo
+                    .insert(traversed.as_ref().into(), FnInfo::new());
+
+                return traversed;
+            }
             Expr::RawAttribute(expr, attr) => Expr::RawAttribute(expr.traverse(state), attr),
             Expr::MappedRawAttribute(expr, spanned) => {
                 let traversed = Expr::MappedRawAttribute(expr.traverse(state), spanned)

{koatl-0.3.7 → koatl-0.3.9}/koatl-core/src/transform.rs

@@ -1314,11 +1314,13 @@ fn transform_postfix_expr<'src, 'ast>(
         Expr::Call(obj, _) => (false, obj),
         Expr::ScopedAttribute(obj, _) => (false, obj),
         Expr::Attribute(obj, _) => (false, obj),
+        Expr::MaybeAttribute(obj, _) => (false, obj),
         Expr::MappedRawAttribute(obj, _) => (true, obj),
         Expr::MappedSubscript(obj, _) => (true, obj),
         Expr::MappedCall(obj, _) => (true, obj),
         Expr::MappedScopedAttribute(obj, _) => (true, obj),
         Expr::MappedAttribute(obj, _) => (true, obj),
+        Expr::MappedMaybeAttribute(obj, _) => (true, obj),
         _ => {
             return Err(simple_err(
                 "Internal error: Postfix expressions can only be attributes, subscripts, calls, or extensions",
@@ -1364,6 +1366,29 @@ fn transform_postfix_expr<'src, 'ast>(
                     a.attribute(lhs, rhs.value.escape(), access_ctx)
                 }
             }
+            Expr::MaybeAttribute(_, rhs) | Expr::MappedMaybeAttribute(_, rhs) => {
+                let temp_var = ctx.create_aux_var("attr", expr.span.start);
+
+                inner_pre.push(a.try_(
+                    PyBlock(vec![a.assign(
+                        a.ident(temp_var.clone(), PyAccessCtx::Store),
+                        a.call(
+                            a.tl_builtin("vget"),
+                            vec![a.call_arg(lhs), a.call_arg(a.str(rhs.value.escape()))],
+                        ),
+                    )]),
+                    vec![PyExceptHandler {
+                        typ: None,
+                        name: None,
+                        body: PyBlock(vec![
+                            a.assign(a.ident(temp_var.clone(), PyAccessCtx::Store), a.none()),
+                        ]),
+                    }],
+                    None,
+                ));
+
+                a.load_ident(temp_var)
+            }
             _ => {
                 panic!()
             }
@@ -1905,7 +1930,11 @@ impl<'src, 'ast> SExprExt<'src, 'ast> for SExpr<'src> {
             | Expr::ScopedAttribute(..)
             | Expr::MappedScopedAttribute(..)
             | Expr::Attribute(..)
-            | Expr::MappedAttribute(..) => pre.bind(transform_postfix_expr(ctx, self, access_ctx)?),
+            | Expr::MappedAttribute(..)
+            | Expr::MaybeAttribute(..)
+            | Expr::MappedMaybeAttribute(..) => {
+                pre.bind(transform_postfix_expr(ctx, self, access_ctx)?)
+            }
             Expr::With(pattern, value, body) => {
                 let temp_var = ctx.create_aux_var("with", span.start);
                 let value = pre.bind(value.transform(ctx)?);

{koatl-0.3.7 → koatl-0.3.9}/koatl-parser/src/cst.rs

@@ -465,6 +465,13 @@ pub enum Expr<TTree: Tree> {
         rhs: TTree::Expr,
         rparen: TTree::Token,
     },
+    MaybeAttribute {
+        expr: TTree::Expr,
+        question: Option<TTree::Token>,
+        dot: TTree::Token,
+        question2: TTree::Token,
+        attr: TTree::Token,
+    },
     Attribute {
         expr: TTree::Expr,
         question: Option<TTree::Token>,

{koatl-0.3.7 → koatl-0.3.9}/koatl-parser/src/parser.rs

@@ -1276,6 +1276,11 @@ impl<'src: 'tok, 'tok> ParseCtx<'src, 'tok> {
                 rhs: SExpr<'src, 'tok>,
                 rparen: &'tok SToken<'src>,
             },
+            MaybeAttribute {
+                question: &'tok SToken<'src>,
+                dot: &'tok SToken<'src>,
+                attr: &'tok SToken<'src>,
+            },
             Attribute {
                 dot: &'tok SToken<'src>,
                 attr: &'tok SToken<'src>,
@@ -1341,6 +1346,15 @@ impl<'src: 'tok, 'tok> ParseCtx<'src, 'tok> {
                             ctx.listing("(", ")", Token::Symbol(","), |ctx| ctx.call_item())?;
                         Ok(Postfix::MethodCall { dot, method, args })
                     },
+                    |ctx| {
+                        let question = ctx.symbol("?")?;
+                        let attr = ctx.any_ident()?;
+                        Ok(Postfix::MaybeAttribute {
+                            question,
+                            dot,
+                            attr,
+                        })
+                    },
                     |ctx| {
                         let attr = ctx.any_ident()?;
                         Ok(Postfix::Attribute { dot, attr })
@@ -1411,6 +1425,17 @@ impl<'src: 'tok, 'tok> ParseCtx<'src, 'tok> {
                         dot,
                         attr,
                     },
+                    Postfix::MaybeAttribute {
+                        question: question2,
+                        dot,
+                        attr,
+                    } => Expr::MaybeAttribute {
+                        expr: expr.boxed(),
+                        question,
+                        dot,
+                        question2,
+                        attr,
+                    },
                     Postfix::Decorator { op, decorator } => {
                         if question.is_some() {
                             return Err(self.set_error(

{koatl-0.3.7 → koatl-0.3.9}/koatl-parser/src/simple_fmt.rs

@@ -190,6 +190,20 @@ impl<'src, 'tok> SimpleFmt for SExprInner<'src, 'tok> {
                     attr.simple_fmt()
                 )
             }
+            Expr::MaybeAttribute {
+                expr,
+                question,
+                attr,
+                ..
+            } => {
+                let question_str = if question.is_some() { "?" } else { "" };
+                format!(
+                    "{}{}.?{}",
+                    expr.simple_fmt(),
+                    question_str,
+                    attr.simple_fmt()
+                )
+            }
             Expr::Slice {
                 start,
                 dots: _,

{koatl-0.3.7 → koatl-0.3.9}/python/koatl/notebook/magic.py

@@ -36,8 +36,7 @@ def _make_help_call(target, esc):
 
 
 def crepr(s):
-    assert isinstance(s, str)
-    return '"' + repr(s)[1:-1] + '"'
+    return repr(s)
 
 
 def _tr_help(content):

koatl-0.3.9/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.7/koatl → koatl-0.3.9}/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.7 → koatl-0.3.9}/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.9/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.7/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.7/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.7/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.7/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})"