ca5fd6f | plum | pyrossh

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

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

ca5fd6f — Peter John 2026-09-05T21:28:50+05:30

feat(number): add Number enum, migrate Int/Float methods, fix Float interpolation

Files changed (39) hide show

examples/basics.plum +1 -2
examples/closures.plum +1 -2
examples/control_flow.plum +1 -1
examples/dop_visitor.plum +1 -1
examples/functions.plum +1 -1
examples/match.plum +1 -1
examples/methods.plum +1 -1
examples/numbers.plum +104 -0
examples/oop_visitor.plum +1 -1
examples/strings.plum +1 -1
examples/testing.plum +1 -1
examples/types.plum +14 -2
plum-checker/src/lib.rs +93 -12
plum-checker/src/monomorphize.rs +119 -1
plum-cli/src/main.rs +101 -19
plum-core/src/loader.rs +24 -9
plum-std/Array.plum +1 -1
plum-std/Base64.plum +1 -1
plum-std/Buffer.plum +1 -1
plum-std/Byte.plum +1 -1
plum-std/ByteSlice.plum +1 -1
plum-std/Err.plum +1 -1
plum-std/Float.plum +0 -377
plum-std/Http.plum +2 -2
plum-std/Int.plum +0 -147
plum-std/Json.plum +4 -5
plum-std/List.plum +1 -1
plum-std/Map.plum +1 -1
plum-std/Number.plum +548 -0
plum-std/Option.plum +1 -1
plum-std/Os.plum +1 -1
plum-std/Result.plum +1 -1
plum-std/Str.plum +1 -1
plum-std/Testing.plum +1 -1
plum-std/Time.plum +1 -2
plum-std/Uuid.plum +1 -1
plum-wasm-codegen/src/lib.rs +99 -44
scripts/test-examples.sh +0 -104
scripts/test-plum.sh +0 -65

examples/basics.plum CHANGED Viewed

@@ -1,7 +1,6 @@
 module basics
 import std/Bool
-import std/Int
-import std/Float
+import std/Number
 import std/Str
 MAX_RETRIES = 3

examples/closures.plum CHANGED Viewed

@@ -1,7 +1,6 @@
 import std/Str
 import std/Bool
-import std/Int
-import std/Float
+import std/Number
 fun each(cb: fn(Int) -> Int) -> Int =
   cb(5)

examples/control_flow.plum CHANGED Viewed

@@ -1,6 +1,6 @@
 import std/Str
 import std/Bool
-import std/Int
+import std/Number
 fun loopSum(limit: Int) -> Int =
   total := 0

examples/dop_visitor.plum CHANGED Viewed

@@ -38,7 +38,7 @@
 import std/Os
 import std/Bool
-import std/Int
+import std/Number
 import std/Str
 enum Rating =

examples/functions.plum CHANGED Viewed

@@ -1,6 +1,6 @@
 import std/Str
 import std/Bool
-import std/Int
+import std/Number
 fun addInts(a: Int, b: Int) -> Int =
   a + b

examples/match.plum CHANGED Viewed

@@ -1,6 +1,6 @@
 import std/Option
 import std/Bool
-import std/Int
+import std/Number
 import std/Str
 enum Color =

examples/methods.plum CHANGED Viewed

@@ -1,6 +1,6 @@
 import std/Str
 import std/Bool
-import std/Int
+import std/Number
 type Cat =
   name: Str

examples/numbers.plum ADDED Viewed

@@ -0,0 +1,104 @@
+import std/Bool
+import std/Str
+import std/Number
+# Regression coverage for `plum-std/Number.plum` — the methods it now hosts
+# for BOTH `Int` and `Float` (via `match self`), after `Int.plum`/`Float.plum`
+# were folded into it and deleted. Every call below reaches its method
+# through the primitive-to-wrapping-enum dispatch fallback (`Int`/`Float`
+# have no method tables of their own any more).
+fun toInt(n: Number) -> Int =
+  match n
+    Int(i) => i
+    Float(f) => Int(f)
+test "abs works for both Int and Float, wrapping back into the same variant"
+  assert {-5}.abs().kind() == "Int"
+  assert {-2.5}.abs().kind() == "Float"
+test "sign returns -1/0/1 (or the matching Float) for both Int and Float"
+  assert toInt({5}.sign()) == 1
+  assert toInt({-5}.sign()) == -1
+  assert toInt({0}.sign()) == 0
+test "hash is identity for Int and truncating for Float"
+  assert {5}.hash() == 5
+  assert {5.9}.hash() == 5
+test "trunc/floor/ceil/round agree with Int passthrough and real Float math"
+  assert {5}.trunc() == 5.0f
+  assert {2.7}.trunc() == 2.0f
+  assert {-2.7}.trunc() == -2.0f
+  assert {2.7}.floor() == 2.0f
+  assert {-2.7}.floor() == -3.0f
+  assert {2.3}.ceil() == 3.0f
+  assert {-2.3}.ceil() == -2.0f
+  assert {2.5}.round() == 3.0f
+  assert {-2.5}.round() == -3.0f
+test "sqrt works for Int (via Float conversion) and Float directly"
+  assert {4}.sqrt() == 2.0f
+  assert {2.25}.sqrt() == 1.5f
+test "pow computes integer powers exactly for both Int and Float self"
+  assert {2}.pow(10.0f) == 1024.0f
+  assert {2.0}.pow(10.0f) == 1024.0f
+test "log2/log10 agree between Int and the equivalent Float"
+  # `log`/`log2`/`log10` are built on the Taylor-series `ln` approximation
+  # (see `plum-std/Number.plum`'s `ln`), not exact libm — compare within a
+  # small epsilon rather than requiring bit-exact equality.
+  a := {8}.log2()
+  b := {8.0}.log2()
+  assert {a - b}.abs().toFloatValue() < 0.0001f
+  c := {100}.log10()
+  d := {100.0}.log10()
+  assert {c - d}.abs().toFloatValue() < 0.0001f
+test "isFinite/isInfinite/isNaN are always well-defined for Int, real for Float"
+  assert {5}.isFinite()
+  assert !{5}.isInfinite()
+  assert !{5}.isNaN()
+  assert {1.0f / 0.0f}.isInfinite()
+  assert {0.0f / 0.0f}.isNaN()
+  assert {1.5}.isFinite()
+test "min/max compare across Int and Float without losing the original variant"
+  assert {3}.min(5).kind() == "Int"
+  assert {3}.max(2.5).kind() == "Int"
+  assert {2.5}.min(3).kind() == "Float"
+test "toStr renders Int and Float correctly, including negatives and fractions"
+  assert {42}.toStr() == "42"
+  assert {-7}.toStr() == "-7"
+  assert {0}.toStr() == "0"
+  assert {3.5}.toStr() == "3.5"
+  assert {-3.5}.toStr() == "-3.5"
+test "parseInt/parseFloat round-trip a rendered number"
+  assert parseInt("123").unwrapOr(-1) == 123
+  assert parseInt("-45").unwrapOr(1) == -45
+  assert parseFloat("3.25").unwrapOr(-1.0f) == 3.25f
+test "trig/hyperbolic/exp/ln free functions and Number methods still work post-migration"
+  assert sin(0.0f) == 0.0f
+  assert cos(0.0f) == 1.0f
+  assert {0}.sinh() == 0.0f
+  assert {0}.cosh() == 1.0f
+test "string interpolation of a Float value works, via Number.toStr"
+  x := 3.5f
+  assert "value is {x}" == "value is 3.5"
+  y := {8}.log2()
+  assert "computed is {y}" == "computed is 3.0"
+test "assert of two directly-chained Float method calls renders a real failure message"
+  # Previously crashed the whole compile with "interpolating a Float value is
+  # not yet supported" instead of a normal pass/fail report — `looksLikeFloat`
+  # only caught an OBVIOUS float literal on either side of the comparison,
+  # missing any Float-typed expression that wasn't written as one (like these
+  # chained method calls). Fixed at the root: `"{expr}"` interpolation of a
+  # Float now genuinely works (via `Number.toStr`), so the "Expected/Actual"
+  # failure-message machinery no longer needs to special-case Float at all.
+  assert {8}.log2() == {8.0}.log2()

examples/oop_visitor.plum CHANGED Viewed

@@ -31,7 +31,7 @@
 import std/Os
 import std/Bool
-import std/Int
+import std/Number
 import std/Str
 enum Rating =

examples/strings.plum CHANGED Viewed

@@ -1,5 +1,5 @@
 import std/Bool
-import std/Int
+import std/Number
 import std/Str
 fun greet(name: Str) -> Str =

examples/testing.plum CHANGED Viewed

@@ -1,6 +1,6 @@
 import std/Str
 import std/Bool
-import std/Int
+import std/Number
 fun add(a: Int, b: Int) -> Int =
   a + b

examples/types.plum CHANGED Viewed

@@ -1,8 +1,7 @@
 import std/Option
 import std/Bool
-import std/Int
-import std/Float
 import std/Str
+import std/Number
 type Point =
   x: Int
@@ -119,6 +118,9 @@ enum ShapeWithFields =
   | CircleField(radius: Int)
   | SquareField(side: Int)
+fun numberKind(n: Number) -> Str =
+  n.kind()
 type OptionBox =
   value: Option[Int]
@@ -186,6 +188,16 @@ test "named-payload field access on a multi-variant enum value works via a check
 test "enum variant used directly as a type checks and runs correctly"
   assert stringifyColor(Red) == "Red"
+test "a bare Int/Float value flows into a Number-typed param with no wrapper syntax"
+  assert numberKind(5) == "Int"
+  assert numberKind(2.5) == "Float"
+test "a bare Int/Float value dispatches a method defined only on Number, via fallback"
+  # `.kind()` isn't defined on `Int`/`Float` themselves — dispatch falls back
+  # to `Number`, the enum that bare-wraps them, boxing `self` first.
+  assert {5}.kind() == "Int"
+  assert {2.5}.kind() == "Float"
 test "enum class field construct and destructure runs correctly"
   b := OptionBox(value: Some(42))
   assert b.unwrap(0) == 42

plum-checker/src/lib.rs CHANGED Viewed

@@ -88,6 +88,21 @@ pub fn unify(t1: &PlumType, t2: &PlumType, ctx: &CheckCtx) -> Result<(), String>
         {
             Ok(())
         }
+        // A "union" enum (`enum Number = | Int | Float`) whose bare variants wrap
+        // builtin primitives, not classes — see `buildGlobalTables`'s primitive
+        // bare-wrap condition. A raw `Int`/`Float` value is accepted directly
+        // wherever the enum is expected, no wrapper syntax needed (mirrors the
+        // class bare-wrap case, which needs no special `unify` arm at all
+        // because a class construction's OWN inferred type already comes back
+        // as the enum name via `bareVariantWrapType` — a primitive literal has
+        // no such construction call to intercept, so `unify` itself has to
+        // bridge the gap here instead).
+        (PlumType::TNamed(enum_name), prim @ (PlumType::TInt | PlumType::TFloat))
+        | (prim @ (PlumType::TInt | PlumType::TFloat), PlumType::TNamed(enum_name))
+            if ctx.enum_variants.values().any(|info| &info.enum_name == enum_name && info.field_types == [prim.clone()]) =>
+        {
+            Ok(())
+        }
         (PlumType::TFun(ps1, r1), PlumType::TFun(ps2, r2)) if ps1.len() == ps2.len() => {
             for (p1, p2) in ps1.iter().zip(ps2.iter()) {
                 unify(p1, p2, ctx)?;
@@ -253,6 +268,30 @@ pub fn buildGlobalTables(source: &ast::Source) -> (TypeEnv, ClassEnv, MethodEnv,
                 for (tag, v) in e.variants.iter().enumerate() {
                     let (field_types, field_names) = if !e.params.is_empty() {
                         (shared_field_types.clone(), e.params.iter().map(|p| p.name.clone()).collect())
+                    } else if v.fields.is_empty() && matches!(v.name.as_str(), "Int" | "Float") {
+                        // Bare-wrap sugar for a "union" enum over builtin
+                        // PRIMITIVES (`enum Number = | Int | Float`, see
+                        // `plum-std/Number.plum`) — the wrapped payload is the
+                        // dedicated primitive `PlumType` itself (`TInt`/
+                        // `TFloat`), not a `TNamed` self-reference. Checked
+                        // BEFORE the class bare-wrap case below: historically
+                        // `Int`/`Float` were ALSO registered as zero-field
+                        // "method-holder" classes (`type Int = fun
+                        // abs(self)...`, attaching methods to the primitive
+                        // receiver, before their methods moved into `Number`
+                        // itself) — this ordering is what made a real
+                        // primitive win that name collision over the
+                        // incidentally-same-named class, and stays a
+                        // defensive safeguard against a future same-named
+                        // class reintroducing it. This is what lets a bare
+                        // `Int`/`Float` value be used directly wherever
+                        // `Number` is expected with no wrapper syntax — see
+                        // `unify`'s matching
+                        // primitive-vs-enum arm, and
+                        // `monomorphize::wrapPrimitiveAgainstExpected`, which
+                        // does the actual AST rewrite into this variant's
+                        // constructor at specific expected-type usage sites.
+                        (vec![plumTypeFromName(&v.name)], Vec::new())
                     } else if v.fields.is_empty() && classes.contains_key(&v.name) {
                         // Bare-type variant sugar: `| FantasyBook` (no `[...]`)
                         // naming a class declared elsewhere means "this variant
@@ -441,7 +480,13 @@ pub fn checkSource(source: &ast::Source) -> CheckResult<()> {
     // as its variant tag and self-wraps it (`field_types == [TNamed(name)]`).
     for name in classes.keys() {
         if let Some(info) = enum_variants.get(name) {
+            // Same exemption, but for a "union" enum's primitive bare-wrap
+            // variant (`enum Number = | Int | Float`) — `Int`/`Float` are
+            // ALSO registered as zero-field "method-holder" classes (see
+            // `buildGlobalTables`'s primitive-bare-wrap comment), so this
+            // exact collision is expected and deliberate for them too.
-            let is_bare_variant_wrap = info.field_types == [PlumType::TNamed(name.clone())];
+            let is_bare_variant_wrap = info.field_types == [PlumType::TNamed(name.clone())]
+                || info.field_types == [plumTypeFromName(name)];
             if !is_bare_variant_wrap {
                 errors.push(CheckError {
                     message: format!("'{}' is declared as both a class and an enum variant", name),
@@ -1162,7 +1207,17 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
             // `Int(x)`/`Float(x)`/`Byte(x)` are builtin numeric conversions, not
             // ordinary calls — handled here so `y = Float(x)` unifies against
             // `TFloat` rather than falling through to the permissive
-            // "unknown fn" case.
+            // "unknown fn" case. EXCEPT when `call.name` is ALSO a
+            // registered enum variant (a "union" enum's bare-primitive-wrap
+            // variant, e.g. `enum Number = | Int | Float`) whose single
+            // field type exactly matches the arg's own type — a same-type
+            // call (`Int(intExpr)`) then means constructing that variant
+            // (`monomorphize::wrapPrimitiveAgainstExpected` synthesizes
+            // exactly this call shape), not a no-op cast; falls through to
+            // the ordinary enum-variant-construction handling just below
+            // instead. A genuinely cross-type call (`Int(floatExpr)`) is
+            // never ambiguous this way, so every existing numeric-cast call
+            // site keeps its normal meaning.
             if (call.name == "Int" || call.name == "Float" || call.name == "Byte") && call.args.len() == 1 {
                 let arg_expr = match &call.args[0] {
                     ast::Arg::Positional(e) => e,
@@ -1170,14 +1225,21 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
                     ast::Arg::Pair { value, .. } => value,
                 };
                 let actual = inferExpr(arg_expr, env, ctx)?;
+                let is_same_type_variant_wrap = ctx.enum_variants.get(call.name.as_str())
+                    .is_some_and(|info| info.field_types == [actual.clone()]);
+                if !is_same_type_variant_wrap {
-                return match (call.name.as_str(), &actual) {
+                    return match (call.name.as_str(), &actual) {
-                    ("Float", PlumType::TInt) => Ok(PlumType::TFloat),
+                        ("Float", PlumType::TInt) => Ok(PlumType::TFloat),
-                    ("Int", PlumType::TFloat) => Ok(PlumType::TInt),
+                        ("Int", PlumType::TFloat) => Ok(PlumType::TInt),
-                    ("Float", PlumType::TFloat) | ("Int", PlumType::TInt) => Ok(actual),
+                        ("Float", PlumType::TFloat) | ("Int", PlumType::TInt) => Ok(actual),
-                    ("Byte", PlumType::TInt) | ("Byte", PlumType::TByte) => Ok(PlumType::TByte),
+                        ("Byte", PlumType::TInt) | ("Byte", PlumType::TByte) => Ok(PlumType::TByte),
-                    ("Int", PlumType::TByte) => Ok(PlumType::TInt),
+                        ("Int", PlumType::TByte) => Ok(PlumType::TInt),
-                    (name, other) => Err(format!("call '{}': cannot convert {} to {}", name, other, name)),
+                        (name, other) => Err(format!("call '{}': cannot convert {} to {}", name, other, name)),
-                };
+                    };
+                }
+                // Else: fall through to the ordinary enum-variant-construction
+                // handling just below, exactly as if this special case didn't
+                // exist for this call.
             }
             if let Some(info) = ctx.enum_variants.get(&call.name) {
                 if call.args.len() != info.field_types.len() {
@@ -1359,7 +1421,25 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
                     other => Err(format!("cannot access field '{}' on non-class type {}", field_name, other)),
                 },
                 ast::AttrKind::Method(call) => match methodReceiverName(&obj_ty) {
+                    Some(class_name) => {
+                    // Fallback: a primitive/class receiver's method might be
+                    // defined once on the "union" enum that bare-wraps it
+                    // instead (`enum Number = | Int | Float`) — `class_name`
+                    // (e.g. "Int") is itself a registered enum-variant name
+                    // in that case (see `buildGlobalTables`'s bare-wrap
+                    // conditions); retry there before falling through to the
+                    // permissive "unmodeled method" case below. Mirrors
+                    // `plum-wasm-codegen`'s equivalent dispatch fallback,
+                    // which also boxes `self` into the wrap-enum's variant.
-                    Some(class_name) => match ctx.methods.get(&(class_name.clone(), call.name.clone())) {
+                    let class_name = if ctx.methods.contains_key(&(class_name.clone(), call.name.clone())) {
+                        class_name
+                    } else {
+                        ctx.enum_variants.get(class_name.as_str())
+                            .map(|info| info.enum_name.clone())
+                            .filter(|enum_name| ctx.methods.contains_key(&(enum_name.clone(), call.name.clone())))
+                            .unwrap_or(class_name)
+                    };
+                    match ctx.methods.get(&(class_name.clone(), call.name.clone())) {
                         Some(PlumType::TFun(param_types, ret)) => {
                             match param_types.last() {
                                 Some(PlumType::TVariadic(elem)) => {
@@ -1420,7 +1500,8 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
                         }
                         // Unmodeled method (e.g. builtin/std): allow, codegen will catch.
                         _ => Ok(PlumType::TVar("_".to_string())),
-                    },
+                    }
+                    }
                     None => Ok(PlumType::TVar("_".to_string())),
                 },
             }

plum-checker/src/monomorphize.rs CHANGED Viewed

@@ -742,6 +742,7 @@ impl<'a> Monomorphizer<'a> {
             ast::FnBody::Expr(e) => {
                 if let Some(expected) = &expected_ret {
                     self.resolveBareVariantAgainstExpected(e, expected);
+                    self.wrapPrimitiveAgainstExpected(e, expected, &env);
                 }
                 self.rewriteExpr(e, &env)?;
                 Some(self.inferConcrete(e, &env))
@@ -750,6 +751,7 @@ impl<'a> Monomorphizer<'a> {
                 if let Some(expected) = &expected_ret {
                     if let Some(ast::Stmt::Expr(e)) = block.stmts.last_mut() {
                         self.resolveBareVariantAgainstExpected(e, expected);
+                        self.wrapPrimitiveAgainstExpected(e, expected, &env);
                     }
                 }
                 self.rewriteBlock(block, &mut env)?;
@@ -928,6 +930,7 @@ impl<'a> Monomorphizer<'a> {
                                 .and_then(|fields| fields.iter().find(|(n, _)| n == field_name).map(|(_, t)| t.clone()))
                             {
                                 self.resolveBareVariantAgainstExpected(value, &field_ty);
+                                self.wrapPrimitiveAgainstExpected(value, &field_ty, env);
                             }
                         }
                     }
@@ -952,6 +955,7 @@ impl<'a> Monomorphizer<'a> {
                     let resolved = self.resolveFieldType(&rt);
                     let expected = crate::plumTypeFromAst(&resolved);
                     self.resolveBareVariantAgainstExpected(e, &expected);
+                    self.wrapPrimitiveAgainstExpected(e, &expected, env);
                 }
                 self.rewriteExpr(e, env)?;
             }
@@ -1046,6 +1050,7 @@ impl<'a> Monomorphizer<'a> {
                         let expected = crate::plumTypeFromAst(&resolved);
                         if let Some(ast::Stmt::Expr(e)) = body.stmts.last_mut() {
                             self.resolveBareVariantAgainstExpected(e, &expected);
+                            self.wrapPrimitiveAgainstExpected(e, &expected, &case_env);
                         }
                     }
                     self.rewriteBlock(body, &mut case_env)?;
@@ -1148,6 +1153,7 @@ impl<'a> Monomorphizer<'a> {
                 let field_ty = self.resolveFieldType(&field.ty);
                 let expected = crate::plumTypeFromAst(&field_ty);
                 self.resolveBareVariantAgainstExpected(&mut fa.value, &expected);
+                self.wrapPrimitiveAgainstExpected(&mut fa.value, &expected, env);
             }
         }
@@ -1495,6 +1501,38 @@ impl<'a> Monomorphizer<'a> {
         }
     }
+    /// If `expr`'s own inferred type is a builtin primitive (`Int`/`Float`)
+    /// and `expected` names a "union" enum with a bare-primitive-wrap variant
+    /// matching that exact primitive (`enum Number = | Int | Float` — see
+    /// `buildGlobalTables`'s primitive bare-wrap condition), rewrites `expr`
+    /// in place into that variant's constructor call (`5` -> `Int(5)`),
+    /// reusing the ordinary positional-variant-construction codegen path
+    /// (`compileVariantConstruction`) unchanged. This is the primitive
+    /// analogue of the class bare-wrap sugar's `ClassCall`->`FnCall` rewrite
+    /// just below — unlike that one (which fires unconditionally, keyed only
+    /// on the constructed name), this MUST be expected-type-directed: `Int`/
+    /// `Float` are used as bare primitives everywhere in the language and
+    /// can't be globally reinterpreted as "the enum-wrapped value". No-op if
+    /// `expected` isn't such an enum, or `expr` isn't already exactly that
+    /// primitive type (a genuine mismatch is left for `unify`/`unifyArg` to
+    /// catch elsewhere).
+    fn wrapPrimitiveAgainstExpected(&mut self, expr: &mut ast::Expr, expected: &PlumType, env: &TypeEnv) {
+        let PlumType::TNamed(enum_name) = expected else { return };
+        let actual = self.infer(expr, env);
+        if !matches!(actual, PlumType::TInt | PlumType::TFloat) {
+            return;
+        }
+        let owner = self.enum_variants.iter()
+            .find(|(_, info)| &info.enum_name == enum_name && info.field_types == [actual.clone()]);
+        if let Some((variant_name, _)) = owner {
+            let inner = expr.clone();
+            *expr = ast::Expr::FnCall(ast::FnCall {
+                name: variant_name.clone(),
+                args: vec![ast::Arg::Positional(inner)],
+            });
+        }
+    }
     /// True if the specialization about to be processed is ITSELF already a
     /// nested instance of `template_name` — one of `bindings`'s VALUES is
     /// either `template_name` itself or a recorded specialization OF it
@@ -2108,7 +2146,25 @@ impl<'a> Monomorphizer<'a> {
     fn rewriteExpr(&mut self, expr: &mut ast::Expr, env: &TypeEnv) -> Result<(), String> {
         match expr {
             ast::Expr::ClassCall(call) => {
+                // A bare `Int`/`Float` field value being constructed into a
+                // "union" enum field (`Wrapper(value: 5)` where `value:
+                // Number`) or a named-payload enum variant field (`Circle
+                // (radius: 5)`, though there `radius: Int` already matches so
+                // this is a no-op) — neither an ordinary class's nor a named
+                // variant's OWN field types depend on generic specialization,
+                // so this can run unconditionally here regardless of whether
+                // `call.type_name` turns out to be generic or not below.
+                for fa in &mut call.fields {
+                    let expected_ty = self.classes.get(call.type_name.as_str())
+                        .and_then(|fields| fields.iter().find(|(n, _)| n == &fa.name).map(|(_, t)| t.clone()))
+                        .or_else(|| self.enum_variants.get(call.type_name.as_str()).and_then(|info| {
+                            info.field_names.iter().position(|n| n == &fa.name).map(|i| info.field_types[i].clone())
+                        }));
+                    if let Some(expected) = expected_ty {
+                        self.wrapPrimitiveAgainstExpected(&mut fa.value, &expected, env);
+                    }
+                }
-                // Runs FIRST (before the generic per-field rewrite below): a
+                // Runs next (before the generic per-field rewrite below): a
                 // bare payload-free variant field value (`Node(..., next:
                 // None)`) carries no type of its own to infer a generic
                 // param from, and needs the class's OWN (about-to-be-
@@ -2141,6 +2197,32 @@ impl<'a> Monomorphizer<'a> {
                 }
             }
             ast::Expr::FnCall(call) => {
+                // Coerce a bare `Int`/`Float` ARGUMENT into a "union" enum
+                // param (`fun useNumber(n: Number)`) — the one call site
+                // `wrapPrimitiveAgainstExpected` didn't already have (return
+                // position and field construction are handled elsewhere).
+                // Looked up from `env` by the call's CURRENT name, which may
+                // still be an unspecialized generic template at this point —
+                // harmless, since a param typed by one of the function's own
+                // generic params is a bare `TVar`/`TNamed(<param>)`, never a
+                // real enum, so `expected` only resolves to an actual
+                // `Number`-like enum for a param that's genuinely concretely
+                // typed that way (generic function or not). Positional zip
+                // against `param_types` mirrors the same simplification
+                // `resolveFnInstantiation` already makes elsewhere in this
+                // file — a keyword arg out of declared order would zip
+                // against the wrong param, but that's a pre-existing
+                // limitation, not one this feature introduces.
+                if let Some(PlumType::TFun(param_types, _)) = env.get(call.name.as_str()).map(|s| *s.body.clone()) {
+                    for (arg, expected) in call.args.iter_mut().zip(param_types.iter()) {
+                        let e = match arg {
+                            ast::Arg::Positional(e) => e,
+                            ast::Arg::Keyword { value, .. } => value,
+                            ast::Arg::Pair { value, .. } => value,
+                        };
+                        self.wrapPrimitiveAgainstExpected(e, expected, env);
+                    }
+                }
                 for arg in &mut call.args {
                     let e = match arg {
                         ast::Arg::Positional(e) => e,
@@ -2178,6 +2260,42 @@ impl<'a> Monomorphizer<'a> {
                     // entirely as a result; every other arg shape still goes
                     // through it exactly as before.
                     self.rewriteMethodClosureArgs(&attr.object, call, env)?;
+                    // Same "union" enum argument coercion as the free-function
+                    // `FnCall` arm above, keyed by (receiver type, method name)
+                    // in `self.methods` instead of a bare function name. Also
+                    // follows the SAME dispatch fallback `plum-wasm-codegen`'s
+                    // `AttrKind::Method` codegen uses (a method not found
+                    // under the receiver's own name might be defined on the
+                    // enum that bare-wraps it, e.g. `Number.min(self, other:
+                    // Number)` dispatched from an `Int` receiver) — without
+                    // this, an OTHER argument like `{3}.min(5)`'s `5` would
+                    // never get boxed into `Number`, even though codegen
+                    // correctly boxes `self` for the very same call, causing
+                    // a wasm validation failure (raw `i64` where the callee
+                    // expects a boxed `Number` struct ref).
+                    let receiver_ty = self.infer(&attr.object, env);
+                    let direct_receiver_name = crate::methodReceiverName(&receiver_ty);
+                    let dispatch_receiver_name = direct_receiver_name.clone().and_then(|name| {
+                        if self.methods.contains_key(&(name.clone(), call.name.clone())) {
+                            Some(name)
+                        } else {
+                            self.enum_variants.get(name.as_str()).map(|info| info.enum_name.clone())
+                        }
+                    });
+                    if let Some(receiver_name) = dispatch_receiver_name {
+                        if let Some(PlumType::TFun(param_types, _)) = self.methods.get(&(receiver_name, call.name.clone())).cloned() {
+                            for (arg, expected) in call.args.iter_mut().zip(param_types.iter()) {
+                                let e = match arg {
+                                    ast::Arg::Positional(e) => e,
+                                    ast::Arg::Keyword { value, .. } => value,
+                                    ast::Arg::Pair { value, .. } => value,
+                                };
+                                if !matches!(e, ast::Expr::Closure(_)) {
+                                    self.wrapPrimitiveAgainstExpected(e, expected, env);
+                                }
+                            }
+                        }
+                    }
                     for arg in &mut call.args {
                         let e = match arg {
                             ast::Arg::Positional(e) => e,

plum-cli/src/main.rs CHANGED Viewed

@@ -65,10 +65,12 @@ enum Command {
         #[arg(long, default_value = ".")]
         lib_path: std::path::PathBuf,
     },
+    /// Compile a Plum source file's (or every file under one or more
-    /// Compile a Plum source file's `test` blocks and run them under wasmtime
+    /// directories') `test` blocks and run them under wasmtime
     Test {
-        /// Source file to compile and test
+        /// One or more source files and/or directories (searched recursively for *.plum files)
+        #[arg(required = true)]
-        file: std::path::PathBuf,
+        paths: Vec<std::path::PathBuf>,
         /// Root directory `import <path>` is resolved against (`import std/x` -> `<lib-path>/std/x.plum`)
         #[arg(long, default_value = ".")]
         lib_path: std::path::PathBuf,
@@ -97,7 +99,7 @@ fn run() -> Result<()> {
         Command::Compile { file, output, lib_path } => cmdCompile(file, output, lib_path),
         Command::Run { file, lib_path } => cmdRun(file, lib_path),
         Command::Build { file, output, lib_path } => cmdBuild(file, output, lib_path),
-        Command::Test { file, lib_path } => cmdTest(file, lib_path),
+        Command::Test { paths, lib_path } => cmdTest(paths, lib_path),
         Command::Editor { editor, insiders } => editor::install(editor, insiders),
     }
 }
@@ -161,10 +163,14 @@ fn compileToTestWasm(file: &std::path::Path, lib_path: &std::path::Path) -> Resu
         .map_err(|e| anyhow::anyhow!("{e}"))?;
     if let Err(errors) = plum_checker::checkSource(&ast) {
+        // Returns an error (rather than exiting the process directly, as
+        // `compileToWasm`'s equivalent check still does for the single-file
+        // `compile`/`run`/`build` commands) so a recursive `plum test <dir>`
+        // sweep can catch it per-file, in `cmdTest`'s directory branch, and
+        // continue to the rest of the directory instead of the whole run
-        for e in &errors {
+        // dying on the first file with a type error.
-            eprintln!("type error: {}", e.message);
+        let messages: Vec<String> = errors.iter().map(|e| format!("type error: {}", e.message)).collect();
-        }
-        process::exit(1);
+        anyhow::bail!(messages.join("\n"));
     }
     plum_wasm_codegen::compileTestSource(&ast).map_err(|e| anyhow::anyhow!("codegen error: {e}"))
@@ -592,12 +598,91 @@ fn cmdRun(file: std::path::PathBuf, lib_path: std::path::PathBuf) -> Result<()>
     Ok(())
 }
+/// `path` is a file if it points directly at one, otherwise a directory
+/// walked recursively for every `*.plum` file (sorted for deterministic
-/// Compiles a Plum file's `test` blocks and runs each one under wasmtime as
+/// output) — what lets `plum test` accept a directory (or several) and run
-/// its own call — a hard `assert` trap fails only that one call (wasmtime
-/// doesn't poison the rest of the store), so one test panicking never stops
+/// every file under it, replacing `scripts/test-plum.sh`'s own
-/// the others from running.
+/// find-and-loop shell logic.
+fn collectPlumFiles(path: &std::path::Path) -> Result<Vec<std::path::PathBuf>> {
+    if path.is_file() {
+        return Ok(vec![path.to_path_buf()]);
+    }
+    let mut files = Vec::new();
+    let mut dirs = vec![path.to_path_buf()];
+    while let Some(dir) = dirs.pop() {
+        for entry in fs::read_dir(&dir)
+            .with_context(|| format!("failed to read directory {}", dir.display()))?
+        {
+            let entry = entry?;
+            let p = entry.path();
+            if p.is_dir() {
+                dirs.push(p);
+            } else if p.extension().is_some_and(|ext| ext == "plum") {
+                files.push(p);
+            }
+        }
+    }
+    files.sort();
+    Ok(files)
+}
-fn cmdTest(file: std::path::PathBuf, lib_path: std::path::PathBuf) -> Result<()> {
+fn cmdTest(paths: Vec<std::path::PathBuf>, lib_path: std::path::PathBuf) -> Result<()> {
+    // A single plain file keeps the exact original single-file UX (no
+    // `=== path ===` header, no aggregate summary line, no "N/1 files
+    // passed" — just that one file's own test tree). Anything else (a
+    // directory, or more than one path) uses the multi-file sweep below,
+    // matching `scripts/test-plum.sh`'s old find-and-loop shell logic.
+    if let [only] = paths.as_slice() {
+        if only.is_file() {
+            let (_, failed) = runTestFile(only, &lib_path)?;
+            if failed > 0 {
+                process::exit(1);
+            }
+            return Ok(());
+        }
+    }
+    let mut files = Vec::new();
+    for path in &paths {
+        files.extend(collectPlumFiles(path)?);
+    }
+    let mut total_passed = 0usize;
+    let mut total_failed = 0usize;
+    let mut files_failed = 0usize;
+    for file in &files {
+        println!("=== {} ===", file.display());
+        match runTestFile(file, &lib_path) {
+            Ok((passed, failed)) => {
+                total_passed += passed;
+                total_failed += failed;
+                if failed > 0 {
+                    files_failed += 1;
+                }
+            }
+            Err(e) => {
+                eprintln!("error: {e:#}");
+                files_failed += 1;
+            }
+        }
+        println!();
+    }
+    let color = io::stdout().is_terminal();
+    let green = |s: &str| if color { format!("\x1b[32m{s}\x1b[0m") } else { s.to_string() };
+    let red = |s: &str| if color { format!("\x1b[31m{s}\x1b[0m") } else { s.to_string() };
+    let summary = format!("{total_passed} passed, {total_failed} failed");
+    println!("{}", if total_failed > 0 { red(&summary) } else { green(&summary) });
+    println!("{}/{} files passed", files.len() - files_failed, files.len());
+    if files_failed > 0 {
+        process::exit(1);
+    }
+    Ok(())
+}
+/// Runs every `test` block in one file, printing the Spock-flavored per-test
+/// tree as it goes, and returns `(passed, failed)` counts — shared by both
+/// the single-file and directory-recursive paths of `cmdTest`.
+fn runTestFile(file: &std::path::Path, lib_path: &std::path::Path) -> Result<(usize, usize)> {
-    let (wasm_bytes, names) = compileToTestWasm(&file, &lib_path)?;
+    let (wasm_bytes, names) = compileToTestWasm(file, lib_path)?;
     let mut config = wasmtime::Config::new();
     config.wasm_gc(true);
@@ -614,7 +699,7 @@ fn cmdTest(file: std::path::PathBuf, lib_path: std::path::PathBuf) -> Result<()>
     if names.is_empty() {
         println!("no tests found in {}", file.display());
-        return Ok(());
+        return Ok((0, 0));
     }
     // A Spock-flavored tree: "├─"/"└─" per test (the last one gets the
@@ -671,10 +756,7 @@ fn cmdTest(file: std::path::PathBuf, lib_path: std::path::PathBuf) -> Result<()>
     println!();
     let summary = format!("{passed} passed, {failed} failed");
     println!("{}", if failed > 0 { red(&summary) } else { green(&summary) });
-    if failed > 0 {
+    Ok((passed, failed))
-        process::exit(1);
-    }
-    Ok(())
 }
 /// Reads a `Str` (wasm-gc `array<i8>`) RESULT value's bytes into a Rust

plum-core/src/loader.rs CHANGED Viewed

@@ -75,30 +75,45 @@ fn loadImport(
 /// nothing naturally stops a file from using an `Int`/`Float` literal, a
 /// bare string literal, or a matching type annotation without ever importing
 /// them. This walks `source` for any such use and requires the matching
-/// `import std/Int` / `import std/Float` / `import std/Str` — except in
+/// `import std/Int` / `import std/Float` (or `import std/Number`, which now
+/// declares both — see `plum-std/Number.plum`) / `import std/Str` — except
-/// `Int.plum`/`Float.plum`/`Str.plum` themselves, which declare the type
+/// in `Number.plum`/`Str.plum` themselves, which declare the type rather
-/// rather than import it.
+/// than import it.
 fn checkBuiltinImports(path: &Path, source: &Source) -> Result<(), String> {
     let used = usedBuiltinTypeNames(source);
     for name in ["Int", "Float", "Str"] {
         if !used.contains(name) {
             continue;
         }
+        // A file can also "declare itself" by giving `Int`/`Float` as a bare,
+        // payload-free variant name of one of its OWN enums (a "union" enum's
+        // primitive bare-wrap sugar, e.g. `enum Number = | Int | Float` — see
+        // `plum-checker`'s `buildGlobalTables`) instead of the older `type
+        // Int = ...` class form — either way, the file is the one DECLARING
+        // the type, not merely using it.
-        let declares_self = source
+        let declares_self = source.items.iter().any(|i| match i {
-            .items
-            .iter()
-            .any(|i| matches!(i, Item::Class(c) if c.name == name));
+            Item::Class(c) => c.name == name,
+            Item::Enum(e) => e.variants.iter().any(|v| v.name == name && v.fields.is_empty()),
+            _ => false,
+        });
         if declares_self {
             continue;
         }
         let import_path = format!("std/{}", name);
+        // `Int`/`Float` moved from their own dedicated files into
+        // `std/Number` (`enum Number = | Int | Float` bare-wraps both) —
+        // importing that satisfies "declares `Int`/`Float`" just as well as
+        // the older per-type file would have.
+        let alt_import_path = matches!(name, "Int" | "Float").then_some("std/Number");
-        let already_imported = source.imports.iter().any(|imp| imp.path == import_path);
+        let already_imported = source.imports.iter().any(|imp| {
+            imp.path == import_path || alt_import_path.is_some_and(|alt| imp.path == alt)
+        });
         if !already_imported {
             return Err(format!(
                 "'{}' uses type '{}' but doesn't import it: add `import {}`",
                 path.display(),
                 name,
-                import_path
+                alt_import_path.unwrap_or(import_path.as_str())
             ));
         }
     }

plum-std/Array.plum CHANGED Viewed

@@ -1,6 +1,6 @@
 module std
 import std/Bool
-import std/Int
+import std/Number
 # A fixed-length, O(1)-indexable array of `T`, backed directly by a wasm-gc
 # `array<anyref>` — every `Array[T]` specialization (`Array$Int`, `Array$Str`,

plum-std/Base64.plum CHANGED Viewed

@@ -3,7 +3,7 @@ import std/Str
 import std/Buffer
 import std/Option
 import std/Bool
-import std/Int
+import std/Number
 # The Base64 package contains support for doing Base64 binary-to-text encodings.
 #

plum-std/Buffer.plum CHANGED Viewed

@@ -2,7 +2,7 @@ module std
 import std/ByteSlice
 import std/Str
 import std/Bool
-import std/Int
+import std/Number
 # A Buffer is a growable, mutable sequence of bytes for efficiently building
 # up a `Str` piece by piece — modeled on Go's `bytes.Buffer`. Backed by a

plum-std/Byte.plum CHANGED Viewed

@@ -1,5 +1,5 @@
 module std
-import std/Int
+import std/Number
 import std/Bool
 import std/Str

plum-std/ByteSlice.plum CHANGED Viewed

@@ -2,7 +2,7 @@ module std
 import std/Byte
 import std/Str
 import std/Bool
-import std/Int
+import std/Number
 # ByteSlice is `[]Byte` — Plum's counterpart to Go's byte slice: a
 # fixed-length, mutable sequence of raw bytes backed directly by a wasm-gc

plum-std/Err.plum CHANGED Viewed

@@ -1,6 +1,6 @@
 module std
 import std/Bool
-import std/Int
+import std/Number
 import std/Str
 # This is used to represent an error value across the language

plum-std/Float.plum DELETED Viewed

@@ -1,377 +0,0 @@
-module std
-import std/Int
-import std/Result
-import std/Str
-import std/Bool
-E = 2.718281828459045f # Euler's number, the base of natural logarithms, e, https://oeis.org/A001113
-LN10 = 2.302585092994046f # The natural logarithm of 10, https://oeis.org/A002392
-LN2 = 0.6931471805599453f # The natural logarithm of 2, https://oeis.org/A002162
-LOG10E = 0.4342944819032518f # The base 10 logarithm of e, formula: 1 / LN10
-LOG2E = 1.4426950408889634f # The base 2 logarithm of e, formula: 1 / LN2
-PI = 3.141592653589793f # The ratio of the circumference of a circle to its diameter, https://oeis.org/A000796
-PHI = 1.618033988749895f # https://oeis.org/A001622
-SQRT1_2 = 0.7071067811865476f # The square root of 1/2
-SQRT2 = 1.4142135623730951f # The square root of 2, https://oeis.org/A002193
-SQRT_E = 1.6487212707001282f # https://oeis.org/A019774
-SQRT_PI = 1.7724538509055159f # https://oeis.org/A002161
-SQRT_PHI = 1.272019649514069f # https://oeis.org/A139339
-EPSILON = 2.220446049250313e-16f # The difference between 1 and the smallest floating point number greater than 1, formula: 7/3 - 4/3 - 1
-MIN_FLOAT_VALUE = 4.9406564584124654417656879286822137236505980e-324 # Lowest value of float
-MAX_FLOAT_VALUE = 1.79769313486231570814527423731704356798070e+308 # Highest value of float
-HALF_PI = 1.5707963267948966f # PI / 2
-TAU = 6.283185307179586f # 2 * PI
-# Natural exponential, e^x, via range reduction (halve x until |x| <= 0.5,
-# run the Taylor series there where it converges fast, then square the
-# result back up the same number of halvings).
-fun exp(x: Float) -> Float =
-  if x != x
-    return x
-  if x > 700.0f
-    return 1.0f / 0.0f
-  if x < -700.0f
-    return 0.0f
-  v := x
-  k := 0
-  while v > 0.5f || v < -0.5f
-    v = v / 2.0f
-    k = k + 1
-  term := 1.0f
-  sum := 1.0f
-  n := 1
-  while n < 25
-    term = term * v / Float(n)
-    sum = sum + term
-    n = n + 1
-  result := sum
-  i := 0
-  while i < k
-    result = result * result
-    i = i + 1
-  return result
-# Natural logarithm, via range reduction to v in [1, 2) plus the
-# fast-converging series ln(v) = 2*atanh((v-1)/(v+1)).
-fun ln(x: Float) -> Float =
-  if x != x || x < 0.0f
-    return 0.0f / 0.0f
-  if x == 0.0f
-    return -1.0f / 0.0f
-  if x > MAX_FLOAT_VALUE
-    return x
-  v := x
-  k := 0
-  while v >= 2.0f
-    v = v / 2.0f
-    k = k + 1
-  while v < 1.0f
-    v = v * 2.0f
-    k = k - 1
-  t := {v - 1.0f} / {v + 1.0f}
-  t2 := t * t
-  term := t
-  sum := t
-  n := 1
-  while n < 30
-    term = term * t2
-    sum = sum + term / Float(2 * n + 1)
-    n = n + 1
-  return Float(k) * LN2 + 2.0f * sum
-# Square root via Newton's method, iterating to a fixed point.
-fun sqrt(x: Float) -> Float =
-  if x < 0.0f
-    return 0.0f / 0.0f
-  if x == 0.0f || x != x
-    return x
-  guess := x
-  prev := 0.0f
-  i := 0
-  while guess != prev && i < 100
-    prev = guess
-    guess = 0.5f * {guess + x / guess}
-    i = i + 1
-  return guess
-# Reduces `x` into roughly `[-PI, PI]` by subtracting the nearest multiple of
-# `TAU` — the range `sin`/`cos`'s Taylor series below actually converge
-# quickly over. For very large `|x|` (many multiples of `TAU`), floating-point
-# cancellation in `x - k*TAU` loses precision the same way any naive
-# range-reduction by subtraction does; a real libm uses extended-precision
-# constants to avoid this, which isn't attempted here.
-fun reduceToPi(x: Float) -> Float =
-  k := Int(x / TAU + {x >= 0.0f ? 0.5f : -0.5f})
-  return x - Float(k) * TAU
-fun sin(x: Float) -> Float =
-  if x != x || x > MAX_FLOAT_VALUE || x < -MAX_FLOAT_VALUE
-    return 0.0f / 0.0f
-  r := reduceToPi(x)
-  r2 := r * r
-  term := r
-  sum := r
-  n := 1
-  while n < 10
-    term = term * {-r2} / Float({2 * n} * {2 * n + 1})
-    sum = sum + term
-    n = n + 1
-  return sum
-fun cos(x: Float) -> Float =
-  if x != x || x > MAX_FLOAT_VALUE || x < -MAX_FLOAT_VALUE
-    return 0.0f / 0.0f
-  return sin(x + HALF_PI)
-fun tan(x: Float) -> Float =
-  return sin(x) / cos(x)
-# Arctangent, via repeated argument-halving (`atan(x) = 2*atan(x / (1 +
-# sqrt(1+x^2)))`) until `|x| <= 0.5` (where the Taylor series below converges
-# quickly), then doubling the result back up the same number of times.
-fun atan(x: Float) -> Float =
-  if x != x
-    return x
-  neg := x < 0.0f
-  v := neg ? -x : x
-  k := 0
-  while v > 0.5f && k < 8
-    v = v / {1.0f + sqrt(1.0f + v * v)}
-    k = k + 1
-  v2 := v * v
-  term := v
-  sum := v
-  n := 1
-  while n < 20
-    term = term * {-v2}
-    sum = sum + term / Float(2 * n + 1)
-    n = n + 1
-  scale := Float(1 << k)
-  result := sum * scale
-  return neg ? -result : result
-fun asin(x: Float) -> Float =
-  if x != x || x < -1.0f || x > 1.0f
-    return 0.0f / 0.0f
-  if x == 1.0f
-    return HALF_PI
-  if x == -1.0f
-    return -HALF_PI
-  return atan(x / sqrt(1.0f - x * x))
-fun acos(x: Float) -> Float =
-  return HALF_PI - asin(x)
-# Angle (in radians) of the point `(x, y)` from the origin, in the correct
-# quadrant for any sign combination of `x`/`y` (unlike plain `atan(y/x)`,
-# which can't distinguish opposite quadrants).
-fun atan2(y: Float, x: Float) -> Float =
-  if x > 0.0f
-    return atan(y / x)
-  if x < 0.0f && y >= 0.0f
-    return atan(y / x) + PI
-  if x < 0.0f && y < 0.0f
-    return atan(y / x) - PI
-  if x == 0.0f && y > 0.0f
-    return HALF_PI
-  if x == 0.0f && y < 0.0f
-    return -HALF_PI
-  return 0.0f
-fun hypot(a: Float, b: Float) -> Float =
-  return sqrt(a * a + b * b)
-# Cube root via Newton's method (fixed iteration count, unlike `sqrt`'s
-# converge-to-a-fixed-point loop, since the cubic update step doesn't reach an
-# exact fixed point in float precision as reliably as the quadratic one does).
-fun cbrt(x: Float) -> Float =
-  if x == 0.0f || x != x
-    return x
-  neg := x < 0.0f
-  v := neg ? -x : x
-  guess := v
-  i := 0
-  while i < 60
-    guess = {2.0f * guess + v / {guess * guess}} / 3.0f
-    i = i + 1
-  return neg ? -guess : guess
-type Float =
-  # Parses a decimal float, with an optional leading `+`/`-` and an optional
-  # `.` fractional part (no exponent notation). Called as `Float.fromStr(...)`.
-  fun fromStr(s: Str) -> Result[Float, Str] =
-    len := s.length()
-    if len == 0
-      return Err("empty string")
-    neg := s.byteAt(0) == 45
-    start := neg || s.byteAt(0) == 43 ? 1 : 0
-    if start >= len
-      return Err("invalid float: '{s}'")
-    int_part := 0.0f
-    saw_digit := False
-    i := start
-    while i < len && s.byteAt(i) != 46
-      b := s.byteAt(i)
-      if b < 48 || b > 57
-        return Err("invalid float: '{s}'")
-      int_part = int_part * 10.0f + Float(b - 48)
-      saw_digit = True
-      i = i + 1
-    frac_part := 0.0f
-    frac_scale := 1.0f
-    if i < len && s.byteAt(i) == 46
-      i = i + 1
-      while i < len
-        b = s.byteAt(i)
-        if b < 48 || b > 57
-          return Err("invalid float: '{s}'")
-        frac_scale = frac_scale / 10.0f
-        frac_part = frac_part + Float(b - 48) * frac_scale
-        saw_digit = True
-        i = i + 1
-    if !saw_digit
-      return Err("invalid float: '{s}'")
-    value := int_part + frac_part
-    return Ok(neg ? -value : value)
-  # Inverse hyperbolic cosine, via acosh(x) = ln(x + sqrt(x^2 - 1)), x >= 1.
-  fun acosh(self) -> Float =
-    if self < 1.0f
-      return 0.0f / 0.0f
-    return ln(self + sqrt(self * self - 1.0f))
-  fun sinh(self) -> Float =
-    return {exp(self) - exp(-self)} / 2.0f
-  fun cosh(self) -> Float =
-    return {exp(self) + exp(-self)} / 2.0f
-  fun tanh(self) -> Float =
-    return self.sinh() / self.cosh()
-  # Inverse hyperbolic sine: asinh(x) = ln(x + sqrt(x^2 + 1)).
-  fun asinh(self) -> Float =
-    return ln(self + sqrt(self * self + 1.0f))
-  # Inverse hyperbolic tangent: atanh(x) = 0.5*ln((1+x)/(1-x)), |x| < 1.
-  fun atanh(self) -> Float =
-    if self <= -1.0f || self >= 1.0f
-      return 0.0f / 0.0f
-    return 0.5f * ln({1.0f + self} / {1.0f - self})
-  fun abs(self) -> Float =
-    return self < 0.0f ? -self : self
-  fun sign(self) -> Float =
-    if self > 0.0f
-      return 1.0f
-    if self < 0.0f
-      return -1.0f
-    return self # preserves 0.0 / -0.0 / NaN
-  # `Int(self)` truncates toward zero (see `plum-wasm-codegen`'s `Int(x)`
-  # conversion) — exactly `trunc`'s definition.
-  fun trunc(self) -> Float =
-    return Float(Int(self))
-  fun floor(self) -> Float =
-    t := self.trunc()
-    if self < 0.0f && t != self
-      return t - 1.0f
-    return t
-  fun ceil(self) -> Float =
-    t := self.trunc()
-    if self > 0.0f && t != self
-      return t + 1.0f
-    return t
-  # Round-half-away-from-zero (matching Go's `math.Round`), not
-  # round-half-to-even.
-  fun round(self) -> Float =
-    neg := self < 0.0f
-    v := neg ? -self : self
-    r := {v + 0.5f}.floor()
-    return neg ? -r : r
-  fun min(self, other: Float) -> Float =
-    return self < other ? self : other
-  fun max(self, other: Float) -> Float =
-    return self > other ? self : other
-  # self^y. Mirrors `Int.pow`: a whole-number `y` (including negative) is
-  # computed exactly by repeated squaring; a fractional `y` falls back to
-  # self^y = exp(y * ln(self)), which requires self > 0.
-  fun pow(self, y: Float) -> Float =
-    if y == 0.0f
-      return 1.0f
-    yi := Int(y)
-    if Float(yi) == y
-      neg := yi < 0
-      n := neg ? -yi : yi
-      result := 1.0f
-      b := self
-      m := n
-      while m > 0
-        if m % 2 == 1
-          result = result * b
-        b = b * b
-        m = m / 2
-      return neg ? 1.0f / result : result
-    if self < 0.0f
-      return 0.0f / 0.0f
-    return exp(y * ln(self))
-  # Check whether this number is finite, ie not +/-infinity and not NaN.
-  fun isFinite(self) -> Bool =
-    !self.isNaN() && !self.isInfinite()
-  # Check whether this number is +/-infinity
-  fun isInfinite(self) -> Bool =
-    self > MAX_FLOAT_VALUE || self < -MAX_FLOAT_VALUE
-  # Check whether this number is NaN.
-  fun isNaN(self) -> Bool =
-    self != self
-  # Rounded to 6 fractional digits, with trailing zeros trimmed (but always at
-  # least one digit after the point, e.g. `3.0` not `3.`).
-  fun toStr(self) -> Str =
-    if self.isNaN()
-      return "NaN"
-    if self.isInfinite()
-      return self < 0.0f ? "-Infinity" : "Infinity"
-    neg := self < 0.0f
-    abs_val := neg ? -self : self
-    int_part := Int(abs_val)
-    frac_val := abs_val - Float(int_part)
-    scaled := Int(frac_val * 1000000.0f + 0.5f)
-    carry := scaled >= 1000000
-    whole_part := carry ? int_part + 1 : int_part
-    frac := carry ? 0 : scaled
-    s := whole_part.toStr() + "." + trimmedFracDigits(frac, 6)
-    return neg ? "-" + s : s
-# Renders `n`'s digits most-significant-first, always emitting exactly as many
-# digits as `place_value` has powers of ten (leading zeros included) — used to
-# render a fractional part at a fixed width regardless of its own leading zeros.
-fun fixedFracDigits(n: Int, place_value: Int) -> Str =
-  if place_value == 0
-    return ""
-  return digitChar(n / place_value % 10) + fixedFracDigits(n, place_value / 10)
-fun pow10(n: Int) -> Int =
-  if n <= 0
-    return 1
-  return 10 * pow10(n - 1)
-# `fixedFracDigits(n, pow10(digits - 1))`, minus however many trailing-zero
-# digits `n` has — but always at least one digit ("0" if `n` is 0 outright).
-fun trimmedFracDigits(n: Int, digits: Int) -> Str =
-  if n == 0 || digits <= 1
-    return digitChar(n % 10)
-  if n % 10 == 0
-    return trimmedFracDigits(n / 10, digits - 1)
-  return fixedFracDigits(n, pow10(digits - 1))

plum-std/Http.plum CHANGED Viewed

@@ -8,7 +8,7 @@ import std/Option
 import std/Result
 import std/Str
 import std/Bool
-import std/Int
+import std/Number
 # An HTTP response: status code, response headers, and the raw response
 # body as a `Str` (a byte array, so binary bodies round-trip intact).
@@ -86,7 +86,7 @@ fun request(method: Str, url: Str, headers: Map[Str, Str], body: Str) -> Result[
   flag := parts.get(0).unwrapOr("")
   if flag != "1"
     return Err(parts.get(2).unwrapOr("http request failed"))
-  match Int.fromStr(parts.get(1).unwrapOr(""))
+  match parseInt(parts.get(1).unwrapOr(""))
     Ok(status) =>
       return Ok(Response(status: status, headers: decodeHeaders(parts.get(2).unwrapOr("")), body: resp_body))
     Err(e) =>

plum-std/Int.plum DELETED Viewed

@@ -1,147 +0,0 @@
-module std
-import std/Float
-import std/Result
-import std/Str
-import std/Bool
-MIN_VALUE = -0x8000_0000_0000_0000 # Lowest value of Int
-MAX_VALUE = 0x7FFF_FFFF_FFFF_FFFF  # Highest value of Int
-LARGE = 1 << 28 # 2**28
-type Int =
-  # returns the absolute value of the Int
-  fun abs(self) -> Int =
-    self < 0 ? -self : self
-  # An `Int` already IS its own well-distributed bit pattern — used by
-  # `Map[K: Hashable, V]` (see `map.plum`) to bucket `Int` keys.
-  fun hash(self) -> Int =
-    self
-  # An Int is always already whole, so ceil/floor/round/trunc are all just
-  # the value itself widened to Float.
-  fun ceil(self) -> Float =
-    Float(self)
-  fun floor(self) -> Float =
-    Float(self)
-  fun round(self) -> Float =
-    Float(self)
-  fun trunc(self) -> Float =
-    Float(self)
-  fun log(self) -> Float =
-    ln(Float(self))
-  fun log2(self) -> Float =
-    ln(Float(self)) * LOG2E
-  fun log10(self) -> Float =
-    ln(Float(self)) * LOG10E
-  # floor(log2(|self|)), computed exactly with integer division rather than
-  # through Float rounding error.
-  fun logb(self) -> Float =
-    if self == 0
-      return -1.0f / 0.0f
-    n := self < 0 ? -self : self
-    k := 0
-    while n >= 2
-      n = n / 2
-      k = k + 1
-    return Float(k)
-  # self^y. Integer exponents (the common case, including negative self) are
-  # computed exactly by repeated squaring; fractional exponents fall back to
-  # self^y = exp(y * ln(self)), which requires self > 0.
-  fun pow(self, y: Float) -> Float =
-    base := Float(self)
-    if y == 0.0f
-      return 1.0f
-    yi := Int(y)
-    if Float(yi) == y
-      neg := yi < 0
-      n := neg ? -yi : yi
-      result := 1.0f
-      b := base
-      m := n
-      while m > 0
-        if m % 2 == 1
-          result = result * b
-        b = b * b
-        m = m / 2
-      return neg ? 1.0f / result : result
-    if base < 0.0f
-      return 0.0f / 0.0f
-    return exp(y * ln(base))
-  fun sqrt(self) -> Float =
-    sqrt(Float(self))
-  # Parses a decimal integer, with an optional leading `+`/`-`. Called as
-  # `Int.fromStr("42")` — a "static" method with no `self`, like `Bool.parse`.
-  fun fromStr(s: Str) -> Result[Int, Str] =
-    len := s.length()
-    if len == 0
-      return Err("empty string")
-    neg := s.byteAt(0) == 45
-    start := neg || s.byteAt(0) == 43 ? 1 : 0
-    if start >= len
-      return Err("invalid integer: '{s}'")
-    value := 0
-    i := start
-    while i < len
-      b := s.byteAt(i)
-      if b < 48 || b > 57
-        return Err("invalid integer: '{s}'")
-      value = value * 10 + b - 48
-      i = i + 1
-    return Ok(neg ? -value : value)
-  fun toStr(self) -> Str =
-    if self == 0
-      return "0"
-    neg := self < 0
-    n := neg ? -self : self
-    s := digitsToStr(n)
-    return neg ? "-" + s : s
-# Builds the decimal digits of a positive Int, most significant first, by
-# peeling off one digit at a time from the least significant end (so the
-# recursion emits digits in reverse call order — the leading, smallest-place
-# digit is appended last).
-fun digitsToStr(n: Int) -> Str =
-  if n == 0
-    return ""
-  return digitsToStr(n / 10) + digitChar(n % 10)
-fun digitChar(d: Int) -> Str =
-  match d
-    0 => "0"
-    1 => "1"
-    2 => "2"
-    3 => "3"
-    4 => "4"
-    5 => "5"
-    6 => "6"
-    7 => "7"
-    8 => "8"
-    9 => "9"
-    _ => "0"
-# A raw, host-provided pseudo-random 64-bit Int (xorshift64*, seeded from the
-# wall clock — not cryptographically secure). Every other random-number
-# function in std is built on top of this one host extern.
-extern fun rawRandomInt() -> Int
-# A random Float uniformly distributed in [0.0, 1.0).
-fun random() -> Float =
-  return Float(rawRandomInt() & MAX_VALUE) / Float(MAX_VALUE)
-# A random Int uniformly distributed in [0, n). Returns 0 for n <= 0.
-fun randomInt(n: Int) -> Int =
-  if n <= 0
-    return 0
-  return { rawRandomInt() & MAX_VALUE } % n

plum-std/Json.plum CHANGED Viewed

@@ -4,8 +4,7 @@ import std/Option
 import std/Result
 import std/List
 import std/Map
-import std/Int
-import std/Float
+import std/Number
 import std/Str
 import std/Buffer
 import std/Err
@@ -188,14 +187,14 @@ type JsonParser =
   fun parseNumberText(self, text: Str) -> Result[Json, JsonParseError] =
     e_index := exponentIndex(text)
     if e_index < 0
-      r := Float.fromStr(text)
+      r := parseFloat(text)
       match r
         Ok(f) =>
           return Ok(JsonFloat(f))
         Err(m) =>
           return Err(self.fail(m))
-    mantissa := Float.fromStr(text.sub(0, e_index))
+    mantissa := parseFloat(text.sub(0, e_index))
-    exponent := Int.fromStr(text.sub(e_index + 1, text.length()))
+    exponent := parseInt(text.sub(e_index + 1, text.length()))
     match mantissa
       Err(m) =>
         return Err(self.fail(m))

plum-std/List.plum CHANGED Viewed

@@ -2,7 +2,7 @@ module std
 import std/Option
 import std/Buffer
-import std/Int
+import std/Number
 import std/Bool
 import std/Str

plum-std/Map.plum CHANGED Viewed

@@ -3,7 +3,7 @@ import std/List
 import std/Option
 import std/Array
 import std/Bool
-import std/Int
+import std/Number
 import std/Str
 # Any type usable as a `Map` key needs a `hash`, so keys landing in different

plum-std/Number.plum ADDED Viewed

@@ -0,0 +1,548 @@
+module std
+import std/Str
+import std/Bool
+import std/Result
+MIN_VALUE = -0x8000_0000_0000_0000 # Lowest value of Int
+MAX_VALUE = 0x7FFF_FFFF_FFFF_FFFF  # Highest value of Int
+LARGE = 1 << 28 # 2**28
+E = 2.718281828459045f # Euler's number, the base of natural logarithms, e, https://oeis.org/A001113
+LN10 = 2.302585092994046f # The natural logarithm of 10, https://oeis.org/A002392
+LN2 = 0.6931471805599453f # The natural logarithm of 2, https://oeis.org/A002162
+LOG10E = 0.4342944819032518f # The base 10 logarithm of e, formula: 1 / LN10
+LOG2E = 1.4426950408889634f # The base 2 logarithm of e, formula: 1 / LN2
+PI = 3.141592653589793f # The ratio of the circumference of a circle to its diameter, https://oeis.org/A000796
+PHI = 1.618033988749895f # https://oeis.org/A001622
+SQRT1_2 = 0.7071067811865476f # The square root of 1/2
+SQRT2 = 1.4142135623730951f # The square root of 2, https://oeis.org/A002193
+SQRT_E = 1.6487212707001282f # https://oeis.org/A019774
+SQRT_PI = 1.7724538509055159f # https://oeis.org/A002161
+SQRT_PHI = 1.272019649514069f # https://oeis.org/A139339
+EPSILON = 2.220446049250313e-16f # The difference between 1 and the smallest floating point number greater than 1, formula: 7/3 - 4/3 - 1
+MIN_FLOAT_VALUE = 4.9406564584124654417656879286822137236505980e-324 # Lowest value of float
+MAX_FLOAT_VALUE = 1.79769313486231570814527423731704356798070e+308 # Highest value of float
+HALF_PI = 1.5707963267948966f # PI / 2
+TAU = 6.283185307179586f # 2 * PI
+# `Int`/`Float` bare-wrap into `Number` with no wrapper syntax at all (see
+# `plum-checker`'s `unify`/`monomorphize::wrapPrimitiveAgainstExpected`) —
+# assigning/returning/passing a bare `Int`/`Float` value wherever `Number` is
+# expected just works. A method not found on `Int`/`Float` directly (they no
+# longer have their own method tables at all) falls back to `Number`'s,
+# boxing `self` first (see `plum-checker`/`plum-wasm-codegen`'s matching
+# `AttrKind::Method` dispatch fallback) — so `x.abs()` for a bare `Int`/
+# `Float` `x` dispatches here exactly as if `Int`/`Float` still had their own
+# `abs` method.
+enum Number =
+  | Int
+  | Float
+  fun kind(self) -> Str =
+    match self
+      Int(_) => "Int"
+      Float(_) => "Float"
+  fun toFloatValue(self) -> Float =
+    match self
+      Int(i) => Float(i)
+      Float(f) => f
+  fun abs(self) -> Number =
+    match self
+      Int(i) => Int(i < 0 ? -i : i)
+      Float(f) => Float(f < 0.0f ? -f : f)
+  # Preserves 0.0 / -0.0 / NaN for the `Float` case, matching Go's
+  # `math.Signbit`-adjacent `Copysign`/`sign` conventions loosely.
+  fun sign(self) -> Number =
+    match self
+      Int(i) => Int(i > 0 ? 1 : i < 0 ? -1 : 0)
+      Float(f) =>
+        if f > 0.0f
+          return Float(1.0f)
+        if f < 0.0f
+          return Float(-1.0f)
+        return Float(f)
+  # An `Int` already IS its own well-distributed bit pattern — used by
+  # `Map[K: Hashable, V]` to bucket `Int` keys. A `Float` hashes via a
+  # truncating conversion (no bit-level float hashing attempted).
+  fun hash(self) -> Int =
+    match self
+      Int(i) => i
+      Float(f) => Int(f)
+  # An Int is always already whole, so trunc/floor/ceil/round are all just
+  # the value itself widened to Float.
+  fun trunc(self) -> Float =
+    match self
+      Int(i) => Float(i)
+      # `Int(f)` truncates toward zero (see `plum-wasm-codegen`'s `Int(x)`
+      # cross-type conversion) — exactly `trunc`'s definition.
+      Float(f) => Float(Int(f))
+  fun floor(self) -> Float =
+    match self
+      Int(i) => Float(i)
+      Float(f) =>
+        t := Float(Int(f))
+        if f < 0.0f && t != f
+          return t - 1.0f
+        return t
+  fun ceil(self) -> Float =
+    match self
+      Int(i) => Float(i)
+      Float(f) =>
+        t := Float(Int(f))
+        if f > 0.0f && t != f
+          return t + 1.0f
+        return t
+  # Round-half-away-from-zero (matching Go's `math.Round`), not
+  # round-half-to-even.
+  fun round(self) -> Float =
+    match self
+      Int(i) => Float(i)
+      Float(f) =>
+        neg := f < 0.0f
+        v := neg ? -f : f
+        r := {v + 0.5f}.floor()
+        return neg ? -r : r
+  fun log(self) -> Float =
+    ln(self.toFloatValue())
+  fun log2(self) -> Float =
+    ln(self.toFloatValue()) * LOG2E
+  fun log10(self) -> Float =
+    ln(self.toFloatValue()) * LOG10E
+  # floor(log2(|self|)). An `Int` self computes this exactly with integer
+  # division rather than through Float rounding error; a `Float` self falls
+  # back to the real logarithm.
+  fun logb(self) -> Float =
+    match self
+      Int(i) =>
+        if i == 0
+          return -1.0f / 0.0f
+        n := i < 0 ? -i : i
+        k := 0
+        while n >= 2
+          n = n / 2
+          k = k + 1
+        return Float(k)
+      Float(f) =>
+        if f == 0.0f
+          return -1.0f / 0.0f
+        return {ln(f < 0.0f ? -f : f) * LOG2E}.floor()
+  fun sqrt(self) -> Float =
+    sqrt(self.toFloatValue())
+  # self^y. Mirrors the original `Int.pow`/`Float.pow`: a whole-number `y`
+  # (including negative) is computed exactly by repeated squaring; a
+  # fractional `y` falls back to self^y = exp(y * ln(self)), which requires
+  # self > 0.
+  fun pow(self, y: Float) -> Float =
+    powFloat(self.toFloatValue(), y)
+  # Check whether this number is finite, ie not +/-infinity and not NaN.
+  fun isFinite(self) -> Bool =
+    !self.isNaN() && !self.isInfinite()
+  fun isInfinite(self) -> Bool =
+    match self
+      Int(_) => False
+      Float(f) => f > MAX_FLOAT_VALUE || f < -MAX_FLOAT_VALUE
+  fun isNaN(self) -> Bool =
+    match self
+      Int(_) => False
+      Float(f) => f != f
+  fun min(self, other: Number) -> Number =
+    self.toFloatValue() < other.toFloatValue() ? self : other
+  fun max(self, other: Number) -> Number =
+    self.toFloatValue() > other.toFloatValue() ? self : other
+  # Inverse hyperbolic cosine, via acosh(x) = ln(x + sqrt(x^2 - 1)), x >= 1.
+  fun acosh(self) -> Float =
+    v := self.toFloatValue()
+    if v < 1.0f
+      return 0.0f / 0.0f
+    return ln(v + sqrt(v * v - 1.0f))
+  fun sinh(self) -> Float =
+    v := self.toFloatValue()
+    return {exp(v) - exp(-v)} / 2.0f
+  fun cosh(self) -> Float =
+    v := self.toFloatValue()
+    return {exp(v) + exp(-v)} / 2.0f
+  fun tanh(self) -> Float =
+    return self.sinh() / self.cosh()
+  # Inverse hyperbolic sine: asinh(x) = ln(x + sqrt(x^2 + 1)).
+  fun asinh(self) -> Float =
+    v := self.toFloatValue()
+    return ln(v + sqrt(v * v + 1.0f))
+  # Inverse hyperbolic tangent: atanh(x) = 0.5*ln((1+x)/(1-x)), |x| < 1.
+  fun atanh(self) -> Float =
+    v := self.toFloatValue()
+    if v <= -1.0f || v >= 1.0f
+      return 0.0f / 0.0f
+    return 0.5f * ln({1.0f + v} / {1.0f - v})
+  # Rounded to 6 fractional digits, with trailing zeros trimmed (but always
+  # at least one digit after the point, e.g. `3.0` not `3.`), for a `Float`;
+  # plain decimal digits for an `Int`.
+  fun toStr(self) -> Str =
+    match self
+      Int(i) => intToStr(i)
+      Float(f) =>
+        if f != f
+          return "NaN"
+        if f > MAX_FLOAT_VALUE || f < -MAX_FLOAT_VALUE
+          return f < 0.0f ? "-Infinity" : "Infinity"
+        neg := f < 0.0f
+        abs_val := neg ? -f : f
+        int_part := Int(abs_val)
+        frac_val := abs_val - Float(int_part)
+        scaled := Int(frac_val * 1000000.0f + 0.5f)
+        carry := scaled >= 1000000
+        whole_part := carry ? int_part + 1 : int_part
+        frac := carry ? 0 : scaled
+        s := intToStr(whole_part) + "." + trimmedFracDigits(frac, 6)
+        return neg ? "-" + s : s
+# ---- free-function helpers (no `self` to dispatch on) ----
+# Plain decimal rendering of an `Int` — factored out of `Number.toStr` so the
+# `Float` branch can reuse it (via `intToStr(whole_part)`) without
+# re-dispatching back through `Number.toStr` itself.
+fun intToStr(n: Int) -> Str =
+  if n == 0
+    return "0"
+  neg := n < 0
+  v := neg ? -n : n
+  s := digitsToStr(v)
+  return neg ? "-" + s : s
+# Builds the decimal digits of a positive Int, most significant first, by
+# peeling off one digit at a time from the least significant end (so the
+# recursion emits digits in reverse call order — the leading, smallest-place
+# digit is appended last).
+fun digitsToStr(n: Int) -> Str =
+  if n == 0
+    return ""
+  return digitsToStr(n / 10) + digitChar(n % 10)
+fun digitChar(d: Int) -> Str =
+  match d
+    0 => "0"
+    1 => "1"
+    2 => "2"
+    3 => "3"
+    4 => "4"
+    5 => "5"
+    6 => "6"
+    7 => "7"
+    8 => "8"
+    9 => "9"
+    _ => "0"
+# Renders `n`'s digits most-significant-first, always emitting exactly as many
+# digits as `place_value` has powers of ten (leading zeros included) — used to
+# render a fractional part at a fixed width regardless of its own leading zeros.
+fun fixedFracDigits(n: Int, place_value: Int) -> Str =
+  if place_value == 0
+    return ""
+  return digitChar(n / place_value % 10) + fixedFracDigits(n, place_value / 10)
+fun pow10(n: Int) -> Int =
+  if n <= 0
+    return 1
+  return 10 * pow10(n - 1)
+# `fixedFracDigits(n, pow10(digits - 1))`, minus however many trailing-zero
+# digits `n` has — but always at least one digit ("0" if `n` is 0 outright).
+fun trimmedFracDigits(n: Int, digits: Int) -> Str =
+  if n == 0 || digits <= 1
+    return digitChar(n % 10)
+  if n % 10 == 0
+    return trimmedFracDigits(n / 10, digits - 1)
+  return fixedFracDigits(n, pow10(digits - 1))
+# Shared `base^y` algorithm behind `Number.pow`, extracted so both the `Int`
+# and `Float` self cases (which only differ in how `base` was obtained) share
+# one body.
+fun powFloat(base: Float, y: Float) -> Float =
+  if y == 0.0f
+    return 1.0f
+  yi := Int(y)
+  if Float(yi) == y
+    neg := yi < 0
+    n := neg ? -yi : yi
+    result := 1.0f
+    b := base
+    m := n
+    while m > 0
+      if m % 2 == 1
+        result = result * b
+      b = b * b
+      m = m / 2
+    return neg ? 1.0f / result : result
+  if base < 0.0f
+    return 0.0f / 0.0f
+  return exp(y * ln(base))
+# Parses a decimal integer, with an optional leading `+`/`-`.
+fun parseInt(s: Str) -> Result[Int, Str] =
+  len := s.length()
+  if len == 0
+    return Err("empty string")
+  neg := s.byteAt(0) == 45
+  start := neg || s.byteAt(0) == 43 ? 1 : 0
+  if start >= len
+    return Err("invalid integer: '{s}'")
+  value := 0
+  i := start
+  while i < len
+    b := s.byteAt(i)
+    if b < 48 || b > 57
+      return Err("invalid integer: '{s}'")
+    value = value * 10 + b - 48
+    i = i + 1
+  return Ok(neg ? -value : value)
+# Parses a decimal float, with an optional leading `+`/`-` and an optional
+# `.` fractional part (no exponent notation).
+fun parseFloat(s: Str) -> Result[Float, Str] =
+  len := s.length()
+  if len == 0
+    return Err("empty string")
+  neg := s.byteAt(0) == 45
+  start := neg || s.byteAt(0) == 43 ? 1 : 0
+  if start >= len
+    return Err("invalid float: '{s}'")
+  int_part := 0.0f
+  saw_digit := False
+  i := start
+  while i < len && s.byteAt(i) != 46
+    b := s.byteAt(i)
+    if b < 48 || b > 57
+      return Err("invalid float: '{s}'")
+    int_part = int_part * 10.0f + Float(b - 48)
+    saw_digit = True
+    i = i + 1
+  frac_part := 0.0f
+  frac_scale := 1.0f
+  if i < len && s.byteAt(i) == 46
+    i = i + 1
+    while i < len
+      b = s.byteAt(i)
+      if b < 48 || b > 57
+        return Err("invalid float: '{s}'")
+      frac_scale = frac_scale / 10.0f
+      frac_part = frac_part + Float(b - 48) * frac_scale
+      saw_digit = True
+      i = i + 1
+  if !saw_digit
+    return Err("invalid float: '{s}'")
+  value := int_part + frac_part
+  return Ok(neg ? -value : value)
+# A raw, host-provided pseudo-random 64-bit Int (xorshift64*, seeded from the
+# wall clock — not cryptographically secure). Every other random-number
+# function in std is built on top of this one host extern.
+extern fun rawRandomInt() -> Int
+# A random Float uniformly distributed in [0.0, 1.0).
+fun random() -> Float =
+  return Float(rawRandomInt() & MAX_VALUE) / Float(MAX_VALUE)
+# A random Int uniformly distributed in [0, n). Returns 0 for n <= 0.
+fun randomInt(n: Int) -> Int =
+  if n <= 0
+    return 0
+  return { rawRandomInt() & MAX_VALUE } % n
+# Natural exponential, e^x, via range reduction (halve x until |x| <= 0.5,
+# run the Taylor series there where it converges fast, then square the
+# result back up the same number of halvings).
+fun exp(x: Float) -> Float =
+  if x != x
+    return x
+  if x > 700.0f
+    return 1.0f / 0.0f
+  if x < -700.0f
+    return 0.0f
+  v := x
+  k := 0
+  while v > 0.5f || v < -0.5f
+    v = v / 2.0f
+    k = k + 1
+  term := 1.0f
+  sum := 1.0f
+  n := 1
+  while n < 25
+    term = term * v / Float(n)
+    sum = sum + term
+    n = n + 1
+  result := sum
+  i := 0
+  while i < k
+    result = result * result
+    i = i + 1
+  return result
+# Natural logarithm, via range reduction to v in [1, 2) plus the
+# fast-converging series ln(v) = 2*atanh((v-1)/(v+1)).
+fun ln(x: Float) -> Float =
+  if x != x || x < 0.0f
+    return 0.0f / 0.0f
+  if x == 0.0f
+    return -1.0f / 0.0f
+  if x > MAX_FLOAT_VALUE
+    return x
+  v := x
+  k := 0
+  while v >= 2.0f
+    v = v / 2.0f
+    k = k + 1
+  while v < 1.0f
+    v = v * 2.0f
+    k = k - 1
+  t := {v - 1.0f} / {v + 1.0f}
+  t2 := t * t
+  term := t
+  sum := t
+  n := 1
+  while n < 30
+    term = term * t2
+    sum = sum + term / Float(2 * n + 1)
+    n = n + 1
+  return Float(k) * LN2 + 2.0f * sum
+# Square root via Newton's method, iterating to a fixed point.
+fun sqrt(x: Float) -> Float =
+  if x < 0.0f
+    return 0.0f / 0.0f
+  if x == 0.0f || x != x
+    return x
+  guess := x
+  prev := 0.0f
+  i := 0
+  while guess != prev && i < 100
+    prev = guess
+    guess = 0.5f * {guess + x / guess}
+    i = i + 1
+  return guess
+# Reduces `x` into roughly `[-PI, PI]` by subtracting the nearest multiple of
+# `TAU` — the range `sin`/`cos`'s Taylor series below actually converge
+# quickly over. For very large `|x|` (many multiples of `TAU`), floating-point
+# cancellation in `x - k*TAU` loses precision the same way any naive
+# range-reduction by subtraction does; a real libm uses extended-precision
+# constants to avoid this, which isn't attempted here.
+fun reduceToPi(x: Float) -> Float =
+  k := Int(x / TAU + {x >= 0.0f ? 0.5f : -0.5f})
+  return x - Float(k) * TAU
+fun sin(x: Float) -> Float =
+  if x != x || x > MAX_FLOAT_VALUE || x < -MAX_FLOAT_VALUE
+    return 0.0f / 0.0f
+  r := reduceToPi(x)
+  r2 := r * r
+  term := r
+  sum := r
+  n := 1
+  while n < 10
+    term = term * {-r2} / Float({2 * n} * {2 * n + 1})
+    sum = sum + term
+    n = n + 1
+  return sum
+fun cos(x: Float) -> Float =
+  if x != x || x > MAX_FLOAT_VALUE || x < -MAX_FLOAT_VALUE
+    return 0.0f / 0.0f
+  return sin(x + HALF_PI)
+fun tan(x: Float) -> Float =
+  return sin(x) / cos(x)
+# Arctangent, via repeated argument-halving (`atan(x) = 2*atan(x / (1 +
+# sqrt(1+x^2)))`) until `|x| <= 0.5` (where the Taylor series below converges
+# quickly), then doubling the result back up the same number of times.
+fun atan(x: Float) -> Float =
+  if x != x
+    return x
+  neg := x < 0.0f
+  v := neg ? -x : x
+  k := 0
+  while v > 0.5f && k < 8
+    v = v / {1.0f + sqrt(1.0f + v * v)}
+    k = k + 1
+  v2 := v * v
+  term := v
+  sum := v
+  n := 1
+  while n < 20
+    term = term * {-v2}
+    sum = sum + term / Float(2 * n + 1)
+    n = n + 1
+  scale := Float(1 << k)
+  result := sum * scale
+  return neg ? -result : result
+fun asin(x: Float) -> Float =
+  if x != x || x < -1.0f || x > 1.0f
+    return 0.0f / 0.0f
+  if x == 1.0f
+    return HALF_PI
+  if x == -1.0f
+    return -HALF_PI
+  return atan(x / sqrt(1.0f - x * x))
+fun acos(x: Float) -> Float =
+  return HALF_PI - asin(x)
+# Angle (in radians) of the point `(x, y)` from the origin, in the correct
+# quadrant for any sign combination of `x`/`y` (unlike plain `atan(y/x)`,
+# which can't distinguish opposite quadrants).
+fun atan2(y: Float, x: Float) -> Float =
+  if x > 0.0f
+    return atan(y / x)
+  if x < 0.0f && y >= 0.0f
+    return atan(y / x) + PI
+  if x < 0.0f && y < 0.0f
+    return atan(y / x) - PI
+  if x == 0.0f && y > 0.0f
+    return HALF_PI
+  if x == 0.0f && y < 0.0f
+    return -HALF_PI
+  return 0.0f
+fun hypot(a: Float, b: Float) -> Float =
+  return sqrt(a * a + b * b)
+# Cube root via Newton's method (fixed iteration count, unlike `sqrt`'s
+# converge-to-a-fixed-point loop, since the cubic update step doesn't reach an
+# exact fixed point in float precision as reliably as the quadratic one does).
+fun cbrt(x: Float) -> Float =
+  if x == 0.0f || x != x
+    return x
+  neg := x < 0.0f
+  v := neg ? -x : x
+  guess := v
+  i := 0
+  while i < 60
+    guess = {2.0f * guess + v / {guess * guess}} / 3.0f
+    i = i + 1
+  return neg ? -guess : guess

plum-std/Option.plum CHANGED Viewed

@@ -3,7 +3,7 @@ module std
 import std/Result
 import std/Str
 import std/Bool
-import std/Int
+import std/Number
 # Option[T] represents a value that may or may not be present — Plum's
 # counterpart to Rust's `Option`/Go's "zero value or ok bool" idiom.

plum-std/Os.plum CHANGED Viewed

@@ -4,7 +4,7 @@ import std/Result
 import std/Str
 import std/Uuid
 import std/Bool
-import std/Int
+import std/Number
 # NOTE: the original file modeled `stdin`/`stdout`/`stderr` as bare top-level
 # variable bindings and a `File(...)` constructor, but this language has no

plum-std/Result.plum CHANGED Viewed

@@ -2,7 +2,7 @@ module std
 import std/Option
 import std/Str
 import std/Bool
-import std/Int
+import std/Number
 # Result[T, E] represents either success (`Ok`, carrying a `T`) or failure
 # (`Err`, carrying an `E`) — used throughout std for fallible operations

plum-std/Str.plum CHANGED Viewed

@@ -3,7 +3,7 @@ module std
 import std/List
 import std/Buffer
 import std/Bool
-import std/Int
+import std/Number
 # Any type that can be converted to a str needs to implement this trait
 trait ToStr =

plum-std/Testing.plum CHANGED Viewed

@@ -4,7 +4,7 @@ import std/Option
 import std/Result
 import std/List
 import std/Bool
-import std/Int
+import std/Number
 import std/Str
 # Small jest/rspec-style assertion helpers for use inside `test` blocks, e.g.

plum-std/Time.plum CHANGED Viewed

@@ -1,8 +1,7 @@
 module std
-import std/Int
+import std/Number
 import std/Str
 import std/Bool
-import std/Float
 # A raw, host-provided wall-clock reading: milliseconds since the Unix epoch.
 extern fun rawNowMillis() -> Int

plum-std/Uuid.plum CHANGED Viewed

@@ -1,5 +1,5 @@
 module std
-import std/Int
+import std/Number
 import std/Result
 import std/Str
 import std/Bool

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

@@ -952,46 +952,21 @@ fn strLit(s: String) -> ast::Expr {
     ast::Expr::String(ast::StringExpr { parts: vec![ast::StringPart::Text(s)] })
 }
-/// True if `expr` is OBVIOUSLY float-valued from its own AST shape alone (a
-/// bare float literal) — no real type inference, just enough to catch the
-/// overwhelmingly common `assert computed() == 1.5` shape. `"{expr}"` string
-/// interpolation doesn't support `Float` yet (see README's Known gaps), so
-/// `assertFailureMessage` skips the actual/expected enhancement whenever
-/// either side looks like one, rather than break compiling a real test that
-/// compares a float against a literal (a computed-float-vs-computed-float
-/// comparison with no literal on either side isn't caught by this — a
-/// narrower residual gap, not a new one: interpolating that value was never
-/// going to work either way).
-fn looksLikeFloat(expr: &ast::Expr) -> bool {
-    match expr {
-        ast::Expr::Float(_) => true,
-        // `-1.5` parses as a unary negation wrapping the literal, not a bare
-        // `Expr::Float` itself.
-        ast::Expr::Unary(u) => looksLikeFloat(&u.operand),
-        _ => false,
-    }
-}
 /// Builds a failing `assert`'s report line: the literal condition text, plus —
-/// when the condition is a top-level comparison (`left OP right`) whose sides
+/// when the condition is a top-level comparison (`left OP right`) — the
-/// aren't obviously `Float` (see `looksLikeFloat`) — the ACTUAL (left) and
-/// EXPECTED (right) sides' own runtime values underneath, `assert computed()
+/// ACTUAL (left) and EXPECTED (right) sides' own runtime values underneath,
-/// == literal` being the overwhelmingly common shape a test writes such a
+/// `assert computed() == literal` being the overwhelmingly common shape a
-/// comparison in. Reuses `"{expr}"` string interpolation's own existing
+/// test writes such a comparison in. Reuses `"{expr}"` string interpolation's
-/// codegen (rather than any special stringification of its own) — so this
+/// own existing codegen (rather than any special stringification of its
-/// shows a value for any type interpolation already supports today, and
+/// own) — including `Float`, which interpolation now supports by rendering
-/// fails to compile with that same, ordinary interpolation error for a type
+/// through `Number.toStr` (`plum-std/Number.plum`), so no type needs
-/// it doesn't (no separate risk introduced beyond what `looksLikeFloat`
-/// already guards against). A non-comparison condition (`assert isEven(4)`)
+/// special-casing out here any more. A non-comparison condition (`assert
-/// has no meaningful actual/expected split — a boolean condition is always
+/// isEven(4)`) has no meaningful actual/expected split — a boolean condition
-/// false by the time this fires — so it's just the bare text.
+/// is always false by the time this fires — so it's just the bare text.
 fn assertFailureMessage(c: &ast::Check) -> ast::Expr {
     let ast::Expr::Compare(cmp) = &c.cond else {
         return strLit(format!("{}\n", c.text));
     };
-    if looksLikeFloat(&cmp.left) || looksLikeFloat(&cmp.right) {
-        return strLit(format!("{}\n", c.text));
-    }
     ast::Expr::String(ast::StringExpr {
         parts: vec![
             ast::StringPart::Text(format!("{}\n", c.text)),
@@ -4248,13 +4223,43 @@ fn compileExpr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
             // dispatched via `call_indirect` — not a direct `Call` to a named function.
             let is_closure_call = ctx.locals.contains_key(&call.name)
                 && matches!(inferLocalType(&ast::Expr::Var(call.name.clone()), ctx), PlumType::TFun(_, _));
+            // `Int(x)`/`Float(x)`/`Byte(x)` is the primitive numeric CAST
+            // special case just below UNLESS `call.name` is ALSO a
-            if (call.name == "Int" || call.name == "Float" || call.name == "Byte") && call.args.len() == 1 && !ctx.func_ids.contains_key(&call.name) {
+            // registered enum variant (a "union" enum's bare-primitive-wrap
+            // variant, e.g. `enum Number = | Int | Float` — see
+            // `buildGlobalTables`'s primitive bare-wrap condition) whose
+            // single field type exactly matches `x`'s own type: that's a
+            // same-type construction (`Int(intExpr)` -> box into `Number`'s
+            // `Int` variant via `compileVariantConstruction` below), not a
+            // cast. A genuinely cross-type call (`Int(floatExpr)`) is never
+            // ambiguous — no bare-wrap variant's field type could match an
+            // argument of a DIFFERENT primitive type — so every existing
+            // numeric-cast call site in the stdlib (`Float(self)`,
+            // `Int(y)`, ...) keeps working unchanged.
+            let single_arg_ty = if call.args.len() == 1 {
                 let arg_expr = match &call.args[0] {
                     ast::Arg::Positional(e) => e,
                     ast::Arg::Keyword { value, .. } => value,
                     ast::Arg::Pair { value, .. } => value,
                 };
-                let arg_ty = inferLocalType(arg_expr, ctx);
+                Some(inferLocalType(arg_expr, ctx))
+            } else {
+                None
+            };
+            let is_same_type_variant_wrap = single_arg_ty.as_ref().is_some_and(|ty| {
+                ctx.enum_variants.get(&call.name).is_some_and(|info| info.field_types == [ty.clone()])
+            });
+            if (call.name == "Int" || call.name == "Float" || call.name == "Byte")
+                && !ctx.func_ids.contains_key(&call.name)
+                && !is_same_type_variant_wrap
+                && single_arg_ty.is_some()
+            {
+                let arg_expr = match &call.args[0] {
+                    ast::Arg::Positional(e) => e,
+                    ast::Arg::Keyword { value, .. } => value,
+                    ast::Arg::Pair { value, .. } => value,
+                };
+                let arg_ty = single_arg_ty.expect("just checked is_some");
                 compileExpr(arg_expr, body, ctx, state)?;
                 match (call.name.as_str(), &arg_ty) {
                     ("Float", PlumType::TInt) => Instruction::F64ConvertI64S.encode(body),
@@ -4508,7 +4513,33 @@ fn compileExpr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
                         PlumType::TByteSlice => "ByteSlice".to_string(),
                         other => return Err(format!("codegen: cannot call method '{}' on non-class type {}", call.name, other)),
                     };
-                    let key = format!("{}::{}", class_name, call.name);
+                    let direct_key = format!("{}::{}", class_name, call.name);
+                    // Fallback: a primitive/class receiver's method might be
+                    // defined once on the "union" enum that bare-wraps it
+                    // instead (`enum Number = | Int | Float`, e.g. `abs`
+                    // defined on `Number` rather than duplicated per
+                    // primitive) — `class_name` (e.g. "Int") is itself a
+                    // registered enum-variant NAME in that case (see
+                    // `buildGlobalTables`'s bare-wrap conditions), so look up
+                    // its owning enum and retry there. `box_variant_idx` is
+                    // this variant's own concrete GC struct type index, used
+                    // below to box the raw `self` value into it before the
+                    // call (the wrap-enum's method expects a boxed `Number`,
+                    // not a bare `i64`/`f64`).
+                    let wrap_fallback = (!ctx.func_ids.contains_key(&direct_key)).then(|| {
+                        ctx.enum_variants.get(class_name.as_str()).and_then(|info| {
+                            let wrap_key = format!("{}::{}", info.enum_name, call.name);
+                            ctx.func_ids.contains_key(&wrap_key).then(|| {
+                                let variant_idx = *ctx.gc_types.variant_type_idx.get(class_name.as_str())
+                                    .expect("class_name is a registered enum variant, checked above");
+                                (info.enum_name.clone(), wrap_key, variant_idx)
+                            })
+                        })
+                    }).flatten();
+                    let (dispatch_name, key, box_variant_idx) = match wrap_fallback {
+                        Some((enum_name, wrap_key, variant_idx)) => (enum_name, wrap_key, Some(variant_idx)),
+                        None => (class_name.clone(), direct_key, None),
+                    };
                     let func_idx = *ctx
                         .func_ids
                         .get(&key)
@@ -4533,10 +4564,17 @@ fn compileExpr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
                         // bare-`TypeName` fallback doesn't know about primitives), whose
                         // `plumTypeToValtype` would wrongly resolve to a GC ref instead
                         // of `i64`.
-                        let vt = astTypeToWasm(&class_name).unwrap_or(ValType::I32);
+                        let vt = astTypeToWasm(&dispatch_name).unwrap_or(ValType::I32);
                         pushSelfPlaceholder(vt, body);
                     } else {
                         compileExpr(&attr.object, body, ctx, state)?; // push self
+                        if let Some(variant_idx) = box_variant_idx {
+                            // Dispatching to the wrap-enum's method (see
+                            // `wrap_fallback` above) — its `self` param is
+                            // typed as the ENUM (`Number`), a boxed GC struct,
+                            // not the bare primitive/class value just pushed.
+                            Instruction::StructNew(variant_idx).encode(body);
+                        }
                     }
                     fn argExprOf(arg: &ast::Arg) -> &ast::Expr {
@@ -4550,7 +4588,7 @@ fn compileExpr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
                     // trailing args into one GC array, exactly like a plain function call
                     // (see the `Expr::FnCall` variadic-call arm) — `call.args` doesn't
                     // include `self`, matching `ctx.methods`' own param list.
-                    let variadic_split = match ctx.methods.get(&(class_name.clone(), call.name.clone())) {
+                    let variadic_split = match ctx.methods.get(&(dispatch_name.clone(), call.name.clone())) {
                         Some(PlumType::TFun(params, _)) => match params.last() {
                             Some(PlumType::TVariadic(elem)) => Some(((**elem).clone(), params.len() - 1)),
                             _ => None,
@@ -4696,9 +4734,10 @@ fn compileStaticString(text: &str, body: &mut Vec<u8>, state: &mut ModuleState)
 /// Lowers a string literal that contains at least one `{expr}` interpolation.
 /// Every part becomes a string-pointer-valued expression (static text via
-/// `compileStaticString`; `Str`/`Int`/`Bool` interpolated values converted at
+/// `compileStaticString`; `Str`/`Int`/`Bool`/`Float` interpolated values
+/// converted at runtime — `Float` via `Number.toStr`, see the `TFloat` arm
-/// runtime), then all parts are left-folded together with the `__string_concat`
+/// below), then all parts are left-folded together with the
-/// runtime helper.
+/// `__string_concat` runtime helper.
 fn compileInterpolatedString(
     s: &ast::StringExpr,
     body: &mut Vec<u8>,
@@ -4731,7 +4770,23 @@ fn compileInterpolatedString(
                         Instruction::End.encode(body);
                     }
                     PlumType::TFloat => {
+                        // Reuses `Number.toStr` (`plum-std/Number.plum`) rather
+                        // than a separate hand-written float-formatting helper —
+                        // box the raw `f64` into `Number`'s `Float` variant (the
+                        // same "box self, call the wrap-enum's method" idiom
+                        // `Expr::Attribute`'s `AttrKind::Method` dispatch
+                        // fallback uses for a method call on a bare `Float`
+                        // receiver), then call it directly. Any program using
+                        // `Float` at all already must `import std/Number` (see
+                        // `plum-core::loader::checkBuiltinImports`), so these
+                        // lookups are always present.
+                        compileExpr(expr, body, ctx, state)?;
+                        let variant_idx = *ctx.gc_types.variant_type_idx.get("Float")
-                        return Err("codegen: interpolating a Float value is not yet supported".to_string());
+                            .ok_or_else(|| "codegen: interpolating a Float value requires `Number` (import std/Number)".to_string())?;
+                        Instruction::StructNew(variant_idx).encode(body);
+                        let func_idx = *ctx.func_ids.get("Number::toStr")
+                            .ok_or_else(|| "codegen: interpolating a Float value requires `Number.toStr` (import std/Number)".to_string())?;
+                        Instruction::Call(func_idx).encode(body);
                     }
                     other => {
                         return Err(format!(

scripts/test-examples.sh DELETED Viewed

@@ -1,104 +0,0 @@
-#!/usr/bin/env bash
-#
-# Integration test: compiles and runs every examples/*.plum file through the
-# REAL toolchain — the `plum` CLI binary (which resolves `import`s against
-# --lib-path, unlike plum-checker/plum-wasm-codegen's unit tests, which parse
-# and compile a single file directly) and, if available, an external
-# `wasmtime` runtime.
-#
-# This exists because the unit tests alone missed a real bug: examples/basics.plum
-# had an `import std/io` where libs/std/io.plum doesn't exist. The unit tests
-# never noticed since they don't touch plum-core's loader/import resolution at
-# all — only compiling and running through the actual CLI catches that class
-# of problem.
-#
-# Usage: scripts/test-examples.sh
-# Exit code is 0 if every example compiled (and, where checked, ran) correctly.
-set -uo pipefail
-cd "$(dirname "${BASH_SOURCE[0]}")/.."
-WORKDIR=$(mktemp -d)
-trap 'rm -rf "$WORKDIR"' EXIT
-echo "Building plum-cli..."
-if ! cargo build -p plum-cli --quiet 2>"$WORKDIR/build.log"; then
-  echo "FAIL: plum-cli failed to build" >&2
-  cat "$WORKDIR/build.log" >&2
-  exit 1
-fi
-PLUM_BIN="target/debug/plum"
-HAVE_WASMTIME=0
-if command -v wasmtime >/dev/null 2>&1; then
-  HAVE_WASMTIME=1
-else
-  echo "note: wasmtime CLI not found on PATH — will compile every example but skip running them" >&2
-fi
-# Examples that export `main` and are expected to run without trapping. Kept
-# in sync with plum-wasm-codegen/tests/examples_test.rs.
-has_main() {
-  case "$1" in
-    basics|closures|match|methods) return 0 ;;
-    *) return 1 ;;
-  esac
-}
-# Expected `main` return value for examples whose result is asserted in
-# plum-wasm-codegen/tests/examples_test.rs. Empty means "just don't trap"
-# (e.g. basics.plum's main returns Unit, not a value to compare).
-expected_value() {
-  case "$1" in
-    closures) echo 120 ;;
-    match) echo 5 ;;
-    methods) echo 10 ;;
-    *) echo "" ;;
-  esac
-}
-failed=0
-passed=0
-for src in examples/*.plum; do
-  name=$(basename "$src" .plum)
-  wasm="$WORKDIR/$name.wasm"
-  printf '%-14s compile ... ' "$name"
-  if ! "$PLUM_BIN" compile "$src" -o "$wasm" >"$WORKDIR/$name.compile.log" 2>&1; then
-    echo "FAIL"
-    sed 's/^/    /' "$WORKDIR/$name.compile.log"
-    failed=$((failed + 1))
-    continue
-  fi
-  echo "ok"
-  if [ "$HAVE_WASMTIME" -eq 1 ] && has_main "$name"; then
-    printf '%-14s run     ... ' "$name"
-    if output=$(wasmtime run --invoke main "$wasm" 2>"$WORKDIR/$name.run.log"); then
-      expected=$(expected_value "$name")
-      if [ -n "$expected" ] && [ "$output" != "$expected" ]; then
-        echo "FAIL (expected $expected, got '$output')"
-        failed=$((failed + 1))
-        continue
-      fi
-      if [ -n "$output" ]; then
-        echo "ok (-> $output)"
-      else
-        echo "ok"
-      fi
-    else
-      echo "FAIL (trapped)"
-      sed 's/^/    /' "$WORKDIR/$name.run.log"
-      failed=$((failed + 1))
-      continue
-    fi
-  fi
-  passed=$((passed + 1))
-done
-echo
-echo "$passed passed, $failed failed"
-[ "$failed" -eq 0 ]

scripts/test-plum.sh DELETED Viewed

@@ -1,65 +0,0 @@
-#!/usr/bin/env bash
-#
-# Runs every native Plum `test`/`assert` block through the REAL `plum` CLI
-# (`plum test`) — the same toolchain used by end users, not a Rust-side
-# unit-test shortcut. Most of what used to be Rust `#[test]` functions in
-# plum-wasm-codegen/tests/codegen_tests.rs (compile a snippet, run it,
-# assert on the result) now live as `test` blocks co-located with the Plum
-# source they exercise — stdlib-shaped regression tests inside
-# plum-std/*.plum itself, and core-language-feature tests inside the
-# matching examples/*.plum (closures.plum, match.plum, functions.plum,
-# types.plum, control_flow.plum) — a Plum-language behavior is verified in
-# Plum itself, not re-described in Rust.
-#
-# `plum test` follows a file's `import`s transitively (same as `plum run`), so
-# running it on one plum-std file also re-runs every test in whatever it
-# imports — harmless duplication, not a correctness issue.
-#
-# Files with no `test` block just report "no tests found" and are skipped
-# without failing the run.
-#
-# Usage: scripts/test-plum.sh
-# Exit code is 0 if every file's tests passed (or it had none).
-set -uo pipefail
-cd "$(dirname "${BASH_SOURCE[0]}")/.."
-echo "Building plum-cli..."
-if ! cargo build -p plum-cli --quiet 2>/tmp/plum-test-plum-build.log; then
-  echo "FAIL: plum-cli failed to build" >&2
-  cat /tmp/plum-test-plum-build.log >&2
-  exit 1
-fi
-PLUM_BIN="target/debug/plum"
-# Known-incomplete stdlib modules that don't compile yet at all (regex/http
-# are documented as deferred in README's "Known gaps") — skipped here so this
-# script stays a useful pass/fail gate instead of always failing for reasons
-# unrelated to `test`/`assert` regressions.
-is_known_incomplete() {
-  case "$(basename "$1")" in
-    Http.plum) return 0 ;;
-    *) return 1 ;;
-  esac
-}
-failed=0
-files_run=0
-for src in plum-std/*.plum examples/*.plum; do
-  [ -f "$src" ] || continue
-  if is_known_incomplete "$src"; then
-    echo "=== $src === (skipped: known incomplete, see README's Known gaps)"
-    continue
-  fi
-  echo "=== $src ==="
-  if ! "$PLUM_BIN" test "$src"; then
-    failed=$((failed + 1))
-  fi
-  files_run=$((files_run + 1))
-  echo
-done
-echo "$((files_run - failed))/$files_run files passed"
-[ "$failed" -eq 0 ]