koatl 0.1.17__tar.gz → 0.1.18__tar.gz

{koatl-0.1.17 → koatl-0.1.18}/Cargo.lock

@@ -99,7 +99,7 @@ checksum = "f4c7245a08504955605670dbf141fceab975f15ca21570696aebe9d2e71576bd"
 
 [[package]]
 name = "koatl"
-version = "0.1.17"
+version = "0.1.18"
 dependencies = [
  "ariadne",
  "koatl-core",
@@ -114,6 +114,7 @@ dependencies = [
  "ariadne",
  "once_cell",
  "parser",
+ "slotmap",
 ]
 
 [[package]]
@@ -288,6 +289,15 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
+[[package]]
+name = "slotmap"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dbff4acf519f630b3a3ddcfaea6c06b42174d9a44bc70c620e9ed1649d58b82a"
+dependencies = [
+ "version_check",
+]
+
 [[package]]
 name = "stacker"
 version = "0.1.21"
@@ -342,6 +352,12 @@ version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
 
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
 [[package]]
 name = "windows-sys"
 version = "0.59.0"

{koatl-0.1.17 → koatl-0.1.18}/PKG-INFO

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

{koatl-0.1.17 → koatl-0.1.18}/koatl/Cargo.toml

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

{koatl-0.1.17 → koatl-0.1.18}/koatl/python/koatl/prelude/functional/result.tl

@@ -29,6 +29,12 @@ export Result = class(Monad):
         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)
 
@@ -42,10 +48,11 @@ export Ok = class(metaclass=OkMeta):
     # so need to copy the methods over manually from Result
 
     # We could just use the object fallback methods, but this avoids
-    # the manual __tl__.vget
+    # the manual __tl__.vget so is slightly faster
     bind_once = Result.bind_once
     bind_gen = Result.bind_gen
     map_err = Result.map_err
+    map_none = Result.map_none
 
     assert = staticmethod& value =>
         value match:
@@ -61,6 +68,12 @@ register_global_attr(
     Result.map_err
 )
 
+register_global_attr(
+    object,
+    "map_none",
+    Result.map_none
+)
+
 register_global_attr(
     object,
     "bind",

{koatl-0.1.17 → koatl-0.1.18}/koatl/src/emit_py.rs

@@ -1,4 +1,4 @@
-use koatl_core::{linecol::LineColCache, parser::ast::*, py::ast::*};
+use koatl_core::{parser::ast::*, py::ast::*, util::LineColCache};
 
 use pyo3::{
     call::PyCallArgs,

{koatl-0.1.17 → koatl-0.1.18}/koatl/src/lib.rs

@@ -4,7 +4,7 @@ use once_cell::sync::Lazy;
 use std::{collections::HashMap, sync::Mutex};
 
 use koatl_core::{
-    format_errs, linecol::LineColCache, transpile_to_py_ast, transpile_to_source, TranspileOptions,
+    format_errs, transpile_to_py_ast, transpile_to_source, util::LineColCache, TranspileOptions,
 };
 use pyo3::{
     prelude::*,

koatl-0.1.18/koatl/tests/parse/assign.tl

@@ -0,0 +1 @@
+let x = 1

{koatl-0.1.17 → koatl-0.1.18}/koatl-core/Cargo.toml

@@ -7,3 +7,4 @@ edition = "2024"
 ariadne = "0.5.1"
 parser = { path = "parser" }
 once_cell = "1.19.0"
+slotmap = "1.0.7"

koatl-0.1.18/koatl-core/parser/src/ast.rs

@@ -0,0 +1,347 @@
+use std::{borrow::Cow, fmt::Display};
+
+use chumsky::span::SimpleSpan;
+
+pub type Indirect<T> = Box<T>;
+
+pub trait FromIndirect<T> {
+    fn extract(self) -> T;
+}
+
+impl<T: Clone> FromIndirect<T> for Indirect<T> {
+    fn extract(self) -> T {
+        *self
+    }
+}
+
+pub trait IntoIndirect<T> {
+    fn indirect(self) -> Indirect<T>;
+}
+
+impl<T> IntoIndirect<T> for Indirect<T> {
+    fn indirect(self) -> Indirect<T> {
+        self
+    }
+}
+
+impl<T> IntoIndirect<T> for T {
+    fn indirect(self) -> Indirect<T> {
+        Box::new(self)
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+pub enum BinaryOp {
+    Add,
+    Sub,
+    Mul,
+    Mod,
+    MatMul,
+    Div,
+    Exp,
+
+    Lt,
+    Leq,
+    Gt,
+    Geq,
+    Eq,
+    Neq,
+    Is,
+    Nis,
+
+    And,
+    Or,
+
+    Coalesce,
+    Pipe,
+}
+
+#[derive(Debug, Copy, Clone)]
+pub enum UnaryOp {
+    Inv,
+    Pos,
+    Neg,
+    Not,
+    Bind,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+pub struct Ident<'a>(pub Cow<'a, str>);
+
+impl<'a> Display for Ident<'a> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl<'a> From<Cow<'a, str>> for Ident<'a> {
+    fn from(value: Cow<'a, str>) -> Self {
+        Ident(value)
+    }
+}
+
+pub type SIdent<'a> = Spanned<Ident<'a>>;
+
+#[derive(Debug, Clone)]
+pub enum Literal<'a> {
+    Num(Cow<'a, str>),
+    Str(Cow<'a, str>),
+    Bool(bool),
+    None,
+}
+
+pub type SLiteral<'a> = Spanned<Literal<'a>>;
+
+#[derive(Debug, Clone)]
+pub enum ImportList<'a> {
+    // ident, alias
+    Leaves(Vec<(SIdent<'a>, Option<SIdent<'a>>)>),
+    Star,
+}
+
+#[derive(Debug, Clone)]
+pub struct ImportStmt<'a> {
+    pub trunk: Vec<SIdent<'a>>,
+    pub imports: ImportList<'a>,
+
+    // number of dots prepending the trunk
+    pub level: usize,
+
+    pub reexport: bool,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum DeclType {
+    Export,
+    Global,
+    Let,
+    Const,
+}
+
+#[derive(Debug, Clone)]
+pub enum Stmt<'a, TTree: Tree> {
+    Module,
+    Decl(Vec<SIdent<'a>>, DeclType),
+    Assign(TTree::Expr, TTree::Expr, Option<DeclType>),
+    Expr(TTree::Expr),
+
+    Return(TTree::Expr),
+    While(TTree::Expr, TTree::Expr),
+    For(TTree::Pattern, TTree::Expr, TTree::Expr),
+    Import(ImportStmt<'a>),
+    Try(TTree::Expr, Vec<MatchCase<TTree>>, Option<TTree::Expr>),
+    Assert(TTree::Expr, Option<TTree::Expr>),
+    Raise(Option<TTree::Expr>),
+
+    Break,
+    Continue,
+}
+
+#[derive(Debug, Clone)]
+pub struct FmtExpr<'a, TTree: Tree> {
+    pub expr: TTree::Expr,
+    pub fmt: Option<Ident<'a>>,
+}
+
+#[derive(Debug, Clone)]
+pub enum ListItem<TTree: Tree> {
+    Item(TTree::Expr),
+    Spread(TTree::Expr),
+}
+
+#[derive(Debug, Clone)]
+pub enum MappingItem<TTree: Tree> {
+    Ident(TTree::Expr),
+    Item(TTree::Expr, TTree::Expr),
+    Spread(TTree::Expr),
+}
+
+#[derive(Debug, Clone)]
+pub enum CallItem<'a, TTree: Tree> {
+    Arg(TTree::Expr),
+    Kwarg(SIdent<'a>, TTree::Expr),
+    ArgSpread(TTree::Expr),
+    KwargSpread(TTree::Expr),
+}
+
+#[derive(Debug, Clone)]
+pub enum ArgDefItem<'a, TTree: Tree> {
+    Arg(TTree::Pattern, Option<TTree::Expr>),
+    ArgSpread(SIdent<'a>),
+    KwargSpread(SIdent<'a>),
+}
+
+#[derive(Debug, Clone)]
+pub struct MatchCase<TTree: Tree> {
+    pub pattern: Option<TTree::Pattern>,
+    pub guard: Option<TTree::Expr>,
+    pub body: TTree::Expr,
+}
+
+pub trait Tree {
+    type Expr;
+    type Pattern;
+    type Stmt;
+}
+
+#[derive(Debug, Clone)]
+pub enum Expr<'a, TTree: Tree> {
+    Literal(SLiteral<'a>),
+    Ident(SIdent<'a>),
+    Tuple(Vec<ListItem<TTree>>),
+    List(Vec<ListItem<TTree>>),
+    Mapping(Vec<MappingItem<TTree>>),
+    Slice(
+        Option<TTree::Expr>,
+        Option<TTree::Expr>,
+        Option<TTree::Expr>,
+    ),
+
+    Unary(UnaryOp, TTree::Expr),
+    Binary(BinaryOp, TTree::Expr, TTree::Expr),
+
+    Await(TTree::Expr),
+    Yield(TTree::Expr),
+    YieldFrom(TTree::Expr),
+
+    If(TTree::Expr, TTree::Expr, Option<TTree::Expr>),
+    Match(TTree::Expr, Vec<MatchCase<TTree>>),
+    Matches(TTree::Expr, TTree::Pattern),
+    Class(Vec<CallItem<'a, TTree>>, TTree::Expr),
+
+    Call(TTree::Expr, Vec<CallItem<'a, TTree>>),
+    Subscript(TTree::Expr, Vec<ListItem<TTree>>),
+    RawAttribute(TTree::Expr, SIdent<'a>),
+    ScopedAttribute(TTree::Expr, TTree::Expr),
+    Attribute(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>),
+
+    Checked(TTree::Expr, Option<TTree::Pattern>),
+
+    Block(Vec<TTree::Stmt>),
+
+    Fn(Vec<ArgDefItem<'a, TTree>>, TTree::Expr),
+    Fstr(Spanned<String>, Vec<(FmtExpr<'a, TTree>, Spanned<String>)>),
+
+    // these are removed during desugaring
+    Decorated(TTree::Expr, TTree::Expr),
+    Placeholder,
+}
+
+// Patterns
+
+#[derive(Debug, Clone)]
+pub enum PatternSequenceItem<'a, TTree: Tree> {
+    Item(TTree::Pattern),
+    Spread(Option<SIdent<'a>>),
+}
+
+#[derive(Debug, Clone)]
+pub enum PatternMappingItem<'a, TTree: Tree> {
+    Ident(SIdent<'a>),
+    Item(TTree::Expr, TTree::Pattern),
+    Spread(Option<SIdent<'a>>),
+}
+
+#[derive(Debug, Clone)]
+pub enum PatternClassItem<'a, TTree: Tree> {
+    Item(TTree::Pattern),
+    Kw(SIdent<'a>, TTree::Pattern),
+}
+
+#[derive(Debug, Clone)]
+pub enum Pattern<'a, TTree: Tree> {
+    Capture(Option<SIdent<'a>>),
+    Value(TTree::Expr),
+    As(TTree::Pattern, SIdent<'a>),
+    Or(Vec<TTree::Pattern>),
+    Literal(SLiteral<'a>),
+    Sequence(Vec<PatternSequenceItem<'a, TTree>>),
+    Mapping(Vec<PatternMappingItem<'a, TTree>>),
+    Class(TTree::Expr, Vec<PatternClassItem<'a, TTree>>),
+}
+
+// Spanned types
+
+#[derive(Debug, Clone)]
+pub struct STree<'src> {
+    phantom: std::marker::PhantomData<&'src ()>,
+}
+
+impl<'src> Tree for STree<'src> {
+    type Expr = Indirect<SExpr<'src>>;
+    type Pattern = Indirect<SPattern<'src>>;
+    type Stmt = Indirect<SStmt<'src>>;
+}
+
+pub type Span = SimpleSpan<usize, ()>;
+
+#[derive(Debug, Clone)]
+pub struct Spanned<T> {
+    pub span: Span,
+    pub value: T,
+}
+
+pub trait Spannable<T> {
+    fn spanned(self, span: Span) -> Spanned<T>;
+}
+
+impl<T> Spannable<T> for T {
+    fn spanned(self, span: Span) -> Spanned<T> {
+        Spanned { span, value: self }
+    }
+}
+
+pub type SPatternInner<'a> = Pattern<'a, STree<'a>>;
+
+#[derive(Debug, Clone)]
+pub struct SPattern<'a> {
+    pub value: SPatternInner<'a>,
+    pub span: Span,
+}
+
+impl<'a> SPatternInner<'a> {
+    pub fn spanned(self, span: Span) -> SPattern<'a> {
+        SPattern { value: self, span }
+    }
+}
+
+pub type SExprInner<'a> = Expr<'a, STree<'a>>;
+
+#[derive(Debug, Clone)]
+pub struct SExpr<'a> {
+    pub value: SExprInner<'a>,
+    pub span: Span,
+}
+
+impl<'a> SExprInner<'a> {
+    pub fn spanned(self, span: Span) -> SExpr<'a> {
+        SExpr { value: self, span }
+    }
+}
+
+pub type SStmtInner<'a> = Stmt<'a, STree<'a>>;
+
+impl<'a> SStmtInner<'a> {
+    pub fn spanned(self, span: Span) -> SStmt<'a> {
+        SStmt { value: self, span }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct SStmt<'a> {
+    pub value: SStmtInner<'a>,
+    pub span: Span,
+}
+
+pub type SListItem<'a> = ListItem<STree<'a>>;
+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>>;