koatl 0.1.33__tar.gz → 0.1.35__tar.gz

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

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

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

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

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

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

{koatl-0.1.33 → koatl-0.1.35}/koatl/python/koatl/prelude/functional/algebra.tl

@@ -8,9 +8,9 @@ export Monad = class(Trait):
     """
     __slots__ = ()
 
-    bind = Abstract& (self, f) => None
+    bind = Trait.abstract& (self, f) => None
 
-    pure = staticmethod& Abstract& value => None
+    pure = staticmethod& Trait.abstract& value => None
 
     # Automatically generated implementations.
     map = (self, f) => self.bind(x => self.pure(f(x)))
@@ -33,7 +33,7 @@ export MonadOnce = class(Monad, Trait):
     __slots__ = ()
 
     # The default implementation required for `@` syntax that should be overridden by subclasses.
-    bind_once = Abstract& (self, f) => None
+    bind_once = Trait.abstract& (self, f) => None
 
     # An optional, optimized implementation of `bind` that skips deep recursion.
     # TODO: can this be automatically generated from bind_once?
@@ -69,4 +69,4 @@ export Traversable = class(Trait):
     """
     __slots__ = ()
 
-    traverse = Abstract& (self, f) => None
+    traverse = Trait.abstract& (self, f) => None

{koatl-0.1.33 → koatl-0.1.35/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.35/koatl}/python/koatl/prelude/iterable.tl

@@ -1,9 +1,9 @@
 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
+    iter = Trait.abstract& self => None
 
     skip = (self, n) =>
         let it = self.iter
@@ -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.35}/koatl/python/koatl/runtime/classes.py

@@ -40,6 +40,7 @@ class MappingMeta(type):
         return [(k, v) for k, v in inspect.getmembers(self) if not k.startswith("_")]
 
 
+# A utility base class to inherit from to enable __getitem__ method lookup on types and thus destructuring.
 class Class(metaclass=MappingMeta):
     pass
 
@@ -104,9 +105,9 @@ class Trait(metaclass=TraitMeta):
         fn._property = True
         return property(fn)
 
-
-Abstract = lambda value: abc.abstractmethod(value)
-Abstract.__isabstractmethod__ = True
+    @staticmethod
+    def abstract(value):
+        return abc.abstractmethod(value)
 
 
-__all__ = ["Class", "Trait", "Abstract"]
+__all__ = ["Class", "Trait"]

{koatl-0.1.33 → koatl-0.1.35/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.35}/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.35}/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.35}/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.35}/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.35}/koatl/tests/e2e/prelude/virtual.tl

@@ -15,7 +15,7 @@ assert_eq(x.a, 1)
 
 
 SomeTrait = Extension.trait& class(Trait):
-    required_method = Abstract
+    required_method = Trait.abstract& self => ()
 
     derived_method = self => self.required_method()
     derived_property = Trait.property& self => self.required_method()

{koatl-0.1.33 → koatl-0.1.35}/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.35}/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.35}/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.35}/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)]