koatl 0.1.33__tar.gz → 0.1.34__tar.gz

{koatl-0.1.33 → koatl-0.1.34}/Cargo.lock

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

{koatl-0.1.33 → koatl-0.1.34}/PKG-INFO

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

{koatl-0.1.33 → koatl-0.1.34}/koatl/Cargo.toml

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

{koatl-0.1.33 → koatl-0.1.34/koatl}/python/koatl/prelude/functional/result.tl

@@ -160,7 +160,7 @@ export Err = class(Result):
         raise ValueError(f"Expected Ok, got {repr(self)}")
     coalesce = (self, f) => f()
 
-Extension.property(object, "result")& Result
+Extension.property(object, "result")& self => Result
 
 __tl__.Ok = Ok
 __tl__.Err = Err

{koatl-0.1.33 → koatl-0.1.34/koatl}/python/koatl/prelude/iterable.tl

@@ -1,6 +1,6 @@
 import itertools
 import builtins
-import .functional.(Traversable, Ok, Err, Memo, Async, AsyncMemo)
+import .functional.(Traversable, Ok, Err, Memo, Async, AsyncMemo, Result)
 
 export Iterable = Extension.trait& class(Traversable, Trait):
     iter = Abstract
@@ -50,6 +50,22 @@ export Iterable = Extension.trait& class(Traversable, Trait):
 
     filter = (self, f) => builtins.filter(f, self.iter)
 
+    filter_map = (self, f=None) =>
+        let impl = () =>
+            if f === None:
+                for i in self.iter:
+                    if Result(i) matches Ok(value):
+                        yield value
+            else:
+                for i in self.iter:
+                    if Result(f(i)) matches Ok(value):
+                        yield value
+
+        impl.__name__ = f"filter_map"
+        impl.__qualname__ = f"Iterable.filter_map"
+
+        impl()
+
     flat_map = (self, f) => itertools.chain.from_iterable(self.map(f))
 
     reverse = self => reversed(list(self.iter))
@@ -59,8 +75,16 @@ export Iterable = Extension.trait& class(Traversable, Trait):
 
     copy = self => itertools.tee(self.iter)
 
-
-    count = self => len(self.iter)
+    count = (self, f=None) =>
+        let acc = 0
+        if f === None:
+            for _ in self:
+                acc += 1
+        else:
+            for i in self:
+                if f(i):
+                    acc += 1
+        acc
 
     fold = (self, init, f) =>
         let acc = init
@@ -163,30 +187,56 @@ export Iterable = Extension.trait& class(Traversable, Trait):
             raise ValueError("mean of empty iterable")
         acc / count
 
-    max = self =>
+    max = (self, key=None) =>
         let it = self.iter
-        let v
+        let v, m
         try:
             v = next(it)
+            if key === None:
+                m = v
+            else:
+                m = key(v)
         except StopIteration(value=value):
             raise ValueError("max of empty iterable")
 
-        for i in it:
-            if i > v:
-                v = i
+
+        if key === None:
+            for i in it:
+                if i > m:
+                    v = i
+                    m = i
+        else:
+            for i in it:
+                let ki = key(i)
+                if ki > m:
+                    v = i
+                    m = ki
+
         v
 
-    min = self =>
+    min = (self, key=None) =>
         let it = self.iter
-        let v
+        let v, m
         try:
             v = next(it)
+            if key === None:
+                m = v
+            else:
+                m = key(v)
         except StopIteration(value=value):
             raise ValueError("min of empty iterable")
 
-        for i in it:
-            if i < v:
-                v = i
+        if key === None:
+            for i in it:
+                if i < m:
+                    v = i
+                    m = i
+        else:
+            for i in it:
+                let ki = key(i)
+                if ki < m:
+                    v = i
+                    m = ki
         v
 
     list = self =>

{koatl-0.1.33 → koatl-0.1.34/koatl}/python/koatl/runtime/record.py

@@ -21,6 +21,16 @@ class Record(dict):
 
         return attr
 
+    def __hash__(self):
+        return hash(tuple(sorted(self.items())))
+
+    def __eq__(self, other):
+        return super().__eq__(other)
+
+    @property
+    def len(self):
+        return len(self)
+
     @staticmethod
     def method(fn):
         fn._method = True

{koatl-0.1.33 → koatl-0.1.34}/koatl/python/koatl/runtime/virtual.py

@@ -7,7 +7,7 @@ from .._rs import fast_vget, fast_vset, fast_vset_trait
 def vget(obj, name, ignore_traits=False):
     try:
         return getattr(obj, name)
-    except:
+    except AttributeError:
         pass
 
     # special case for iter - this could be implemented using types and trait vtbls

{koatl-0.1.33 → koatl-0.1.34}/koatl/src/emit_py.rs

@@ -553,6 +553,7 @@ impl<'src> PyExprExt<'src> for SPyExpr<'src> {
                     PyBinaryOp::Sub => Some("Sub"),
                     PyBinaryOp::Mult => Some("Mult"),
                     PyBinaryOp::Div => Some("Div"),
+                    PyBinaryOp::FloorDiv => Some("FloorDiv"),
                     PyBinaryOp::Mod => Some("Mod"),
                     PyBinaryOp::Pow => Some("Pow"),
                     _ => None,
@@ -596,6 +597,8 @@ impl<'src> PyExprExt<'src> for SPyExpr<'src> {
                     PyBinaryOp::Neq => Some("NotEq"),
                     PyBinaryOp::Is => Some("Is"),
                     PyBinaryOp::Nis => Some("IsNot"),
+                    PyBinaryOp::In => Some("In"),
+                    PyBinaryOp::Nin => Some("NotIn"),
                     _ => None,
                 };
 

{koatl-0.1.33 → koatl-0.1.34}/koatl/tests/e2e/base/coal.tl

@@ -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)

{koatl-0.1.33 → koatl-0.1.34}/koatl/tests/e2e/prelude/try.tl

@@ -25,5 +25,5 @@ except:
 
 assert_eq(try 1 matches Ok(1), True)
 
-assert_eq((try 5)?.($+1)?(), Ok(6))
-assert_eq((try x)?.($+1)?() matches Err(), True)
+assert_eq((try 5)?.($+1), Ok(6))
+assert_eq((try x)?.($+1) matches Err(), True)

{koatl-0.1.33 → koatl-0.1.34}/koatl-core/parser/src/ast.rs

@@ -35,11 +35,15 @@ pub enum BinaryOp {
     Add,
     Sub,
     Mul,
-    Mod,
     MatMul,
     Div,
     Exp,
 
+    FloorDiv,
+    Mod,
+
+    In,
+    Nin,
     Lt,
     Leq,
     Gt,
@@ -138,9 +142,9 @@ pub enum Stmt<'a, TTree: Tree> {
 }
 
 #[derive(Debug, Clone)]
-pub struct FmtExpr<'a, TTree: Tree> {
+pub struct FmtExpr<TTree: Tree> {
     pub expr: TTree::Expr,
-    pub fmt: Option<Ident<'a>>,
+    pub fmt: Option<TTree::Expr>,
 }
 
 #[derive(Debug, Clone)]
@@ -229,7 +233,7 @@ pub enum Expr<'a, TTree: Tree> {
     Block(Vec<TTree::Stmt>),
 
     Fn(Vec<ArgDefItem<'a, TTree>>, TTree::Expr),
-    Fstr(Spanned<String>, Vec<(FmtExpr<'a, TTree>, Spanned<String>)>),
+    Fstr(Spanned<String>, Vec<(FmtExpr<TTree>, Spanned<String>)>),
 
     // these are removed during desugaring
     Decorated(TTree::Expr, TTree::Expr),
@@ -347,4 +351,4 @@ pub type SMappingItem<'a> = MappingItem<STree<'a>>;
 pub type SMatchCase<'a> = MatchCase<STree<'a>>;
 pub type SCallItem<'a> = CallItem<'a, STree<'a>>;
 pub type SArgDefItem<'a> = ArgDefItem<'a, STree<'a>>;
-pub type SFmtExpr<'a> = FmtExpr<'a, STree<'a>>;
+pub type SFmtExpr<'a> = FmtExpr<STree<'a>>;

{koatl-0.1.33 → koatl-0.1.34}/koatl-core/parser/src/lexer.rs

@@ -5,7 +5,10 @@ use chumsky::{
     label::LabelError,
     prelude::*,
 };
-use std::{collections::HashSet, fmt};
+use std::{
+    collections::HashSet,
+    fmt::{self},
+};
 
 use crate::ast::{Span, Spannable, Spanned};
 
@@ -321,7 +324,7 @@ where
     fn parse_symbol(&mut self) -> TResult<'src, Spanned<Token<'src>>> {
         const POLYGRAMS: &[&str] = &[
             "+=", "-=", "*=", "/=", "|=", "??=", "===", "<=>", "=>", "..", "==", "<>", "<=", ">=",
-            "//", "**", "??", ".=",
+            "//", "**", "??", ".=", "::",
         ];
         const MONOGRAMS: &str = "[](){}<>.,;:!?@$%^&*+-=|\\/`~";
 
@@ -612,23 +615,13 @@ where
         }
     }
 
-    fn parse_fstr(&mut self, verbatim: bool) -> TResult<'src, TokenList<'src>> {
+    fn parse_fstr_inner(&mut self, ending: &str, verbatim: bool) -> TResult<'src, TokenList<'src>> {
         let mut marker = self.cursor();
-
-        if verbatim {
-            self.parse_seq("f\"\"\"")?;
-        } else {
-            self.parse_seq("f\"")?;
-        }
-
         let mut tokens = vec![];
         let mut current_str = String::new();
 
         loop {
-            if self
-                .try_parse(|x| x.parse_seq(if verbatim { "\"\"\"" } else { "\"" }))
-                .is_ok()
-            {
+            if self.look_ahead(|x| x.parse_seq(ending)).is_ok() {
                 if tokens.len() == 0 {
                     tokens.push(Token::FstrBegin(current_str).spanned(self.span_since(&marker)));
                 } else {
@@ -667,12 +660,19 @@ where
 
                 self.parse_nonsemantic()?;
                 let _ = self.try_parse(|x| x.parse_newline());
-
                 let sexpr = self.try_parse(|x| x.parse_block(0, NewBlockType::BeginInput))?;
-
                 let _ = self.try_parse(|x| x.parse_newline());
-                self.try_parse(|x| x.parse_indentation())?;
-                self.try_parse(|x| x.parse_seq("}"))?;
+
+                self.parse_indentation()?;
+
+                marker = self.cursor();
+                let mut format_tokens = vec![];
+                if self.try_parse(|x| x.parse_seq("!")).is_ok() {
+                    format_tokens.push(Token::Symbol("!").spanned(self.span_since(&marker)));
+                    format_tokens.extend(self.parse_fstr_inner("}", verbatim)?);
+                }
+
+                self.parse_seq("}")?;
 
                 tokens.push(Token::Indent.spanned(Span::new(
                     sexpr.span.context,
@@ -687,6 +687,7 @@ where
                     sexpr.span.context,
                     sexpr.span.end..sexpr.span.end,
                 )));
+                tokens.extend(format_tokens);
 
                 marker = self.cursor();
 
@@ -703,6 +704,20 @@ where
         }
     }
 
+    fn parse_fstr(&mut self, verbatim: bool) -> TResult<'src, TokenList<'src>> {
+        if verbatim {
+            self.parse_seq("f\"\"\"")?;
+            let inner = self.parse_fstr_inner("\"\"\"", true)?;
+            self.parse_seq("\"\"\"")?;
+            return Ok(inner);
+        } else {
+            self.parse_seq("f\"")?;
+            let inner = self.parse_fstr_inner("\"", false)?;
+            self.parse_seq("\"")?;
+            return Ok(inner);
+        }
+    }
+
     fn parse_str_start(&mut self) -> TResult<'src, ()> {
         let start = self.cursor();
 
@@ -818,6 +833,13 @@ where
                         break;
                     }
 
+                    if let Token::Symbol("!") = &tok.value {
+                        // Format specifier delimiter; end block.
+                        self.input.rewind(saved);
+                        end_block = true;
+                        break;
+                    }
+
                     if let Token::Symbol(s) = &tok.value {
                         let char = s.chars().next().unwrap_or('\0');
                         if OPEN_DELIMS.contains(&char) {

{koatl-0.1.33 → koatl-0.1.34}/koatl-core/parser/src/parser.rs

@@ -525,6 +525,8 @@ where
         symbol("-=").to(BinaryOp::Sub),
         symbol("*=").to(BinaryOp::Mul),
         symbol("/=").to(BinaryOp::Div),
+        symbol("//=").to(BinaryOp::FloorDiv),
+        symbol("%=").to(BinaryOp::Mod),
         symbol("|=").to(BinaryOp::Pipe),
         symbol("??=").to(BinaryOp::Coalesce),
     ))
@@ -543,6 +545,7 @@ where
             SStmtInner::Expr(lhs.indirect())
         }
     })
+    .labelled("assignment")
     .boxed();
 
     let inline_assign_stmt = group((expr.clone(), assign_op.clone().then(expr.clone()).or_not()))
@@ -553,6 +556,7 @@ where
                 SStmtInner::Expr(lhs.indirect())
             }
         })
+        .labelled("assignment")
         .boxed();
 
     let while_stmt = just(Token::Kw("while"))
@@ -955,27 +959,32 @@ where
     }
     .map_with(|x, e| x.spanned(e.span()));
 
-    let fstr = fstr_begin
-        .then(
-            expr_or_block
-                .clone()
-                .then(fstr_continue)
-                .map(|(block, cont)| {
-                    (
-                        FmtExpr {
-                            expr: block.indirect(),
-                            fmt: None,
-                        },
-                        cont,
-                    )
-                })
-                .repeated()
-                .collect::<Vec<_>>(),
-        )
-        .map(|(begin, parts)| SExprInner::Fstr(begin, parts))
-        .spanned_expr()
-        .labelled("f-string")
-        .boxed();
+    let mut fstr = Recursive::<chumsky::recursive::Indirect<TInput, SExpr, TExtra>>::declare();
+
+    fstr.define(
+        fstr_begin
+            .then(
+                expr_or_block
+                    .clone()
+                    .then(symbol("!").ignore_then(fstr.clone()).or_not())
+                    .then(fstr_continue)
+                    .map(|((block, fmt), cont)| {
+                        (
+                            FmtExpr {
+                                expr: block.indirect(),
+                                fmt: fmt.map(|x| x.indirect()),
+                            },
+                            cont,
+                        )
+                    })
+                    .repeated()
+                    .collect::<Vec<_>>(),
+            )
+            .map(|(begin, parts)| SExprInner::Fstr(begin, parts))
+            .spanned_expr()
+            .labelled("f-string")
+            .boxed(),
+    );
 
     let class_ = just(Token::Kw("class"))
         .ignore_then(
@@ -1183,7 +1192,7 @@ where
         .labelled("then-attribute")
         .boxed();
 
-    let raw_attr = symbol("!")
+    let raw_attr = symbol("::")
         .ignore_then(ident.clone())
         .map(Postfix::RawAttribute)
         .labelled("raw-attribute")
@@ -1307,6 +1316,7 @@ where
         select! {
             Token::Symbol("*") => BinaryOp::Mul,
             Token::Symbol("/") => BinaryOp::Div,
+            Token::Symbol("//") => BinaryOp::FloorDiv,
             Token::Symbol("%") => BinaryOp::Mod,
             Token::Symbol("@") => BinaryOp::MatMul,
         },
@@ -1325,6 +1335,7 @@ where
     let binary3 = make_binary_op(
         binary2.clone(),
         select! {
+            Token::Kw("in") => BinaryOp::In,
             Token::Symbol("<") => BinaryOp::Lt,
             Token::Symbol("<=") => BinaryOp::Leq,
             Token::Symbol(">") => BinaryOp::Gt,
@@ -1333,7 +1344,10 @@ where
             Token::Symbol("<>") => BinaryOp::Neq,
             Token::Symbol("===") => BinaryOp::Is,
             Token::Symbol("<=>") => BinaryOp::Nis,
-        },
+        }
+        .or(just(Token::Kw("not"))
+            .then(just(Token::Kw("in")))
+            .to(BinaryOp::Nin)),
         false,
     );
 

{koatl-0.1.33 → koatl-0.1.34}/koatl-core/src/py/ast.rs

@@ -146,6 +146,7 @@ pub enum PyBinaryOp {
     Mult,
     Div,
     Mod,
+    FloorDiv,
     Pow,
     MatMult,
 
@@ -160,6 +161,8 @@ pub enum PyBinaryOp {
     Geq,
     Is,
     Nis,
+    In,
+    Nin,
 }
 
 #[derive(Debug, Clone)]
@@ -200,7 +203,7 @@ pub enum PyDictItem<'a> {
 #[derive(Debug, Clone)]
 pub enum PyFstrPart<'a> {
     Str(PyIdent<'a>),
-    Expr(SPyExpr<'a>, Option<PyIdent<'a>>),
+    Expr(SPyExpr<'a>, Option<SPyExpr<'a>>),
 }
 
 #[derive(Debug, Clone)]

{koatl-0.1.33 → koatl-0.1.34}/koatl-core/src/py/emit.rs

@@ -5,7 +5,10 @@ use parser::{
     lexer::{py_escape_fstr, py_escape_str},
 };
 
-use crate::{py::ast::*, util::TlResult};
+use crate::{
+    py::ast::*,
+    util::{TlErrBuilder, TlResult},
+};
 
 const LOW_PREC: f32 = -100.0;
 const HIGH_PREC: f32 = 100.0;
@@ -258,10 +261,16 @@ impl PyBinaryOp {
             | PyBinaryOp::Geq
             | PyBinaryOp::Is
             | PyBinaryOp::Nis
+            | PyBinaryOp::In
+            | PyBinaryOp::Nin
             | PyBinaryOp::And
             | PyBinaryOp::Or => 0.0,
             PyBinaryOp::Add | PyBinaryOp::Sub => 1.0,
-            PyBinaryOp::Mult | PyBinaryOp::Div | PyBinaryOp::Mod | PyBinaryOp::MatMult => 2.0,
+            PyBinaryOp::Mult
+            | PyBinaryOp::Div
+            | PyBinaryOp::Mod
+            | PyBinaryOp::MatMult
+            | PyBinaryOp::FloorDiv => 2.0,
             PyBinaryOp::Pow => 3.0,
         }
     }
@@ -272,6 +281,7 @@ impl PyBinaryOp {
             PyBinaryOp::Sub => "-",
             PyBinaryOp::Mult => "*",
             PyBinaryOp::Div => "/",
+            PyBinaryOp::FloorDiv => "//",
             PyBinaryOp::Mod => "%",
             PyBinaryOp::Pow => "**",
             PyBinaryOp::MatMult => "@",
@@ -283,6 +293,8 @@ impl PyBinaryOp {
             PyBinaryOp::Geq => ">=",
             PyBinaryOp::Is => "is",
             PyBinaryOp::Nis => "is not",
+            PyBinaryOp::In => "in",
+            PyBinaryOp::Nin => "not in",
             PyBinaryOp::And => "and",
             PyBinaryOp::Or => "or",
         });
@@ -476,22 +488,7 @@ impl SPyExpr<'_> {
             PyExpr::Literal(literal) => literal.emit_to(ctx, parent_precendence)?,
             PyExpr::Fstr(fstr_parts) => {
                 ctx.emit("f\"");
-                for part in fstr_parts.iter_mut() {
-                    match part {
-                        PyFstrPart::Str(s) => {
-                            ctx.emit_escaped_fstr(s);
-                        }
-                        PyFstrPart::Expr(expr, fmt) => {
-                            ctx.emit("{");
-                            expr.emit_sided_to(ctx, HIGH_PREC, true)?;
-                            if let Some(fmt) = fmt {
-                                ctx.emit(":");
-                                ctx.emit(fmt);
-                            }
-                            ctx.emit("}");
-                        }
-                    }
-                }
+                emit_fstr_inner(ctx, fstr_parts)?;
                 ctx.emit("\"");
             }
             PyExpr::Slice(start, stop, step) => {
@@ -547,6 +544,34 @@ impl SPyExpr<'_> {
     }
 }
 
+fn emit_fstr_inner(ctx: &mut EmitCtx, fstr_parts: &mut [PyFstrPart<'_>]) -> TlResult<()> {
+    for part in fstr_parts.iter_mut() {
+        match part {
+            PyFstrPart::Str(s) => {
+                ctx.emit_escaped_fstr(s);
+            }
+            PyFstrPart::Expr(expr, fmt) => {
+                ctx.emit("{");
+                expr.emit_sided_to(ctx, HIGH_PREC, true)?;
+
+                if let Some(fmt) = fmt {
+                    ctx.emit(":");
+                    let PyExpr::Fstr(fmt_parts) = &mut fmt.value else {
+                        return Err(TlErrBuilder::new()
+                            .message("Format specifier must be an fstr")
+                            .span(fmt.tl_span)
+                            .build());
+                    };
+                    emit_fstr_inner(ctx, fmt_parts)?;
+                }
+                ctx.emit("}");
+            }
+        }
+    }
+
+    Ok(())
+}
+
 impl PyBlock<'_> {
     pub fn emit_to(&mut self, ctx: &mut EmitCtx, delta_indentation: i32) -> TlResult<()> {
         let old_indentation = ctx.indentation;

{koatl-0.1.33 → koatl-0.1.34}/koatl-core/src/py/util.rs

@@ -376,7 +376,7 @@ impl PyAstBuilder {
     pub fn fstr_expr<'src>(
         &self,
         expr: SPyExpr<'src>,
-        format_spec: impl Into<Option<PyIdent<'src>>>,
+        format_spec: impl Into<Option<SPyExpr<'src>>>,
     ) -> PyFstrPart<'src> {
         PyFstrPart::Expr(expr, format_spec.into())
     }

{koatl-0.1.33 → koatl-0.1.34}/koatl-core/src/resolve_scopes.rs

@@ -1319,7 +1319,7 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
                         (
                             FmtExpr {
                                 expr: expr.expr.traverse(state),
-                                fmt: expr.fmt,
+                                fmt: expr.fmt.map(|x| x.traverse(state)),
                             },
                             suffix,
                         )

{koatl-0.1.33 → koatl-0.1.34}/koatl-core/src/transform.rs

@@ -1348,10 +1348,7 @@ fn transform_postfix_expr<'src, 'ast>(
             }
             Expr::ScopedAttribute(_, rhs) | Expr::MappedScopedAttribute(_, rhs) => {
                 let t = inner_pre.bind(rhs.transform(ctx)?);
-                a.call(
-                    a.tl_builtin("partial"),
-                    vec![PyCallItem::Arg(t), PyCallItem::Arg(lhs)],
-                )
+                a.call(t, vec![PyCallItem::Arg(lhs)])
             }
             Expr::RawAttribute(_, attr) | Expr::MappedRawAttribute(_, attr) => {
                 a.attribute(lhs, attr.value.escape(), access_ctx)
@@ -2168,10 +2165,14 @@ impl<'src, 'ast> SExprExt<'src, 'ast> for SExpr<'src> {
                 nodes.push(PyFstrPart::Str(begin.value.clone().into()));
 
                 for (fmt_expr, str_part) in parts {
-                    // TODO format specifiers?
                     let expr = pre.bind(fmt_expr.expr.transform(ctx)?);
+                    let fmt = fmt_expr
+                        .fmt
+                        .as_ref()
+                        .map(|x| -> TlResult<_> { Ok(pre.bind(x.transform(ctx)?)) })
+                        .transpose()?;
 
-                    nodes.push(PyFstrPart::Expr(expr, None));
+                    nodes.push(PyFstrPart::Expr(expr, fmt));
                     nodes.push(PyFstrPart::Str(str_part.value.clone().into()));
                 }
 
@@ -2225,6 +2226,7 @@ fn map_py_binary_op(op: BinaryOp, span: Span) -> TlResult<PyBinaryOp> {
         BinaryOp::Sub => PyBinaryOp::Sub,
         BinaryOp::Mul => PyBinaryOp::Mult,
         BinaryOp::Div => PyBinaryOp::Div,
+        BinaryOp::FloorDiv => PyBinaryOp::FloorDiv,
         BinaryOp::Mod => PyBinaryOp::Mod,
         BinaryOp::Exp => PyBinaryOp::Pow,
         BinaryOp::MatMul => PyBinaryOp::MatMult,
@@ -2237,6 +2239,8 @@ fn map_py_binary_op(op: BinaryOp, span: Span) -> TlResult<PyBinaryOp> {
         BinaryOp::Neq => PyBinaryOp::Neq,
         BinaryOp::Is => PyBinaryOp::Is,
         BinaryOp::Nis => PyBinaryOp::Nis,
+        BinaryOp::In => PyBinaryOp::In,
+        BinaryOp::Nin => PyBinaryOp::Nin,
 
         _ => return Err(simple_err("Internal error: Unsupported binary op", span)),
     })

{koatl-0.1.33/koatl → koatl-0.1.34}/python/koatl/prelude/functional/result.tl

@@ -160,7 +160,7 @@ export Err = class(Result):
         raise ValueError(f"Expected Ok, got {repr(self)}")
     coalesce = (self, f) => f()
 
-Extension.property(object, "result")& Result
+Extension.property(object, "result")& self => Result
 
 __tl__.Ok = Ok
 __tl__.Err = Err

{koatl-0.1.33/koatl → koatl-0.1.34}/python/koatl/prelude/iterable.tl

@@ -1,6 +1,6 @@
 import itertools
 import builtins
-import .functional.(Traversable, Ok, Err, Memo, Async, AsyncMemo)
+import .functional.(Traversable, Ok, Err, Memo, Async, AsyncMemo, Result)
 
 export Iterable = Extension.trait& class(Traversable, Trait):
     iter = Abstract
@@ -50,6 +50,22 @@ export Iterable = Extension.trait& class(Traversable, Trait):
 
     filter = (self, f) => builtins.filter(f, self.iter)
 
+    filter_map = (self, f=None) =>
+        let impl = () =>
+            if f === None:
+                for i in self.iter:
+                    if Result(i) matches Ok(value):
+                        yield value
+            else:
+                for i in self.iter:
+                    if Result(f(i)) matches Ok(value):
+                        yield value
+
+        impl.__name__ = f"filter_map"
+        impl.__qualname__ = f"Iterable.filter_map"
+
+        impl()
+
     flat_map = (self, f) => itertools.chain.from_iterable(self.map(f))
 
     reverse = self => reversed(list(self.iter))
@@ -59,8 +75,16 @@ export Iterable = Extension.trait& class(Traversable, Trait):
 
     copy = self => itertools.tee(self.iter)
 
-
-    count = self => len(self.iter)
+    count = (self, f=None) =>
+        let acc = 0
+        if f === None:
+            for _ in self:
+                acc += 1
+        else:
+            for i in self:
+                if f(i):
+                    acc += 1
+        acc
 
     fold = (self, init, f) =>
         let acc = init
@@ -163,30 +187,56 @@ export Iterable = Extension.trait& class(Traversable, Trait):
             raise ValueError("mean of empty iterable")
         acc / count
 
-    max = self =>
+    max = (self, key=None) =>
         let it = self.iter
-        let v
+        let v, m
         try:
             v = next(it)
+            if key === None:
+                m = v
+            else:
+                m = key(v)
         except StopIteration(value=value):
             raise ValueError("max of empty iterable")
 
-        for i in it:
-            if i > v:
-                v = i
+
+        if key === None:
+            for i in it:
+                if i > m:
+                    v = i
+                    m = i
+        else:
+            for i in it:
+                let ki = key(i)
+                if ki > m:
+                    v = i
+                    m = ki
+
         v
 
-    min = self =>
+    min = (self, key=None) =>
         let it = self.iter
-        let v
+        let v, m
         try:
             v = next(it)
+            if key === None:
+                m = v
+            else:
+                m = key(v)
         except StopIteration(value=value):
             raise ValueError("min of empty iterable")
 
-        for i in it:
-            if i < v:
-                v = i
+        if key === None:
+            for i in it:
+                if i < m:
+                    v = i
+                    m = i
+        else:
+            for i in it:
+                let ki = key(i)
+                if ki < m:
+                    v = i
+                    m = ki
         v
 
     list = self =>

{koatl-0.1.33/koatl → koatl-0.1.34}/python/koatl/runtime/record.py

@@ -21,6 +21,16 @@ class Record(dict):
 
         return attr
 
+    def __hash__(self):
+        return hash(tuple(sorted(self.items())))
+
+    def __eq__(self, other):
+        return super().__eq__(other)
+
+    @property
+    def len(self):
+        return len(self)
+
     @staticmethod
     def method(fn):
         fn._method = True

{koatl-0.1.33 → koatl-0.1.34}/python/koatl/runtime/virtual.py

@@ -7,7 +7,7 @@ from .._rs import fast_vget, fast_vset, fast_vset_trait
 def vget(obj, name, ignore_traits=False):
     try:
         return getattr(obj, name)
-    except:
+    except AttributeError:
         pass
 
     # special case for iter - this could be implemented using types and trait vtbls