bf629a2 | plum | pyrossh

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

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

bf629a2 — Peter John 2026-09-03T19:47:08+05:30

feat(plum): trait conformance checking, Stringable->ToStr, finish str.plum

Generated files not shown: Cargo.lock, plum-runtime/Cargo.lock

Files changed (22) hide show

README.md +5 -2
examples/types.plum +1 -1
libs/std/buffer.plum +1 -1
libs/std/http.plum +156 -22
libs/std/list.plum +2 -2
libs/std/map.plum +3 -3
libs/std/option.plum +1 -1
libs/std/result.plum +1 -1
libs/std/str.plum +96 -7
libs/std/time.plum +1 -1
libs/std/uuid.plum +1 -1
plum-checker/src/lib.rs +114 -2
plum-checker/src/monomorphize.rs +19 -3
plum-checker/tests/checker_tests.rs +126 -0
plum-cli/Cargo.toml +1 -0
plum-cli/src/main.rs +48 -0
plum-runtime/Cargo.toml +1 -0
plum-runtime/src/main.rs +43 -0
test/sample.plum +1 -1
tooling/tree-sitter-plum/test/corpus/type.txt +1 -1
website/src/content/docs/declarations/enum.md +1 -1
website/src/content/docs/index.mdx +2 -2

README.md CHANGED Viewed

@@ -234,7 +234,7 @@ type Point =
   x: Int
   y: Int
-type Named(Stringable) =    # implements Stringable
+type Named(ToStr) =    # implements ToStr
   name: Str
 trait Shape =
@@ -253,6 +253,8 @@ enum Option =
 Full example: [`examples/types.plum`](examples/types.plum).
+`type X(TraitName, ...) = ...`'s trait claims are checked: `plum-checker` verifies `X` actually defines every method `TraitName` declares, with a matching param count/types and return type (a return/param type the trait itself can't parameterize, like `Err`'s `cause() -> Option`, matches any concrete instantiation an implementer declares, e.g. `Option[MyError]`). A trait name that isn't actually declared anywhere (`Comparable`/`Readable`/`Writable` are used this way in a few places in `libs/std` today) is silently unenforced rather than an error, since there's nothing real yet to check it against.
 ### Generics
 Generic type parameters are single letters only: `a`, `b`, `c`, `d`.
@@ -389,7 +391,8 @@ hello, world!
 Some things parse and type-check but don't compile to wasm yet — `plum-wasm-codegen` reports a clear error rather than silently producing wrong code:
 - interpolating a `Float` value in a string (`Str`/`Int`/`Bool` interpolation, and plain non-interpolated literals, all compile) — correct decimal formatting of a float is a substantial separate undertaking (something like Grisu/Ryu), scoped out for now
-- The generic-field-type gap that used to block `libs/std`'s real `List[T]`/`Node[T]` from compiling at all (a class/enum-variant field declared with a concrete instantiation of another generic type, e.g. `Node.next: Option[Node]`) is fixed — `List[T]`'s methods (`get`/`length`/`add`/`set`/`removeAt`/`remove`/`clear`/`reverse`/`each`/`map`/`reduce`/`sort`/`join`, including its `Stringable`-bounded dispatch) are exercised directly, at their real generic type, by the `test` blocks at the bottom of [`libs/std/list.plum`](libs/std/list.plum) itself (run via `plum test libs/std/list.plum`) — not a non-generic stand-in.
+- The generic-field-type gap that used to block `libs/std`'s real `List[T]`/`Node[T]` from compiling at all (a class/enum-variant field declared with a concrete instantiation of another generic type, e.g. `Node.next: Option[Node]`) is fixed — `List[T]`'s methods (`get`/`length`/`add`/`set`/`removeAt`/`remove`/`clear`/`reverse`/`each`/`map`/`reduce`/`sort`/`join`, including its `ToStr`-bounded dispatch) are exercised directly, at their real generic type, by the `test` blocks at the bottom of [`libs/std/list.plum`](libs/std/list.plum) itself (run via `plum test libs/std/list.plum`) — not a non-generic stand-in.
 - `Map[K, V]` previously hit a *different* bug here: a top-level function whose own declared return type was a fully-concrete generic instantiation (e.g. `fun makeMap() -> Map[Str, Int] = ...`) caused monomorphization to eagerly (and incorrectly) attempt to specialize an unrelated generic type's method (`Option.filter`) at an unresolved type variable, producing a spurious `expected Option, found Option$V` type error even though `filter` was never called anywhere in the program. Root cause: `maybeRewriteReturn` (in `plum-checker/src/monomorphize.rs`) treated ANY return type merely NAMING a known generic class/enum as still-unresolved and in need of rewriting from the body's inferred tail type — even when that name already carried concrete type args (`List[Str]`, `Map[Str, Int]`), clobbering an already-correct declared return type with a stale, unmangled one inferred through tables monomorphization hadn't finished refreshing yet. Fixed by only treating a BARE reference (no `[...]` at all, e.g. `-> Box`) as needing that rewrite; a companion fix pre-resolves every ordinary (non-generic) fn/method's signature into the type tables before any body rewriting begins, so cross-file call order no longer matters. `Option.andThen`/`Result.map`/`Result.mapErr` (a single extra generic, possibly nested inside a closure's return type) are now implemented and working. `Map.map` (needing TWO new generic params nested inside a closure's return type, on a class rather than an enum) is now implemented too, once `specializeFn` was fixed to also substitute a method's own extra generics inside its BODY (not just its params/return) — an explicit bracketed construction like `Map[X, Y](items: ...)` written directly in a method's own body previously kept the literal letters "X"/"Y" forever, silently minting bogus specializations that corrupted unrelated template compilation elsewhere in the program. A second, narrower gap remains: a closure-literal argument whose body does field access on its own param (`|p| cb(p.key, p.val)`) still can't type-check once more than one specialization of the same generic class shares that field name (e.g. both `Pair$Str$Int` and `Pair$Str$Str` declare `key`/`val`) — the checker's field-usage heuristic for inferring a closure param's class becomes ambiguous and gives up; `Map.map`'s own body sidesteps this by using a manual linked-list walk (matching `keys`/`values`/`each`'s existing style) instead of `List.map` with a field-accessing closure
 - A generic class/enum method whose return type nests that SAME class/enum inside itself (`List[T].chunk(self) -> List[List[T]]`) used to stack-overflow the compiler for every program merely importing the class, whether or not anything called the method — fixed; `List.chunk`/`List.partition` now ship and work as a working example of the pattern (build any inner `List[T]` value via an EXISTING ordinary method, e.g. `self.sublist(...)`, never a second bare `List(...)` construction in the same body, which is ambiguous with the method's own return-type fallback)
 - A ternary as a closure's own inline body (`|n| cond ? a : b`) used to parse as an OUTER ternary wrapping the whole closure instead (`(|n| cond) ? a : b`) — a grammar shift/reduce ambiguity where `closure`'s default precedence (0) beat `ternary_expression`'s deliberately-low `PREC.conditional` (-1) at the point the parser decides whether to keep extending the closure's body or reduce it as already-complete. Fixed by giving `closure` its own even-lower precedence (`PREC.closure = -2`, `tooling/tree-sitter-plum/grammar.js`) so the parser now always prefers letting a ternary (or anything else valid there) keep extending the closure's inline body — see `examples/closures.plum`'s `"closure with an inline ternary body runs correctly"` test.
+- `libs/std/str.plum` is otherwise complete (including `endsWith`/`pad`/`truncate`, filled in alongside the `ToStr`-conformance work below), but three methods remain deliberately unimplemented `todo` stubs (they compile fine and trap at runtime if actually called, rather than failing to compile — a different flavor of gap than the rest of this section): `test`/`matchPattern`/`matchAll`/`replace`/`replaceAll`/`search` all need a real `Regex` type/engine, which doesn't exist anywhere in `libs/std` yet; `deburr` (diacritic stripping, `é` -> `e`) needs a full Unicode decomposition table; `template` (lodash's `_.template`) needs the ability to compile and run Plum source from a `Str` value at runtime — there's no `eval`/dynamic-codegen capability in the language to build it on.

examples/types.plum CHANGED Viewed

@@ -2,7 +2,7 @@ type Point =
   x: Int
   y: Int
-type Named(Stringable) =
+type Named(ToStr) =
   name: Str
 type Box[T] =

libs/std/buffer.plum CHANGED Viewed

@@ -12,7 +12,7 @@ import std/str
 # `bytes.Buffer`'s asymptotic behavior — unlike the previous `Str`-backed
 # version of this type, which recopied everything written so far on every
 # write.
-type Buffer(Stringable) =
+type Buffer(ToStr) =
   data: []Byte
   len: Int

libs/std/http.plum CHANGED Viewed

@@ -1,28 +1,162 @@
 module std
+import std/buffer
+import std/json
+import std/list
-import std/path
+import std/map
+import std/option
+import std/result
-import std/os
+import std/str
-import std/http/content_type
+# An HTTP response: status code, response headers, and the raw response
+# body as a `Str` (a byte array, so binary bodies round-trip intact).
 type Response =
-  headers: Map(Str, Str)
-  body: Buffer
   status: Int
+  headers: Map[Str, Str]
+  body: Str
+  # 2xx status codes are success; everything else (redirects, 4xx, 5xx) is
+  # surfaced here rather than as an `Err` from `request` — a non-2xx
-# builds a Response by reading the file at `file_path` and inferring its content type.
+  # response is still a complete, well-formed HTTP exchange, not a failed
-# NOTE: the original used a `Response::create()` fluent builder chain
-# (`.header(...).contentType(...).body(...).status(...)`), but this language has
-# no "::" static-call syntax and no mutating "with"-style builder methods, so
-# this constructs the Response directly instead.
-fun createFileResponse(file_path: Str) -> Response =
+  # one (`request` itself only fails for transport-level problems like a
-  content := content_type.fromExt(file_path.ext())
-  data := os.readFile(file_path)
+  # DNS/connection error).
-  Response(headers: Map(), body: data, status: 200)
-fun index() -> Response =
+  fun ok(self) -> Bool =
+    self.status >= 200 && self.status < 300
+  # Parses `body` as JSON. Fails the same way `Json.fromStr` does for a
+  # response body that isn't valid JSON.
+  fun json(self) -> Result[Json, JsonParseError] =
+    return Json.fromStr(self.body)
+fun emptyHeaders() -> Map[Str, Str] =
+  return Map[Str, Str](items: List[Pair[Str, Str]](head: None, tail: None, size: 0))
+# A single blocking network round trip — this VM has no async/event-loop
+# mechanism, so `rawHttpRequest` runs to completion before returning (same
+# idea as `libs/std/os.plum`'s `rawReadFile`). `headers` is `"Key: Value"`
+# lines joined by `\n` (`""` for none). The result packs an outcome flag,
+# then either the status code and response headers (success) or an error
+# message (failure), as fields joined by `\x01`, up to the first `\x00` —
+# everything after that byte is the raw response body. `\x00`/`\x01` can
+# never occur in the metadata fields themselves (the flag/status are
+# decimal digits, header names/values and the error message are always
+# plain text), so they safely mark where the opaque body bytes start even
+# when the body itself is arbitrary binary data.
+extern fun rawHttpRequest(method: Str, url: Str, headers: Str, body: Str) -> Str
+# Packs `headers` into the `"Key: Value"`-per-line format `rawHttpRequest`
+# expects for its own `headers` argument.
+fun encodeHeaders(headers: Map[Str, Str]) -> Str =
+  buf := Buffer()
+  headers.each(|k, v|
+    if buf.length() > 0
-  createFileResponse("index.html")
+      buf.write("\n")
+    buf.write(k)
+    buf.write(": ")
+    buf.write(v))
+  return buf.toStr()
+# The reverse of `encodeHeaders`, for the response headers `rawHttpRequest`
+# packs into its result.
-fun serveFile(file_path: Str) -> Response =
+fun decodeHeaders(raw: Str) -> Map[Str, Str] =
+  result := emptyHeaders()
+  if raw == ""
+    return result
+  raw.split("\n", 0).each(|line|
+    idx := line.indexOf(": ")
+    if idx >= 0
+      key := line.sub(0, idx)
+      val := line.sub(idx + 2, line.length())
+      result.set(key, val))
+  return result
+# Performs a single HTTP request and waits for the full response. Fails
+# only for a transport-level problem (DNS failure, connection refused, TLS
+# error, ...) — an HTTP-level error status (404, 500, ...) is still a
+# successful round trip, returned as `Ok(Response(...))` with that status
+# (check `Response.ok()`).
+fun request(method: Str, url: Str, headers: Map[Str, Str], body: Str) -> Result[Response, Str] =
+  raw := rawHttpRequest(method, url, encodeHeaders(headers), body)
+  sep := raw.indexOf("\x00")
+  meta := sep >= 0 ? raw.sub(0, sep) : raw
+  resp_body := sep >= 0 ? raw.sub(sep + 1, raw.length()) : ""
+  parts := meta.split("\x01", 3)
+  flag := parts.get(0).unwrapOr("")
+  if flag != "1"
+    return Err(parts.get(2).unwrapOr("http request failed"))
+  match Int.fromStr(parts.get(1).unwrapOr(""))
+    Ok(status) =>
+      return Ok(Response(status: status, headers: decodeHeaders(parts.get(2).unwrapOr("")), body: resp_body))
+    Err(e) =>
+      return Err("invalid status code in http response: {e}")
+fun get(url: Str, headers: Map[Str, Str]) -> Result[Response, Str] =
+  return request("GET", url, headers, "")
+fun head(url: Str, headers: Map[Str, Str]) -> Result[Response, Str] =
+  return request("HEAD", url, headers, "")
+fun delete(url: Str, headers: Map[Str, Str]) -> Result[Response, Str] =
+  return request("DELETE", url, headers, "")
+fun post(url: Str, headers: Map[Str, Str], body: Str) -> Result[Response, Str] =
+  return request("POST", url, headers, body)
+fun put(url: Str, headers: Map[Str, Str], body: Str) -> Result[Response, Str] =
+  return request("PUT", url, headers, body)
+fun patch(url: Str, headers: Map[Str, Str], body: Str) -> Result[Response, Str] =
+  return request("PATCH", url, headers, body)
+# Convenience wrapper: sends `body` as a JSON `Str`, adding a
+# `Content-Type: application/json` header, and parses the response back as
+# JSON via `Response.json()`.
+fun postJson(url: Str, headers: Map[Str, Str], body: Json) -> Result[Response, Str] =
+  headers.set("Content-Type", "application/json")
+  return post(url, headers, body.toStr())
+test "encodeHeaders/decodeHeaders round-trip a header map"
+  h := emptyHeaders()
+  h.set("Content-Type", "application/json")
+  h.set("Accept", "*/*")
-  content := content_type.fromExt(file_path.ext())
+  decoded := decodeHeaders(encodeHeaders(h))
+  expect decoded.get("Content-Type").unwrap() == "application/json"
+  expect decoded.get("Accept").unwrap() == "*/*"
-  data := os.readFile(file_path)
+test "decodeHeaders returns an empty map for an empty string"
-  Response(headers: Map(), body: data, status: 200)
+  expect decodeHeaders("").isEmpty() == True
+test "get performs a real HTTP round trip"
+  match get("https://httpbin.org/get", emptyHeaders())
+    Ok(resp) =>
+      expect resp.ok() == True
+      expect resp.status == 200
+    Err(_) =>
+      expect True == False
+test "get reports a non-2xx status without failing the request"
+  match get("https://httpbin.org/status/404", emptyHeaders())
+    Ok(resp) =>
+      expect resp.ok() == False
+      expect resp.status == 404
+    Err(_) =>
+      expect True == False
+test "post sends a body and the server echoes it back"
+  match post("https://httpbin.org/post", emptyHeaders(), "hello world")
+    Ok(resp) =>
+      expect resp.ok() == True
+      match resp.json()
+        Ok(j) =>
+          expect j.asMap().unwrap().get("data").unwrap().asStr().unwrap() == "hello world"
+        Err(_) =>
+          expect True == False
+    Err(_) =>
+      expect True == False
+test "request fails for an unreachable host"
+  match get("http://this-host-does-not-exist.invalid/", emptyHeaders())
+    Ok(_) =>
+      expect True == False
+    Err(_) =>
+      expect True == True

libs/std/list.plum CHANGED Viewed

@@ -12,7 +12,7 @@ type Node[T] =
 # A list is a data structure describing a contiguous section of an array stored separately from the slice variable itself.
 # It contains the pointers to the start and end nodes (head, tail) and maintains the size as well
-type List[T: Stringable](Stringable) =
+type List[T: ToStr](ToStr) =
   head: Option[Node[T]]
   tail: Option[Node[T]]
   size: Int
@@ -460,7 +460,7 @@ type List[T: Stringable](Stringable) =
           break
     res.toStr()
-  # `List[T: Stringable](Stringable)` declared implementing `Stringable`
+  # `List[T: ToStr](ToStr)` declared implementing `ToStr`
   # from the start but never actually defined `toStr` — harmless for a
   # PLAIN `List[Int]`/`List[Str]`/etc (nothing needs to call `.toStr()` on
   # the LIST ITSELF, just on its elements, which `join` above already

libs/std/map.plum CHANGED Viewed

@@ -7,11 +7,11 @@ import std/option
 # `toStr` (unlike `Option`'s — see `libs/std/option.plum`'s note on
 # `toOptionStr`) IS safe as an ordinary method here: `Pair[K, V]` is only
 # ever used as `List[Pair[K, V]]`'s element type inside `Map[K, V]`, and
-# `List[T: Stringable]` already requires its own `T` to support `toStr` —
+# `List[T: ToStr]` already requires its own `T` to support `toStr` —
-# so a `Pair` used as a `List` element always has `K`/`V: Stringable` too,
+# so a `Pair` used as a `List` element always has `K`/`V: ToStr` too,
 # and `List`'s own eagerly-compiled `join`/`toStr` (which call `.toStr()` on
 # every element) need this to exist for every `Map` specialization anyway.
-type Pair[K, V](Stringable) =
+type Pair[K, V](ToStr) =
   key: K
   val: V

libs/std/option.plum CHANGED Viewed

@@ -112,7 +112,7 @@ enum Option =
   # `toStr` — so an `Option.toStr` calling `.toStr()` on the wrapped value
   # would fail to compile for THAT specialization even though nothing ever
   # actually calls `.toStr()` on an `Option[Node[Int]]`. Use `toOptionStr`
-  # below (an explicit stringifier callback, not an implicit `T: Stringable`
+  # below (an explicit stringifier callback, not an implicit `T: ToStr`
   # bound) wherever printing an `Option` is needed.
   fun toOptionStr(self, valueToStr: fn(T) -> Str) -> Str =
     match self

libs/std/result.plum CHANGED Viewed

@@ -116,7 +116,7 @@ enum Result =
   # No implicit `toStr(self) -> Str` — see the identical note on
   # `Option.toOptionStr` in `libs/std/option.plum`: a method that assumes
-  # `T`/`E: Stringable` gets compiled for EVERY specialization of `Result`
+  # `T`/`E: ToStr` gets compiled for EVERY specialization of `Result`
   # anywhere in the program (there's no lazy/on-demand method compilation),
   # so an implicit bound like this can break an unrelated specialization
   # whose payload doesn't support it. Explicit stringifier callbacks instead.

libs/std/str.plum CHANGED Viewed

@@ -3,13 +3,13 @@ module std
 import std/list
 # Any type that can be converted to a str needs to implement this trait
-trait Stringable =
+trait ToStr =
   toStr() -> Str
 # A Str is an array of contiguous data stored in memory with a null termination using hex 0x00 or ASCII 0x00.
 # It is immutable and cannot be modified. It is copied for any changes and saved to a new memory location.
 # The previous str is freed if its reference count is 0 within the block.
-type Str(Comparable, Stringable, Readable, Writable) =
+type Str(Comparable, ToStr, Readable, Writable) =
   data: Buffer
   # Number of bytes in the string. Every other method below is built on top of
@@ -104,6 +104,9 @@ type Str(Comparable, Stringable, Readable, Writable) =
   fun startsWith(self, search: Str) -> Bool =
     matchesAt(self, search, 0, search.length())
+  fun endsWith(self, search: Str) -> Bool =
+    matchesAt(self, search, self.length() - search.length(), search.length())
   fun concat(self, other: Str) -> Str =
     self + other
@@ -247,9 +250,28 @@ type Str(Comparable, Stringable, Readable, Writable) =
   fun escapeRegExp(self) -> Str =
     escapeRegExpFrom(self, 0, self.length())
+  # Pads BOTH sides of `self` with repeated copies of `sub` until its length
+  # is at least `count`, split as evenly as possible between the two sides
+  # (the left side gets any odd byte of the remainder, matching lodash's
+  # `_.pad`). Inherits `padStart`/`padEnd`'s own overshoot behavior when
+  # `sub` doesn't evenly divide the needed amount on either side.
-  fun pad(self) -> Str =
+  fun pad(self, sub: Str, count: Int) -> Str =
+    len := self.length()
+    if len >= count || sub.length() == 0
+      return self
+    total := count - len
+    left := total / 2
+    right := total - left
+    return self.padStart(sub, len + left).padEnd(sub, len + left + right)
+  # `template` (lodash's `_.template`) compiles a string containing
+  # `<%= expr %>`-style placeholders into a REUSABLE function that renders it
+  # against different data each call — that needs the ability to compile and
+  # run Plum source AT RUNTIME (from a `Str` value, not a `.plum` file), which
+  # the language has no way to do (no `eval`, no dynamic codegen from within
+  # a running program). Left as a known gap rather than a fundamentally
+  # different, simpler feature (e.g. a one-shot find/replace) under the same
-    todo
+  # name.
   fun template(self) -> Str =
     todo
@@ -262,8 +284,17 @@ type Str(Comparable, Stringable, Readable, Writable) =
   fun trimStart(self) -> Str =
     trimStartFrom(self, 0, self.length())
+  # Truncates `self` to at most `length` bytes (INCLUDING the "..." suffix,
+  # lodash's default `omission` string) if it's longer than `length`; returns
+  # `self` unchanged otherwise. `length` too small to fit the full "..."
+  # itself just returns as many of its leading bytes as fit.
-  fun truncate(self) -> Str =
+  fun truncate(self, length: Int) -> Str =
+    if self.length() <= length
-    todo
+      return self
+    omission := "..."
+    if length <= omission.length()
+      return omission.sub(0, length)
+    return self.sub(0, length - omission.length()) + omission
   fun unescape(self) -> Str =
     unescapeFrom(self, 0, self.length())
@@ -526,3 +557,61 @@ test "string interpolation supports a method call taking a closure literal"
 test "string interpolation supports a ternary expression"
   n := 5
   expect "{n > 0 ? "positive" : "non-positive"}" == "positive"
+# ---- Str method regression tests ----
+test "endsWith matches a real suffix and rejects a non-suffix or an over-long search"
+  expect "hello.plum".endsWith(".plum") == True
+  expect "hello.plum".endsWith(".rs") == False
+  expect "hi".endsWith("hello") == False
+test "startsWith/endsWith/contains/indexOf agree on a shared example"
+  s := "the quick brown fox"
+  expect s.startsWith("the") == True
+  expect s.endsWith("fox") == True
+  expect s.contains("quick") == True
+  expect s.indexOf("brown") == 10
+  expect s.indexOf("missing") == -1
+test "trim/trimStart/trimEnd strip only leading/trailing whitespace"
+  expect "  hi  ".trim() == "hi"
+  expect "  hi  ".trimStart() == "hi  "
+  expect "  hi  ".trimEnd() == "  hi"
+  expect "hi".trim() == "hi"
+test "repeat concatenates self count times, and is empty for count <= 0"
+  expect "ab".repeat(3) == "ababab"
+  expect "ab".repeat(0) == ""
+  expect "ab".repeat(-1) == ""
+test "padStart/padEnd/pad grow a string to at least the target length"
+  expect "5".padStart("0", 3) == "005"
+  expect "5".padEnd("0", 3) == "500"
+  expect "hi".pad("-", 6) == "--hi--"
+  expect "hi".pad("-", 5) == "-hi--"
+  expect "hello".pad("-", 3) == "hello"
+test "truncate shortens a too-long string with a trailing ellipsis"
+  expect "hello world".truncate(8) == "hello..."
+  expect "hi".truncate(8) == "hi"
+  expect "hello world".truncate(2) == ".."
+test "toLower/upperCase/capitalize/lowerFirst/upperFirst case-convert as expected"
+  expect "Hello World".toLower() == "hello world"
+  expect "Hello World".upperCase() == "HELLO WORLD"
+  expect "hello".capitalize() == "Hello"
+  expect "Hello".lowerFirst() == "hello"
+  expect "hello".upperFirst() == "Hello"
+test "camelCase/snakeCase/kebabCase/startCase convert a multi-word phrase"
+  expect "foo bar baz".camelCase() == "fooBarBaz"
+  expect "foo bar baz".snakeCase() == "foo_bar_baz"
+  expect "foo bar baz".kebabCase() == "foo-bar-baz"
+  expect "foo bar baz".startCase() == "Foo Bar Baz"
+test "reverse reverses by character, not by raw byte"
+  expect "hello".reverse() == "olleh"
+test "escape/unescape round-trip HTML-sensitive characters"
+  expect "<a href=\"x\">&'</a>".escape() == "&lt;a href=&quot;x&quot;&gt;&amp;&#39;&lt;/a&gt;"
+  expect "&lt;a href=&quot;x&quot;&gt;&amp;&#39;&lt;/a&gt;".unescape() == "<a href=\"x\">&'</a>"

libs/std/time.plum CHANGED Viewed

@@ -6,7 +6,7 @@ import std/str
 extern fun rawNowMillis() -> Int
 # A single point in time, stored as milliseconds since the Unix epoch.
-type Time(Stringable) =
+type Time(ToStr) =
   value: Int
   fun toMillis(self) -> Int =

libs/std/uuid.plum CHANGED Viewed

@@ -5,7 +5,7 @@ import std/str
 # A UUID, stored as its canonical 36-character
 # `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx` text form.
-type Uuid(Stringable) =
+type Uuid(ToStr) =
   value: Str
   fun toStr(self) -> Str =

plum-checker/src/lib.rs CHANGED Viewed

@@ -260,9 +260,111 @@ pub fn buildGlobalTables(source: &ast::Source) -> (TypeEnv, ClassEnv, MethodEnv,
     (global_env, classes, methods, enum_variants, enum_params)
 }
+/// A `Type`'s name for comparison purposes only — deliberately ignores `.generics`
+/// entirely (on both sides), so a trait's bare return/param type (`cause() ->
+/// Option`, unable to name a concrete payload since a trait has no instance to
+/// infer one from) is treated as compatible with ANY instantiation an implementer
+/// declares (`cause(self) -> Option[JsonParseError]`) — a real but deliberately
+/// coarse check (arity + base type names), not full structural/generic equality.
+fn paramTypeCompareName(pt: &ast::ParamType) -> Option<&str> {
+    match pt {
+        ast::ParamType::Type(t) => Some(t.name.as_str()),
+        ast::ParamType::Variadic(t) => Some(t.name.as_str()),
+        // A function-value param type has no single "name" to compare — never
+        // matches a trait method's plain `Type` param either way, but no real
+        // trait in `libs/std` declares one today, so this never actually fires.
+        ast::ParamType::Fn(_, _) => None,
+    }
+}
+/// Verifies every `type X(TraitName, ...) = ...` claim against `TraitName`'s own
+/// declared methods — until now, `implements` was pure documentation with zero
+/// enforcement (a class could claim any trait, real or not, and never define a
+/// single one of its methods, with nothing ever catching it). A `TraitName` that
+/// doesn't resolve to any declared `trait` in this source (e.g. `Comparable`,
+/// `Readable`, `Writable` — used across `libs/std` but never actually declared
+/// anywhere) is silently SKIPPED rather than an error: those names are still
+/// purely aspirational today, and erroring on them would break every existing
+/// type that names one, for reasons unrelated to whether it actually implements
+/// its REAL trait claims. Runs on the pre-monomorphization source deliberately —
+/// a generic class's own methods (and a real trait's own declared signatures,
+/// which are never specialized at all) read naturally here, before mangling
+/// folds a method's concrete return/param types into new, unrelated-looking
+/// names (`Option[JsonParseError]` -> `Option$JsonParseError`).
+fn checkTraitConformance(source: &ast::Source) -> Vec<CheckError> {
+    let mut errors = Vec::new();
+    let traits: BTreeMap<&str, &ast::Trait> = source.items.iter()
+        .filter_map(|i| match i { ast::Item::Trait(t) => Some((t.name.as_str(), t)), _ => None })
+        .collect();
+    let methods_by_receiver: BTreeMap<(&str, &str), &ast::Fn> = source.items.iter()
+        .filter_map(|i| match i {
+            ast::Item::Fn(f) => f.type_param.as_deref().map(|recv| ((recv, f.name.as_str()), f)),
+            _ => None,
+        })
+        .collect();
+    for item in &source.items {
+        let ast::Item::Class(c) = item else { continue };
+        for trait_name in &c.implements {
+            let Some(tr) = traits.get(trait_name.as_str()) else { continue };
+            for tm in &tr.methods {
+                let Some(f) = methods_by_receiver.get(&(c.name.as_str(), tm.name.as_str())) else {
+                    errors.push(CheckError {
+                        message: format!("class '{}' claims to implement trait '{}' but is missing method '{}'", c.name, trait_name, tm.name),
+                    });
+                    continue;
+                };
+                if f.params.len() != tm.params.len() {
+                    errors.push(CheckError {
+                        message: format!(
+                            "class '{}' method '{}' (implementing trait '{}'): expected {} param(s), got {}",
+                            c.name, tm.name, trait_name, tm.params.len(), f.params.len()
+                        ),
+                    });
+                    continue;
+                }
+                for (i, (fp, tp)) in f.params.iter().zip(tm.params.iter()).enumerate() {
+                    let (actual, expected) = (paramTypeCompareName(&fp.ty), paramTypeCompareName(&tp.ty));
+                    if actual != expected {
+                        errors.push(CheckError {
+                            message: format!(
+                                "class '{}' method '{}' (implementing trait '{}'): param {} ('{}'): expected type '{}', got '{}'",
+                                c.name, tm.name, trait_name, i, tp.name,
+                                expected.unwrap_or("<fn>"), actual.unwrap_or("<fn>")
+                            ),
+                        });
+                    }
+                }
+                match (&f.returns, &tm.returns) {
+                    (Some(ft), Some(tt)) if ft.name != tt.name => {
+                        errors.push(CheckError {
+                            message: format!(
+                                "class '{}' method '{}' (implementing trait '{}'): expected return type '{}', got '{}'",
+                                c.name, tm.name, trait_name, tt.name, ft.name
+                            ),
+                        });
+                    }
+                    (None, Some(tt)) => {
+                        errors.push(CheckError {
+                            message: format!(
+                                "class '{}' method '{}' (implementing trait '{}'): expected return type '{}', got none",
+                                c.name, tm.name, trait_name, tt.name
+                            ),
+                        });
+                    }
+                    _ => {}
+                }
+            }
+        }
+    }
+    errors
+}
 pub fn checkSource(source: &ast::Source) -> CheckResult<()> {
+    // Runs against the ORIGINAL (pre-monomorphization) source, deliberately —
+    // see `checkTraitConformance`'s own doc comment for why.
+    let mut errors: Vec<CheckError> = checkTraitConformance(source);
     let source = monomorphize::monomorphizeSource(source).map_err(|e| vec![CheckError { message: e }])?;
-    let mut errors: Vec<CheckError> = Vec::new();
     let (global_env, classes, methods, enum_variants, enum_params) = buildGlobalTables(&source);
     let min_required = buildMinRequiredArgs(&source);
     let ctx = CheckCtx { classes: &classes, methods: &methods, enum_variants: &enum_variants, enum_params: &enum_params, min_required: &min_required };
@@ -1099,7 +1201,17 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
                             None => Ok(PlumType::TVar("_".to_string())),
                         },
                     },
+                    // An unresolved generic method return (e.g. `Result[T, E].unwrap()`'s
+                    // bare `T`, which this checker's `PlumType` erases entirely — see
+                    // `types.rs`'s `TNamed` having no type-argument slot) reaches here as
+                    // a plain `TVar`, not a real "wrong type". Field access on it is
+                    // "unmodeled" the same way an unknown enum's fields already are just
+                    // above (`ctx.enum_params.get` returning `None`) — allow it and let
+                    // codegen (which DOES track concrete monomorphized types) catch a
+                    // genuine mismatch. Only a definitely-wrong concrete type (`Int`,
+                    // `Str`, ...) still hard-errors here.
+                    PlumType::TVar(_) => Ok(PlumType::TVar("_".to_string())),
-                    _ => Err(format!("cannot access field '{}' on non-class type {}", field_name, obj_ty)),
+                    other => Err(format!("cannot access field '{}' on non-class type {}", field_name, other)),
                 },
                 ast::AttrKind::Method(call) => match methodReceiverName(&obj_ty) {
                     Some(class_name) => match ctx.methods.get(&(class_name.clone(), call.name.clone())) {

plum-checker/src/monomorphize.rs CHANGED Viewed

@@ -1622,12 +1622,28 @@ impl<'a> Monomorphizer<'a> {
     fn fnBareGenericRefs(&self, f: &ast::Fn) -> Vec<String> {
         let mut names: Vec<String> = Vec::new();
         for p in &f.params {
-            let n = match &p.ty {
+            let t = match &p.ty {
-                ast::ParamType::Type(t) => &t.name,
+                ast::ParamType::Type(t) => t,
-                ast::ParamType::Variadic(t) => &t.name,
+                ast::ParamType::Variadic(t) => t,
                 // TODO: fn-value params don't yet participate in bare-generic resolution.
                 ast::ParamType::Fn(_, _) => continue,
             };
+            // A param already fully instantiated with concrete type arguments
+            // (`headers: Map[Str, Str]`) is NOT a bare reference to the generic
+            // template — only the truly bare spelling (`headers: Map`, no `[...]`
+            // at all) needs this function's own per-call-site specialization.
+            // Without this check, ANY function taking an already-concrete
+            // generic-typed param (however unrelated to its own logic) was
+            // wrongly routed through `fns_bare_generic`'s worklist instead of
+            // the ordinary per-item pass, silently dropping it from `m.produced`
+            // under its original name — the caller's own inferred return type
+            // (via `fn_return_generic_enum`, which doesn't consult this
+            // classification at all) still looked correct, masking the missing
+            // function until codegen.
+            if !t.generics.is_empty() {
+                continue;
+            }
+            let n = &t.name;
             if (self.classes_generic.contains_key(n.as_str()) || self.enums_generic_by_name.contains_key(n.as_str()))
                 && !names.iter().any(|x| x == n)
             {

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -906,3 +906,129 @@ fun bad(nums: ...Int) -> Int =
     let source = parse(src);
     assert!(checkSource(&source).is_err());
 }
+#[test]
+fn classImplementingTraitWithMatchingMethodPasses() {
+    let src = "\
+trait Greeter =
+  greet(name: Str) -> Str
+type Robot(Greeter) =
+  id: Int
+  fun greet(self, name: Str) -> Str =
+    \"beep {name}\"
+";
+    let source = parse(src);
+    assert!(checkSource(&source).is_ok(), "expected Ok, got: {:?}", checkSource(&source));
+}
+#[test]
+fn classClaimingTraitButMissingMethodIsError() {
+    let src = "\
+trait Greeter =
+  greet(name: Str) -> Str
+type Robot(Greeter) =
+  id: Int
+";
+    let source = parse(src);
+    let result = checkSource(&source);
+    assert!(result.is_err());
+    let errs = result.unwrap_err();
+    assert!(errs.iter().any(|e| e.message.contains("missing method 'greet'")), "got: {:?}", errs);
+}
+#[test]
+fn classClaimingTraitWithWrongParamCountIsError() {
+    let src = "\
+trait Greeter =
+  greet(name: Str) -> Str
+type Robot(Greeter) =
+  id: Int
+  fun greet(self) -> Str =
+    \"beep\"
+";
+    let source = parse(src);
+    let result = checkSource(&source);
+    assert!(result.is_err());
+    let errs = result.unwrap_err();
+    assert!(errs.iter().any(|e| e.message.contains("expected 1 param(s), got 0")), "got: {:?}", errs);
+}
+#[test]
+fn classClaimingTraitWithWrongParamTypeIsError() {
+    let src = "\
+trait Greeter =
+  greet(name: Str) -> Str
+type Robot(Greeter) =
+  id: Int
+  fun greet(self, name: Int) -> Str =
+    \"beep\"
+";
+    let source = parse(src);
+    let result = checkSource(&source);
+    assert!(result.is_err());
+    let errs = result.unwrap_err();
+    assert!(errs.iter().any(|e| e.message.contains("expected type 'Str', got 'Int'")), "got: {:?}", errs);
+}
+#[test]
+fn classClaimingTraitWithWrongReturnTypeIsError() {
+    let src = "\
+trait Greeter =
+  greet(name: Str) -> Str
+type Robot(Greeter) =
+  id: Int
+  fun greet(self, name: Str) -> Int =
+    0
+";
+    let source = parse(src);
+    let result = checkSource(&source);
+    assert!(result.is_err());
+    let errs = result.unwrap_err();
+    assert!(errs.iter().any(|e| e.message.contains("expected return type 'Str', got 'Int'")), "got: {:?}", errs);
+}
+#[test]
+fn classClaimingUndeclaredTraitNameIsNotEnforced() {
+    // `Comparable`/`Readable`/`Writable`-style names used across `libs/std` but
+    // never declared as a real `trait` anywhere — silently unenforced, not an
+    // error, since there is nothing real to check it against.
+    let src = "\
+type Robot(NotARealTrait) =
+  id: Int
+";
+    let source = parse(src);
+    assert!(checkSource(&source).is_ok(), "expected Ok, got: {:?}", checkSource(&source));
+}
+#[test]
+fn classImplementingTraitWithGenericReturnTypeMismatchIsPermitted() {
+    // A trait method's own return type can never name a concrete payload (it
+    // has no instance to infer one from) — an implementer instantiating that
+    // same generic type with a concrete arg is still a match (base type name
+    // only; see `checkTraitConformance`'s doc comment).
+    let src = "\
+enum Option[T] =
+  | Some[T]
+  | None
+trait Err =
+  cause() -> Option
+type MyErr(Err) =
+  pos: Int
+  fun cause(self) -> Option[MyErr] =
+    None
+";
+    let source = parse(src);
+    assert!(checkSource(&source).is_ok(), "expected Ok, got: {:?}", checkSource(&source));
+}

plum-cli/Cargo.toml CHANGED Viewed

@@ -17,3 +17,4 @@ tree-sitter = "0.26"
 tree-sitter-plum = { path = "../tooling/tree-sitter-plum" }
 toml_edit = "0.22"
 wasmtime = "47"
+ureq = "2.10"

plum-cli/src/main.rs CHANGED Viewed

@@ -389,11 +389,59 @@ fn hostImports(store: &mut wasmtime::Store<()>, module: &wasmtime::Module) -> Re
                     Ok(())
                 })))
             }
+            ("plum", "rawHttpRequest") => {
+                let func_ty = imp.ty().func().cloned()
+                    .ok_or_else(|| anyhow::anyhow!("plum::rawHttpRequest import must be a function"))?;
+                Ok(wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty.clone(), move |mut caller, params, results| {
+                    let method = readStrArg(&mut caller, &params[0])?;
+                    let url = readStrArg(&mut caller, &params[1])?;
+                    let headers = readStrArg(&mut caller, &params[2])?;
+                    let body = readStrArg(&mut caller, &params[3])?;
+                    let raw = performHttpRequest(&method, &url, &headers, &body);
+                    results[0] = wasmtime::Val::AnyRef(Some(makeStrResult(&mut caller, &func_ty, raw.as_bytes())?));
+                    Ok(())
+                })))
+            }
             (m, n) => anyhow::bail!("unsupported host import {m}::{n}"),
         }
     }).collect()
 }
+/// Performs one blocking HTTP round trip for `plum::rawHttpRequest` and packs
+/// the outcome into the wire format `libs/std/http.plum`'s `request` expects
+/// (see that extern's doc comment): `"1\x01<status>\x01<headers>\x00<body>"`
+/// on success, `"0\x01\x01<message>\x00"` for a transport-level failure. A
+/// non-2xx HTTP status (404, 500, ...) is NOT a failure here — it's still a
+/// complete response, so it goes through the success branch with its own
+/// status code.
+fn performHttpRequest(method: &str, url: &str, headers: &str, body: &str) -> String {
+    let agent = ureq::Agent::new();
+    let mut req = agent.request(method, url);
+    for line in headers.split('\n') {
+        if let Some((k, v)) = line.split_once(": ") {
+            req = req.set(k, v);
+        }
+    }
+    let result = if body.is_empty() { req.call() } else { req.send_string(body) };
+    match result {
+        Ok(resp) | Err(ureq::Error::Status(_, resp)) => {
+            let status = resp.status();
+            let mut header_lines = String::new();
+            for name in resp.headers_names() {
+                if let Some(v) = resp.header(&name) {
+                    if !header_lines.is_empty() {
+                        header_lines.push('\n');
+                    }
+                    header_lines.push_str(&format!("{name}: {v}"));
+                }
+            }
+            let body_text = resp.into_string().unwrap_or_default();
+            format!("1\x01{status}\x01{header_lines}\x00{body_text}")
+        }
+        Err(e) => format!("0\x01\x01{e}\x00"),
+    }
+}
 /// A pseudo-random `i64` seeded from the wall clock — `xorshift64*`, cheap and
 /// dependency-free (no `rand` crate in this workspace). Not cryptographically
 /// secure; fine for `Int.random`/`List.shuffle`/`Uuid.v4`, none of which need

plum-runtime/Cargo.toml CHANGED Viewed

@@ -11,6 +11,7 @@ path = "src/main.rs"
 [dependencies]
 wasmtime = "47"
+ureq = "2.10"
 # Stand on its own rather than joining the parent directory's workspace: `plum
 # build` compiles this crate on demand with PLUM_WASM_PATH set, and it would

plum-runtime/src/main.rs CHANGED Viewed

@@ -193,11 +193,54 @@ fn hostImports(store: &mut wasmtime::Store<()>, module: &wasmtime::Module) -> Ve
                     Ok(())
                 }))
             }
+            ("plum", "rawHttpRequest") => {
+                let func_ty = imp.ty().func().cloned().expect("plum::rawHttpRequest import should be a function");
+                wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty.clone(), move |mut caller, params, results| {
+                    let method = readStrArg(&mut caller, &params[0])?;
+                    let url = readStrArg(&mut caller, &params[1])?;
+                    let headers = readStrArg(&mut caller, &params[2])?;
+                    let body = readStrArg(&mut caller, &params[3])?;
+                    let raw = performHttpRequest(&method, &url, &headers, &body);
+                    results[0] = wasmtime::Val::AnyRef(Some(makeStrResult(&mut caller, &func_ty, raw.as_bytes())?));
+                    Ok(())
+                }))
+            }
             (m, n) => panic!("unsupported host import {m}::{n}"),
         }
     }).collect()
 }
+/// See the identical helper in `plum-cli/src/main.rs` — this crate is built
+/// fresh per `plum build` invocation, not linked against `plum-cli`, so the
+/// logic is duplicated rather than shared.
+fn performHttpRequest(method: &str, url: &str, headers: &str, body: &str) -> String {
+    let agent = ureq::Agent::new();
+    let mut req = agent.request(method, url);
+    for line in headers.split('\n') {
+        if let Some((k, v)) = line.split_once(": ") {
+            req = req.set(k, v);
+        }
+    }
+    let result = if body.is_empty() { req.call() } else { req.send_string(body) };
+    match result {
+        Ok(resp) | Err(ureq::Error::Status(_, resp)) => {
+            let status = resp.status();
+            let mut header_lines = String::new();
+            for name in resp.headers_names() {
+                if let Some(v) = resp.header(&name) {
+                    if !header_lines.is_empty() {
+                        header_lines.push('\n');
+                    }
+                    header_lines.push_str(&format!("{name}: {v}"));
+                }
+            }
+            let body_text = resp.into_string().unwrap_or_default();
+            format!("1\x01{status}\x01{header_lines}\x00{body_text}")
+        }
+        Err(e) => format!("0\x01\x01{e}\x00"),
+    }
+}
 /// See the identical helper in `plum-cli/src/main.rs` — this crate is built
 /// fresh per `plum build` invocation, not linked against `plum-cli`, so the
 /// logic is duplicated rather than shared.

test/sample.plum CHANGED Viewed

@@ -216,7 +216,7 @@ fun random() -> Float = # generate random number
 fun fromStr() -> Result(Int, Err) = # convert Str to Int
   Ok(0)
-type Int(Comparable, Stringable)
+type Int(Comparable, ToStr)
 fun toFloat<Int>() -> Float = # convert Int to Float
   Float(self)

tooling/tree-sitter-plum/test/corpus/type.txt CHANGED Viewed

@@ -6,7 +6,7 @@ type Dog =
   name: Str
   age: B
-type Cat(Stringable) =
+type Cat(ToStr) =
   name: Str
   age: Int

website/src/content/docs/declarations/enum.md CHANGED Viewed

@@ -6,7 +6,7 @@ description: These are basic types
 An Algebraic Data Type
 ```rs
-enum Ordering: Stringable {
+enum Ordering: ToStr {
   LT
   EQ
   GT

website/src/content/docs/index.mdx CHANGED Viewed

@@ -55,11 +55,11 @@ fn toCelsius(f: float): float =
 fn addItems(items ...str) =
   list.add(items)
-trait Stringable where
+trait ToStr where
   fn toStr(): str
 // `Cat is a speciecs of felidae
-struct Cat is Stringable, Equal, Comparable =
+struct Cat is ToStr, Equal, Comparable =
   | name: str
   | age:  int