d1ea2ff | plum

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

d1ea2ff — Peter John 2026-07-20T21:46:46+05:30

feat(plum-checker): infer closure literal types; type-check fn(...)-typed params

Files changed (2) hide show

plum-checker/src/lib.rs CHANGED Viewed

@@ -429,9 +429,20 @@ pub fn infer_expr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plu
             },
         },
         ast::Expr::Paren(inner) => infer_expr(inner, env, ctx),
+        ast::Expr::Closure(cl) => {
-        // TODO: closures are not yet type-checked; treat as an unconstrained type
+            let mut closure_env = env.clone();
-        // for now so downstream code can compile against `Expr::Closure`.
+            let param_types: Vec<PlumType> = cl.params.iter().map(|p| {
-        ast::Expr::Closure(_) => Ok(PlumType::TVar("_".to_string())),
+                let t = PlumType::TVar(format!("_closure_{}", p));
+                closure_env.insert(p.clone(), TypeScheme::mono(t.clone()));
+                t
+            }).collect();
+            let body_ty = match &cl.body.stmts.last() {
+                Some(ast::Stmt::Expr(e)) => infer_expr(e, &closure_env, ctx)?,
+                Some(ast::Stmt::Return(Some(e))) => infer_expr(e, &closure_env, ctx)?,
+                _ => PlumType::TUnit,
+            };
+            Ok(PlumType::TFun(param_types, Box::new(body_ty)))
+        }
         ast::Expr::Not(inner) => {
             let t = infer_expr(inner, env, ctx)?;
             unify(&PlumType::TBool, &t)?;

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -572,3 +572,42 @@ use() -> Int =
     let result = check_source(&source);
     assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
 }
+#[test]
+fn closure_literal_infers_as_a_function_type() {
+    let src = "\
+useClosure() -> Bool =
+  cb = |v|
+    True
+  cb(5)
+";
+    let source = parse(src);
+    let result = check_source(&source);
+    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
+}
+#[test]
+fn fn_value_typed_param_can_be_called() {
+    let src = "\
+each(cb: fn(Int) -> Bool) -> Bool =
+  cb(5)
+";
+    let source = parse(src);
+    let result = check_source(&source);
+    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
+}
+#[test]
+fn closure_passed_to_fn_value_typed_param_type_checks() {
+    let src = "\
+each(cb: fn(Int) -> Bool) -> Bool =
+  cb(5)
+use() -> Bool =
+  each(|v|
+    True)
+";
+    let source = parse(src);
+    let result = check_source(&source);
+    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
+}