ac67871 | plum | pyrossh

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

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

ac67871 — Peter John 2026-10-26T11:04:01+05:30

feat: narrow Int to i32 at extern boundaries; remove Bool.plum

Files changed (41) hide show

README.md +1 -1
plum-cli/src/main.rs +18 -18
plum-core/src/loader.rs +28 -0
plum-examples/basics.plum +0 -1
plum-examples/closures.plum +0 -1
plum-examples/control_flow.plum +0 -1
plum-examples/dop_visitor.plum +0 -1
plum-examples/error_propagation.plum +0 -1
plum-examples/functions.plum +0 -1
plum-examples/generics.plum +0 -1
plum-examples/io.plum +0 -1
plum-examples/match.plum +0 -1
plum-examples/methods.plum +0 -1
plum-examples/numbers.plum +0 -1
plum-examples/oop_visitor.plum +0 -1
plum-examples/safe_navigation.plum +0 -1
plum-examples/strings.plum +0 -1
plum-examples/testing.plum +0 -1
plum-examples/traits.plum +0 -1
plum-examples/types.plum +0 -1
plum-runtime/src/main.rs +16 -16
plum-std/Array.plum +0 -1
plum-std/Base64.plum +0 -1
plum-std/Bool.plum +0 -27
plum-std/Buffer.plum +0 -1
plum-std/Byte.plum +0 -1
plum-std/ByteSlice.plum +0 -1
plum-std/Http.plum +0 -1
plum-std/Json.plum +0 -1
plum-std/List.plum +0 -1
plum-std/Map.plum +0 -1
plum-std/Number.plum +14 -2
plum-std/Os.plum +0 -1
plum-std/Str.plum +21 -1
plum-std/Testing.plum +0 -1
plum-std/Time.plum +6 -3
plum-std/Try.plum +0 -1
plum-std/Uuid.plum +0 -1
plum-wasm-codegen/src/lib.rs +45 -3
plum-wasm-codegen/tests/codegen_tests.rs +85 -7
plum-wasm-codegen/tests/examples_test.rs +4 -4

README.md CHANGED Viewed

@@ -471,7 +471,7 @@ It's sugar for `obj.map(|v| v.field)` — nothing more than that; chain it as ma
 ## Standard library highlights
-- **`Bool`** (`import std/Bool`) — ordinary `enum Bool = | True | False`
+- **`Bool`** — built in (no import); `True`/`False`, `toStr` is a compiler intrinsic, `"true".parseBool()` (in `std/Str`) parses it
 - **`Try[T, E]`** (`import std/Try`) — `Ok(T)` or `Err(E)`; `isOk`/`isErr`/`unwrap`/`unwrapOr`/`unwrapOrElse`/`map`/`mapErr`/`andThen`
 - **`Str`** (`import std/Str`) — a byte array with a codepoint-aware layer for Unicode correctness: `runeLength`, `runeAt`, `codePointAt`, `codePointToStr`
 - **`Byte`** / **`[]Byte`** (`import std/Byte`) — a scalar unsigned 8-bit value and a fixed-length mutable byte slice

plum-cli/src/main.rs CHANGED Viewed

@@ -255,15 +255,15 @@ fn hostImports(
                         },
                     )))
                 }
-                ("plum", "rawRandomInt") => {
+                ("plum", "rawRandomHalf") => {
                     let func_ty = imp.ty().func().cloned().ok_or_else(|| {
-                        anyhow::anyhow!("plum::rawRandomInt import must be a function")
+                        anyhow::anyhow!("plum::rawRandomHalf import must be a function")
                     })?;
                     Ok(wasmtime::Extern::Func(wasmtime::Func::new(
                         &mut *store,
                         func_ty,
                         |_caller, _params, results| {
-                            results[0] = wasmtime::Val::I64(randomI64());
+                            results[0] = wasmtime::Val::I32((randomI64() >> 32) as i32);
                             Ok(())
                         },
                     )))
@@ -276,7 +276,7 @@ fn hostImports(
                         &mut *store,
                         func_ty,
                         |_caller, _params, results| {
-                            results[0] = wasmtime::Val::I64(nowMillis());
+                            results[0] = wasmtime::Val::F64((nowMillis() as f64).to_bits());
                             Ok(())
                         },
                     )))
@@ -311,7 +311,7 @@ fn hostImports(
                             let path = readStrArg(&mut caller, &params[0])?;
                             let data = readStrArg(&mut caller, &params[1])?;
                             results[0] =
-                                wasmtime::Val::I64(std::fs::write(&path, &data).is_ok() as i64);
+                                wasmtime::Val::I32(std::fs::write(&path, &data).is_ok() as i32);
                             Ok(())
                         },
                     )))
@@ -330,7 +330,7 @@ fn hostImports(
                             // otherwise `remove` on a broken symlink would report "no such file"
                             // and never get to call `rawRemove` on the symlink itself.
                             results[0] =
-                                wasmtime::Val::I64(std::fs::symlink_metadata(&path).is_ok() as i64);
+                                wasmtime::Val::I32(std::fs::symlink_metadata(&path).is_ok() as i32);
                             Ok(())
                         },
                     )))
@@ -345,7 +345,7 @@ fn hostImports(
                         |mut caller, params, results| {
                             let path = readStrArg(&mut caller, &params[0])?;
                             results[0] =
-                                wasmtime::Val::I64(std::fs::create_dir_all(&path).is_ok() as i64);
+                                wasmtime::Val::I32(std::fs::create_dir_all(&path).is_ok() as i32);
                             Ok(())
                         },
                     )))
@@ -360,7 +360,7 @@ fn hostImports(
                         |mut caller, params, results| {
                             let path = readStrArg(&mut caller, &params[0])?;
                             results[0] =
-                                wasmtime::Val::I64(std::fs::remove_file(&path).is_ok() as i64);
+                                wasmtime::Val::I32(std::fs::remove_file(&path).is_ok() as i32);
                             Ok(())
                         },
                     )))
@@ -375,7 +375,7 @@ fn hostImports(
                         |mut caller, params, results| {
                             let path = readStrArg(&mut caller, &params[0])?;
                             results[0] =
-                                wasmtime::Val::I64(std::fs::remove_dir(&path).is_ok() as i64);
+                                wasmtime::Val::I32(std::fs::remove_dir(&path).is_ok() as i32);
                             Ok(())
                         },
                     )))
@@ -390,8 +390,8 @@ fn hostImports(
                         |mut caller, params, results| {
                             let old_path = readStrArg(&mut caller, &params[0])?;
                             let new_path = readStrArg(&mut caller, &params[1])?;
-                            results[0] = wasmtime::Val::I64(
+                            results[0] = wasmtime::Val::I32(
-                                std::fs::rename(&old_path, &new_path).is_ok() as i64,
+                                std::fs::rename(&old_path, &new_path).is_ok() as i32,
                             );
                             Ok(())
                         },
@@ -406,7 +406,7 @@ fn hostImports(
                         func_ty,
                         |mut caller, params, results| {
                             let path = readStrArg(&mut caller, &params[0])?;
-                            let wasmtime::Val::I64(len) = params[1] else {
+                            let wasmtime::Val::I32(len) = params[1] else {
                                 return Err(wasmtime::Error::msg(
                                     "rawTruncate expects an Int length argument",
                                 ));
@@ -416,7 +416,7 @@ fn hostImports(
                                 .open(&path)
                                 .and_then(|f| f.set_len(len.max(0) as u64))
                                 .is_ok();
-                            results[0] = wasmtime::Val::I64(ok as i64);
+                            results[0] = wasmtime::Val::I32(ok as i32);
                             Ok(())
                         },
                     )))
@@ -431,8 +431,8 @@ fn hostImports(
                         |mut caller, params, results| {
                             let existing_path = readStrArg(&mut caller, &params[0])?;
                             let new_path = readStrArg(&mut caller, &params[1])?;
-                            results[0] = wasmtime::Val::I64(
+                            results[0] = wasmtime::Val::I32(
-                                std::fs::hard_link(&existing_path, &new_path).is_ok() as i64,
+                                std::fs::hard_link(&existing_path, &new_path).is_ok() as i32,
                             );
                             Ok(())
                         },
@@ -452,7 +452,7 @@ fn hostImports(
                             let ok = std::os::unix::fs::symlink(&target, &path).is_ok();
                             #[cfg(not(unix))]
                             let ok = false;
-                            results[0] = wasmtime::Val::I64(ok as i64);
+                            results[0] = wasmtime::Val::I32(ok as i32);
                             Ok(())
                         },
                     )))
@@ -510,7 +510,7 @@ fn hostImports(
                         func_ty,
                         |mut caller, params, results| {
                             let path = readStrArg(&mut caller, &params[0])?;
-                            let wasmtime::Val::I64(mode) = params[1] else {
+                            let wasmtime::Val::I32(mode) = params[1] else {
                                 return Err(wasmtime::Error::msg(
                                     "rawChmod expects an Int mode argument",
                                 ));
@@ -526,7 +526,7 @@ fn hostImports(
                             };
                             #[cfg(not(unix))]
                             let ok = false;
-                            results[0] = wasmtime::Val::I64(ok as i64);
+                            results[0] = wasmtime::Val::I32(ok as i32);
                             Ok(())
                         },
                     )))

plum-core/src/loader.rs CHANGED Viewed

@@ -57,6 +57,8 @@ pub fn loadAndMergeWithOverrides(
         )?;
     }
+    injectBoolIntrinsics(&mut items);
     Ok(Source {
         module: entry_source.module,
         imports: entry_source.imports,
@@ -65,6 +67,32 @@ pub fn loadAndMergeWithOverrides(
     })
 }
+/// `Bool` is a built-in i32 with no source file; its one method, `toStr`
+/// ("True"/"False" — the same text string interpolation emits), is a compiler
+/// intrinsic. It is supplied as a synthetic method item so the checker, `ToStr`
+/// trait conformance, dyn dispatch and codegen all see an ordinary method. Only
+/// injected once `Str` is in the program (the method returns `Str`).
+fn injectBoolIntrinsics(items: &mut Vec<Item>) {
+    let has_str = items
+        .iter()
+        .any(|i| matches!(i, Item::Enum(e) if e.name == "Str"));
+    if !has_str {
+        return;
+    }
+    const SNIPPET: &str = "enum Bool =\n  | Bool\n\n  fun toStr(self) -> Str =\n    self ? \"True\" : \"False\"\n";
+    let mut parser = tree_sitter::Parser::new();
+    parser
+        .set_language(&tree_sitter_plum::LANGUAGE.into())
+        .expect("plum grammar loads");
+    let tree = parser.parse(SNIPPET, None).expect("intrinsic snippet parses");
+    let source = AstParser::new(SNIPPET).parseSource(tree.root_node());
+    for item in source.items {
+        if let Item::Fn(f) = item {
+            items.push(Item::Fn(f));
+        }
+    }
+}
 fn canonicalizeMaybeMissing(path: &Path) -> Result<PathBuf, String> {
     if let Ok(canon) = std::fs::canonicalize(path) {
         return Ok(canon);

plum-examples/basics.plum CHANGED Viewed

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

plum-examples/closures.plum CHANGED Viewed

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

plum-examples/control_flow.plum CHANGED Viewed

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

plum-examples/dop_visitor.plum CHANGED Viewed

@@ -37,7 +37,6 @@
 #     for anything that needs to treat the shapes polymorphically.
 import std/Os
-import std/Bool
 import std/Number
 import std/Str

plum-examples/error_propagation.plum CHANGED Viewed

@@ -1,5 +1,4 @@
 import std/Try
-import std/Bool
 import std/Number
 import std/Str
 import std/List

plum-examples/functions.plum CHANGED Viewed

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

plum-examples/generics.plum CHANGED Viewed

@@ -1,7 +1,6 @@
 module generics
 import std/Str
 import std/Number
-import std/Bool
 import std/List
 import std/Map
 import std/Try

plum-examples/io.plum CHANGED Viewed

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

plum-examples/match.plum CHANGED Viewed

@@ -1,5 +1,4 @@
 import std/Try
-import std/Bool
 import std/Number
 import std/Str

plum-examples/methods.plum CHANGED Viewed

@@ -1,5 +1,4 @@
 import std/Str
-import std/Bool
 import std/Number
 enum Cat =

plum-examples/numbers.plum CHANGED Viewed

@@ -1,4 +1,3 @@
-import std/Bool
 import std/Str
 import std/Number

plum-examples/oop_visitor.plum CHANGED Viewed

@@ -30,7 +30,6 @@
 #     which is a real cost specific to this language.
 import std/Os
-import std/Bool
 import std/Number
 import std/Str

plum-examples/safe_navigation.plum CHANGED Viewed

@@ -1,5 +1,4 @@
 import std/Try
-import std/Bool
 import std/Number
 import std/Str
 # `obj?.field` / `obj?.method(args)` — Groovy/Kotlin-style safe navigation.

plum-examples/strings.plum CHANGED Viewed

@@ -1,4 +1,3 @@
-import std/Bool
 import std/Number
 import std/Str

plum-examples/testing.plum CHANGED Viewed

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

plum-examples/traits.plum CHANGED Viewed

@@ -1,4 +1,3 @@
-import std/Bool
 import std/Str
 import std/Number
 import std/Try

plum-examples/types.plum CHANGED Viewed

@@ -1,5 +1,4 @@
 import std/Try
-import std/Bool
 import std/Str
 import std/Number

plum-runtime/src/main.rs CHANGED Viewed

@@ -45,17 +45,17 @@ fn hostImports(store: &mut wasmtime::Store<()>, module: &wasmtime::Module) -> Ve
                     Ok(())
                 }))
             }
-            ("plum", "rawRandomInt") => {
+            ("plum", "rawRandomHalf") => {
-                let func_ty = imp.ty().func().cloned().expect("plum::rawRandomInt import should be a function");
+                let func_ty = imp.ty().func().cloned().expect("plum::rawRandomHalf import should be a function");
                 wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty, |_caller, _params, results| {
-                    results[0] = wasmtime::Val::I64(randomI64());
+                    results[0] = wasmtime::Val::I32((randomI64() >> 32) as i32);
                     Ok(())
                 }))
             }
             ("plum", "rawNowMillis") => {
                 let func_ty = imp.ty().func().cloned().expect("plum::rawNowMillis import should be a function");
                 wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty, |_caller, _params, results| {
-                    results[0] = wasmtime::Val::I64(nowMillis());
+                    results[0] = wasmtime::Val::F64((nowMillis() as f64).to_bits());
                     Ok(())
                 }))
             }
@@ -73,7 +73,7 @@ fn hostImports(store: &mut wasmtime::Store<()>, module: &wasmtime::Module) -> Ve
                 wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty, |mut caller, params, results| {
                     let path = readStrArg(&mut caller, &params[0])?;
                     let data = readStrArg(&mut caller, &params[1])?;
-                    results[0] = wasmtime::Val::I64(std::fs::write(&path, &data).is_ok() as i64);
+                    results[0] = wasmtime::Val::I32(std::fs::write(&path, &data).is_ok() as i32);
                     Ok(())
                 }))
             }
@@ -83,7 +83,7 @@ fn hostImports(store: &mut wasmtime::Store<()>, module: &wasmtime::Module) -> Ve
                     let path = readStrArg(&mut caller, &params[0])?;
                     // See the identical `rawExists` in plum-cli for why this uses
                     // `symlink_metadata` rather than `Path::exists`.
-                    results[0] = wasmtime::Val::I64(std::fs::symlink_metadata(&path).is_ok() as i64);
+                    results[0] = wasmtime::Val::I32(std::fs::symlink_metadata(&path).is_ok() as i32);
                     Ok(())
                 }))
             }
@@ -91,7 +91,7 @@ fn hostImports(store: &mut wasmtime::Store<()>, module: &wasmtime::Module) -> Ve
                 let func_ty = imp.ty().func().cloned().expect("plum::rawMkdir import should be a function");
                 wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty, |mut caller, params, results| {
                     let path = readStrArg(&mut caller, &params[0])?;
-                    results[0] = wasmtime::Val::I64(std::fs::create_dir_all(&path).is_ok() as i64);
+                    results[0] = wasmtime::Val::I32(std::fs::create_dir_all(&path).is_ok() as i32);
                     Ok(())
                 }))
             }
@@ -99,7 +99,7 @@ fn hostImports(store: &mut wasmtime::Store<()>, module: &wasmtime::Module) -> Ve
                 let func_ty = imp.ty().func().cloned().expect("plum::rawRemove import should be a function");
                 wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty, |mut caller, params, results| {
                     let path = readStrArg(&mut caller, &params[0])?;
-                    results[0] = wasmtime::Val::I64(std::fs::remove_file(&path).is_ok() as i64);
+                    results[0] = wasmtime::Val::I32(std::fs::remove_file(&path).is_ok() as i32);
                     Ok(())
                 }))
             }
@@ -107,7 +107,7 @@ fn hostImports(store: &mut wasmtime::Store<()>, module: &wasmtime::Module) -> Ve
                 let func_ty = imp.ty().func().cloned().expect("plum::rawRemoveDir import should be a function");
                 wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty, |mut caller, params, results| {
                     let path = readStrArg(&mut caller, &params[0])?;
-                    results[0] = wasmtime::Val::I64(std::fs::remove_dir(&path).is_ok() as i64);
+                    results[0] = wasmtime::Val::I32(std::fs::remove_dir(&path).is_ok() as i32);
                     Ok(())
                 }))
             }
@@ -116,7 +116,7 @@ fn hostImports(store: &mut wasmtime::Store<()>, module: &wasmtime::Module) -> Ve
                 wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty, |mut caller, params, results| {
                     let old_path = readStrArg(&mut caller, &params[0])?;
                     let new_path = readStrArg(&mut caller, &params[1])?;
-                    results[0] = wasmtime::Val::I64(std::fs::rename(&old_path, &new_path).is_ok() as i64);
+                    results[0] = wasmtime::Val::I32(std::fs::rename(&old_path, &new_path).is_ok() as i32);
                     Ok(())
                 }))
             }
@@ -124,12 +124,12 @@ fn hostImports(store: &mut wasmtime::Store<()>, module: &wasmtime::Module) -> Ve
                 let func_ty = imp.ty().func().cloned().expect("plum::rawTruncate import should be a function");
                 wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty, |mut caller, params, results| {
                     let path = readStrArg(&mut caller, &params[0])?;
-                    let wasmtime::Val::I64(len) = params[1] else {
+                    let wasmtime::Val::I32(len) = params[1] else {
                         return Err(wasmtime::Error::msg("rawTruncate expects an Int length argument"));
                     };
                     let ok = std::fs::OpenOptions::new().write(true).open(&path)
                         .and_then(|f| f.set_len(len.max(0) as u64)).is_ok();
-                    results[0] = wasmtime::Val::I64(ok as i64);
+                    results[0] = wasmtime::Val::I32(ok as i32);
                     Ok(())
                 }))
             }
@@ -138,7 +138,7 @@ fn hostImports(store: &mut wasmtime::Store<()>, module: &wasmtime::Module) -> Ve
                 wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty, |mut caller, params, results| {
                     let existing_path = readStrArg(&mut caller, &params[0])?;
                     let new_path = readStrArg(&mut caller, &params[1])?;
-                    results[0] = wasmtime::Val::I64(std::fs::hard_link(&existing_path, &new_path).is_ok() as i64);
+                    results[0] = wasmtime::Val::I32(std::fs::hard_link(&existing_path, &new_path).is_ok() as i32);
                     Ok(())
                 }))
             }
@@ -151,7 +151,7 @@ fn hostImports(store: &mut wasmtime::Store<()>, module: &wasmtime::Module) -> Ve
                     let ok = std::os::unix::fs::symlink(&target, &path).is_ok();
                     #[cfg(not(unix))]
                     let ok = false;
-                    results[0] = wasmtime::Val::I64(ok as i64);
+                    results[0] = wasmtime::Val::I32(ok as i32);
                     Ok(())
                 }))
             }
@@ -179,7 +179,7 @@ fn hostImports(store: &mut wasmtime::Store<()>, module: &wasmtime::Module) -> Ve
                 let func_ty = imp.ty().func().cloned().expect("plum::rawChmod import should be a function");
                 wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty, |mut caller, params, results| {
                     let path = readStrArg(&mut caller, &params[0])?;
-                    let wasmtime::Val::I64(mode) = params[1] else {
+                    let wasmtime::Val::I32(mode) = params[1] else {
                         return Err(wasmtime::Error::msg("rawChmod expects an Int mode argument"));
                     };
                     #[cfg(unix)]
@@ -189,7 +189,7 @@ fn hostImports(store: &mut wasmtime::Store<()>, module: &wasmtime::Module) -> Ve
                     };
                     #[cfg(not(unix))]
                     let ok = false;
-                    results[0] = wasmtime::Val::I64(ok as i64);
+                    results[0] = wasmtime::Val::I32(ok as i32);
                     Ok(())
                 }))
             }

plum-std/Array.plum CHANGED Viewed

@@ -1,5 +1,4 @@
 module std
-import std/Bool
 import std/Number
 # A fixed-length, O(1)-indexable array of `T`, backed directly by a wasm-gc

plum-std/Base64.plum CHANGED Viewed

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

plum-std/Bool.plum DELETED Viewed

@@ -1,27 +0,0 @@
-module std
-import std/Try
-import std/Str
-# `Bool` is a built-in primitive (a wasm i32, 0/1); `True`/`False` are always
-# available literals and need no import. This file only provides the METHODS
-# whose receiver is a `Bool` (the single-variant enum is a pure marker, exactly
-# like `Byte.plum`/`Number.plum`).
-enum Bool =
-  | Bool
-  fun parse(v: Str) -> Try[Bool, [BadBoolStr]] =
-    if v == "true"
-      Ok(True)
-    else if v == "false"
-      Ok(False)
-    else
-      Err(BadBoolStr)
-  fun and(self, o: Bool) -> Bool =
-    self && o
-  fun or(self, o: Bool) -> Bool =
-    self || o
-  fun toStr(self) -> Str =
-    self ? "True" : "False"

plum-std/Buffer.plum CHANGED Viewed

@@ -1,7 +1,6 @@
 module std
 import std/ByteSlice
 import std/Str
-import std/Bool
 import std/Number
 # A Buffer is a growable, mutable sequence of bytes for efficiently building

plum-std/Byte.plum CHANGED Viewed

@@ -1,6 +1,5 @@
 module std
 import std/Number
-import std/Bool
 import std/Str
 # Byte is an unsigned 8-bit value (0-255) — Plum's counterpart to Go's

plum-std/ByteSlice.plum CHANGED Viewed

@@ -1,7 +1,6 @@
 module std
 import std/Byte
 import std/Str
-import std/Bool
 import std/Number
 # ByteSlice is `[]Byte` — Plum's counterpart to Go's byte slice: a

plum-std/Http.plum CHANGED Viewed

@@ -6,7 +6,6 @@ import std/List
 import std/Map
 import std/Try
 import std/Str
-import std/Bool
 import std/Number
 # An HTTP response: status code, response headers, and the raw response

plum-std/Json.plum CHANGED Viewed

@@ -6,7 +6,6 @@ import std/Map
 import std/Number
 import std/Str
 import std/Buffer
-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`/

plum-std/List.plum CHANGED Viewed

@@ -4,7 +4,6 @@ import std/Try
 import std/Array
 import std/Buffer
 import std/Number
-import std/Bool
 import std/Str
 # A growable list: `data` is a backing `Array[T]` whose length is the list's

plum-std/Map.plum CHANGED Viewed

@@ -2,7 +2,6 @@ module std
 import std/List
 import std/Try
 import std/Array
-import std/Bool
 import std/Number
 import std/Str

plum-std/Number.plum CHANGED Viewed

@@ -1,6 +1,5 @@
 module std
 import std/Str
-import std/Bool
 import std/Try
 MIN_VALUE = -0x8000_0000_0000_0000 # Lowest value of Int
@@ -361,7 +360,14 @@ fun parseFloat(s: Str) -> Try[Float, [BadNumStr]] =
 # 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
+extern fun rawRandomHalf() -> Int
+# 64 random bits, assembled from two i32 halves (`Int` is narrowed to i32 at the
+# extern boundary, so the host can only hand back 32 bits per call).
+fun rawRandomInt() -> Int =
+  hi := rawRandomHalf()
+  lo := rawRandomHalf() & 0xFFFFFFFF
+  return { hi << 32 } | lo
 # A random Float uniformly distributed in [0.0, 1.0).
 fun random() -> Float =
@@ -546,3 +552,9 @@ fun cbrt(x: Float) -> Float =
     guess = {2.0f * guess + v / {guess * guess}} / 3.0f
     i = i + 1
   return neg ? -guess : guess
+test "random stays in range with 64-bit assembled from two i32 halves"
+  r := random()
+  assert r >= 0.0f && r < 1.0f
+  assert randomInt(10) >= 0 && randomInt(10) < 10
+  assert rawRandomInt() != rawRandomInt()

plum-std/Os.plum CHANGED Viewed

@@ -3,7 +3,6 @@ import std/List
 import std/Try
 import std/Str
 import std/Uuid
-import std/Bool
 import std/Number
 # NOTE: the original file modeled `stdin`/`stdout`/`stderr` as bare top-level

plum-std/Str.plum CHANGED Viewed

@@ -2,8 +2,8 @@ module std
 import std/List
 import std/Buffer
-import std/Bool
 import std/Number
+import std/Try
 # Any type that can be converted to a str needs to implement this trait
 trait ToStr =
@@ -146,6 +146,15 @@ enum Str(Comparable, ToStr, Readable, Writable) =
   fun toStr(self) -> Str =
     self
+  # Parses exactly `"true"` or `"false"`.
+  fun parseBool(self) -> Try[Bool, [BadBoolStr]] =
+    if self == "true"
+      Ok(True)
+    else if self == "false"
+      Ok(False)
+    else
+      Err(BadBoolStr)
   fun matchPattern(self, pattern: Regex) -> List[Str] =
     todo
@@ -648,3 +657,14 @@ test "reverse reverses by character, not by raw byte"
 test "escape/unescape round-trip HTML-sensitive characters"
   assert "<a href=\"x\">&'</a>".escape() == "&lt;a href=&quot;x&quot;&gt;&amp;&#39;&lt;/a&gt;"
   assert "&lt;a href=&quot;x&quot;&gt;&amp;&#39;&lt;/a&gt;".unescape() == "<a href=\"x\">&'</a>"
+test "Bool.toStr is a compiler intrinsic: True/False, also through interpolation"
+  t := True
+  assert t.toStr() == "True"
+  assert False.toStr() == "False"
+  assert "{t}-{!t}" == "True-False"
+test "Str.parseBool accepts true/false and rejects everything else"
+  assert "true".parseBool() ?? False
+  assert !{"false".parseBool() ?? True}
+  assert !{"yes".parseBool() ?? False}

plum-std/Testing.plum CHANGED Viewed

@@ -2,7 +2,6 @@ module std
 import std/Try
 import std/List
-import std/Bool
 import std/Number
 import std/Str

plum-std/Time.plum CHANGED Viewed

@@ -1,10 +1,10 @@
 module std
 import std/Number
 import std/Str
-import std/Bool
 # A raw, host-provided wall-clock reading: milliseconds since the Unix epoch.
+# Returned as Float (exact up to 2^53) because `Int` externs are narrowed to i32.
-extern fun rawNowMillis() -> Int
+extern fun rawNowMillis() -> Float
 # A single point in time, stored as milliseconds since the Unix epoch.
 enum Time(ToStr) =
@@ -75,7 +75,7 @@ enum Time(ToStr) =
       + "." + self.millisecond().toStr().padStart("0", 3) + "Z"
 fun now() -> Time =
-  return Time(value: rawNowMillis())
+  return Time(value: Int(rawNowMillis()))
 # A Gregorian calendar date, decomposed from a day count by `civilFromDays`.
 enum Civil =
@@ -190,3 +190,6 @@ test "Duration arithmetic and unit constructors compute correctly"
   assert Duration(value: 0).isZero() == True
   assert Duration.seconds(1).isBefore(Duration.seconds(2)) == True
   assert Duration.seconds(2).isAfter(Duration.seconds(1)) == True
+test "now() reads a wall clock beyond 2^31 ms through the Float extern"
+  assert now().toMillis() > 1600000000000

plum-std/Try.plum CHANGED Viewed

@@ -1,7 +1,6 @@
 module std
 import std/Str
-import std/Bool
 import std/Number
 import std/List
 import std/Map

plum-std/Uuid.plum CHANGED Viewed

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

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

@@ -1852,6 +1852,7 @@ fn compileSourceInner(
     // always its unique key.
     let mut func_ids: HashMap<String, u32> = HashMap::new();
     let mut func_sigs: HashMap<String, FuncSig> = HashMap::new();
+    let mut extern_wrappers: Vec<(String, u32, Vec<ValType>, Option<ValType>)> = Vec::new();
     for item in &source.items {
         if let ast::Item::Fn(f) = item {
             if !f.is_extern {
@@ -1859,10 +1860,17 @@ fn compileSourceInner(
             }
             let param_types = fnWasmParamTypes(f, &gc_types);
             let ret = retTypeToWasm(f.returns.as_ref());
+            // `Int` in an extern signature is narrowed to wasm i32 at the host
+            // boundary (the browser host never sees a BigInt). The import gets the
+            // narrowed type; a same-named wrapper with the plain i64 signature (added
+            // below, once all imports exist) range-checks/wraps args and sign-extends
+            // the result, so every Plum call site is unchanged.
+            let narrow = |v: &ValType| if *v == ValType::I64 { ValType::I32 } else { *v };
+            let imp_params: Vec<ValType> = param_types.iter().map(narrow).collect();
-            let results_vec: Vec<ValType> = ret.into_iter().collect();
+            let imp_results: Vec<ValType> = ret.iter().map(narrow).collect();
-            let type_idx = module.addType(&param_types, &results_vec);
+            let type_idx = module.addType(&imp_params, &imp_results);
             let func_idx = module.addImport("plum", &f.name, type_idx);
-            func_ids.insert(f.name.clone(), func_idx);
+            extern_wrappers.push((f.name.clone(), func_idx, param_types.clone(), ret));
             func_sigs.insert(
                 f.name.clone(),
                 FuncSig {
@@ -1892,6 +1900,40 @@ fn compileSourceInner(
         }
     }
+    // Extern `Int` narrowing wrappers (see the import loop above). The i32 range
+    // check is unconditional (one wrap/extend/compare per Int arg; the CLI has no
+    // separate debug mode): an `Int` that doesn't fit in i32 traps.
+    for (name, imp_idx, params, ret) in &extern_wrappers {
+        let mut b = vec![0u8];
+        for (i, vt) in params.iter().enumerate() {
+            if *vt == ValType::I64 {
+                Instruction::LocalGet(i as u32).encode(&mut b);
+                Instruction::LocalGet(i as u32).encode(&mut b);
+                Instruction::I32WrapI64.encode(&mut b);
+                Instruction::I64ExtendI32S.encode(&mut b);
+                Instruction::I64Ne.encode(&mut b);
+                Instruction::If(BlockType::Empty).encode(&mut b);
+                Instruction::Unreachable.encode(&mut b);
+                Instruction::End.encode(&mut b);
+            }
+        }
+        for (i, vt) in params.iter().enumerate() {
+            Instruction::LocalGet(i as u32).encode(&mut b);
+            if *vt == ValType::I64 {
+                Instruction::I32WrapI64.encode(&mut b);
+            }
+        }
+        Instruction::Call(*imp_idx).encode(&mut b);
+        if *ret == Some(ValType::I64) {
+            Instruction::I64ExtendI32S.encode(&mut b);
+        }
+        Instruction::End.encode(&mut b);
+        let results_vec: Vec<ValType> = ret.iter().cloned().collect();
+        let t = module.addType(params, &results_vec);
+        let w = module.addFunction(t, &b);
+        func_ids.insert(name.clone(), w);
+    }
     // Pre-allocate one instance of every payload-free variant (True/False/End/...)
     // as a global, populated once by a `start` function rather than reconstructed on
     // every reference — see this migration plan's Decision 2. `struct.new` isn't

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

@@ -1598,7 +1598,6 @@ fn runMerged<R: wasmtime::WasmResults>(name: &str, src: &str) -> R {
 #[test]
 fn heterogeneous_list_dispatch() {
     let src = "\
-import std/Bool
 import std/Str
 import std/Number
 import std/Try
@@ -1661,7 +1660,6 @@ fun main() -> Float =
 #[test]
 fn boxed_int_dispatch() {
     let src = "\
-import std/Bool
 import std/Str
 import std/Number
@@ -1681,7 +1679,6 @@ fun main() -> Int =
 #[test]
 fn boxed_i64_extremes_through_generic() {
     let src = "\
-import std/Bool
 import std/Str
 import std/Number
@@ -1704,7 +1701,6 @@ fun main() -> Int =
 #[test]
 fn generic_closure_thunk() {
     let src = "\
-import std/Bool
 import std/Str
 import std/Number
 import std/Try
@@ -1720,7 +1716,6 @@ fun main() -> Int =
 #[test]
 fn try_of_list_of_try() {
     let src = "\
-import std/Bool
 import std/Str
 import std/Number
 import std/Try
@@ -1750,7 +1745,6 @@ fun main() -> Int =
 #[test]
 fn one_copy_per_generic() {
     let src = "\
-import std/Bool
 import std/Str
 import std/Number
 import std/Try
@@ -1862,10 +1856,94 @@ fun chain(ok: Bool) -> Try[Bool, [Nope]] =
 fun main() -> Int =
   a := chain(True) ?? True
   b := chain(False) ?? True
-  p := Bool.parse(\"true\") ?? False
+  p := \"true\".parseBool() ?? False
   if !a && b && p
     return 1
   return 0
 ";
     assert_eq!(runMerged::<i64>("bool_try", src), 1);
 }
+// ---- extern `Int` narrowing (T1): i32 at the host boundary ----
+/// Compiles a program whose `main` returns `echo(<arg>)` through a host `echo`
+/// import that is `(i32) -> i32`; returns the module plus `main`'s outcome.
+fn externEcho(arg: &str) -> (wasmtime::Module, Result<i64, String>) {
+    let src = format!(
+        "extern fun echo(x: Int) -> Int\n\nfun main() -> Int =\n  echo({})\n",
+        arg
+    );
+    let source = parse(&src);
+    let bytes = compileSource(&source).expect("compile failed");
+    wasmparser::validate(&bytes).expect("valid wasm");
+    let engine = gcEngine();
+    let module = wasmtime::Module::new(&engine, &bytes).unwrap();
+    let mut store = wasmtime::Store::new(&engine, ());
+    let mut linker = wasmtime::Linker::new(&engine);
+    linker.func_wrap("plum", "echo", |x: i32| -> i32 { x }).unwrap();
+    let instance = linker.instantiate(&mut store, &module).unwrap();
+    let main = instance.get_typed_func::<(), i64>(&mut store, "main").unwrap();
+    let r = main.call(&mut store, ()).map_err(|e| e.to_string());
+    (module, r)
+}
+#[test]
+fn extern_int_is_i32() {
+    let (module, _) = externEcho("1");
+    let imp = module
+        .imports()
+        .find(|i| i.module() == "plum" && i.name() == "echo")
+        .expect("echo import");
+    let ty = imp.ty().func().cloned().expect("func import");
+    let params: Vec<_> = ty.params().collect();
+    let results: Vec<_> = ty.results().collect();
+    assert!(matches!(params.as_slice(), [wasmtime::ValType::I32]), "{:?}", params);
+    assert!(matches!(results.as_slice(), [wasmtime::ValType::I32]), "{:?}", results);
+}
+#[test]
+fn extern_int_roundtrip_negative() {
+    assert_eq!(externEcho("0 - 5").1.unwrap(), -5);
+    assert_eq!(externEcho("2147483647").1.unwrap(), 2147483647);
+    assert_eq!(externEcho("0 - 2147483647 - 1").1.unwrap(), -2147483648);
+}
+#[test]
+fn extern_int_overflow_traps() {
+    assert!(externEcho("2147483648").1.is_err(), "Int > i32::MAX must trap");
+    assert!(externEcho("1 << 40").1.is_err(), "Int that doesn't fit must trap");
+    assert!(externEcho("0 - 2147483649").1.is_err(), "Int < i32::MIN must trap");
+}
+#[test]
+fn bool_tostr_intrinsic() {
+    let src = "\
+import std/Number
+import std/Str
+fun main() -> Int =
+  t := True
+  if t.toStr() == \"True\" && False.toStr() == \"False\" && \"{t}\" == \"True\"
+    return 1
+  return 0
+";
+    assert_eq!(runMerged::<i64>("bool_tostr_intrinsic", src), 1);
+}
+#[test]
+fn parse_bool() {
+    let src = "\
+import std/Number
+import std/Str
+import std/Try
+fun main() -> Int =
+  a := \"true\".parseBool() ?? False
+  b := \"false\".parseBool() ?? True
+  c := \"nope\".parseBool() ?? False
+  if a && !b && !c
+    return 1
+  return 0
+";
+    assert_eq!(runMerged::<i64>("parse_bool", src), 1);
+}

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

@@ -157,7 +157,7 @@ fn ioExampleCompilesAndRunsCorrectly() {
         },
     );
-    // `io.plum` now also transitively pulls in `rawRandomInt` (via the
+    // `io.plum` now also transitively pulls in `rawRandomHalf` (via the
     // always-implicit `std/str` prelude — `str` -> `list` -> `int`, which
     // declares it for `List.sample`/`shuffle` — see
     // `plum-core::loader::loadAndMerge`), even though this test never
@@ -168,17 +168,17 @@ fn ioExampleCompilesAndRunsCorrectly() {
         .imports()
         .map(|imp| match (imp.module(), imp.name()) {
             ("plum", "printLn") => wasmtime::Extern::Func(print_ln),
-            ("plum", "rawRandomInt") => {
+            ("plum", "rawRandomHalf") => {
                 let func_ty = imp
                     .ty()
                     .func()
                     .cloned()
-                    .expect("rawRandomInt import should be a function");
+                    .expect("rawRandomHalf import should be a function");
                 wasmtime::Extern::Func(wasmtime::Func::new(
                     &mut store,
                     func_ty,
                     |_caller, _params, results| {
-                        results[0] = wasmtime::Val::I64(0);
+                        results[0] = wasmtime::Val::I32(0);
                         Ok(())
                     },
                 ))