3deb646 | plum | pyrossh

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

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

3deb646 — Peter John 2026-11-01T22:02:52+05:30

refactor: Bool.parse and Bool.toStr live in primitive Bool; builtin Bool.toStr removed

Files changed (7) hide show

README.md +2 -2
plum-checker/src/lib.rs +0 -54
plum-lsp/src/main.rs +1 -1
plum-std/Bool.plum +29 -0
plum-std/Str.plum +0 -20
plum-wasm-codegen/src/lib.rs +0 -3
plum-wasm-codegen/tests/codegen_tests.rs +48 -4

README.md CHANGED Viewed

@@ -929,7 +929,7 @@ primitive Int =
   fun parse(s: Str) -> error{BadNumStr}!Int
 ```
-The std signatures: `List.get` fails with `OutOfBounds`, `first`/`last`/`pop`/`sample` with `ListWasEmpty`, `findValue` with `NotFound`, `Map.get` with `KeyNotFound`, `Int.parse`/`Float.parse` with `BadNumStr`, `Str.parseBool` with `BadBoolStr`, `Json.fromStr` with `InvalidJson` (`Json.parse` returns where and why as an ordinary value), the `Os` file functions with `NoSuchPath`/`IoFailed` (the set `IoError` where a function can hit both), `Http.request` with `HttpFailed`/`BadResponse` (the set `HttpError`), `Uuid.fromStr` with `InvalidUuid`. Where absence is not an error the result is an optional instead: `List.head`, the `find()` terminal and `Map.getOrNull` return `T?`.
+The std signatures: `List.get` fails with `OutOfBounds`, `first`/`last`/`pop`/`sample` with `ListWasEmpty`, `findValue` with `NotFound`, `Map.get` with `KeyNotFound`, `Int.parse`/`Float.parse` with `BadNumStr`, `Bool.parse` with `BadBoolStr`, `Json.fromStr` with `InvalidJson` (`Json.parse` returns where and why as an ordinary value), the `Os` file functions with `NoSuchPath`/`IoFailed` (the set `IoError` where a function can hit both), `Http.request` with `HttpFailed`/`BadResponse` (the set `HttpError`), `Uuid.fromStr` with `InvalidUuid`. Where absence is not an error the result is an optional instead: `List.head`, the `find()` terminal and `Map.getOrNull` return `T?`.
 ### Propagating: `try expr`
@@ -1036,7 +1036,7 @@ hello, world!
 ## Standard library highlights
-- **`Bool`** — built in (no import); `true`/`false`, `toStr` is a compiler intrinsic, `"true".parseBool()` (in `std/Str`) parses it
+- **`Bool`** — `true`/`false`, `if`, `&&`/`||`/`!` and `==` are built in (no import); `toStr` (also used by `"{b}"` interpolation) and `Bool.parse("true")` need `import std/Bool`
 - **`Int`** / **`Float`** (`import std/Int`, `import std/Float`) — built-in numbers with their API in `primitive Int` / `primitive Float`: `abs`, `sign`, `min`, `max`, `sqrt`, `pow`, `floor`, `round`, `toStr`, ..., the constants `Int.MAX`, `Float.PI`, ..., and `Int.parse` / `Float.parse`
 - **`Math`** (`import std/Math`) — a `primitive` namespace of floating-point functions: `Math.sqrt`, `Math.sin`, `Math.exp`, `Math.ln`, ...
 - **`Str`** (`import std/Str`) — a byte array with a codepoint-aware layer for Unicode correctness: `runeLength`, `runeAt`, `codePointAt`, `codePointToStr`

plum-checker/src/lib.rs CHANGED Viewed

@@ -1102,63 +1102,9 @@ pub fn buildGlobalTables(source: &ast::Source) -> (TypeEnv, MethodEnv, EnumVaria
         }
     }
-    // `Bool.toStr` is a compiler builtin (see `builtinBoolToStr`); it is visible as a
-    // method once `Str` is in the program.
-    if hasStr(source) {
-        methods
-            .entry(("Bool".to_string(), "toStr".to_string()))
-            .or_insert_with(|| PlumType::TFun(Vec::new(), Box::new(PlumType::TStr)));
-    }
     (global_env, methods, enum_variants, enum_params)
 }
-fn hasStr(source: &ast::Source) -> bool {
-    source
-        .items
-        .iter()
-        .any(|i| matches!(i, ast::Item::Enum(e) if e.name == "Str"))
-}
-/// True if `source` should get the builtin `Bool.toStr` (it returns `Str`, and
-/// the user has not defined their own).
-pub fn needsBuiltinBoolToStr(source: &ast::Source) -> bool {
-    hasStr(source)
-        && !source.items.iter().any(|i| {
-            matches!(i, ast::Item::Fn(f) if f.name == "toStr" && f.type_param.as_deref() == Some("Bool"))
-        })
-}
-/// The builtin `Bool.toStr` as an ordinary method AST (`if self then "true" else "false"`),
-/// for codegen to compile as one wasm function. Nothing is added to the source.
-pub fn builtinBoolToStr() -> ast::Fn {
-    let lit = |t: &str| {
-        ast::Expr::String(ast::StringExpr {
-            parts: vec![ast::StringPart::Text(t.to_string())],
-        })
-    };
-    ast::Fn {
-        file: String::new(),
-        name: "toStr".to_string(),
-        line: 0,
-        column: 0,
-        type_param: Some("Bool".to_string()),
-        is_extern: false,
-        is_star: false,
-        has_self: true,
-        yields: None,
-        params: Vec::new(),
-        returns: Some(ast::Type {
-            name: "Str".to_string(),
-            generics: Vec::new(),
-        }),
-        body: ast::FnBody::Expr(ast::Expr::InlineIf(Box::new(ast::InlineIf {
-            condition: ast::Expr::Self_,
-            then: lit("true"),
-            else_: lit("false"),
-        }))),
-    }
-}
 pub fn checkSource(source: &ast::Source) -> CheckResult<()> {
     checkSourceFull(source).0
 }

plum-lsp/src/main.rs CHANGED Viewed

@@ -448,7 +448,7 @@ mod tests {
         std::fs::write(&path, text).unwrap();
         let cases: [(usize, &str, &[&str]); 3] = [
             (9, "f", &["sqrt", "toStr"]),
-            (11, "s", &["length", "split", "parseBool"]),
+            (11, "s", &["length", "split"]),
             (13, "m", &["get", "keys", "values", "entries"]),
         ];
         for (line, recv, wants) in cases {

plum-std/Bool.plum ADDED Viewed

@@ -0,0 +1,29 @@
+module std
+import std/Str
+# The API of the built-in `Bool` type: `Bool.parse` and `toStr` (also used by
+# `"{b}"` interpolation). `true`/`false` and the operators are built in; the
+# methods need `import std/Bool`.
+primitive Bool =
+  fun toStr(self) -> Str =
+    if self then "true" else "false"
+  # Parses exactly `"true"` or `"false"`.
+  fun parse(s: Str) -> error{BadBoolStr}!Bool =
+    if s == "true"
+      true
+    else if s == "false"
+      false
+    else
+      return error.BadBoolStr
+test "Bool.parse accepts true/false and rejects everything else"
+  assert Bool.parse("true") catch false
+  assert !{Bool.parse("false") catch true}
+  assert !{Bool.parse("yes") catch false}
+test "Bool.toStr is true/false, also through interpolation"
+  t := true
+  assert t.toStr() == "true"
+  assert false.toStr() == "false"
+  assert "{t}-{!t}" == "true-false"

plum-std/Str.plum CHANGED Viewed

@@ -140,15 +140,6 @@ record Str(bytes: []Byte) =
   fun toStr(self) -> Str =
     self
-  # Parses exactly `"true"` or `"false"`.
-  fun parseBool(self) -> error{BadBoolStr}!Bool =
-    if self == "true"
-      true
-    else if self == "false"
-      false
-    else
-      return error.BadBoolStr
   # Pads the start of `self` with repeated copies of `sub` until its length is
   # at least `count`. If `sub` doesn't evenly divide the needed amount, the
   # final length may overshoot `count` by up to `sub.length() - 1`.
@@ -757,17 +748,6 @@ 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() catch false
-  assert !{"false".parseBool() catch true}
-  assert !{"yes".parseBool() catch false}
 # ---- large-input (linear-time, no stack growth) regression tests ----
 test "sub of a 200000-byte string is a single copy"

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

@@ -1859,8 +1859,6 @@ fn compileSourceInner(
     for ((id, ptr), t) in inst_expr_types {
         inst_types[id].insert(ptr, t);
     }
-    // `Bool.toStr` is a checker/codegen builtin: compiled as one extra method, never added to the source.
-    let bool_to_str_fn = plum_checker::needsBuiltinBoolToStr(source).then(plum_checker::builtinBoolToStr);
     let (global_env, methods, enum_variants, enum_params) = plum_checker::buildGlobalTables(source);
     let min_required = plum_checker::buildMinRequiredArgs(source);
     let primitive_generics = plum_checker::buildPrimitiveGenerics(source);
@@ -1884,7 +1882,6 @@ fn compileSourceInner(
             ast::Item::Fn(f) if !f.is_extern && !f.is_star => Some(f),
             _ => None,
         })
-        .chain(bool_to_str_fn.iter())
         .collect();
     let mut units: Vec<UnitDef> = Vec::new();
     let mut known_fns: HashSet<String> = HashSet::new();

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

@@ -1459,6 +1459,7 @@ fun main() -> Int =
 fn boxed_bool_to_str_and_eq() {
     let src = "\
 import std/Str
+import std/Bool
 import std/Int
 import std/Float
@@ -1480,6 +1481,7 @@ fun main() -> Int =
 fn builtin_bool_in_error_union_with_question_and_catch() {
     let src = "\
 import std/Str
+import std/Bool
 import std/Int
 import std/Float
@@ -1496,7 +1498,7 @@ fun chain(ok: Bool) -> error{Nope}!Bool =
 fun main() -> Int =
   a := chain(true) catch true
   b := chain(false) catch true
-  p := \"true\".parseBool() catch false
+  p := Bool.parse(\"true\") catch false
   if !a && b && p
     return 1
   return 0
@@ -1561,6 +1563,7 @@ fn bool_tostr_intrinsic() {
 import std/Int
 import std/Float
 import std/Str
+import std/Bool
 fun main() -> Int =
   t := true
@@ -1577,6 +1580,7 @@ fn bool_tostr_lowercase() {
 import std/Int
 import std/Float
 import std/Str
+import std/Bool
 fun main() -> Int =
   t := true
@@ -1588,17 +1592,57 @@ fun main() -> Int =
     assert_eq!(runMerged::<i64>("bool_tostr_lowercase", src), 1);
 }
+#[test]
+fn bool_interpolation_with_import() {
+    let src = "\
+import std/Int
+import std/Float
+import std/Str
+import std/Bool
+fun main() -> Int =
+  if \"{true}\" == \"true\" && \"{1 > 2}\" == \"false\"
+    return 1
+  return 0
+";
+    assert_eq!(runMerged::<i64>("bool_interp_import", src), 1);
+}
+#[test]
+fn bool_tostr_without_import_is_rejected() {
+    let src = "\
+import std/Int
+import std/Float
+import std/Str
+fun main() -> Int =
+  t := true
+  if t.toStr() == \"true\"
+    return 1
+  return 0
+";
+    let dir = std::env::temp_dir().join(format!("plum_t3_bool_noimport_{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("main.plum");
+    std::fs::write(&path, src).unwrap();
+    let source = plum_core::loadAndMerge(&path, &repoRoot()).expect("load");
+    // Same as any other method of a std type that was not imported: rejected by the checker or by codegen.
+    let rejected = plum_checker::checkSource(&source).is_err() || compileSource(&source).is_err();
+    assert!(rejected, "Bool.toStr without import std/Bool must be rejected");
+}
 #[test]
 fn parse_bool() {
     let src = "\
 import std/Int
 import std/Float
 import std/Str
+import std/Bool
 fun main() -> Int =
-  a := \"true\".parseBool() catch false
+  a := Bool.parse(\"true\") catch false
-  b := \"false\".parseBool() catch true
+  b := Bool.parse(\"false\") catch true
-  c := \"nope\".parseBool() catch false
+  c := Bool.parse(\"nope\") catch false
   if a && !b && !c
     return 1
   return 0