koatl 0.1.23__tar.gz → 0.1.24__tar.gz

{koatl-0.1.23 → koatl-0.1.24}/Cargo.lock

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

{koatl-0.1.23 → koatl-0.1.24}/PKG-INFO

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

{koatl-0.1.23 → koatl-0.1.24}/koatl/Cargo.toml

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

{koatl-0.1.23 → koatl-0.1.24/koatl}/python/koatl/prelude/functional/memo.tl

@@ -1,6 +1,6 @@
 import collections.defaultdict
 import functools.wraps
-import .result.Ok
+import .result.(Result, Ok)
 import .Monad
 
 export Memo = class(Monad):
@@ -11,7 +11,8 @@ export Memo = class(Monad):
         __repr__ = self => f"Memo.Cache({self.cache})"
 
         try_get = (self, name, deps) =>
-            try self.cache[name][deps] except KeyError()
+            # TODO should try operator return a Result directly?
+            Result(try self.cache[name][deps] except KeyError())
 
         update = (self, name, deps, value) =>
             self.cache[name][deps] = value
@@ -23,7 +24,7 @@ export Memo = class(Monad):
 
     value = staticmethod& (id, deps, f) =>
         Memo(ctx =>
-            if ctx.try_get(id, tuple(deps)) matches Ok() as value:
+            if ctx.try_get(id, tuple(deps)) matches Ok(value):
                 return value
 
             ctx.update(id, tuple(deps), f())
@@ -34,7 +35,7 @@ export Memo = class(Monad):
         let deps = (tuple(args), tuple(kwargs.items()))
 
         Memo(ctx =>
-            if ctx.try_get(id, deps) matches Ok() as value:
+            if ctx.try_get(id, deps) matches Ok(value):
                 return value
 
             let v = f(*args, **kwargs)

{koatl-0.1.23 → koatl-0.1.24/koatl}/python/koatl/prelude/functional/monad.tl

@@ -1,6 +1,8 @@
 import abc
 
 export Monad = class(abc.ABC):
+    __slots__ = ()
+
     # The default implementation required for `@` syntax that should be overridden by subclasses.
     bind_once = abc.abstractmethod& (self, f) => None
 

koatl-0.1.24/koatl/python/koatl/prelude/functional/result.tl

@@ -0,0 +1,131 @@
+import functools.wraps
+import .monad.Monad
+import koatl.runtime.virtual.register_global_attr
+
+export Result = class:
+    __slots__ = ()
+    __match_args__ = ("value",)
+
+    __new__ = (cls, value) =>
+        if isinstance(value, Result):
+            return value
+        value.ok then Ok(value) else Err(value)
+
+    __init__ = (self, *args, **kwargs) =>
+        raise ValueError("Result should not be instantiated directly, use Ok or Err")
+
+    raw = self =>
+        """
+        Unwraps the value from a Result, making it look like
+        a non-monadic Python value.
+        """
+        if self matches not Result():
+            return self
+
+        if self.ok:
+            if self.value.ok:
+                return self.value
+            else:
+                return self
+        else:
+            if self.value.ok:
+                return self
+            else:
+                return self.value
+
+    bind_once = (self, f) =>
+        self = Result(self)
+        if not self.ok:
+            return self
+
+        let v = Result(f(self.value))
+
+    bind = bind_once
+
+    bind_gen = (self, gen) =>
+        self = Result(self)
+        try:
+            while True:
+                if not self.ok:
+                    return self
+
+                self = Result(gen.send(self.value))
+        except StopIteration(value=value):
+            return Result.pure(value)
+
+    pure = staticmethod& x => Ok(x)
+
+    apply = (self, f) =>
+        self = Result(self)
+        f = Result(f)
+
+        if not self.ok:
+            return self
+        if not f.ok:
+            return f
+
+        Ok(f(self))
+
+    map = (self, f) =>
+        self = Result(self)
+        if self.ok:
+            return Ok(f(self.value))
+        return self
+
+    map_err = (self, f) =>
+        self = Result(self)
+        if not self.ok:
+            return Err(f(self.value))
+        return self
+
+    map_none = (self, f) =>
+        self = Result(self)
+        if not self.ok and self.value === None:
+            return Err(f())
+        return self
+
+export Ok = class(Result):
+    __slots__ = ("value",)
+    ok = True
+    __new__ = (cls, value) => object.__new__(cls)
+    __init__ = (self, value) =>
+        if hasattr(self, "value"):
+            # This is necessary to prevent overwriting the value
+            # since Python's Result.__new__ will call Ok.__init__ again
+            # if the object is already created.
+            return None
+        self.value = value
+
+    __repr__ = self => f"Ok({repr(self.value)})"
+    unwrap = self => self.value
+
+export Err = class(Result):
+    __slots__ = ("value",)
+    ok = False
+    __new__ = (cls, value) => object.__new__(cls)
+    __init__ = (self, value) =>
+        if hasattr(self, "value"):
+            return None
+        self.value = value
+
+    __repr__ = self => f"Err({repr(self.value)})"
+    unwrap = self =>
+        if self.value matches BaseException():
+            raise self.value
+        raise ValueError(f"Expected Ok, got {repr(self.value)}")
+
+
+# Provide a default implementation for *most* Result methods
+# ...we shouldn't provide a default for `map` since that
+# would prevent virtual trait lookup. TODO: fix this?
+for name, method in Result.__dict__:
+    if name.startswith("_"):
+        continue
+    if name == "map":
+        continue
+
+    let make_closure = method => (self, *args, **kwargs) => Result.raw(method(self, *args, **kwargs))
+
+    register_global_attr(object, name, make_closure(method))
+
+register_global_attr(object, "ok", ExtensionProperty(__tl__.ok))

{koatl-0.1.23 → koatl-0.1.24}/koatl/python/koatl/runtime/helpers.py

@@ -46,6 +46,11 @@ def unpack_record(obj):
 
 
 def ok(obj):
+    try:
+        return obj.ok
+    except AttributeError:
+        pass
+
     if obj is None:
         return False
     if isinstance(obj, BaseException):

{koatl-0.1.23 → koatl-0.1.24}/koatl/src/emit_py.rs

@@ -502,7 +502,7 @@ impl<'src> PyExprExt<'src> for SPyExpr<'src> {
                 ctx.ast_node("Name", (ident, c.emit_py(ctx)?), &self.tl_span)?
             }
             PyExpr::Binary(op, left, right) => {
-                let py_op_str = match op {
+                let py_bin_op = match op {
                     PyBinaryOp::Add => Some("Add"),
                     PyBinaryOp::Sub => Some("Sub"),
                     PyBinaryOp::Mult => Some("Mult"),
@@ -512,18 +512,35 @@ impl<'src> PyExprExt<'src> for SPyExpr<'src> {
                     _ => None,
                 };
 
-                if let Some(py_op_str) = py_op_str {
+                if let Some(py_bin_op) = py_bin_op {
                     return ctx.ast_node(
                         "BinOp",
                         (
                             left.emit_py(ctx)?,
-                            ctx.ast_cls(py_op_str, ())?,
+                            ctx.ast_cls(py_bin_op, ())?,
                             right.emit_py(ctx)?,
                         ),
                         &self.tl_span,
                     );
                 }
 
+                let py_bool_op = match op {
+                    PyBinaryOp::And => Some("And"),
+                    PyBinaryOp::Or => Some("Or"),
+                    _ => None,
+                };
+
+                if let Some(py_bool_op) = py_bool_op {
+                    return ctx.ast_node(
+                        "BoolOp",
+                        (
+                            ctx.ast_cls(py_bool_op, ())?,
+                            [left.emit_py(ctx)?, right.emit_py(ctx)?],
+                        ),
+                        &self.tl_span,
+                    );
+                }
+
                 let py_cmp_op = match op {
                     PyBinaryOp::Lt => Some("Lt"),
                     PyBinaryOp::Gt => Some("Gt"),

{koatl-0.1.23 → koatl-0.1.24}/koatl-core/src/resolve_scopes.rs

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 use std::collections::HashSet;
 use std::fmt::Display;
 
+use slotmap::Key;
 use slotmap::SlotMap;
 use slotmap::new_key_type;
 
@@ -70,10 +71,10 @@ fn top_scope_and_key<'src, 'state>(
 #[allow(dead_code)]
 impl<'src> ResolveState<'src> {
     fn new(source: &'src str) -> Self {
-        let mut root_scope = Scope::new();
+        let mut root_scope = Scope::new(ScopeKey::null());
         root_scope.is_global = true;
 
-        let err_scope = Scope::new();
+        let err_scope = Scope::new(ScopeKey::null());
 
         let mut scopes = SlotMap::with_key();
         let root_scope_key = scopes.insert(root_scope);
@@ -107,6 +108,10 @@ impl<'src> ResolveState<'src> {
         top_scope(&self.scope_stack, &mut self.scopes)
     }
 
+    fn top_scope_key(&mut self) -> ScopeKey {
+        *self.scope_stack.last_mut().unwrap()
+    }
+
     fn top_scope_and_key(&mut self) -> (&mut Scope, ScopeKey) {
         top_scope_and_key(&self.scope_stack, &mut self.scopes)
     }
@@ -185,10 +190,10 @@ impl<'src> ResolveState<'src> {
     where
         F: FnOnce(&mut ResolveState<'src>) -> Indirect<SExpr<'src>>,
     {
-        let mut temp_scope = Scope::new();
-        temp_scope.is_fn = true;
+        let mut dummy_scope = Scope::new(ScopeKey::null());
+        dummy_scope.is_fn = true;
 
-        let temp_scope_key = self.scopes.insert(temp_scope);
+        let temp_scope_key = self.scopes.insert(dummy_scope);
 
         let ph_decl = self.declarations.insert_declaration(
             Ident("x".into()).spanned(span),
@@ -460,6 +465,9 @@ impl Display for Declaration<'_> {
 
 #[derive(Debug)]
 pub struct Scope {
+    // TODO make this option
+    pub parent: ScopeKey,
+
     pub locals: Vec<DeclarationKey>,
 
     pub is_class: bool,
@@ -488,8 +496,9 @@ impl Display for Scope {
 }
 
 impl Scope {
-    fn new() -> Scope {
+    fn new(parent: ScopeKey) -> Scope {
         Self {
+            parent,
             locals: Vec::new(),
             lifted_decls: Vec::new(),
 
@@ -797,7 +806,7 @@ fn pattern_scoped<'src>(
     state: &mut ResolveState<'src>,
     pattern: Indirect<SPattern<'src>>,
 ) -> (Indirect<SPattern<'src>>, ScopeKey, PatternMeta<'src>) {
-    let scope = Scope::new();
+    let scope = Scope::new(state.top_scope_key());
     let scope_key = state.scopes.insert(scope);
 
     let (pattern, meta) = pattern.traverse(state);
@@ -946,7 +955,8 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
                     }
                     new_stmts
                 } else {
-                    let scope = state.scopes.insert(Scope::new());
+                    let parent = state.top_scope_key();
+                    let scope = state.scopes.insert(Scope::new(parent));
                     state
                         .scoped(scope, |state| {
                             let mut new_stmts = Vec::new();
@@ -1040,7 +1050,8 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
                             let (pattern, scope, _meta) = pattern_scoped(state, pattern);
                             (Some(pattern), scope)
                         } else {
-                            (None, state.scopes.insert(Scope::new()))
+                            let parent = state.top_scope_key();
+                            (None, state.scopes.insert(Scope::new(parent)))
                         };
 
                         SMatchCase {
@@ -1058,7 +1069,7 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
             Expr::Class(bases, body) => {
                 let bases = traverse_call_items(state, bases);
 
-                let mut scope = Scope::new();
+                let mut scope = Scope::new(state.top_scope_key());
                 scope.is_class = true;
                 let scope = state.scopes.insert(scope);
 
@@ -1071,7 +1082,7 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
             Expr::Fn(arg_def_items, body) => {
                 let mut decls = vec![];
 
-                let mut scope = Scope::new();
+                let mut scope = Scope::new(state.top_scope_key());
                 scope.is_fn = true;
                 let scope = state.scopes.insert(scope);
 
@@ -1297,7 +1308,7 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
                 let mut fn_ctx = FnInfo::new();
                 fn_ctx.is_memo = true;
 
-                let mut scope = Scope::new();
+                let mut scope = Scope::new(state.top_scope_key());
                 scope.is_fn = true;
 
                 // TODO it's confusing that we need to
@@ -1467,7 +1478,8 @@ impl<'src> SStmtExt<'src> for Indirect<SStmt<'src>> {
                             let (pattern, scope, _meta) = pattern_scoped(state, pattern);
                             (Some(pattern), scope)
                         } else {
-                            (None, state.scopes.insert(Scope::new()))
+                            let parent = state.top_scope_key();
+                            (None, state.scopes.insert(Scope::new(parent)))
                         };
 
                         let body = state

{koatl-0.1.23 → koatl-0.1.24}/koatl-core/src/transform.rs

@@ -14,7 +14,7 @@ use crate::{
 };
 use once_cell::sync::Lazy;
 use parser::ast::*;
-use slotmap::SlotMap;
+use slotmap::{Key, SlotMap};
 use std::hash::{Hash, Hasher};
 
 static PY_KWS: &[&str] = &[
@@ -1404,25 +1404,9 @@ fn prepare_py_fn<'src, 'ast>(
                 decorators.push(a.tl_builtin("do"));
             }
 
-            let mut nonlocals = vec![];
-            let mut globals = vec![];
-
-            for capture in fn_info.captures.iter() {
-                let scope = &ctx.scopes[ctx.declarations[*capture].scope];
-                if scope.is_global || scope.is_class {
-                    globals.push(ctx.decl_py_ident(*capture)?);
-                } else {
-                    nonlocals.push(ctx.decl_py_ident(*capture)?);
-                }
-            }
-
-            if !nonlocals.is_empty() {
-                py_body.push(a.nonlocal(nonlocals.iter().map(|x| x.clone()).collect()));
-            }
-            if !globals.is_empty() {
-                py_body.push(a.global(globals.iter().map(|x| x.clone()).collect()));
-            }
+            let (py_bindings, _, _) = py_fn_bindings(ctx, fn_info, *span)?;
 
+            py_body.extend(py_bindings);
             py_body.extend(body.pre);
             py_body.push(a.return_(body.value));
         }
@@ -2257,24 +2241,9 @@ impl<'src, 'ast> SExprExt<'src, 'ast> for SExpr<'src> {
                 let py_expr = expr.transform(ctx)?;
                 let mut py_body = PyBlock::new();
 
-                let mut nonlocals = vec![];
-                let mut globals = vec![];
-
-                for capture in memo_captures.captures.iter() {
-                    if ctx.scopes[ctx.declarations[*capture].scope].is_global {
-                        globals.push(ctx.decl_py_ident(*capture)?);
-                    } else {
-                        nonlocals.push(ctx.decl_py_ident(*capture)?);
-                    }
-                }
-
-                if !nonlocals.is_empty() {
-                    py_body.push(a.nonlocal(nonlocals.iter().map(|x| x.clone()).collect()));
-                }
-                if !globals.is_empty() {
-                    py_body.push(a.global(globals.iter().map(|x| x.clone()).collect()));
-                }
+                let (py_bindings, nonlocals, _globals) = py_fn_bindings(ctx, memo_captures, span)?;
 
+                py_body.extend(py_bindings);
                 py_body.extend(py_expr.pre);
                 py_body.push(a.return_(py_expr.value));
 
@@ -2430,6 +2399,47 @@ impl<'src, 'ast> SExprExt<'src, 'ast> for SExpr<'src> {
     }
 }
 
+fn py_fn_bindings<'src, 'ast>(
+    ctx: &mut TlCtx<'src, 'ast>,
+    memo_captures: &FnInfo,
+    span: Span,
+) -> TlResult<(PyBlock<'src>, Vec<PyIdent<'src>>, Vec<PyIdent<'src>>)> {
+    let a = PyAstBuilder::new(span);
+
+    let mut nonlocals = vec![];
+    let mut globals = vec![];
+    let mut py_body = PyBlock::new();
+
+    for capture in memo_captures.captures.iter() {
+        let mut scope = &ctx.scopes[ctx.declarations[*capture].scope];
+        loop {
+            if scope.parent.is_null() {
+                break;
+            }
+
+            if scope.is_fn || scope.is_class || scope.is_global {
+                break;
+            }
+            scope = &ctx.scopes[scope.parent];
+        }
+
+        if scope.is_global || scope.is_class {
+            globals.push(ctx.decl_py_ident(*capture)?);
+        } else {
+            nonlocals.push(ctx.decl_py_ident(*capture)?);
+        }
+    }
+
+    if !nonlocals.is_empty() {
+        py_body.push(a.nonlocal(nonlocals.iter().map(|x| x.clone()).collect()));
+    }
+    if !globals.is_empty() {
+        py_body.push(a.global(globals.iter().map(|x| x.clone()).collect()));
+    }
+
+    Ok((py_body, nonlocals, globals))
+}
+
 pub struct TransformOutput<'src> {
     pub py_block: PyBlock<'src>,
     pub exports: Vec<PyIdent<'src>>,

{koatl-0.1.23/koatl → koatl-0.1.24}/python/koatl/prelude/functional/memo.tl

@@ -1,6 +1,6 @@
 import collections.defaultdict
 import functools.wraps
-import .result.Ok
+import .result.(Result, Ok)
 import .Monad
 
 export Memo = class(Monad):
@@ -11,7 +11,8 @@ export Memo = class(Monad):
         __repr__ = self => f"Memo.Cache({self.cache})"
 
         try_get = (self, name, deps) =>
-            try self.cache[name][deps] except KeyError()
+            # TODO should try operator return a Result directly?
+            Result(try self.cache[name][deps] except KeyError())
 
         update = (self, name, deps, value) =>
             self.cache[name][deps] = value
@@ -23,7 +24,7 @@ export Memo = class(Monad):
 
     value = staticmethod& (id, deps, f) =>
         Memo(ctx =>
-            if ctx.try_get(id, tuple(deps)) matches Ok() as value:
+            if ctx.try_get(id, tuple(deps)) matches Ok(value):
                 return value
 
             ctx.update(id, tuple(deps), f())
@@ -34,7 +35,7 @@ export Memo = class(Monad):
         let deps = (tuple(args), tuple(kwargs.items()))
 
         Memo(ctx =>
-            if ctx.try_get(id, deps) matches Ok() as value:
+            if ctx.try_get(id, deps) matches Ok(value):
                 return value
 
             let v = f(*args, **kwargs)

{koatl-0.1.23/koatl → koatl-0.1.24}/python/koatl/prelude/functional/monad.tl

@@ -1,6 +1,8 @@
 import abc
 
 export Monad = class(abc.ABC):
+    __slots__ = ()
+
     # The default implementation required for `@` syntax that should be overridden by subclasses.
     bind_once = abc.abstractmethod& (self, f) => None
 

koatl-0.1.24/python/koatl/prelude/functional/result.tl

@@ -0,0 +1,131 @@
+import functools.wraps
+import .monad.Monad
+import koatl.runtime.virtual.register_global_attr
+
+export Result = class:
+    __slots__ = ()
+    __match_args__ = ("value",)
+
+    __new__ = (cls, value) =>
+        if isinstance(value, Result):
+            return value
+        value.ok then Ok(value) else Err(value)
+
+    __init__ = (self, *args, **kwargs) =>
+        raise ValueError("Result should not be instantiated directly, use Ok or Err")
+
+    raw = self =>
+        """
+        Unwraps the value from a Result, making it look like
+        a non-monadic Python value.
+        """
+        if self matches not Result():
+            return self
+
+        if self.ok:
+            if self.value.ok:
+                return self.value
+            else:
+                return self
+        else:
+            if self.value.ok:
+                return self
+            else:
+                return self.value
+
+    bind_once = (self, f) =>
+        self = Result(self)
+        if not self.ok:
+            return self
+
+        let v = Result(f(self.value))
+
+    bind = bind_once
+
+    bind_gen = (self, gen) =>
+        self = Result(self)
+        try:
+            while True:
+                if not self.ok:
+                    return self
+
+                self = Result(gen.send(self.value))
+        except StopIteration(value=value):
+            return Result.pure(value)
+
+    pure = staticmethod& x => Ok(x)
+
+    apply = (self, f) =>
+        self = Result(self)
+        f = Result(f)
+
+        if not self.ok:
+            return self
+        if not f.ok:
+            return f
+
+        Ok(f(self))
+
+    map = (self, f) =>
+        self = Result(self)
+        if self.ok:
+            return Ok(f(self.value))
+        return self
+
+    map_err = (self, f) =>
+        self = Result(self)
+        if not self.ok:
+            return Err(f(self.value))
+        return self
+
+    map_none = (self, f) =>
+        self = Result(self)
+        if not self.ok and self.value === None:
+            return Err(f())
+        return self
+
+export Ok = class(Result):
+    __slots__ = ("value",)
+    ok = True
+    __new__ = (cls, value) => object.__new__(cls)
+    __init__ = (self, value) =>
+        if hasattr(self, "value"):
+            # This is necessary to prevent overwriting the value
+            # since Python's Result.__new__ will call Ok.__init__ again
+            # if the object is already created.
+            return None
+        self.value = value
+
+    __repr__ = self => f"Ok({repr(self.value)})"
+    unwrap = self => self.value
+
+export Err = class(Result):
+    __slots__ = ("value",)
+    ok = False
+    __new__ = (cls, value) => object.__new__(cls)
+    __init__ = (self, value) =>
+        if hasattr(self, "value"):
+            return None
+        self.value = value
+
+    __repr__ = self => f"Err({repr(self.value)})"
+    unwrap = self =>
+        if self.value matches BaseException():
+            raise self.value
+        raise ValueError(f"Expected Ok, got {repr(self.value)}")
+
+
+# Provide a default implementation for *most* Result methods
+# ...we shouldn't provide a default for `map` since that
+# would prevent virtual trait lookup. TODO: fix this?
+for name, method in Result.__dict__:
+    if name.startswith("_"):
+        continue
+    if name == "map":
+        continue
+
+    let make_closure = method => (self, *args, **kwargs) => Result.raw(method(self, *args, **kwargs))
+
+    register_global_attr(object, name, make_closure(method))
+
+register_global_attr(object, "ok", ExtensionProperty(__tl__.ok))

{koatl-0.1.23 → koatl-0.1.24}/python/koatl/runtime/helpers.py

@@ -46,6 +46,11 @@ def unpack_record(obj):
 
 
 def ok(obj):
+    try:
+        return obj.ok
+    except AttributeError:
+        pass
+
     if obj is None:
         return False
     if isinstance(obj, BaseException):

koatl-0.1.23/koatl/python/koatl/prelude/functional/result.tl

@@ -1,90 +0,0 @@
-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 = bind_once
-
-    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
-
-    pure = staticmethod& x => Ok(x)
-
-    apply = (self, f) =>
-        if not __tl__.ok(self):
-            return self
-        if not __tl__.ok(f):
-            return f
-
-        # unwrap the Oks - this is a bit weird
-        # but it allows bare types to be Results
-        if self matches Ok(value):
-            self = self.value
-        if f matches Ok(value):
-            f = f.value
-
-        f(self)
-
-    # Map must not be defined since it will override any special map
-    # implementation for traits, specifically for Iterable -
-    # is there a better way around this (in the vtable implementation)?
-    # map = ...
-
-    map_err = (self, f) =>
-        if self matches Err():
-            return f(self)
-        else:
-            return self
-
-    map_none = (self, f) =>
-        if self matches None:
-            return f()
-        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
-
-    assert = staticmethod& value =>
-        value match:
-            BaseException() as e => raise e
-            None => raise ValueError("Expected a value, got None")
-            default 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 vget so is slightly faster
-for name, method in Result.__dict__:
-    if name.startswith("_"):
-        continue
-
-    setattr(Ok, name, method)
-    register_global_attr(object, name, method)
-
-export Err = BaseException

koatl-0.1.23/python/koatl/prelude/functional/result.tl

@@ -1,90 +0,0 @@
-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 = bind_once
-
-    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
-
-    pure = staticmethod& x => Ok(x)
-
-    apply = (self, f) =>
-        if not __tl__.ok(self):
-            return self
-        if not __tl__.ok(f):
-            return f
-
-        # unwrap the Oks - this is a bit weird
-        # but it allows bare types to be Results
-        if self matches Ok(value):
-            self = self.value
-        if f matches Ok(value):
-            f = f.value
-
-        f(self)
-
-    # Map must not be defined since it will override any special map
-    # implementation for traits, specifically for Iterable -
-    # is there a better way around this (in the vtable implementation)?
-    # map = ...
-
-    map_err = (self, f) =>
-        if self matches Err():
-            return f(self)
-        else:
-            return self
-
-    map_none = (self, f) =>
-        if self matches None:
-            return f()
-        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
-
-    assert = staticmethod& value =>
-        value match:
-            BaseException() as e => raise e
-            None => raise ValueError("Expected a value, got None")
-            default 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 vget so is slightly faster
-for name, method in Result.__dict__:
-    if name.startswith("_"):
-        continue
-
-    setattr(Ok, name, method)
-    register_global_attr(object, name, method)
-
-export Err = BaseException