d7e5ff4 | plum

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

d7e5ff4 — Peter John 2026-07-20T21:40:35+05:30

feat(plum-core): parse closure literals and fn(...) type annotations

Files changed (6) hide show

plum-checker/src/lib.rs +13 -0
plum-checker/src/monomorphize.rs +28 -0
plum-core/src/ast.rs +11 -0
plum-core/src/parser.rs +36 -5
plum-core/tests/parser_test.rs +69 -0
plum-wasm-codegen/src/lib.rs +16 -0

plum-checker/src/lib.rs CHANGED Viewed

@@ -115,6 +115,11 @@ pub fn build_global_tables(source: &ast::Source) -> (TypeEnv, ClassEnv, MethodEn
                     match &p.ty {
                         ast::ParamType::Type(t) => plum_type_from_ast(t),
                         ast::ParamType::Variadic(t) => plum_type_from_ast(t),
+                        ast::ParamType::Fn(params, ret) => {
+                            let param_types = params.iter().map(plum_type_from_ast).collect();
+                            let ret_ty = ret.as_ref().map(|r| plum_type_from_ast(r)).unwrap_or(PlumType::TUnit);
+                            PlumType::TFun(param_types, Box::new(ret_ty))
+                        }
                     }
                 }).collect();
                 let ret = f.returns.as_ref()
@@ -179,6 +184,11 @@ fn check_fn(f: &ast::Fn, global_env: &TypeEnv, ctx: &CheckCtx) -> Vec<CheckError
         let ty = match &p.ty {
             ast::ParamType::Type(t) => plum_type_from_ast(t),
             ast::ParamType::Variadic(t) => plum_type_from_ast(t),
+            ast::ParamType::Fn(params, ret) => {
+                let param_types = params.iter().map(plum_type_from_ast).collect();
+                let ret_ty = ret.as_ref().map(|r| plum_type_from_ast(r)).unwrap_or(PlumType::TUnit);
+                PlumType::TFun(param_types, Box::new(ret_ty))
+            }
         };
         env.insert(p.name.clone(), TypeScheme::mono(ty));
     }
@@ -419,6 +429,9 @@ pub fn infer_expr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plu
             },
         },
         ast::Expr::Paren(inner) => infer_expr(inner, env, ctx),
+        // TODO: closures are not yet type-checked; treat as an unconstrained type
+        // for now so downstream code can compile against `Expr::Closure`.
+        ast::Expr::Closure(_) => Ok(PlumType::TVar("_".to_string())),
         ast::Expr::Not(inner) => {
             let t = infer_expr(inner, env, ctx)?;
             unify(&PlumType::TBool, &t)?;

plum-checker/src/monomorphize.rs CHANGED Viewed

@@ -33,6 +33,9 @@ pub fn fn_generic_params(f: &ast::Fn) -> Vec<String> {
         match &p.ty {
             ast::ParamType::Type(t) => consider(&t.name),
             ast::ParamType::Variadic(t) => consider(&t.name),
+            // TODO: closures/fn-value params don't yet participate in generic
+            // parameter inference.
+            ast::ParamType::Fn(_, _) => {}
         }
     }
     if let Some(r) = &f.returns {
@@ -140,6 +143,8 @@ pub fn specialize_fn(f: &ast::Fn, subst: &Substitution, mangled_name: &str, new_
             ty: match &p.ty {
                 ast::ParamType::Type(t) => ast::ParamType::Type(substitute_type(t, subst)),
                 ast::ParamType::Variadic(t) => ast::ParamType::Variadic(substitute_type(t, subst)),
+                // TODO: substitution into fn-value param/return types is not yet supported.
+                ast::ParamType::Fn(params, ret) => ast::ParamType::Fn(params.clone(), ret.clone()),
             },
             default: p.default.clone(),
         }).collect(),
@@ -246,6 +251,11 @@ impl<'a> Monomorphizer<'a> {
             let ty = match &p.ty {
                 ast::ParamType::Type(t) => crate::plum_type_from_ast(t),
                 ast::ParamType::Variadic(t) => crate::plum_type_from_ast(t),
+                ast::ParamType::Fn(params, ret) => {
+                    let param_types = params.iter().map(crate::plum_type_from_ast).collect();
+                    let ret_ty = ret.as_ref().map(|r| crate::plum_type_from_ast(r)).unwrap_or(PlumType::TUnit);
+                    PlumType::TFun(param_types, Box::new(ret_ty))
+                }
             };
             env.insert(p.name.clone(), TypeScheme::mono(ty));
         }
@@ -436,6 +446,8 @@ impl<'a> Monomorphizer<'a> {
             let gp = match &param.ty {
                 ast::ParamType::Type(t) => t.name.clone(),
                 ast::ParamType::Variadic(t) => t.name.clone(),
+                // TODO: fn-value params don't yet resolve to a generic parameter.
+                ast::ParamType::Fn(_, _) => String::new(),
             };
             if params.contains(&gp) {
                 let arg_expr = match arg {
@@ -472,6 +484,8 @@ impl<'a> Monomorphizer<'a> {
             let n = match &p.ty {
                 ast::ParamType::Type(t) => &t.name,
                 ast::ParamType::Variadic(t) => &t.name,
+                // TODO: fn-value params don't yet participate in bare-generic resolution.
+                ast::ParamType::Fn(_, _) => continue,
             };
             if (self.classes_generic.contains_key(n.as_str()) || self.enums_generic_by_name.contains_key(n.as_str()))
                 && !names.iter().any(|x| x == n)
@@ -497,6 +511,8 @@ impl<'a> Monomorphizer<'a> {
             let n = match &param.ty {
                 ast::ParamType::Type(t) => t.name.clone(),
                 ast::ParamType::Variadic(t) => t.name.clone(),
+                // TODO: fn-value params don't yet resolve to a bare generic reference.
+                ast::ParamType::Fn(_, _) => String::new(),
             };
             if refs.contains(&n) {
                 let arg_expr = match arg {
@@ -665,6 +681,8 @@ impl<'a> Monomorphizer<'a> {
             }
             ast::Expr::Int(_) | ast::Expr::Float(_)
             | ast::Expr::Self_ | ast::Expr::Var(_) | ast::Expr::TypeName(_) => {}
+            // TODO: closure bodies don't yet get rewritten for generic call sites.
+            ast::Expr::Closure(_) => {}
         }
         Ok(())
     }
@@ -775,6 +793,11 @@ pub fn monomorphize_source(source: &ast::Source) -> Result<ast::Source, String>
                         let param_types: Vec<PlumType> = specialized_method.params.iter().map(|p| match &p.ty {
                             ast::ParamType::Type(t) => crate::plum_type_from_ast(t),
                             ast::ParamType::Variadic(t) => crate::plum_type_from_ast(t),
+                            ast::ParamType::Fn(params, ret) => {
+                                let param_types = params.iter().map(crate::plum_type_from_ast).collect();
+                                let ret_ty = ret.as_ref().map(|r| crate::plum_type_from_ast(r)).unwrap_or(PlumType::TUnit);
+                                PlumType::TFun(param_types, Box::new(ret_ty))
+                            }
                         }).collect();
                         let ret = specialized_method.returns.as_ref()
                             .map(|r| crate::plum_type_from_ast(&ast::Type { name: r.name.clone(), generics: vec![] }))
@@ -793,6 +816,11 @@ pub fn monomorphize_source(source: &ast::Source) -> Result<ast::Source, String>
                 let param_types: Vec<PlumType> = specialized_fn.params.iter().map(|p| match &p.ty {
                     ast::ParamType::Type(t) => crate::plum_type_from_ast(t),
                     ast::ParamType::Variadic(t) => crate::plum_type_from_ast(t),
+                    ast::ParamType::Fn(params, ret) => {
+                        let param_types = params.iter().map(crate::plum_type_from_ast).collect();
+                        let ret_ty = ret.as_ref().map(|r| crate::plum_type_from_ast(r)).unwrap_or(PlumType::TUnit);
+                        PlumType::TFun(param_types, Box::new(ret_ty))
+                    }
                 }).collect();
                 let ret = specialized_fn.returns.as_ref()
                     .map(|r| crate::plum_type_from_ast(&ast::Type { name: r.name.clone(), generics: vec![] }))

plum-core/src/ast.rs CHANGED Viewed

@@ -101,6 +101,9 @@ pub struct Param {
 pub enum ParamType {
     Type(Type),
     Variadic(Type),
+    /// `fn(Int, Str) -> Bool` — a function-value type annotation. Positional types
+    /// only, no param names (types don't need names).
+    Fn(Vec<Type>, Option<Box<Type>>),
 }
 #[derive(Debug, Clone, PartialEq)]
@@ -128,6 +131,12 @@ pub struct Block {
     pub stmts: Vec<Stmt>,
 }
+#[derive(Debug, Clone, PartialEq)]
+pub struct Closure {
+    pub params: Vec<String>,
+    pub body: Block,
+}
 #[derive(Debug, Clone, PartialEq)]
 pub enum Stmt {
     Assign(Assign),
@@ -231,6 +240,8 @@ pub enum Expr {
     Self_,
     Var(String),
     TypeName(String),
+    /// `|params| body`
+    Closure(Box<Closure>),
 }
 #[derive(Debug, Clone, PartialEq)]

plum-core/src/parser.rs CHANGED Viewed

@@ -251,17 +251,17 @@ impl<'a> AstParser<'a> {
     }
     fn parse_param(&self, node: Node) -> Param {
-        // param: var_identifier ":" (type | variadic_type) ("=" expression)?
+        // param: var_identifier ":" (type | variadic_type | fn_value_type) ("=" expression)?
         let name = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();
-        let ty = node.named_child(1).map(|n| {
+        let ty = node.named_child(1).map(|n| match n.kind() {
-            if n.kind() == "variadic_type" {
+            "variadic_type" => {
                 let inner = n.named_child(0)
                     .map(|t| self.parse_type(t))
                     .unwrap_or(Type { name: String::new(), generics: vec![] });
                 ParamType::Variadic(inner)
-            } else {
-                ParamType::Type(self.parse_type(n))
             }
+            "fn_value_type" => self.parse_fn_value_type(n),
+            _ => ParamType::Type(self.parse_type(n)),
         }).unwrap_or(ParamType::Type(Type { name: String::new(), generics: vec![] }));
         let default = node.named_child(2).map(|n| {
             let unwrapped = self.unwrap_expr_node(n);
@@ -270,6 +270,22 @@ impl<'a> AstParser<'a> {
         Param { name, ty, default }
     }
+    fn parse_fn_value_type(&self, node: Node) -> ParamType {
+        // fn_value_type: "fn" "(" field("params", type,*) ")" ("->" field("returns", type))?
+        // The "returns" field (if present) is a distinct field from "params", so the
+        // two are disambiguated unambiguously by field name, not by counting/position
+        // among same-kind "type" children — the same idiom `fn`'s own `returns` field
+        // already uses.
+        let returns_node = node.child_by_field_name("returns");
+        let param_types: Vec<Type> = self.children_of_kind(node, "type")
+            .into_iter()
+            .filter(|n| Some(*n) != returns_node)
+            .map(|n| self.parse_type(n))
+            .collect();
+        let ret = returns_node.map(|n| Box::new(self.parse_type(n)));
+        ParamType::Fn(param_types, ret)
+    }
     fn parse_type(&self, node: Node) -> Type {
         // type: type_identifier ("[" type,* "]")?
         // named_child(0) = type_identifier
@@ -497,10 +513,25 @@ impl<'a> AstParser<'a> {
             }
             "boolean_operator" => self.parse_bool_op(node),
             "ternary_expression" => self.parse_ternary(node),
+            "closure" => Expr::Closure(Box::new(self.parse_closure(node))),
             _ => self.parse_primary_expression(node),
         }
     }
+    fn parse_closure(&self, node: Node) -> Closure {
+        // closure: "|" var_identifier,* "|" body
+        let params: Vec<String> = self.children_of_kind(node, "var_identifier")
+            .into_iter()
+            .map(|n| self.text(n))
+            .collect();
+        let body = self.children_of_kind(node, "body")
+            .into_iter()
+            .next()
+            .map(|n| self.parse_block(n))
+            .unwrap_or(Block { stmts: vec![] });
+        Closure { params, body }
+    }
     pub fn parse_primary_expression(&self, node: Node) -> Expr {
         let node = self.unwrap_expr_node(node);
         match node.kind() {

plum-core/tests/parser_test.rs ADDED Viewed

@@ -0,0 +1,69 @@
+use plum_core::ast::*;
+use plum_core::AstParser;
+fn parse(src: &str) -> Source {
+    let mut parser = tree_sitter::Parser::new();
+    parser.set_language(&tree_sitter_plum::LANGUAGE.into()).unwrap();
+    let tree = parser.parse(src, None).unwrap();
+    assert!(!tree.root_node().has_error(), "parse error:\n{}", tree.root_node().to_sexp());
+    let ap = AstParser::new(src);
+    ap.parse_source(tree.root_node())
+}
+fn only_fn(source: &Source) -> &Fn {
+    source.items.iter().find_map(|i| match i { Item::Fn(f) => Some(f), _ => None }).expect("expected a Fn item")
+}
+#[test]
+fn closure_literal_parses_with_params_and_body() {
+    let src = "\
+useClosure() -> Bool =
+  cb = |v|
+    True
+  cb(5)
+";
+    let source = parse(src);
+    let f = only_fn(&source);
+    let FnBody::Block(block) = &f.body else { panic!("expected a block body") };
+    let Stmt::Assign(assign) = &block.stmts[0] else { panic!("expected an assign statement") };
+    let Expr::Closure(closure) = &assign.values[0] else { panic!("expected a closure expression, got {:?}", assign.values[0]) };
+    assert_eq!(closure.params, vec!["v".to_string()]);
+    assert_eq!(closure.body.stmts.len(), 1);
+}
+#[test]
+fn closure_literal_parses_with_no_params() {
+    let src = "\
+useClosure() -> Bool =
+  cb = ||
+    True
+  cb()
+";
+    let source = parse(src);
+    let f = only_fn(&source);
+    let FnBody::Block(block) = &f.body else { panic!("expected a block body") };
+    let Stmt::Assign(assign) = &block.stmts[0] else { panic!("expected an assign statement") };
+    let Expr::Closure(closure) = &assign.values[0] else { panic!("expected a closure expression") };
+    assert!(closure.params.is_empty());
+}
+#[test]
+fn fn_value_type_param_parses_with_positional_types_and_return() {
+    let src = "each(cb: fn(Int) -> Bool) -> Bool =\n  True\n";
+    let source = parse(src);
+    let f = only_fn(&source);
+    let ParamType::Fn(param_types, ret) = &f.params[0].ty else { panic!("expected ParamType::Fn, got {:?}", f.params[0].ty) };
+    assert_eq!(param_types.len(), 1);
+    assert_eq!(param_types[0].name, "Int");
+    assert_eq!(ret.as_ref().map(|t| t.name.clone()), Some("Bool".to_string()));
+}
+#[test]
+fn fn_value_type_param_parses_with_no_return() {
+    let src = "each(cb: fn(Int)) -> Bool =\n  True\n";
+    let source = parse(src);
+    let f = only_fn(&source);
+    let ParamType::Fn(param_types, ret) = &f.params[0].ty else { panic!("expected ParamType::Fn") };
+    assert_eq!(param_types.len(), 1);
+    assert!(ret.is_none());
+}

plum-wasm-codegen/src/lib.rs CHANGED Viewed

@@ -232,6 +232,9 @@ fn param_type_name(pt: &ast::ParamType) -> &str {
     match pt {
         ast::ParamType::Type(t) => t.name.as_str(),
         ast::ParamType::Variadic(t) => t.name.as_str(),
+        // TODO: fn-value params aren't modeled as a wasm value type yet; treat as
+        // an unmodeled type (pointer), same as a class instance.
+        ast::ParamType::Fn(_, _) => "Fn",
     }
 }
@@ -522,6 +525,9 @@ impl<'a> Collector<'a> {
             | ast::Expr::Self_
             | ast::Expr::Var(_)
             | ast::Expr::TypeName(_) => {}
+            // TODO: closures aren't compiled yet; codegen for closure bodies lands
+            // in a later task.
+            ast::Expr::Closure(_) => {}
         }
     }
@@ -545,6 +551,11 @@ fn compile_fn_body(f: &ast::Fn, ctx: &CompileCtx, state: &mut ModuleState) -> Re
         let ty = match &p.ty {
             ast::ParamType::Type(t) => plum_checker::plum_type_from_ast(t),
             ast::ParamType::Variadic(t) => plum_checker::plum_type_from_ast(t),
+            ast::ParamType::Fn(params, ret) => {
+                let param_types = params.iter().map(plum_checker::plum_type_from_ast).collect();
+                let ret_ty = ret.as_ref().map(|r| plum_checker::plum_type_from_ast(r)).unwrap_or(PlumType::TUnit);
+                PlumType::TFun(param_types, Box::new(ret_ty))
+            }
         };
         base_env.insert(p.name.clone(), TypeScheme::mono(ty));
     }
@@ -1390,6 +1401,11 @@ fn compile_expr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mu
             state.data_segments.push((offset, data));
             Instruction::I32Const(offset as i32).encode(body);
         }
+        // TODO: closure codegen (capturing free variables, emitting an indirect-callable
+        // value) lands in a later task.
+        ast::Expr::Closure(_) => {
+            return Err("codegen: closures are not yet supported".to_string());
+        }
     }
     Ok(())
 }