73b5e55 | plum | pyrossh

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

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

73b5e55 — Peter John 2026-09-04T20:39:27+05:30

feat(plum): make Bool an ordinary import-gated enum, no hardcoded prelude

Files changed (36) hide show

examples/basics.plum +1 -0
examples/closures.plum +1 -0
examples/control_flow.plum +1 -0
examples/dop_visitor.plum +1 -0
examples/functions.plum +1 -0
examples/io.plum +1 -0
examples/match.plum +1 -0
examples/methods.plum +1 -0
examples/oop_visitor.plum +1 -0
examples/strings.plum +2 -0
examples/testing.plum +1 -0
examples/types.plum +1 -0
libs/std/Array.plum +1 -0
libs/std/Buffer.plum +1 -0
libs/std/Byte.plum +1 -0
libs/std/ByteSlice.plum +1 -0
libs/std/Err.plum +1 -0
libs/std/Float.plum +1 -0
libs/std/Int.plum +1 -0
libs/std/Json.plum +1 -0
libs/std/List.plum +1 -0
libs/std/Map.plum +1 -0
libs/std/Option.plum +1 -0
libs/std/Result.plum +1 -0
libs/std/Str.plum +1 -0
libs/std/Time.plum +1 -0
libs/std/Uuid.plum +1 -0
libs/std/encoding/Base64.plum +1 -0
libs/std/http.plum +1 -0
libs/std/os.plum +1 -0
libs/std/testing.plum +1 -0
plum-checker/src/lib.rs +22 -22
plum-checker/tests/checker_tests.rs +17 -1
plum-checker/tests/examples_test.rs +12 -18
plum-wasm-codegen/src/lib.rs +5 -21
plum-wasm-codegen/tests/codegen_tests.rs +16 -3

examples/basics.plum CHANGED Viewed

@@ -1,4 +1,5 @@
 module basics
+import std/Bool
 MAX_RETRIES = 3
 GOLDEN_RATIO = 1.61803

examples/closures.plum CHANGED Viewed

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

examples/control_flow.plum CHANGED Viewed

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

examples/dop_visitor.plum CHANGED Viewed

@@ -37,6 +37,7 @@
 #     for anything that needs to treat the shapes polymorphically.
 import std/os
+import std/Bool
 enum Rating =
   | Good(name: Str)

examples/functions.plum CHANGED Viewed

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

examples/io.plum CHANGED Viewed

@@ -1,4 +1,5 @@
 import std/Str
+import std/Bool
 # `printLn` mirrors `libs/std/os.plum`'s declaration; redeclared locally (rather
 # than `import std/os`) so this stays a self-contained example for the

examples/match.plum CHANGED Viewed

@@ -1,4 +1,5 @@
 import std/Option
+import std/Bool
 enum Color =
   | Red

examples/methods.plum CHANGED Viewed

@@ -1,4 +1,5 @@
 import std/Str
+import std/Bool
 type Cat =
   name: Str

examples/oop_visitor.plum CHANGED Viewed

@@ -30,6 +30,7 @@
 #     which is a real cost specific to this language.
 import std/os
+import std/Bool
 enum Rating =
   | Good(name: Str)

examples/strings.plum CHANGED Viewed

@@ -1,3 +1,5 @@
+import std/Bool
 fun greet(name: Str) -> Str =
   "Hello, {name}!"

examples/testing.plum CHANGED Viewed

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

examples/types.plum CHANGED Viewed

@@ -1,4 +1,5 @@
 import std/Option
+import std/Bool
 type Point =
   x: Int

libs/std/Array.plum CHANGED Viewed

@@ -1,4 +1,5 @@
 module std
+import std/Bool
 # 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`,

libs/std/Buffer.plum CHANGED Viewed

@@ -1,6 +1,7 @@
 module std
 import std/ByteSlice
 import std/Str
+import std/Bool
 # 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

libs/std/Byte.plum CHANGED Viewed

@@ -1,5 +1,6 @@
 module std
 import std/Int
+import std/Bool
 # Byte is an unsigned 8-bit value (0-255) — Plum's counterpart to Go's
 # `byte`/`uint8`. `Byte(x)` converts an `Int` (wrapping, not trapping, if `x`

libs/std/ByteSlice.plum CHANGED Viewed

@@ -1,6 +1,7 @@
 module std
 import std/Byte
 import std/Str
+import std/Bool
 # 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

libs/std/Err.plum CHANGED Viewed

@@ -1,4 +1,5 @@
 module std
+import std/Bool
 # This is used to represent an error value across the language
 trait Err =

libs/std/Float.plum CHANGED Viewed

@@ -2,6 +2,7 @@ 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

libs/std/Int.plum CHANGED Viewed

@@ -2,6 +2,7 @@ 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

libs/std/Json.plum CHANGED Viewed

@@ -9,6 +9,7 @@ import std/Float
 import std/Str
 import std/Buffer
 import std/Err
+import std/Bool
 # A parsed JSON value. Numbers are always stored as `Float` (JSON doesn't
 # distinguish integers from floats the way Plum does), and `JsonList`/

libs/std/List.plum CHANGED Viewed

@@ -3,6 +3,7 @@ module std
 import std/Option
 import std/Buffer
 import std/Int
+import std/Bool
 # A node stores the data in a list and contains pointers to the previous and next sibling nodes
 type Node[T] =

libs/std/Map.plum CHANGED Viewed

@@ -2,6 +2,7 @@ module std
 import std/List
 import std/Option
 import std/Array
+import std/Bool
 # Any type usable as a `Map` key needs a `hash`, so keys landing in different
 # buckets (`hash(k) % BUCKET_COUNT`) can be told apart in O(1) without a full

libs/std/Option.plum CHANGED Viewed

@@ -2,6 +2,7 @@ module std
 import std/Result
 import std/Str
+import std/Bool
 # 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.

libs/std/Result.plum CHANGED Viewed

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

libs/std/Str.plum CHANGED Viewed

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

libs/std/Time.plum CHANGED Viewed

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

libs/std/Uuid.plum CHANGED Viewed

@@ -2,6 +2,7 @@ module std
 import std/Int
 import std/Result
 import std/Str
+import std/Bool
 # A UUID, stored as its canonical 36-character
 # `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx` text form.

libs/std/encoding/Base64.plum CHANGED Viewed

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

libs/std/http.plum CHANGED Viewed

@@ -7,6 +7,7 @@ import std/Map
 import std/Option
 import std/Result
 import std/Str
+import std/Bool
 # An HTTP response: status code, response headers, and the raw response
 # body as a `Str` (a byte array, so binary bodies round-trip intact).

libs/std/os.plum CHANGED Viewed

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

libs/std/testing.plum CHANGED Viewed

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

plum-checker/src/lib.rs CHANGED Viewed

@@ -63,6 +63,13 @@ pub fn unify(t1: &PlumType, t2: &PlumType) -> Result<(), String> {
         // the same real type spelled two different ways depending on how the
         // checker reached it, so they must unify with each other too.
         (PlumType::TStr, PlumType::TNamed(n)) | (PlumType::TNamed(n), PlumType::TStr) if n == "Str" => Ok(()),
+        // Same reasoning as `Str` above — `Bool` is an ordinary enum now
+        // (`enum Bool = | True | False` in `libs/std/Bool.plum`), so a bare
+        // `True`/`False`/`Ok(...)`-wrapped-variant reference can infer as
+        // `TNamed("Bool")` (via `EnumVariantInfo`/`bareVariantWrapType`)
+        // while a `Bool` type ANNOTATION resolves via `plumTypeFromName` to
+        // the dedicated `TBool` variant instead.
+        (PlumType::TBool, PlumType::TNamed(n)) | (PlumType::TNamed(n), PlumType::TBool) if n == "Bool" => Ok(()),
         (PlumType::TByte, PlumType::TByte) => Ok(()),
         (PlumType::TByteSlice, PlumType::TByteSlice) => Ok(()),
         (PlumType::TUnit, PlumType::TUnit) => Ok(()),
@@ -158,10 +165,6 @@ pub fn buildGlobalTables(source: &ast::Source) -> (TypeEnv, ClassEnv, MethodEnv,
     let mut methods: MethodEnv = BTreeMap::new();
     let mut enum_variants: EnumVariants = BTreeMap::new();
     let mut enum_params: EnumParams = BTreeMap::new();
-    // `Bool`'s variants are built in (see `inferExpr`'s TypeName handling) rather
-    // than requiring every source file to redeclare `enum Bool = | True | False`.
-    enum_variants.insert("True".to_string(), EnumVariantInfo { enum_name: "Bool".to_string(), tag: 1, field_types: vec![], field_names: vec![], values: vec![] });
-    enum_variants.insert("False".to_string(), EnumVariantInfo { enum_name: "Bool".to_string(), tag: 0, field_types: vec![], field_names: vec![], values: vec![] });
     // First pass: register class fields, THEN enum variants, so a bare variant
     // (`| FantasyBook`, no `[...]` payload) that names an already-declared
@@ -179,15 +182,6 @@ pub fn buildGlobalTables(source: &ast::Source) -> (TypeEnv, ClassEnv, MethodEnv,
     }
     for item in &source.items {
         match item {
-            // `Bool` may be re-"declared" (`enum Bool = | True | False`) purely to
-            // give it a nesting site for methods (`and`/`or`/`parse`/...) — the
-            // language currently has no other way to attach a method to a builtin
-            // type (see `libs/std/int.plum`/`float.plum`'s own `type Int =`/`type
-            // Float =` for the same pattern). Re-registering its variants here
-            // would silently overwrite the hardcoded tags above with whatever
-            // order this declaration happens to list them in, flipping every
-            // `True`/`False` tag used throughout the rest of the codegen. Skip.
-            ast::Item::Enum(e) if e.name == "Bool" => {}
             ast::Item::Enum(e) => {
                 let shared_field_types: Vec<PlumType> = e.params.iter()
                     .map(|p| plumTypeFromAst(&p.ty))
@@ -1015,15 +1009,21 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
         // const (`PI`, `MAX_VALUE`, ...), since there's no separate "constant"
         // token. Prefer a matching const's real type over the enum-variant/
         // unmodeled-type-name fallbacks below.
-        ast::Expr::TypeName(n) => match n.as_str() {
+        ast::Expr::TypeName(n) => match lookup(env, n) {
-            "True" | "False" => Ok(PlumType::TBool),
-            _ => match lookup(env, n) {
-                Ok(ty) if !matches!(ty, PlumType::TVar(_)) => Ok(ty),
+            Ok(ty) if !matches!(ty, PlumType::TVar(_)) => Ok(ty),
-                _ => match ctx.enum_variants.get(n) {
+            _ => match ctx.enum_variants.get(n) {
+                // `Bool` normalizes to the dedicated `TBool` variant (not
+                // `TNamed("Bool")`) — `True`/`False` only resolve here at all
+                // once `enum Bool = | True | False` (`libs/std/Bool.plum`) is
+                // actually imported, but every OTHER part of the checker AND
+                // `plum-wasm-codegen` (which reuses `inferExpr` via
+                // `inferLocalType`) still branches on the literal `TBool`
+                // variant, not a generic `TNamed` name — normalizing here
+                // keeps that working without patching every such site.
+                Some(info) if info.enum_name == "Bool" => Ok(PlumType::TBool),
-                    Some(info) => Ok(PlumType::TNamed(info.enum_name.clone())),
+                Some(info) => Ok(PlumType::TNamed(info.enum_name.clone())),
-                    // Unmodeled/builtin type name: allow, codegen will catch.
+                // Unmodeled/builtin type name: allow, codegen will catch.
-                    None => Ok(PlumType::TNamed(n.to_string())),
+                None => Ok(PlumType::TNamed(n.to_string())),
-                },
             },
         },
         ast::Expr::Paren(inner) => inferExpr(inner, env, ctx),

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -114,7 +114,7 @@ fn typeMismatchInBinaryOpIsError() {
 #[test]
 fn boolLiteralTrueFalseAreBool() {
-    let src = "fun isTrue() -> Bool =\n  True\n";
+    let src = "enum Bool =\n  | True\n  | False\n\nfun isTrue() -> Bool =\n  True\n";
     let source = parse(src);
     assert!(checkSource(&source).is_ok(), "expected Ok, got {:?}", checkSource(&source).err());
 }
@@ -490,6 +490,10 @@ fun makeStrBox() -> Box =
 #[test]
 fn genericFunctionCalledWithDifferentConcreteTypesPerSiteTypeChecks() {
     let src = "\
+enum Bool =
+  | True
+  | False
 fun wrap(value: T) -> Bool =
   True
@@ -507,6 +511,10 @@ fun useStr() -> Bool =
 #[test]
 fn genericFunctionWithTwoIndependentTypeParamsTypeChecks() {
     let src = "\
+enum Bool =
+  | True
+  | False
 fun pair(first: T, second: U) -> Bool =
   True
@@ -730,6 +738,10 @@ fun use() -> Int =
 #[test]
 fn closureLiteralInfersAsAFunctionType() {
     let src = "\
+enum Bool =
+  | True
+  | False
 fun useClosure() -> Bool =
   cb = |v|
     True
@@ -798,6 +810,10 @@ type Cat =
 #[test]
 fn closurePassedToFnValueTypedParamTypeChecks() {
     let src = "\
+enum Bool =
+  | True
+  | False
 fun each(cb: fn(Int) -> Bool) -> Bool =
   cb(5)

plum-checker/tests/examples_test.rs CHANGED Viewed

@@ -1,11 +1,14 @@
 #![allow(non_snake_case)]
 use plum_checker::checkSource;
-use plum_core::AstParser;
 fn examplesDir() -> std::path::PathBuf {
     std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../examples")
 }
+fn libPath() -> std::path::PathBuf {
+    std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../libs")
+}
 fn exampleFiles() -> Vec<std::path::PathBuf> {
     let mut files: Vec<_> = std::fs::read_dir(examplesDir())
         .expect("examples/ directory should exist")
@@ -18,26 +21,17 @@ fn exampleFiles() -> Vec<std::path::PathBuf> {
     files
 }
-/// Every example must parse with zero ERROR/MISSING nodes and pass `checkSource`.
+/// Every example must load (resolving its own `import`s against `../libs`,
+/// the real compilation path — several examples now genuinely `import` real
+/// stdlib types like `std/Bool`/`std/Str`, so a bare single-file parse would
+/// leave those names undeclared) and pass `checkSource`. These files exist
-/// These files exist specifically to prove each piece of the currently-supported
+/// specifically to prove each piece of the currently-supported grammar
-/// grammar surface actually works end to end, not just in isolated unit tests.
+/// surface actually works end to end, not just in isolated unit tests.
 #[test]
 fn everyExampleParsesAndTypeChecks() {
-    let mut parser = tree_sitter::Parser::new();
-    parser.set_language(&tree_sitter_plum::LANGUAGE.into()).unwrap();
     for path in exampleFiles() {
+        let source = plum_core::loadAndMerge(&path, &libPath())
-        let src = std::fs::read_to_string(&path).unwrap_or_else(|e| panic!("failed to read {}: {}", path.display(), e));
+            .unwrap_or_else(|e| panic!("failed to load {}: {}", path.display(), e));
-        let tree = parser.parse(&src, None).unwrap_or_else(|| panic!("failed to parse {}", path.display()));
-        assert!(
-            !tree.root_node().has_error(),
-            "{} has a parse error:\n{}",
-            path.display(),
-            tree.root_node().to_sexp()
-        );
-        let ap = AstParser::new(&src);
-        let source = ap.parseSource(tree.root_node());
         let result = checkSource(&source);
         assert!(
             result.is_ok(),

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

@@ -742,29 +742,13 @@ fn buildGcTypeRegistry(
         }
     }
-    // Bool is built into `EnumVariants` (True/False) by `buildGlobalTables` with no
+    // `Bool` is an ordinary enum now (`type Bool = | True | False` in
-    // `ast::Item::Enum` of its own (see `docs/superpowers/plans/2026-07-25-wasm-gc-migration.md`'s
-    // Decision 1: Bool is a full wasm-gc struct, no special-casing) — register it
+    // `libs/std/Bool.plum`) — registered exactly like any other enum
-    // exactly like a real enum here, ahead of whatever the source actually declares.
+    // declared in `source.items`, present only if actually imported.
-    let mut enum_decls: Vec<(String, Vec<String>)> =
+    let mut enum_decls: Vec<(String, Vec<String>)> = Vec::new();
-        vec![("Bool".to_string(), vec!["False".to_string(), "True".to_string()])];
     for item in &source.items {
-        // A source file may re-"declare" `enum Bool = | True | False` purely to
-        // give it a nesting site for methods (no other way exists to attach a
-        // method to a builtin type) — see the identical skip, with the full
-        // rationale, in `plum-checker`'s `buildGlobalTables`. Registering it
-        // again here would give Bool a SECOND, orphaned GC struct (the first,
-        // hardcoded one is still referenced by every OTHER already-registered
-        // slot/type by index) and — worse — since slot assignment for a
-        // specialized generic enum with a `Bool` field (e.g. `Result[Bool,
-        // Str]`) resolves "Bool" by NAME at the point it's compiled, later
-        // duplicate registrations can leave that field pointing at whichever
-        // Bool slot was assigned last, an index that isn't guaranteed to
-        // satisfy wasm-gc's "supertypes before subtypes" ordering rule.
         if let ast::Item::Enum(e) = item {
-            if e.name != "Bool" {
-                enum_decls.push((e.name.clone(), e.variants.iter().map(|v| v.name.clone()).collect()));
+            enum_decls.push((e.name.clone(), e.variants.iter().map(|v| v.name.clone()).collect()));
-            }
         }
     }
     for (enum_name, variant_names) in &enum_decls {

plum-wasm-codegen/tests/codegen_tests.rs CHANGED Viewed

@@ -47,6 +47,10 @@ fn outputValidates() {
 #[test]
 fn factorialCompiles() {
     let src = "\
+enum Bool =
+  | True
+  | False
 fun factorial(x: Int) -> Int =
   if x < 2
     return 1
@@ -92,6 +96,10 @@ fn readStrResult(store: &mut wasmtime::Store<()>, val: &wasmtime::Val) -> String
 #[test]
 fn testBlocksCompileAndRun() {
     let src = "\
+enum Bool =
+  | True
+  | False
 fun add(a: Int, b: Int) -> Int =
   a + b
@@ -166,8 +174,9 @@ fn assertValid(src: &str) -> Vec<u8> {
 #[test]
 fn boolLiteralsCompile() {
+    let boolDecl = "enum Bool =\n  | True\n  | False\n\n";
-    assertValid("fun main() -> Bool =\n  True\n");
+    assertValid(&format!("{}fun main() -> Bool =\n  True\n", boolDecl));
-    assertValid("fun main() -> Bool =\n  False\n");
+    assertValid(&format!("{}fun main() -> Bool =\n  False\n", boolDecl));
 }
 #[test]
@@ -252,7 +261,7 @@ fn matchInlineCaseBodyCompiles() {
 #[test]
 fn matchBoolVariantPatternCompiles() {
-    let src = "fun main(a: Bool) -> Int =\n  match a\n    True =>\n      return 1\n    False =>\n      return 0\n";
+    let src = "enum Bool =\n  | True\n  | False\n\nfun main(a: Bool) -> Int =\n  match a\n    True =>\n      return 1\n    False =>\n      return 0\n";
     assertValid(src);
 }
@@ -272,6 +281,10 @@ fn matchStringPatternIsAClearError() {
 #[test]
 fn assertTrapsOnFalse() {
     let src_trap = "\
+enum Bool =
+  | True
+  | False
 fun check(n: Int) -> Int =
   assert n > 0
   n