45dada4 | plum | pyrossh

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

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

45dada4 — Peter John 2026-10-25T16:17:50+05:30

feat(std)!: replace Option/Result with Try and structural error tags

Files changed (17) hide show

plum-std/Base64.plum +6 -6
plum-std/Bool.plum +3 -3
plum-std/Err.plum +0 -10
plum-std/Http.plum +12 -13
plum-std/Json.plum +45 -60
plum-std/List.plum +113 -108
plum-std/Map.plum +24 -25
plum-std/Number.plum +11 -11
plum-std/Option.plum +0 -144
plum-std/Os.plum +19 -19
plum-std/Result.plum +0 -141
plum-std/Str.plum +1 -1
plum-std/Testing.plum +9 -24
plum-std/Try.plum +184 -0
plum-std/Uuid.plum +2 -2
plum-wasm-codegen/src/lib.rs +10 -1
plum-wasm-codegen/tests/codegen_tests.rs +19 -0

plum-std/Base64.plum CHANGED Viewed

@@ -1,7 +1,7 @@
 module std
 import std/Str
 import std/Buffer
-import std/Option
+import std/Try
 import std/Bool
 import std/Number
@@ -100,13 +100,13 @@ fun isBase64Whitespace(b: Int) -> Bool =
   b == 32 || b == 9 || b == 10 || b == 13
 # Decode for URLs (RFC 4648).
-fun decodeUrl(data: Str) -> Option[Str] =
+fun decodeUrl(data: Str) -> Try[Str, [InvalidBase64]] =
   return decode(data, "-", "_", "=")
 # Configurable decoding. The defaults are for RFC 4648. Missing padding is
 # not an error. Non-base64 data, other than whitespace (which can appear at
-# any point), is an error (`None`).
+# any point), is an error (`Err(InvalidBase64)`).
-fun decode(data: Str, at62: Str = "+", at63: Str = "/", pad: Str = "=") -> Option[Str] =
+fun decode(data: Str, at62: Str = "+", at63: Str = "/", pad: Str = "=") -> Try[Str, [InvalidBase64]] =
   at62b := at62.byteAt(0)
   at63b := at63.byteAt(0)
   has_pad := pad.length() > 0
@@ -123,10 +123,10 @@ fun decode(data: Str, at62: Str = "+", at63: Str = "/", pad: Str = "=") -> Optio
       continue
     v := decodeByte(b, at62b, at63b)
     if v < 0
-      return None
+      return Err(InvalidBase64)
     bits = {bits << 6} | v
     nbits = nbits + 6
     if nbits >= 8
       nbits = nbits - 8
       res.writeByte(Byte({bits >> nbits} & 0xFF))
-  return Some(res.toStr())
+  return Ok(res.toStr())

plum-std/Bool.plum CHANGED Viewed

@@ -1,18 +1,18 @@
 module std
-import std/Result
+import std/Try
 import std/Str
 enum Bool =
   | True
   | False
-  fun parse(v: Str) -> Result[Bool, Str] =
+  fun parse(v: Str) -> Try[Bool, [BadBoolStr]] =
     if v == "true"
       Ok(True)
     else if v == "false"
       Ok(False)
     else
-      Err("could not parse bool from '{v}'")
+      Err(BadBoolStr)
   fun and(self, o: Bool) -> Bool =
     match self, o

plum-std/Err.plum DELETED Viewed

@@ -1,10 +0,0 @@
-module std
-import std/Bool
-import std/Number
-import std/Str
-# This is used to represent an error value across the language
-trait Err =
-  code() -> Int
-  msg() -> Str
-  cause() -> Option

plum-std/Http.plum CHANGED Viewed

@@ -4,8 +4,7 @@ import std/Buffer
 import std/Json
 import std/List
 import std/Map
-import std/Option
+import std/Try
-import std/Result
 import std/Str
 import std/Bool
 import std/Number
@@ -25,7 +24,7 @@ enum Response =
   # 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] =
+  fun json(self) -> Try[Json, [InvalidJson(Str)]] =
     return Json.fromStr(self.body)
 fun emptyHeaders() -> Map[Str, Str] =
@@ -75,7 +74,7 @@ fun decodeHeaders(raw: Str) -> Map[Str, Str] =
 # 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] =
+fun request(method: Str, url: Str, headers: Map[Str, Str], body: Str) -> Try[Response, Str] =
   raw := rawHttpRequest(method, url, encodeHeaders(headers), body)
   sep := raw.indexOf("\x00")
   meta := sep >= 0 ? raw.sub(0, sep) : raw
@@ -87,31 +86,31 @@ fun request(method: Str, url: Str, headers: Map[Str, Str], body: Str) -> Result[
   match parseInt(parts.get(1).unwrapOr(""))
     Ok(status) =>
       return Ok(Response(status: status, headers: decodeHeaders(parts.get(2).unwrapOr("")), body: resp_body))
-    Err(e) =>
+    Err(_) =>
-      return Err("invalid status code in http response: {e}")
+      return Err("invalid status code in http response")
-fun get(url: Str, headers: Map[Str, Str]) -> Result[Response, Str] =
+fun get(url: Str, headers: Map[Str, Str]) -> Try[Response, Str] =
   return request("GET", url, headers, "")
-fun head(url: Str, headers: Map[Str, Str]) -> Result[Response, Str] =
+fun head(url: Str, headers: Map[Str, Str]) -> Try[Response, Str] =
   return request("HEAD", url, headers, "")
-fun delete(url: Str, headers: Map[Str, Str]) -> Result[Response, Str] =
+fun delete(url: Str, headers: Map[Str, Str]) -> Try[Response, Str] =
   return request("DELETE", url, headers, "")
-fun post(url: Str, headers: Map[Str, Str], body: Str) -> Result[Response, Str] =
+fun post(url: Str, headers: Map[Str, Str], body: Str) -> Try[Response, Str] =
   return request("POST", url, headers, body)
-fun put(url: Str, headers: Map[Str, Str], body: Str) -> Result[Response, Str] =
+fun put(url: Str, headers: Map[Str, Str], body: Str) -> Try[Response, Str] =
   return request("PUT", url, headers, body)
-fun patch(url: Str, headers: Map[Str, Str], body: Str) -> Result[Response, Str] =
+fun patch(url: Str, headers: Map[Str, Str], body: Str) -> Try[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] =
+fun postJson(url: Str, headers: Map[Str, Str], body: Json) -> Try[Response, Str] =
   headers.set("Content-Type", "application/json")
   return post(url, headers, body.toStr())

plum-std/Json.plum CHANGED Viewed

@@ -1,19 +1,17 @@
 module std
-import std/Option
+import std/Try
-import std/Result
 import std/List
 import std/Map
 import std/Number
 import std/Str
 import std/Buffer
-import std/Err
 import std/Bool
 # A parsed JSON value. Numbers are always stored as `Float` (JSON doesn't
 # distinguish integers from floats the way Plum does), and `JsonList`/
 # `JsonMap` nest `Json` itself — the same self-referential shape `List[T]`
-# already uses internally for `Node[T].next: Option[Node[T]]`.
+# already uses internally for `Node[T].next: Link[Node[T]]`.
 enum Json =
   | JsonNull
   | JsonBool(Bool)
@@ -25,17 +23,17 @@ enum Json =
   # Parses `s` as a single JSON document, requiring the whole string (aside
   # from surrounding whitespace) to be consumed. Called as `Json.fromStr(s)`,
   # matching `Int.fromStr`/`Float.fromStr`'s naming.
-  fun fromStr(s: Str) -> Result[Json, JsonParseError] =
+  fun fromStr(s: Str) -> Try[Json, [InvalidJson(Str)]] =
     parser := JsonParser(src: s, pos: 0)
     parser.skipSpace()
     r := parser.parseValue()
     match r
       Err(e) =>
-        return Err(e)
+        return Err(InvalidJson(e.msg()))
       Ok(v) =>
         parser.skipSpace()
         if parser.pos < parser.src.length()
-          return Err(parser.fail("unexpected trailing characters"))
+          return Err(InvalidJson(parser.fail("unexpected trailing characters").msg()))
         return Ok(v)
   # Renders `self` back to its JSON text form. A literal `{`/`}` is written
@@ -55,52 +53,39 @@ enum Json =
       JsonNull => True
       _ => False
-  fun asBool(self) -> Option[Bool] =
+  fun asBool(self) -> Try[Bool, [WrongJsonType]] =
     match self
-      JsonBool(b) => Some(b)
+      JsonBool(b) => Ok(b)
-      _ => None
+      _ => Err(WrongJsonType)
-  fun asFloat(self) -> Option[Float] =
+  fun asFloat(self) -> Try[Float, [WrongJsonType]] =
     match self
-      JsonFloat(f) => Some(f)
+      JsonFloat(f) => Ok(f)
-      _ => None
+      _ => Err(WrongJsonType)
-  fun asStr(self) -> Option[Str] =
+  fun asStr(self) -> Try[Str, [WrongJsonType]] =
     match self
-      JsonStr(s) => Some(s)
+      JsonStr(s) => Ok(s)
-      _ => None
+      _ => Err(WrongJsonType)
-  fun asList(self) -> Option[List[Json]] =
+  fun asList(self) -> Try[List[Json], [WrongJsonType]] =
     match self
-      JsonList(items) => Some(items)
+      JsonList(items) => Ok(items)
-      _ => None
+      _ => Err(WrongJsonType)
-  fun asMap(self) -> Option[Map[Str, Json]] =
+  fun asMap(self) -> Try[Map[Str, Json], [WrongJsonType]] =
     match self
-      JsonMap(pairs) => Some(pairs)
+      JsonMap(pairs) => Ok(pairs)
-      _ => None
+      _ => Err(WrongJsonType)
 # Carries where in the source a parse failure happened, alongside the
-# message — implements the shared `Err` trait (`libs/std/err.plum`) rather
+# message, so the public `Json.fromStr` can fold it into `InvalidJson(Str)`.
-# than being a plain `Str`, so a caller that wants the position can get it
-# without re-parsing the message.
-enum JsonParseError(Err) =
+enum JsonParseError =
   | JsonParseError(pos: Int, text: Str)
-  fun code(self) -> Int =
-    1
   fun msg(self) -> Str =
     "json parse error at position {self.pos}: {self.text}"
-  # A bare payload-free `None` here can't be disambiguated to one specific
-  # `Option` instantiation from this expression alone (see the README's
-  # "Known gaps" note on this residual generics limitation — unrelated to the
-  # 3 points fixed above) — an explicit `Option[JsonParseError]` return type
-  # sidesteps it.
-  fun cause(self) -> Option[JsonParseError] =
-    None
 # A recursive-descent parser over a `Str` source, tracking its read position
 # in `pos`. (The original design threaded a `Readable` stream through here,
 # but `Readable` is an undefined trait with no methods anywhere in `libs/std`
@@ -129,7 +114,7 @@ enum JsonParser =
     while isSpace(self.peek())
       self.advance()
-  fun parseValue(self) -> Result[Json, JsonParseError] =
+  fun parseValue(self) -> Try[Json, JsonParseError] =
     self.skipSpace()
     c := self.peek()
     if c == 34
@@ -148,14 +133,14 @@ enum JsonParser =
       return self.parseNumber()
     return Err(self.fail("unexpected character"))
-  fun parseLiteral(self, lit: Str, value: Json) -> Result[Json, JsonParseError] =
+  fun parseLiteral(self, lit: Str, value: Json) -> Try[Json, JsonParseError] =
     n := lit.length()
     if !matchesAt(self.src, lit, self.pos, n)
       return Err(self.fail("invalid literal, expected '{lit}'"))
     self.pos = self.pos + n
     return Ok(value)
-  fun parseNumber(self) -> Result[Json, JsonParseError] =
+  fun parseNumber(self) -> Try[Json, JsonParseError] =
     start := self.pos
     if self.peek() == 45
       self.advance()
@@ -182,32 +167,32 @@ enum JsonParser =
   # `Float.fromStr` (`libs/std/float.plum`) doesn't understand exponent
   # notation, so a number that has one is split into its mantissa and
   # exponent around the `e`/`E` and recombined here instead.
-  fun parseNumberText(self, text: Str) -> Result[Json, JsonParseError] =
+  fun parseNumberText(self, text: Str) -> Try[Json, JsonParseError] =
     e_index := exponentIndex(text)
     if e_index < 0
       r := parseFloat(text)
       match r
         Ok(f) =>
           return Ok(JsonFloat(f))
-        Err(m) =>
+        Err(_) =>
-          return Err(self.fail(m))
+          return Err(self.fail("invalid number"))
     mantissa := parseFloat(text.sub(0, e_index))
     exponent := parseInt(text.sub(e_index + 1, text.length()))
     match mantissa
-      Err(m) =>
+      Err(_) =>
-        return Err(self.fail(m))
+        return Err(self.fail("invalid number"))
       Ok(mv) =>
         match exponent
-          Err(m) =>
+          Err(_) =>
-            return Err(self.fail(m))
+            return Err(self.fail("invalid number"))
           Ok(ev) =>
             return Ok(JsonFloat(mv * 10.pow(Float(ev))))
-  fun parseString(self) -> Result[Json, JsonParseError] =
+  fun parseString(self) -> Try[Json, JsonParseError] =
     self.advance()
     return self.parseStringBody(Buffer())
-  fun parseStringBody(self, buf: Buffer) -> Result[Json, JsonParseError] =
+  fun parseStringBody(self, buf: Buffer) -> Try[Json, JsonParseError] =
     c := self.peek()
     if c == 0
       return Err(self.fail("unterminated string"))
@@ -221,7 +206,7 @@ enum JsonParser =
     self.pos = self.pos + n
     return self.parseStringBody(buf)
-  fun parseEscape(self, buf: Buffer) -> Result[Json, JsonParseError] =
+  fun parseEscape(self, buf: Buffer) -> Try[Json, JsonParseError] =
     self.advance()
     esc := self.peek()
     if esc == 34
@@ -261,10 +246,10 @@ enum JsonParser =
       return self.parseUnicodeEscape(buf)
     return Err(self.fail("invalid escape character"))
-  fun parseHex4(self) -> Result[Int, JsonParseError] =
+  fun parseHex4(self) -> Try[Int, JsonParseError] =
     return self.parseHex4From(0, 0)
-  fun parseHex4From(self, value: Int, count: Int) -> Result[Int, JsonParseError] =
+  fun parseHex4From(self, value: Int, count: Int) -> Try[Int, JsonParseError] =
     if count == 4
       return Ok(value)
     d := hexDigitValue(self.peek())
@@ -273,7 +258,7 @@ enum JsonParser =
     self.advance()
     return self.parseHex4From(value * 16 + d, count + 1)
-  fun parseUnicodeEscape(self, buf: Buffer) -> Result[Json, JsonParseError] =
+  fun parseUnicodeEscape(self, buf: Buffer) -> Try[Json, JsonParseError] =
     hr := self.parseHex4()
     match hr
       Err(e) =>
@@ -284,7 +269,7 @@ enum JsonParser =
   # A high surrogate (`0xD800`..`0xDBFF`) must be followed immediately by a
   # low surrogate (`0xDC00`..`0xDFFF`) `\u` escape; the pair together encodes
   # one codepoint above `0xFFFF`. Any other codepoint is used as-is.
-  fun parseUnicodeEscapeCont(self, buf: Buffer, cp: Int) -> Result[Json, JsonParseError] =
+  fun parseUnicodeEscapeCont(self, buf: Buffer, cp: Int) -> Try[Json, JsonParseError] =
     if cp >= 0xD800 && cp <= 0xDBFF && self.peek() == 92 && self.peekAt(1) == 117
       self.advance()
       self.advance()
@@ -301,16 +286,16 @@ enum JsonParser =
     buf.writeRune(cp)
     return self.parseStringBody(buf)
-  fun parseArray(self) -> Result[Json, JsonParseError] =
+  fun parseArray(self) -> Try[Json, JsonParseError] =
     self.advance()
     self.skipSpace()
-    items := List[Json](head: None, tail: None, size: 0)
+    items := List[Json](head: End, tail: End, size: 0)
     if self.peek() == 93
       self.advance()
       return Ok(JsonList(items))
     return self.parseArrayItems(items)
-  fun parseArrayItems(self, items: List[Json]) -> Result[Json, JsonParseError] =
+  fun parseArrayItems(self, items: List[Json]) -> Try[Json, JsonParseError] =
     self.skipSpace()
     r := self.parseValue()
     match r
@@ -328,7 +313,7 @@ enum JsonParser =
           return Ok(JsonList(items))
         return Err(self.fail("expected ',' or ']'"))
-  fun parseObject(self) -> Result[Json, JsonParseError] =
+  fun parseObject(self) -> Try[Json, JsonParseError] =
     self.advance()
     self.skipSpace()
     pairs := Map[Str, Json]()
@@ -337,7 +322,7 @@ enum JsonParser =
       return Ok(JsonMap(pairs))
     return self.parseObjectItems(pairs)
-  fun parseObjectItems(self, pairs: Map[Str, Json]) -> Result[Json, JsonParseError] =
+  fun parseObjectItems(self, pairs: Map[Str, Json]) -> Try[Json, JsonParseError] =
     self.skipSpace()
     if self.peek() != 34
       return Err(self.fail("expected string key"))
@@ -348,7 +333,7 @@ enum JsonParser =
       Ok(keyJson) =>
         return self.parseObjectValue(pairs, jsonStrValue(keyJson))
-  fun parseObjectValue(self, pairs: Map[Str, Json], key: Str) -> Result[Json, JsonParseError] =
+  fun parseObjectValue(self, pairs: Map[Str, Json], key: Str) -> Try[Json, JsonParseError] =
     self.skipSpace()
     if self.peek() != 58
       return Err(self.fail("expected ':'"))

plum-std/List.plum CHANGED Viewed

@@ -1,19 +1,24 @@
 module std
-import std/Option
+import std/Try
 import std/Buffer
 import std/Number
 import std/Bool
 import std/Str
 # A node stores the data in a list and contains pointers to the previous and next sibling nodes
+# Private link between nodes (not an error tag, so a domain enum rather than Try).
+enum Link[N] =
+  | Next(N)
+  | End
 enum Node[T] =
-  | Node(value: T, prev: Option[Node[T]], next: Option[Node[T]])
+  | Node(value: T, prev: Link[Node[T]], next: Link[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
 enum List[T: ToStr](ToStr) =
-  | List(head: Option[Node[T]], tail: Option[Node[T]], size: Int)
+  | List(head: Link[Node[T]], tail: Link[Node[T]], size: Int)
   # `List[T](1, 2, 3)` (or, for an empty list, `List[T]()` — explicit
   # generics required either way, since nothing else in a call this shape
@@ -21,42 +26,42 @@ enum List[T: ToStr](ToStr) =
   # `plum-checker`/`plum-wasm-codegen`'s `ClassCall`/`FnCall` handling, which
   # desugars both call shapes to `List.init(...)`.
   fun init(values: ...T) -> List[T] =
-    l := List(head: None, tail: None, size: 0)
+    l := List(head: End, tail: End, size: 0)
     for v := range values
       l.add(v)
     return l
   # gets the element at i'th index of the list
-  fun get(self, i: Int) -> Option[T] =
+  fun get(self, i: Int) -> Try[T, [OutOfBounds]] =
     current := self.head
     index := 0
-    while current != None
+    while current != End
       match current
-        Some(Node(value, _, next)) =>
+        Next(Node(value, _, next)) =>
           if index == i
-            return Some(value)
+            return Ok(value)
           current = next
           index = index + 1
-        None =>
+        End =>
           break
-    None
+    Err(OutOfBounds)
-  # sets the element at i'th index of the list, returning the old value (or None if i is out of bounds)
+  # sets the element at i'th index of the list, returning the old value (or Err(OutOfBounds) if i is out of bounds)
-  fun set(self, i: Int, v: T) -> Option[T] =
+  fun set(self, i: Int, v: T) -> Try[T, [OutOfBounds]] =
     current := self.head
     index := 0
-    while current != None
+    while current != End
       match current
-        Some(node) =>
+        Next(node) =>
           if index == i
             old := node.value
             node.value = v
-            return Some(old)
+            return Ok(old)
           current = node.next
           index = index + 1
-        None =>
+        End =>
           break
-    None
+    Err(OutOfBounds)
   # returns the no of elements in the list
   fun length(self) -> Int =
@@ -76,26 +81,26 @@ enum List[T: ToStr](ToStr) =
   # adds the specified elements to the end of the list
   fun add(self, values: ...T) =
     for v := range values
-      node := Node(value: v, prev: self.tail, next: None)
+      node := Node(value: v, prev: self.tail, next: End)
       match self.tail
-        Some(t) =>
+        Next(t) =>
-          t.next = Some(node)
+          t.next = Next(node)
-        None =>
+        End =>
-          self.head = Some(node)
+          self.head = Next(node)
-      self.tail = Some(node)
+      self.tail = Next(node)
       self.size = self.size + 1
   # unlinks node from the list, patching its neighbors (or head/tail) to close the gap
   fun unlink(self, node: Node[T]) =
     match node.prev
-      Some(p) =>
+      Next(p) =>
         p.next = node.next
-      None =>
+      End =>
         self.head = node.next
     match node.next
-      Some(n) =>
+      Next(n) =>
         n.prev = node.prev
-      None =>
+      End =>
         self.tail = node.prev
     self.size = self.size - 1
@@ -103,47 +108,47 @@ enum List[T: ToStr](ToStr) =
   fun removeAt(self, i: Int) =
     current := self.head
     index := 0
-    while current != None
+    while current != End
       match current
-        Some(node) =>
+        Next(node) =>
           if index == i
             self.unlink(node)
             return
           current = node.next
           index = index + 1
-        None =>
+        End =>
           break
   # removes the first element equal to v from list
   fun remove(self, v: T) =
     current := self.head
-    while current != None
+    while current != End
       match current
-        Some(node) =>
+        Next(node) =>
           if node.value == v
             self.unlink(node)
             return
           current = node.next
-        None =>
+        End =>
           break
   # removes all objects from this list
   fun clear(self) =
-    self.head = None
+    self.head = End
-    self.tail = None
+    self.tail = End
     self.size = 0
   # returns the list with the elements relinked in reverse order.
   fun reverse(self) -> List =
     current := self.head
-    while current != None
+    while current != End
       match current
-        Some(node) =>
+        Next(node) =>
           next := node.next
           node.next = node.prev
           node.prev = next
           current = next
-        None =>
+        End =>
           break
     old_head := self.head
     self.head = self.tail
@@ -155,13 +160,13 @@ enum List[T: ToStr](ToStr) =
   # `sort`'s pointer surgery, split out since `unlink`'s counterpart already
   # gets its own method.
   fun insertBefore(self, node: Node[T], value: T) -> Unit =
-    new_node := Node(value: value, prev: node.prev, next: Some(node))
+    new_node := Node(value: value, prev: node.prev, next: Next(node))
     match node.prev
-      Some(p) =>
+      Next(p) =>
-        p.next = Some(new_node)
+        p.next = Next(new_node)
-      None =>
+      End =>
-        self.head = Some(new_node)
+        self.head = Next(new_node)
-    node.prev = Some(new_node)
+    node.prev = Next(new_node)
     self.size = self.size + 1
   # Inserts `value` into `self` (assumed already sorted by `before`) at the
@@ -169,14 +174,14 @@ enum List[T: ToStr](ToStr) =
   # `before(value, existing)` holds for, or the end if none does.
   fun insertSorted(self, value: T, before: fn(T, T) -> Bool) -> Unit =
     current := self.head
-    while current != None
+    while current != End
       match current
-        Some(node) =>
+        Next(node) =>
           if before(value, node.value)
             self.insertBefore(node, value)
             return
           current = node.next
-        None =>
+        End =>
           break
     self.add(value)
@@ -184,42 +189,42 @@ enum List[T: ToStr](ToStr) =
   # the "does a belong before b" comparator. Insertion sort (O(n^2)) — simple
   # and adequate for the list sizes a linked list is already suited to.
   fun sort(self, before: fn(T, T) -> Bool) -> List[T] =
-    result := List(head: None, tail: None, size: 0)
+    result := List(head: End, tail: End, size: 0)
     current := self.head
-    while current != None
+    while current != End
       match current
-        Some(Node(value, _, next)) =>
+        Next(Node(value, _, next)) =>
           result.insertSorted(value, before)
           current = next
-        None =>
+        End =>
           break
     return result
-  # Returns the first element equal to `search`, or `None`.
+  # Returns the first element equal to `search`, or `Err(NotFound)`.
-  fun find(self, search: T) -> Option[T] =
+  fun find(self, search: T) -> Try[T, [NotFound]] =
     current := self.head
-    while current != None
+    while current != End
       match current
-        Some(Node(value, _, next)) =>
+        Next(Node(value, _, next)) =>
           if value == search
-            return Some(value)
+            return Ok(value)
           current = next
-        None =>
+        End =>
           break
-    return None
+    return Err(NotFound)
   fun contains(self, v: T) -> Bool =
-    return self.find(v) != None
+    return self.find(v).isOk()
   # calls f for each elem in the list
   fun each(self, cb: fn(T)) -> Unit =
     current := self.head
-    while current != None
+    while current != End
       match current
-        Some(Node(value, _, next)) =>
+        Next(Node(value, _, next)) =>
           cb(value)
           current = next
-        None =>
+        End =>
           break
   # Returns a new list with each element transformed by `cb`.
@@ -229,14 +234,14 @@ enum List[T: ToStr](ToStr) =
   # when `List[T]` itself is specialized, via `resolveMethodOwnGenerics` in
   # `plum-checker/src/monomorphize.rs`.
   fun map(self, cb: fn(T) -> U) -> List[U] =
-    result := List(head: None, tail: None, size: 0)
+    result := List(head: End, tail: End, size: 0)
     current := self.head
-    while current != None
+    while current != End
       match current
-        Some(Node(value, _, next)) =>
+        Next(Node(value, _, next)) =>
           result.add(cb(value))
           current = next
-        None =>
+        End =>
           break
     return result
@@ -246,53 +251,53 @@ enum List[T: ToStr](ToStr) =
   # Returns a new list with only the elements `predicate` holds for.
   fun retain(self, predicate: fn(T) -> Bool) -> List[T] =
-    result := List(head: None, tail: None, size: 0)
+    result := List(head: End, tail: End, size: 0)
     current := self.head
-    while current != None
+    while current != End
       match current
-        Some(Node(value, _, next)) =>
+        Next(Node(value, _, next)) =>
           if predicate(value)
             result.add(value)
           current = next
-        None =>
+        End =>
           break
     return result
   # Returns a new list with the elements `predicate` holds for removed.
   fun reject(self, predicate: fn(T) -> Bool) -> List[T] =
-    result := List(head: None, tail: None, size: 0)
+    result := List(head: End, tail: End, size: 0)
     current := self.head
-    while current != None
+    while current != End
       match current
-        Some(Node(value, _, next)) =>
+        Next(Node(value, _, next)) =>
           if !predicate(value)
             result.add(value)
           current = next
-        None =>
+        End =>
           break
     return result
   fun any(self, predicate: fn(T) -> Bool) -> Bool =
     current := self.head
-    while current != None
+    while current != End
       match current
-        Some(Node(value, _, next)) =>
+        Next(Node(value, _, next)) =>
           if predicate(value)
             return True
           current = next
-        None =>
+        End =>
           break
     return False
   fun every(self, predicate: fn(T) -> Bool) -> Bool =
     current := self.head
-    while current != None
+    while current != End
       match current
-        Some(Node(value, _, next)) =>
+        Next(Node(value, _, next)) =>
           if !predicate(value)
             return False
           current = next
-        None =>
+        End =>
           break
     return True
@@ -304,43 +309,43 @@ enum List[T: ToStr](ToStr) =
   fun reduce(self, acc: U, cb: fn(U, T) -> U) -> U =
     result := acc
     current := self.head
-    while current != None
+    while current != End
       match current
-        Some(Node(value, _, next)) =>
+        Next(Node(value, _, next)) =>
           result = cb(result, value)
           current = next
-        None =>
+        End =>
           break
     return result
   # returns the first element in the list
-  fun first(self) -> Option[T] =
+  fun first(self) -> Try[T, [ListWasEmpty]] =
     match self.head
-      Some(Node(value, _, _)) => Some(value)
+      Next(Node(value, _, _)) => Ok(value)
-      None => None
+      End => Err(ListWasEmpty)
   # returns the last element in the list
-  fun last(self) -> Option[T] =
+  fun last(self) -> Try[T, [ListWasEmpty]] =
     match self.tail
-      Some(Node(value, _, _)) => Some(value)
+      Next(Node(value, _, _)) => Ok(value)
-      None => None
+      End => Err(ListWasEmpty)
   # Returns a new list of the elements at index `[start, end)`, clamped into
   # range (a `start`/`end` outside `[0, length]` is clamped, not an error).
   fun sublist(self, start: Int, end: Int) -> List[T] =
-    result := List(head: None, tail: None, size: 0)
+    result := List(head: End, tail: End, size: 0)
     s := start < 0 ? 0 : start
     e := end > self.size ? self.size : end
     current := self.head
     i := 0
-    while current != None && i < e
+    while current != End && i < e
       match current
-        Some(Node(value, _, next)) =>
+        Next(Node(value, _, next)) =>
           if i >= s
             result.add(value)
           current = next
           i = i + 1
-        None =>
+        End =>
           break
     return result
@@ -355,11 +360,11 @@ enum List[T: ToStr](ToStr) =
   fun drop(self, n: Int) -> List[T] =
     return self.skip(n)
-  # Returns one uniformly random element, or `None` if `self` is empty.
+  # Returns one uniformly random element, or `Err(ListWasEmpty)` if `self` is empty.
-  fun sample(self) -> Option[T] =
+  fun sample(self) -> Try[T, [ListWasEmpty]] =
     if self.size == 0
-      return None
+      return Err(ListWasEmpty)
-    return self.get(randomInt(self.size))
+    return Ok(self.get(randomInt(self.size)).unwrap())
   # Returns a new list with `self`'s elements in random order (Fisher-Yates).
   fun shuffle(self) -> List[T] =
@@ -381,7 +386,7 @@ enum List[T: ToStr](ToStr) =
   # doc comments for the full fix) — that danger is now FIXED (2026-09-02).
   #
   # A second, more contained bug surfaced once past that: two SEPARATE bare
-  # `List(head: None, tail: None, size: 0)` constructions in the SAME method
+  # `List(head: End, tail: End, size: 0)` constructions in the SAME method
   # body — one for the OUTER `result: List[List[T]]` (matching this
   # method's own declared return type) and one for an INNER per-chunk
   # `piece: List[T]` — are ambiguous to `resolveClassInstantiation`'s
@@ -397,7 +402,7 @@ enum List[T: ToStr](ToStr) =
   # unambiguously resolved through the RECEIVER's own (already-correct)
   # binding, no `current_return_type` guessing involved at all.
   fun chunk(self, size: Int) -> List[List[T]] =
-    result := List(head: None, tail: None, size: 0)
+    result := List(head: End, tail: End, size: 0)
     if size <= 0
       return result
     i := 0
@@ -411,7 +416,7 @@ enum List[T: ToStr](ToStr) =
   # in that order. Returns them as a 2-element `List[List[T]]` (`[matched,
   # unmatched]`) since this language has no tuple type. Deliberately built
   # from `self.retain(predicate)`/`self.reject(predicate)` rather than two
-  # local `matched`/`unmatched := List(head: None, ...)` bare constructions
+  # local `matched`/`unmatched := List(head: End, ...)` bare constructions
   # — see `chunk`'s doc comment above for exactly why that would be
   # ambiguous (`matched`/`unmatched` need `List[T]`, but a bare
   # construction here would resolve via `current_return_type` fallback
@@ -420,7 +425,7 @@ enum List[T: ToStr](ToStr) =
   # bare construction per method body, matching their own single-level
   # return type).
   fun partition(self, predicate: fn(T) -> Bool) -> List[List[T]] =
-    result := List(head: None, tail: None, size: 0)
+    result := List(head: End, tail: End, size: 0)
     result.add(self.retain(predicate))
     result.add(self.reject(predicate))
     return result
@@ -443,14 +448,14 @@ enum List[T: ToStr](ToStr) =
   fun join(self, sep: Str = ",") -> Str =
     res := Buffer()
     current := self.head
-    while current != None
+    while current != End
       match current
-        Some(Node(value, _, next)) =>
+        Next(Node(value, _, next)) =>
           res.write(value.toStr())
-          if next != None
+          if next != End
             res.write(sep)
           current = next
-        None =>
+        End =>
           break
     res.toStr()
@@ -471,10 +476,10 @@ enum List[T: ToStr](ToStr) =
 # ---- regression tests ----
-fun optSumForListTest(o: Option[Int]) -> Int =
+fun optSumForListTest(o: Try[Int, [OutOfBounds]]) -> Int =
   match o
-    Some(v) => v
+    Ok(v) => v
-    None => -1000
+    Err(_) => -1000
 fun exerciseList() -> Int =
   l = List(1, 2, 3, 4, 5)

plum-std/Map.plum CHANGED Viewed

@@ -1,6 +1,6 @@
 module std
 import std/List
-import std/Option
+import std/Try
 import std/Array
 import std/Bool
 import std/Number
@@ -22,8 +22,7 @@ trait Hashable =
 # A Pair is a grouping of a key with a value.
 #
-# `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
+# `toStr` (unlike `Try`'s — see `Try.plum`'s note on `toTryStr`) 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: ToStr]` already requires its own `T` to support `toStr` —
 # so a `Pair` used as a `List` element always has `K`/`V: ToStr` too,
@@ -70,21 +69,21 @@ enum Map[K: Hashable, V] =
     m := k.hash() % BUCKET_COUNT
     return m < 0 ? m + BUCKET_COUNT : m
-  # Gets the value for `k`, or `None` if absent.
+  # Gets the value for `k`, or `Err(KeyNotFound)` if absent.
-  fun get(self, k: K) -> Option[V] =
+  fun get(self, k: K) -> Try[V, [KeyNotFound]] =
     current := self.buckets.get(self.bucketIndex(k)).head
-    while current != None
+    while current != End
       match current
-        Some(Node(Pair(key, val), _, next)) =>
+        Next(Node(Pair(key, val), _, next)) =>
           if key == k
-            return Some(val)
+            return Ok(val)
           current = next
-        None =>
+        End =>
           break
-    return None
+    return Err(KeyNotFound)
   fun has(self, k: K) -> Bool =
-    return self.get(k) != None
+    return self.get(k).isOk()
   # Sets `k`'s value to `v` — replacing an existing entry for `k` in place
   # (mutating the stored `Pair`'s `val` field) rather than appending a
@@ -93,14 +92,14 @@ enum Map[K: Hashable, V] =
   fun set(self, k: K, v: V) -> Unit =
     bucket := self.buckets.get(self.bucketIndex(k))
     current := bucket.head
-    while current != None
+    while current != End
       match current
-        Some(Node(pair, _, next)) =>
+        Next(Node(pair, _, next)) =>
           if pair.key == k
             pair.val = v
             return
           current = next
-        None =>
+        End =>
           break
     bucket.add(Pair(key: k, val: v))
     self.size = self.size + 1
@@ -114,15 +113,15 @@ enum Map[K: Hashable, V] =
   fun remove(self, k: K) -> Unit =
     bucket := self.buckets.get(self.bucketIndex(k))
     current := bucket.head
-    while current != None
+    while current != End
       match current
-        Some(node) =>
+        Next(node) =>
           if node.value.key == k
             bucket.unlink(node)
             self.size = self.size - 1
             return
           current = node.next
-        None =>
+        End =>
           break
   fun length(self) -> Int =
@@ -145,22 +144,22 @@ enum Map[K: Hashable, V] =
     i := 0
     while i < self.buckets.length()
       current := self.buckets.get(i).head
-      while current != None
+      while current != End
         match current
-          Some(Node(Pair(key, val), _, next)) =>
+          Next(Node(Pair(key, val), _, next)) =>
             cb(key, val)
             current = next
-          None =>
+          End =>
             break
       i = i + 1
   fun keys(self) -> List[K] =
-    result := List(head: None, tail: None, size: 0)
+    result := List(head: End, tail: End, size: 0)
     self.each(|k, v| result.add(k))
     return result
   fun values(self) -> List[V] =
-    result := List(head: None, tail: None, size: 0)
+    result := List(head: End, tail: End, size: 0)
     self.each(|k, v| result.add(v))
     return result
@@ -174,13 +173,13 @@ enum Map[K: Hashable, V] =
     j := 0
     while j < self.buckets.length()
       current := self.buckets.get(j).head
-      while current != None
+      while current != End
         match current
-          Some(Node(Pair(key, val), _, next)) =>
+          Next(Node(Pair(key, val), _, next)) =>
             pair := cb(key, val)
             result.set(pair.key, pair.val)
             current = next
-          None =>
+          End =>
             break
       j = j + 1
     return result

plum-std/Number.plum CHANGED Viewed

@@ -1,7 +1,7 @@
 module std
 import std/Str
 import std/Bool
-import std/Result
+import std/Try
 MIN_VALUE = -0x8000_0000_0000_0000 # Lowest value of Int
 MAX_VALUE = 0x7FFF_FFFF_FFFF_FFFF  # Highest value of Int
@@ -303,41 +303,41 @@ fun powFloat(base: Float, y: Float) -> Float =
   return exp(y * ln(base))
 # Parses a decimal integer, with an optional leading `+`/`-`.
-fun parseInt(s: Str) -> Result[Int, Str] =
+fun parseInt(s: Str) -> Try[Int, [BadNumStr]] =
   len := s.length()
   if len == 0
-    return Err("empty string")
+    return Err(BadNumStr)
   neg := s.byteAt(0) == 45
   start := neg || s.byteAt(0) == 43 ? 1 : 0
   if start >= len
-    return Err("invalid integer: '{s}'")
+    return Err(BadNumStr)
   value := 0
   i := start
   while i < len
     b := s.byteAt(i)
     if b < 48 || b > 57
-      return Err("invalid integer: '{s}'")
+      return Err(BadNumStr)
     value = value * 10 + b - 48
     i = i + 1
   return Ok(neg ? -value : value)
 # Parses a decimal float, with an optional leading `+`/`-` and an optional
 # `.` fractional part (no exponent notation).
-fun parseFloat(s: Str) -> Result[Float, Str] =
+fun parseFloat(s: Str) -> Try[Float, [BadNumStr]] =
   len := s.length()
   if len == 0
-    return Err("empty string")
+    return Err(BadNumStr)
   neg := s.byteAt(0) == 45
   start := neg || s.byteAt(0) == 43 ? 1 : 0
   if start >= len
-    return Err("invalid float: '{s}'")
+    return Err(BadNumStr)
   int_part := 0.0f
   saw_digit := False
   i := start
   while i < len && s.byteAt(i) != 46
     b := s.byteAt(i)
     if b < 48 || b > 57
-      return Err("invalid float: '{s}'")
+      return Err(BadNumStr)
     int_part = int_part * 10.0f + Float(b - 48)
     saw_digit = True
     i = i + 1
@@ -348,13 +348,13 @@ fun parseFloat(s: Str) -> Result[Float, Str] =
     while i < len
       b = s.byteAt(i)
       if b < 48 || b > 57
-        return Err("invalid float: '{s}'")
+        return Err(BadNumStr)
       frac_scale = frac_scale / 10.0f
       frac_part = frac_part + Float(b - 48) * frac_scale
       saw_digit = True
       i = i + 1
   if !saw_digit
-    return Err("invalid float: '{s}'")
+    return Err(BadNumStr)
   value := int_part + frac_part
   return Ok(neg ? -value : value)

plum-std/Option.plum DELETED Viewed

@@ -1,144 +0,0 @@
-module std
-import std/Result
-import std/Str
-import std/Bool
-import std/Number
-# Option[T] represents a value that may or may not be present — Plum's
-# counterpart to Rust's `Option`/Go's "zero value or ok bool" idiom.
-enum Option[T] =
-  | Some(T)
-  | None
-  fun isSome(self) -> Bool =
-    match self
-      Some(_) => True
-      None => False
-  fun isNone(self) -> Bool =
-    match self
-      Some(_) => False
-      None => True
-  # Returns the wrapped value, or traps if `self` is `None`.
-  fun unwrap(self) -> T =
-    match self
-      Some(v) =>
-        return v
-      None =>
-        todo
-  # Returns the wrapped value, or traps if `self` is `None`. `msg` documents
-  # the expectation at the call site (matching Rust's `Option::expect`) but
-  # isn't surfaced anywhere at runtime — there's no host-independent "print
-  # this and trap" primitive to build that on.
-  fun expect(self, msg: Str) -> T =
-    match self
-      Some(v) =>
-        return v
-      None =>
-        todo
-  fun unwrapOr(self, default: T) -> T =
-    match self
-      Some(v) =>
-        return v
-      None =>
-        return default
-  # Like `unwrapOr`, but the fallback is computed lazily (only when `self` is
-  # `None`) via `cb` — useful when producing the default is expensive.
-  fun unwrapOrElse(self, cb: fn() -> T) -> T =
-    match self
-      Some(v) =>
-        return v
-      None =>
-        return cb()
-  # Keeps `self` only if it's `Some` AND `predicate` holds for its value;
-  # otherwise returns `None`.
-  fun filter(self, predicate: fn(T) -> Bool) -> Option[T] =
-    match self
-      Some(v) =>
-        if predicate(v)
-          return Some(v)
-        return None
-      None =>
-        return None
-  # Transforms the wrapped value with `cb`, leaving `None` as `None`. `U` is
-  # `map`'s OWN generic param (the transformed value's type), separate from
-  # `Option[T]`'s own `T` — resolved per CALL SITE, not when `Option[T]`
-  # itself is specialized (see `resolveMethodOwnGenerics`).
-  fun map(self, cb: fn(T) -> U) -> Option[U] =
-    match self
-      Some(v) =>
-        return Some(cb(v))
-      None =>
-        return None
-  # Like `map`, but `cb` itself returns an `Option[U]` (rather than a bare
-  # `U`) and the result isn't re-wrapped — useful for chaining together
-  # several fallible steps without nesting (`Option[Option[U]]`). `U` here is
-  # `andThen`'s OWN generic param, nested inside `cb`'s declared return type
-  # `Option[U]` rather than being `cb`'s bare return type — resolved from the
-  # closure's actual inferred return type via `bindGenericArg` in
-  # `plum-checker/src/monomorphize.rs`'s `resolveMethodOwnGenerics`.
-  fun andThen(self, cb: fn(T) -> Option[U]) -> Option[U] =
-    match self
-      Some(v) =>
-        return cb(v)
-      None =>
-        return None
-  # Converts to a `Result`, using `err` as the failure value if `self` is
-  # `None`. `E` is `okOr`'s OWN generic param, inferred directly from `err`'s
-  # own value (same mechanism as `List.reduce`'s accumulator param).
-  fun okOr(self, err: E) -> Result[T, E] =
-    match self
-      Some(v) =>
-        return Ok(v)
-      None =>
-        return Err(err)
-  # No `toStr(self) -> Str` here — every method on a generic type gets
-  # compiled for EVERY concrete specialization that type is ever used at
-  # ANYWHERE in the whole program, whether or not that particular method is
-  # actually called for that specialization (there's no lazy/on-demand
-  # method compilation). `libs/std/list.plum`'s `List[T]` internally uses
-  # `Option[Node[T]]` for its own `head`/`tail` fields — and `Node` has no
-  # `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: ToStr`
-  # bound) wherever printing an `Option` is needed.
-  fun toOptionStr(self, valueToStr: fn(T) -> Str) -> Str =
-    match self
-      Some(v) =>
-        return "Some({valueToStr(v)})"
-      None =>
-        return "None"
-fun makeNoneIntForOptionTest() -> Option[Int] =
-  return None
-test "filter keeps a Some value only when the predicate holds"
-  assert Some(4).filter(|v| v > 2).isSome()
-  assert Some(1).filter(|v| v > 2).isNone()
-  assert makeNoneIntForOptionTest().filter(|v| v > 2).isNone()
-test "andThen chains fallible steps without double-wrapping"
-  half := |n| n % 2 == 0
-  a := Some(8).andThen(|n| Some(n / 2)).andThen(|n| Some(n / 2))
-  assert a.isSome()
-  assert a.unwrap() == 2
-  assert half(a.unwrap())
-  b := makeNoneIntForOptionTest().andThen(|n| Some(n / 2))
-  assert b.isNone()
-test "okOr converts to a Result using the given error on None"
-  assert Some(5).okOr("missing").isOk()
-  assert Some(5).okOr("missing").unwrap() == 5
-  assert makeNoneIntForOptionTest().okOr("missing").isErr()
-  assert makeNoneIntForOptionTest().okOr("missing").unwrapErr() == "missing"

plum-std/Os.plum CHANGED Viewed

@@ -1,6 +1,6 @@
 module std
 import std/List
-import std/Result
+import std/Try
 import std/Str
 import std/Uuid
 import std/Bool
@@ -58,13 +58,13 @@ extern fun rawReadDir(path: Str) -> Str
 # Reads the whole file at `path` as a `Str` (`Str` is a byte array here — see
 # `libs/std/str.plum` — so this works for binary content too, not just text).
-fun readFile(path: Str) -> Result[Str, Str] =
+fun readFile(path: Str) -> Try[Str, Str] =
   if !exists(path)
     return Err("no such file: '{path}'")
   return Ok(rawReadFile(path))
 # Writes `data` to `path`, replacing its previous contents (or creating it).
-fun writeFile(path: Str, data: Str) -> Result[Bool, Str] =
+fun writeFile(path: Str, data: Str) -> Try[Bool, Str] =
   if rawWriteFile(path, data) == 1
     return Ok(True)
   return Err("failed to write file: '{path}'")
@@ -72,13 +72,13 @@ fun writeFile(path: Str, data: Str) -> Result[Bool, Str] =
 fun exists(path: Str) -> Bool =
   return rawExists(path) == 1
-fun mkdir(path: Str) -> Result[Bool, Str] =
+fun mkdir(path: Str) -> Try[Bool, Str] =
   if rawMkdir(path) == 1
     return Ok(True)
   return Err("failed to create directory: '{path}'")
 # Removes the file (not directory) at `path`.
-fun remove(path: Str) -> Result[Bool, Str] =
+fun remove(path: Str) -> Try[Bool, Str] =
   if !exists(path)
     return Err("no such file: '{path}'")
   if rawRemove(path) == 1
@@ -95,7 +95,7 @@ fun access(path: Str) -> Bool =
 # contents) if it doesn't already exist. There's no host-level "open for
 # append" primitive, so this reads the existing bytes and writes the
 # concatenation back — not atomic, and O(existing file size) per call.
-fun appendFile(path: Str, data: Str) -> Result[Bool, Str] =
+fun appendFile(path: Str, data: Str) -> Try[Bool, Str] =
   if exists(path)
     match readFile(path)
       Ok(existing) =>
@@ -106,7 +106,7 @@ fun appendFile(path: Str, data: Str) -> Result[Bool, Str] =
 # Unix permission bits only (e.g. `0o644`) — this VM has no Windows ACL
 # equivalent to fall back to.
-fun chmod(path: Str, mode: Int) -> Result[Bool, Str] =
+fun chmod(path: Str, mode: Int) -> Try[Bool, Str] =
   if rawChmod(path, mode) == 1
     return Ok(True)
   return Err("failed to chmod: '{path}'")
@@ -116,18 +116,18 @@ fun chmod(path: Str, mode: Int) -> Result[Bool, Str] =
 fun chown(path: Str, uid: Int, gid: Int) =
   todo
-fun copyFile(src: Str, dest: Str) -> Result[Bool, Str] =
+fun copyFile(src: Str, dest: Str) -> Try[Bool, Str] =
   match readFile(src)
     Ok(data) => writeFile(dest, data)
     Err(e) => Err(e)
-fun cp(src: Str, dest: Str) -> Result[Bool, Str] =
+fun cp(src: Str, dest: Str) -> Try[Bool, Str] =
   return copyFile(src, dest)
 # Symlinks aren't modeled separately from regular files/dirs by this VM's
 # host primitives (`rawChmod` always follows them), so this is the same as
 # `chmod`.
-fun lchmod(path: Str, mode: Int) -> Result[Bool, Str] =
+fun lchmod(path: Str, mode: Int) -> Try[Bool, Str] =
   return chmod(path, mode)
 # See `chown` — no uid/gid syscall exposed by this VM.
@@ -139,7 +139,7 @@ fun lchown(path: Str, uid: Int, gid: Int) =
 fun lutimes(path: Str, atime: Int, mtime: Int) =
   todo
-fun link(existing_path: Str, new_path: Str) -> Result[Bool, Str] =
+fun link(existing_path: Str, new_path: Str) -> Try[Bool, Str] =
   if rawLink(existing_path, new_path) == 1
     return Ok(True)
   return Err("failed to link '{existing_path}' -> '{new_path}'")
@@ -152,7 +152,7 @@ fun lstat(path: Str) =
 # Creates a fresh directory named `prefix` followed by a random suffix,
 # retrying on the (astronomically unlikely) chance of a collision, and
 # returns the path actually created.
-fun mkdtemp(prefix: Str) -> Result[Str, Str] =
+fun mkdtemp(prefix: Str) -> Try[Str, Str] =
   path := prefix + v4().toStr()
   if exists(path)
     return mkdtemp(prefix)
@@ -173,7 +173,7 @@ fun opendir(path: Str) =
   todo
 # The names of `path`'s directory entries (not full paths).
-fun readdir(path: Str) -> Result[List[Str], Str] =
+fun readdir(path: Str) -> Try[List[Str], Str] =
   if !exists(path)
     return Err("no such directory: '{path}'")
   # `reject`ing empty names handles both a genuinely empty directory (whose
@@ -182,17 +182,17 @@ fun readdir(path: Str) -> Result[List[Str], Str] =
   # check above) the same way — no directory entry is ever named `""`.
   return Ok(rawReadDir(path).split("\n", 0).reject(|n| n == ""))
-fun readlink(path: Str) -> Result[Str, Str] =
+fun readlink(path: Str) -> Try[Str, Str] =
   if !exists(path)
     return Err("no such file: '{path}'")
   return Ok(rawReadlink(path))
-fun realpath(path: Str) -> Result[Str, Str] =
+fun realpath(path: Str) -> Try[Str, Str] =
   if !exists(path)
     return Err("no such file: '{path}'")
   return Ok(rawRealpath(path))
-fun rename(old_path: Str, new_path: Str) -> Result[Bool, Str] =
+fun rename(old_path: Str, new_path: Str) -> Try[Bool, Str] =
   if !exists(old_path)
     return Err("no such file: '{old_path}'")
   if rawRename(old_path, new_path) == 1
@@ -200,7 +200,7 @@ fun rename(old_path: Str, new_path: Str) -> Result[Bool, Str] =
   return Err("failed to rename '{old_path}' -> '{new_path}'")
 # Removes an empty directory. (`remove` above covers plain files.)
-fun rmdir(path: Str) -> Result[Bool, Str] =
+fun rmdir(path: Str) -> Try[Bool, Str] =
   if !exists(path)
     return Err("no such directory: '{path}'")
   if rawRemoveDir(path) == 1
@@ -215,14 +215,14 @@ fun stat(path: Str) =
 fun statfs(path: Str) =
   todo
-fun symlink(target: Str, path: Str) -> Result[Bool, Str] =
+fun symlink(target: Str, path: Str) -> Try[Bool, Str] =
   if rawSymlink(target, path) == 1
     return Ok(True)
   return Err("failed to symlink '{path}' -> '{target}'")
 # Resizes the file at `path` to exactly `len` bytes — truncated if shorter,
 # zero-padded if longer.
-fun truncate(path: Str, len: Int) -> Result[Bool, Str] =
+fun truncate(path: Str, len: Int) -> Try[Bool, Str] =
   if !exists(path)
     return Err("no such file: '{path}'")
   if rawTruncate(path, len) == 1

plum-std/Result.plum DELETED Viewed

@@ -1,141 +0,0 @@
-module std
-import std/Option
-import std/Str
-import std/Bool
-import std/Number
-# Result[T, E] represents either success (`Ok`, carrying a `T`) or failure
-# (`Err`, carrying an `E`) — used throughout std for fallible operations
-# (`Bool.parse`, `Int.fromStr`, `Float.fromStr`).
-#
-# `andThen` (which would need `cb`'s return type's `T` to be found NESTED
-# inside another `Result[U, E]`, not `cb`'s own bare return type) is
-# intentionally not implemented here — same method-level-generics gap
-# documented on `Option.andThen` in `libs/std/option.plum`. `map`/`mapErr`
-# don't have that problem (`cb`'s return type IS directly the new generic
-# param, same shape as `List.map`), so those ARE implemented below.
-enum Result[T, E] =
-  | Ok(T)
-  | Err(E)
-  fun isOk(self) -> Bool =
-    match self
-      Ok(_) => True
-      Err(_) => False
-  fun isErr(self) -> Bool =
-    match self
-      Ok(_) => False
-      Err(_) => True
-  # Returns the wrapped success value, or traps if `self` is `Err`.
-  fun unwrap(self) -> T =
-    match self
-      Ok(v) =>
-        return v
-      Err(_) =>
-        todo
-  # Returns the wrapped error value, or traps if `self` is `Ok`.
-  fun unwrapErr(self) -> E =
-    match self
-      Ok(_) =>
-        todo
-      Err(e) =>
-        return e
-  # Returns the wrapped success value, or traps if `self` is `Err`. `msg`
-  # documents the expectation at the call site (matching Rust's
-  # `Result::expect`) but isn't surfaced anywhere at runtime — see the
-  # identical note on `Option.expect`.
-  fun expect(self, msg: Str) -> T =
-    match self
-      Ok(v) =>
-        return v
-      Err(_) =>
-        todo
-  fun expectErr(self, msg: Str) -> E =
-    match self
-      Ok(_) =>
-        todo
-      Err(e) =>
-        return e
-  fun unwrapOr(self, default: T) -> T =
-    match self
-      Ok(v) =>
-        return v
-      Err(_) =>
-        return default
-  # Like `unwrapOr`, but the fallback is computed lazily from the error via
-  # `cb` (only when `self` is `Err`).
-  fun unwrapOrElse(self, cb: fn(E) -> T) -> T =
-    match self
-      Ok(v) =>
-        return v
-      Err(e) =>
-        return cb(e)
-  # Discards the error, keeping only the success value (if any).
-  fun ok(self) -> Option[T] =
-    match self
-      Ok(v) =>
-        return Some(v)
-      Err(_) =>
-        return None
-  # Discards the success value, keeping only the error (if any).
-  fun err(self) -> Option[E] =
-    match self
-      Ok(_) =>
-        return None
-      Err(e) =>
-        return Some(e)
-  # Transforms the success value with `cb`, leaving `Err` untouched. `U` is
-  # `map`'s OWN generic param, separate from `Result[T, E]`'s own `T`/`E` —
-  # resolved per CALL SITE, same mechanism as `List.map`/`Option.map`.
-  fun map(self, cb: fn(T) -> U) -> Result[U, E] =
-    match self
-      Ok(v) =>
-        return Ok(cb(v))
-      Err(e) =>
-        return Err(e)
-  # Transforms the error value with `cb`, leaving `Ok` untouched. `F` is
-  # `mapErr`'s OWN generic param, separate from `Result[T, E]`'s own `T`/`E`.
-  fun mapErr(self, cb: fn(E) -> F) -> Result[T, F] =
-    match self
-      Ok(v) =>
-        return Ok(v)
-      Err(e) =>
-        return Err(cb(e))
-  # No implicit `toStr(self) -> Str` — see the identical note on
-  # `Option.toOptionStr` in `libs/std/option.plum`: a method that assumes
-  # `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.
-  fun toResultStr(self, okToStr: fn(T) -> Str, errToStr: fn(E) -> Str) -> Str =
-    match self
-      Ok(v) =>
-        return "Ok({okToStr(v)})"
-      Err(e) =>
-        return "Err({errToStr(e)})"
-fun makeOkForResultTest() -> Result[Int, Str] =
-  return Ok(5)
-fun makeErrForResultTest() -> Result[Int, Str] =
-  return Err("bad")
-test "map transforms an Ok value and leaves Err untouched"
-  assert makeOkForResultTest().map(|v| v * 2).unwrap() == 10
-  assert makeErrForResultTest().map(|v| v * 2).isErr() == True
-test "mapErr transforms an Err value and leaves Ok untouched"
-  assert makeErrForResultTest().mapErr(|e| e + "!").unwrapErr() == "bad!"
-  assert makeOkForResultTest().mapErr(|e| e + "!").unwrap() == 5

plum-std/Str.plum CHANGED Viewed

@@ -193,7 +193,7 @@ enum Str(Comparable, ToStr, Readable, Writable) =
   # `strings.SplitN` semantics, not JS's (which instead discards anything
   # past the limit). An empty `separator` splits into individual bytes.
   fun split(self, separator: Str, limit: Int) -> List[Str] =
-    result := List(head: None, tail: None, size: 0)
+    result := List(head: End, tail: End, size: 0)
     len := self.length()
     sep_len := separator.length()
     if sep_len == 0

plum-std/Testing.plum CHANGED Viewed

@@ -1,7 +1,6 @@
 module std
-import std/Option
+import std/Try
-import std/Result
 import std/List
 import std/Bool
 import std/Number
@@ -18,8 +17,8 @@ import std/Str
 # grammar form. They exist purely to make the condition read like an
 # assertion instead of a raw comparison.
 #
-# `expectArray`/`expectSome`/`expectOk`/`expectErr` below take a container
+# `expectArray`/`expectOk`/`expectErr` below take a container
-# type (`List[T]`/`Option[T]`/`Result[T, E]`) whose OWN generic param is
+# type (`List[T]`/`Try[T, E]`) whose OWN generic param is
 # nested inside the param type — this used to hit a real monomorphizer bug
 # (misclassified as a "bare generic class reference" fn, then lost its type
 # argument when the specialized signature was registered, mismatching the
@@ -61,27 +60,18 @@ fun expectObject(a: T, b: T) -> Bool =
 fun expectArray(a: List[T], b: List[T]) -> Bool =
   a.equals(b)
-fun expectSome(o: Option[T]) -> Bool =
-  o.isSome()
-fun expectNone(o: Option[T]) -> Bool =
-  o.isNone()
-fun expectOk(r: Result[T, E]) -> Bool =
+fun expectOk(r: Try[T, E]) -> Bool =
   r.isOk()
-fun expectErr(r: Result[T, E]) -> Bool =
+fun expectErr(r: Try[T, E]) -> Bool =
   r.isErr()
-fun makeOkForTestingTest() -> Result[Int, Str] =
+fun makeOkForTestingTest() -> Try[Int, Str] =
   return Ok(5)
-fun makeErrForTestingTest() -> Result[Int, Str] =
+fun makeErrForTestingTest() -> Try[Int, Str] =
   return Err("bad")
-fun makeNoneForTestingTest() -> Option[Int] =
-  return None
 test "expectTrue and expectFalse"
   assert expectTrue(1 == 1)
   assert expectFalse(1 == 2)
@@ -98,9 +88,7 @@ test "list equality via the List.equals method"
   assert a.equals(b)
   assert expectFalse(a.equals(c))
-test "Option/Result checks via their own isSome/isNone/isOk/isErr methods"
+test "Try checks via its own isOk/isErr methods"
-  assert Some(1).isSome()
-  assert makeNoneForTestingTest().isNone()
   assert makeOkForTestingTest().isOk()
   assert makeErrForTestingTest().isErr()
@@ -114,10 +102,7 @@ test "expectArray compares two List[T]s elementwise"
   e := List("x", "y")
   assert expectArray(d, e)
-test "expectSome/expectNone/expectOk/expectErr check the right variant"
+test "expectOk/expectErr check the right variant"
-  assert expectSome(Some(1))
-  assert expectFalse(expectSome(makeNoneForTestingTest()))
-  assert expectNone(makeNoneForTestingTest())
   assert expectOk(makeOkForTestingTest())
   assert expectFalse(expectOk(makeErrForTestingTest()))
   assert expectErr(makeErrForTestingTest())

plum-std/Try.plum ADDED Viewed

@@ -0,0 +1,184 @@
+module std
+import std/Str
+import std/Bool
+import std/Number
+import std/List
+import std/Map
+# Try[T, E] is either success (`Ok`, carrying a `T`) or failure (`Err`,
+# carrying an `E`). `E` is normally a structural tag union such as
+# `[NotFound, BadNum(Str)]`; `?` merges the error unions of different calls
+# into the enclosing function's declared union. A missing value is just an
+# error tag (`[OutOfBounds]`, `[KeyNotFound]`, ...), so there is no Option.
+enum Try[T, E] =
+  | Ok(T)
+  | Err(E)
+  fun isOk(self) -> Bool =
+    match self
+      Ok(_) => True
+      Err(_) => False
+  fun isErr(self) -> Bool =
+    match self
+      Ok(_) => False
+      Err(_) => True
+  # Returns the wrapped success value, or crashes if `self` is `Err`.
+  fun unwrap(self) -> T =
+    match self
+      Ok(v) =>
+        return v
+      Err(_) =>
+        crash "unwrap called on Err"
+  # Returns the wrapped error value, or crashes if `self` is `Ok`.
+  fun unwrapErr(self) -> E =
+    match self
+      Ok(_) =>
+        crash "unwrapErr called on Ok"
+      Err(e) =>
+        return e
+  fun unwrapOr(self, default: T) -> T =
+    match self
+      Ok(v) =>
+        return v
+      Err(_) =>
+        return default
+  # Like `unwrapOr`, but the fallback is computed lazily from the error.
+  fun unwrapOrElse(self, cb: fn(E) -> T) -> T =
+    match self
+      Ok(v) =>
+        return v
+      Err(e) =>
+        return cb(e)
+  # Transforms the success value with `cb`, leaving `Err` untouched.
+  fun map(self, cb: fn(T) -> U) -> Try[U, E] =
+    match self
+      Ok(v) =>
+        return Ok(cb(v))
+      Err(e) =>
+        return Err(e)
+  # Transforms the error value with `cb`, leaving `Ok` untouched.
+  fun mapErr(self, cb: fn(E) -> F) -> Try[T, F] =
+    match self
+      Ok(v) =>
+        return Ok(v)
+      Err(e) =>
+        return Err(cb(e))
+  # Like `map`, but `cb` itself returns a `Try` and the result isn't re-wrapped.
+  fun andThen(self, cb: fn(T) -> Try[U, E]) -> Try[U, E] =
+    match self
+      Ok(v) =>
+        return cb(v)
+      Err(e) =>
+        return Err(e)
+  # No implicit `toStr`: every method of a generic type is compiled for every
+  # specialization, so assuming `T`/`E: ToStr` would break unrelated uses.
+  fun toTryStr(self, okToStr: fn(T) -> Str, errToStr: fn(E) -> Str) -> Str =
+    match self
+      Ok(v) =>
+        return "Ok({okToStr(v)})"
+      Err(e) =>
+        return "Err({errToStr(e)})"
+fun okIntForTryTest() -> Try[Int, [Bad]] =
+  return Ok(5)
+fun errIntForTryTest() -> Try[Int, [Bad]] =
+  return Err(Bad)
+fun fifthForTryTest(n: Int) -> Try[Int, [Bad]] =
+  return Ok(n / 5)
+fun mergeForTryTest(s: Str, i: Int) -> Try[Int, [BadNumStr, OutOfBounds]] =
+  n := parseInt(s)?
+  xs := List(10, 20, 30)
+  x := xs.get(i)?
+  return Ok(n + x)
+fun closureMapForTryTest(s: Str) -> Try[Int, [InvalidFirst]] =
+  n := parseInt(s) ? |e| InvalidFirst
+  return Ok(n)
+test "map transforms an Ok value and leaves Err untouched"
+  assert okIntForTryTest().map(|v| v * 2).unwrap() == 10
+  assert errIntForTryTest().map(|v| v * 2).isErr()
+test "mapErr transforms an Err and leaves Ok untouched"
+  assert okIntForTryTest().mapErr(|e| Other).unwrap() == 5
+  assert errIntForTryTest().mapErr(|e| Other).isErr()
+test "andThen chains fallible steps"
+  a := okIntForTryTest().andThen(|n| fifthForTryTest(n))
+  assert a.unwrap() == 1
+  assert errIntForTryTest().andThen(|n| fifthForTryTest(n)).isErr()
+test "unwrapOr and unwrapOrElse fall back on Err"
+  assert errIntForTryTest().unwrapOr(9) == 9
+  assert okIntForTryTest().unwrapOr(9) == 5
+  assert errIntForTryTest().unwrapOrElse(|e| 3) == 3
+test "toTryStr renders both variants"
+  assert okIntForTryTest().toTryStr(|v| v.toStr(), |e| "bad") == "Ok(5)"
+  assert errIntForTryTest().toTryStr(|v| v.toStr(), |e| "bad") == "Err(bad)"
+test "list_get_out_of_bounds"
+  r := List(1).get(5)
+  match r
+    Ok(_) =>
+      assert False
+    Err(OutOfBounds) =>
+      assert True
+test "map_get_missing"
+  m := Map[Str, Int]()
+  match m.get("x")
+    Ok(_) =>
+      assert False
+    Err(KeyNotFound) =>
+      assert True
+test "parse_int_bad"
+  match parseInt("x")
+    Ok(_) =>
+      assert False
+    Err(BadNumStr) =>
+      assert True
+  assert parseInt("42").unwrap() == 42
+test "question_mark_merges_two_unions"
+  assert mergeForTryTest("5", 1).unwrap() == 25
+  match mergeForTryTest("x", 1)
+    Ok(_) =>
+      assert False
+    Err(BadNumStr) =>
+      assert True
+    Err(OutOfBounds) =>
+      assert False
+  match mergeForTryTest("5", 9)
+    Ok(_) =>
+      assert False
+    Err(BadNumStr) =>
+      assert False
+    Err(OutOfBounds) =>
+      assert True
+test "try_closure_maps_error"
+  assert closureMapForTryTest("7").unwrap() == 7
+  match closureMapForTryTest("x")
+    Ok(_) =>
+      assert False
+    Err(InvalidFirst) =>
+      assert True
+test "default_operator"
+  assert {List[Int]().first() ?? 7} == 7
+  assert {List(3).first() ?? 7} == 3

plum-std/Uuid.plum CHANGED Viewed

@@ -1,6 +1,6 @@
 module std
 import std/Number
-import std/Result
+import std/Try
 import std/Str
 import std/Bool
@@ -45,7 +45,7 @@ fun nil() -> Uuid =
 # Parses the canonical `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx` text form
 # (case-insensitive), returning `Err` if `s` isn't exactly that shape.
-fun fromStr(s: Str) -> Result[Uuid, Str] =
+fun fromStr(s: Str) -> Try[Uuid, Str] =
   if s.length() != 36
     return Err("invalid UUID length: '{s}'")
   i := 0

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

@@ -3613,9 +3613,18 @@ impl<'a> Collector<'a> {
                 }
             }
             ast::Expr::TypeName(_) => {}
+            // `"{x ?? 0}"` / `"{f()?}"` — interpolated parts compile like any
+            // other expression, so any `?`/`??` scratch slot inside needs
+            // allocating here too (`assert a ?? b == c` desugars into one).
+            ast::Expr::String(s) => {
+                for part in &s.parts {
+                    if let ast::StringPart::Interp(e) = part {
+                        self.walkExpr(e);
+                    }
+                }
+            }
             ast::Expr::Int(_)
             | ast::Expr::Float(_)
-            | ast::Expr::String(_)
             | ast::Expr::Self_
             | ast::Expr::Var(_) => {}
             // A closure literal's body has its own locals, belonging to the separate

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

@@ -1326,3 +1326,22 @@ fun main() -> Int =
     );
     assert_eq!(got, 10);
 }
+/// Regression (T5): the scratch-slot collector didn't descend into string
+/// interpolations, so a `??`/`?` inside `"{...}"` -- which is exactly what a
+/// failing `assert a ?? b == c` in a `test` block desugars to -- hit
+/// "missing '?:' scratch slot" at compile time.
+#[test]
+fn elvis_inside_string_interpolation_compiles() {
+    let got = runTryMain(
+        "\
+fun make() -> Try[Int, [Nope]] =
+  Err(Nope)
+fun main() -> Int =
+  s := \"v={make() ?? 5}\"
+  return 1
+",
+    );
+    assert_eq!(got, 1);
+}