6d21ab6 | plum | pyrossh

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

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

6d21ab6 — Peter John 2026-11-02T10:51:33+05:30

refactor(std): no free functions; every std function is a static

Files changed (15) hide show

README.md +5 -5
plum-std/Base64.plum +110 -105
plum-std/Buffer.plum +8 -11
plum-std/ByteSlice.plum +27 -46
plum-std/Float.plum +1 -1
plum-std/Http.plum +78 -77
plum-std/Int.plum +57 -57
plum-std/Json.plum +98 -105
plum-std/List.plum +30 -53
plum-std/Os.plum +241 -240
plum-std/Str.plum +228 -228
plum-std/Testing.plum +55 -56
plum-std/Time.plum +29 -29
plum-std/Uuid.plum +30 -30
plum-wasm-codegen/src/lib.rs +27 -26

README.md CHANGED Viewed

@@ -663,7 +663,7 @@ primitive Byte =                  # in plum-std/Byte.plum
     Int(self)
 ```
-The std library uses namespaces where free functions clearly belong together: `Math` (see [Standard library highlights](#standard-library-highlights)). `Time.now()`, `Uuid.v4()`, `Uuid.fromStr(s)`, `Random.float()` and `Random.intBelow(n)` are statics of their types. See [`plum-examples/constants.plum`](plum-examples/constants.plum) and [`plum-examples/numbers.plum`](plum-examples/numbers.plum).
+The std library has no free functions: each function is a static of its type or of a `primitive` namespace, so `Math.sqrt(x)`, `Os.readFile(path)`, `Base64.encode(s)`, `Http.get(url)` and `Testing.expectEq(a, b)` (see [Standard library highlights](#standard-library-highlights)). `Time.now()`, `Uuid.v4()`, `Uuid.fromStr(s)`, `Random.float()` and `Random.intBelow(n)` are statics of their types. See [`plum-examples/constants.plum`](plum-examples/constants.plum) and [`plum-examples/numbers.plum`](plum-examples/numbers.plum).
 ## Closures
@@ -985,7 +985,7 @@ $ plum test plum-examples/testing.plum
 1 passed, 0 failed
 ```
-A failing `assert` prints the actual and expected values for `==` comparisons. `import std/Testing` adds small assertion helpers (`expectEq`, `expectTrue`, `expectSome`, ...). The `plum-std` library and every file in `plum-examples` carry their own tests: `plum test plum-std plum-examples`.
+A failing `assert` prints the actual and expected values for `==` comparisons. `import std/Testing` adds small assertion helpers (`Testing.expectEq`, `Testing.expectTrue`, `Testing.expectSuccess`, ...). The `plum-std` library and every file in `plum-examples` carry their own tests: `plum test plum-std plum-examples`.
 ## `extern` functions and hosts
@@ -1006,8 +1006,8 @@ hello, world!
 - **`Bool`** — `true`/`false`, `if`, `&&`/`||`/`!` and `==` are built in (no import); `toStr` (also used by `"{b}"` interpolation) and `Bool.parse("true")` need `import std/Bool`
 - **`Int`** / **`Float`** (`import std/Int`, `import std/Float`) — built-in numbers with their API in `primitive Int` / `primitive Float`: `abs`, `sign`, `min`, `max`, `sqrt`, `pow`, `floor`, `round`, `toStr`, ... (constants and `parse`: see [Constants](#constants-statics-and-primitive))
 - **`Math`** (`import std/Math`) — a `primitive` namespace of floating-point functions: `Math.sqrt`, `Math.sin`, `Math.exp`, `Math.ln`, ...
-- **`Str`** (`import std/Str`) — a byte array with a codepoint-aware layer for Unicode correctness: `runeLength`, `runeAt`, `codePointAt`, `codePointToStr`
-- **`Byte`** / **`ByteSlice`** (`import std/Byte`, `import std/ByteSlice`) — a scalar unsigned 8-bit value and a fixed-length mutable byte slice
+- **`Str`** (`import std/Str`) — a byte array with a codepoint-aware layer for Unicode correctness: `runeLength`, `runeAt`, `codePointAt`, `Str.codePointToStr(cp)`
+- **`Byte`** / **`ByteSlice`** (`import std/Byte`, `import std/ByteSlice`) — a scalar unsigned 8-bit value and a fixed-length mutable byte slice (`ByteSlice.make(n)`, `ByteSlice.copy`, `ByteSlice.equal`)
 - **`Buffer`** (`import std/Buffer`) — a growable, mutable byte sequence for building up a `Str`, amortized O(n) writes
 - **`Array[T]`** (`import std/Array`) — the compiler-intrinsic generic array that `List` and `Map` are written on; `Grid[T]` is a flat 2D array
 - **`List[T]`** (`import std/List`) — a growable list built on `Array`, with `get`/`add`/`set`/`removeAt`/`remove`/`sort`/`join`/`chunk` (iteration and transformation via `for`)
@@ -1015,7 +1015,7 @@ hello, world!
 - **`Set[T]`**, **`Deque[T]`**, **`Heap[T]`** — a set over `Map`'s bucketed hash table, a ring-buffer double-ended queue and a key-ordered min-heap
 - **`Seq[T]`** (`import std/Seq`) — the adapters and terminals of the `for` chains
 - **`Json`**, **`Base64`**, **`Uuid`**, **`Time`**, **`Random`** — parsing, encoding, ids, wall-clock time and a seeded deterministic generator (the `Random` statics use the wall clock)
-- **`Os`**, **`Http`** — printing and the file system; HTTP requests through the host
+- **`Os`**, **`Http`** — printing and the file system (`Os.readFile`, `Os.writeFile`, ...); HTTP requests through the host (`Http.get`, `Http.post`, ...)
 - **`Testing`** (`import std/Testing`) — assertion helpers for `test` blocks
 See [`plum-examples/`](plum-examples) for a runnable file per feature above, and [`plum-std/`](plum-std) for the standard library source.

plum-std/Base64.plum CHANGED Viewed

@@ -16,116 +16,121 @@ import std/Float
 # byte array here (see `libs/std/str.plum`), so this is a plain byte string,
 # not a claim that the content is valid UTF-8 text.
+primitive Base64 =
-# Encode for PEM (RFC 1421): 64-character lines.
+  # Encode for PEM (RFC 1421): 64-character lines.
-fun encodePEM(data: Str) -> Str =
+  fun encodePEM(data: Str) -> Str =
-  return encode(data, "+", "/", "=", 64, "\r\n")
+    return encode(data, "+", "/", "=", 64, "\r\n")
-# Encode for MIME (RFC 2045): 76-character lines.
+  # Encode for MIME (RFC 2045): 76-character lines.
-fun encodeMIME(data: Str) -> Str =
+  fun encodeMIME(data: Str) -> Str =
-  return encode(data, "+", "/", "=", 76, "\r\n")
+    return encode(data, "+", "/", "=", 76, "\r\n")
-# Encode for URLs (RFC 4648). Padding characters are stripped by default.
+  # Encode for URLs (RFC 4648). Padding characters are stripped by default.
-fun encodeURL(data: Str, pad: Bool = false) -> Str =
+  fun encodeURL(data: Str, pad: Bool = false) -> Str =
-  return encode(data, "-", "_", if pad then "=" else "", 0, "")
+    return encode(data, "-", "_", if pad then "=" else "", 0, "")
-# Configurable encoding. The defaults are for RFC 4648. `pad` is the padding
+  # Configurable encoding. The defaults are for RFC 4648. `pad` is the padding
-# character, or `""` to omit padding entirely; `linelen` is the output line
+  # character, or `""` to omit padding entirely; `linelen` is the output line
-# length to wrap at (`0` disables wrapping), separated by `linesep`.
+  # length to wrap at (`0` disables wrapping), separated by `linesep`.
-fun encode(data: Str, at62: Str = "+", at63: Str = "/", pad: Str = "=", linelen: Int = 0, linesep: Str = "\r\n") -> Str =
+  fun encode(data: Str, at62: Str = "+", at63: Str = "/", pad: Str = "=", linelen: Int = 0, linesep: Str = "\r\n") -> Str =
-  at62b := at62.byteAt(0)
+    at62b := at62.byteAt(0)
-  at63b := at63.byteAt(0)
+    at63b := at63.byteAt(0)
-  has_pad := pad.length() > 0
+    has_pad := pad.length() > 0
-  padb := if has_pad then pad.byteAt(0) else 0
+    padb := if has_pad then pad.byteAt(0) else 0
-  res := Buffer()
+    res := Buffer()
-  n := data.length()
+    n := data.length()
-  i := 0
+    i := 0
-  line_chars := 0
+    line_chars := 0
-  while i < n
+    while i < n
-    b0 := data.byteAt(i)
+      b0 := data.byteAt(i)
-    has1 := i + 1 < n
+      has1 := i + 1 < n
-    has2 := i + 2 < n
+      has2 := i + 2 < n
-    b1 := if has1 then data.byteAt(i + 1) else 0
+      b1 := if has1 then data.byteAt(i + 1) else 0
-    b2 := if has2 then data.byteAt(i + 2) else 0
+      b2 := if has2 then data.byteAt(i + 2) else 0
-    res.writeByte(Byte(encodeByte(b0 >> 2, at62b, at63b)))
+      res.writeByte(Byte(encodeByte(b0 >> 2, at62b, at63b)))
-    res.writeByte(Byte(encodeByte({b0 & 0x03} << 4 | b1 >> 4, at62b, at63b)))
+      res.writeByte(Byte(encodeByte({b0 & 0x03} << 4 | b1 >> 4, at62b, at63b)))
-    line_chars = line_chars + 2
+      line_chars = line_chars + 2
-    if has1
+      if has1
-      res.writeByte(Byte(encodeByte({b1 & 0x0F} << 2 | b2 >> 6, at62b, at63b)))
+        res.writeByte(Byte(encodeByte({b1 & 0x0F} << 2 | b2 >> 6, at62b, at63b)))
-      line_chars = line_chars + 1
+        line_chars = line_chars + 1
-    else if has_pad
+      else if has_pad
-      res.writeByte(Byte(padb))
+        res.writeByte(Byte(padb))
-      line_chars = line_chars + 1
+        line_chars = line_chars + 1
-    if has2
+      if has2
-      res.writeByte(Byte(encodeByte(b2 & 0x3F, at62b, at63b)))
+        res.writeByte(Byte(encodeByte(b2 & 0x3F, at62b, at63b)))
-      line_chars = line_chars + 1
+        line_chars = line_chars + 1
-    else if has_pad
+      else if has_pad
-      res.writeByte(Byte(padb))
+        res.writeByte(Byte(padb))
-      line_chars = line_chars + 1
+        line_chars = line_chars + 1
-    i = i + 3
+      i = i + 3
-    if linelen > 0 && line_chars >= linelen && i < n
+      if linelen > 0 && line_chars >= linelen && i < n
-      res.write(linesep)
+        res.write(linesep)
-      line_chars = 0
+        line_chars = 0
-  return res.toStr()
+    return res.toStr()
-# Encodes a single 6-bit value (0-63) as its base64 alphabet character.
+  # Encodes a single 6-bit value (0-63) as its base64 alphabet character.
-fun encodeByte(i: Int, at62: Int, at63: Int) -> Int =
+  fun encodeByte(i: Int, at62: Int, at63: Int) -> Int =
-  if i < 26
+    if i < 26
-    return 65 + i # 'A'..'Z'
+      return 65 + i # 'A'..'Z'
-  if i < 52
+    if i < 52
-    return 97 + {i - 26} # 'a'..'z'
+      return 97 + {i - 26} # 'a'..'z'
-  if i < 62
+    if i < 62
-    return 48 + {i - 52} # '0'..'9'
+      return 48 + {i - 52} # '0'..'9'
-  if i == 62
+    if i == 62
-    return at62
+      return at62
-  return at63
+    return at63
-# The inverse of `encodeByte`: a base64 alphabet character's 6-bit value, or
+  # The inverse of `encodeByte`: a base64 alphabet character's 6-bit value, or
-# -1 if `b` isn't one of the 64 alphabet characters (whitespace/padding are
+  # -1 if `b` isn't one of the 64 alphabet characters (whitespace/padding are
-# handled by the caller, not here).
+  # handled by the caller, not here).
-fun decodeByte(b: Int, at62: Int, at63: Int) -> Int =
+  fun decodeByte(b: Int, at62: Int, at63: Int) -> Int =
-  if b >= 65 && b <= 90
+    if b >= 65 && b <= 90
-    return b - 65
+      return b - 65
-  if b >= 97 && b <= 122
+    if b >= 97 && b <= 122
-    return b - 97 + 26
+      return b - 97 + 26
-  if b >= 48 && b <= 57
+    if b >= 48 && b <= 57
-    return b - 48 + 52
+      return b - 48 + 52
-  if b == at62
+    if b == at62
-    return 62
+      return 62
-  if b == at63
+    if b == at63
-    return 63
+      return 63
-  return -1
+    return -1
-fun isBase64Whitespace(b: Int) -> Bool =
+  fun isBase64Whitespace(b: Int) -> Bool =
-  b == 32 || b == 9 || b == 10 || b == 13
+    b == 32 || b == 9 || b == 10 || b == 13
-# Decode for URLs (RFC 4648).
+  # Decode for URLs (RFC 4648).
-fun decodeUrl(data: Str) -> error{InvalidBase64}!Str =
+  fun decodeUrl(data: Str) -> error{InvalidBase64}!Str =
-  return decode(data, "-", "_", "=")
+    return decode(data, "-", "_", "=")
-# Configurable decoding. The defaults are for RFC 4648. Missing padding is
+  # Configurable decoding. The defaults are for RFC 4648. Missing padding is
-# not an error. Non-base64 data, other than whitespace (which can appear at
+  # not an error. Non-base64 data, other than whitespace (which can appear at
-# any point), fails with `InvalidBase64`.
+  # any point), fails with `InvalidBase64`.
-fun decode(data: Str, at62: Str = "+", at63: Str = "/", pad: Str = "=") -> error{InvalidBase64}!Str =
+  fun decode(data: Str, at62: Str = "+", at63: Str = "/", pad: Str = "=") -> error{InvalidBase64}!Str =
-  at62b := at62.byteAt(0)
+    at62b := at62.byteAt(0)
-  at63b := at63.byteAt(0)
+    at63b := at63.byteAt(0)
-  has_pad := pad.length() > 0
+    has_pad := pad.length() > 0
-  padb := if has_pad then pad.byteAt(0) else -1
+    padb := if has_pad then pad.byteAt(0) else -1
-  res := Buffer()
+    res := Buffer()
-  n := data.length()
+    n := data.length()
-  i := 0
+    i := 0
-  bits := 0
+    bits := 0
-  nbits := 0
+    nbits := 0
-  while i < n
+    while i < n
-    b := data.byteAt(i)
+      b := data.byteAt(i)
-    i = i + 1
+      i = i + 1
-    if isBase64Whitespace(b) || b == padb
+      if isBase64Whitespace(b) || b == padb
-      continue
+        continue
-    v := decodeByte(b, at62b, at63b)
+      v := decodeByte(b, at62b, at63b)
-    if v < 0
+      if v < 0
-      return error.InvalidBase64
+        return error.InvalidBase64
-    bits = {bits << 6} | v
+      bits = {bits << 6} | v
-    nbits = nbits + 6
+      nbits = nbits + 6
-    if nbits >= 8
+      if nbits >= 8
-      nbits = nbits - 8
+        nbits = nbits - 8
-      res.writeByte(Byte({bits >> nbits} & 0xFF))
+        res.writeByte(Byte({bits >> nbits} & 0xFF))
-  return res.toStr()
+    return res.toStr()
+test "statics are reached through the Base64 namespace and round-trip"
+  assert Base64.decode(Base64.encodePEM("hello"))! == "hello"
+  assert Base64.decode(Base64.encodeMIME("hi there"))! == "hi there"

plum-std/Buffer.plum CHANGED Viewed

@@ -21,13 +21,13 @@ record Buffer(data: []Byte, len: Int) =
   # and `plum-wasm-codegen`'s `ClassCall` handling), so this is the only place
   # that ever needs to know `data`/`len`'s starting values.
   fun init() -> Buffer =
-    Buffer(data: makeBytes(0), len: 0)
+    Buffer(data: ByteSlice.make(0), len: 0)
   # Appends `s` to the buffer.
   fun write(self, s: Str) -> Unit =
     n := s.length()
     self.ensureCapacity(self.len + n)
-    copyStrToBytes(self.data, self.len, s, 0, n)
+    ByteSlice.copy(self.data, self.len, s.bytes, 0, n)
     self.len = self.len + n
   # Appends the single raw byte `b` to the buffer.
@@ -38,11 +38,11 @@ record Buffer(data: []Byte, len: Int) =
   # Appends the Unicode codepoint `cp`, UTF-8 encoded, to the buffer.
   fun writeRune(self, cp: Int) -> Unit =
-    self.write(codePointToStr(cp))
+    self.write(Str.codePointToStr(cp))
   # Returns the buffer's contents as a `Str`.
   fun toStr(self) -> Str =
-    bytesToStr(self.data, 0, self.len)
+    Str.fromBytes(self.data, 0, self.len)
   # Number of bytes currently in the buffer.
   fun length(self) -> Int =
@@ -67,18 +67,15 @@ record Buffer(data: []Byte, len: Int) =
       return
     new_cap := if cap == 0 then 16 else cap * 2
     new_cap = if needed > new_cap then needed else new_cap
-    new_data := makeBytes(new_cap)
+    new_data := ByteSlice.make(new_cap)
-    copyBytes(new_data, 0, self.data, 0, self.len)
+    ByteSlice.copy(new_data, 0, self.data, 0, self.len)
     self.data = new_data
-fun exerciseBufferInit() -> Str =
+test "Buffer() with no args runs init() and works immediately"
   b := Buffer()
   b.write("hello ")
   b.write("world")
-  b.toStr()
-test "Buffer() with no args runs init() and works immediately"
-  assert exerciseBufferInit() == "hello world"
+  assert b.toStr() == "hello world"
 test "toStr length equals bytes written, even after capacity doubling"
   b := Buffer()

plum-std/ByteSlice.plum CHANGED Viewed

@@ -8,10 +8,10 @@ import std/Float
 # fixed-length, mutable sequence of raw bytes backed directly by a wasm-gc
 # `array<i8>` (see `plum-wasm-codegen`'s `PlumType::TByteSlice`) — the same
 # raw array type `Buffer`'s own `data` field uses underneath (`Str` is a record wrapping one of these;
-# see `Str.plum`). Every method here, and `makeBytes`/
+# see `Str.plum`). Every method here, including the statics
-# `copyBytes` below, is a compiler intrinsic (see `compileIntrinsicFnBody`)
+# `make`/`copy`/`equal`, is a compiler intrinsic (see `compileIntrinsicFnBody`)
 # — there's no way to express raw array length/indexing/construction/copying
-# in Plum source itself; `copyStrToBytes`/`bytesToStr` build on top of them
+# in Plum source itself; `Str.fromBytes` and `Buffer` build on top of them
 # instead of needing intrinsics of their own.
 primitive ByteSlice =
@@ -27,49 +27,30 @@ primitive ByteSlice =
   fun set(self, i: Int, b: Byte) -> Unit =
     todo
-# A new zero-filled `[]Byte` of length `n`.
+  # A new zero-filled `[]Byte` of length `n`.
-fun makeBytes(n: Int) -> []Byte =
+  fun make(n: Int) -> []Byte =
-  todo
+    todo
-# Copies `n` bytes from `src` (starting at `srcStart`) into `dst` (starting at
-# `dstStart`). `dst` and `src` may be the same slice — overlapping ranges are
-# handled correctly, matching wasm's `array.copy`.
-fun copyBytes(dst: []Byte, dstStart: Int, src: []Byte, srcStart: Int, n: Int) -> Unit =
-  todo
-# True when `a[aStart..aStart+n]` and `b[bStart..bStart+n]` hold the same
-# bytes (the memcmp analog; `n == 0` is always true). Traps if out of range.
-fun bytesEqual(a: []Byte, aStart: Int, b: []Byte, bStart: Int, n: Int) -> Bool =
-  todo
-# Like `copyBytes`, but the source is a `Str` — ordinary Plum glue over
-# `copyBytes` itself, reaching through `Str`'s `bytes: []Byte` field.
-fun copyStrToBytes(dst: []Byte, dstStart: Int, src: Str, srcStart: Int, n: Int) -> Unit =
-  copyBytes(dst, dstStart, src.bytes, srcStart, n)
-# Copies out `n` bytes of `src` starting at `start` into a fresh, independent
+  # Copies `n` bytes from `src` (starting at `srcStart`) into `dst` (starting at
-# `Str` — never aliases `src`, so mutating `src` afterwards can't
+  # `dstStart`). `dst` and `src` may be the same slice — overlapping ranges are
-# retroactively change an already-returned `Str`. Ordinary Plum: allocate a
-# right-sized `[]Byte`, copy into it, wrap it in a fresh `Str`.
+  # handled correctly, matching wasm's `array.copy`.
-fun bytesToStr(src: []Byte, start: Int, n: Int) -> Str =
+  fun copy(dst: []Byte, dstStart: Int, src: []Byte, srcStart: Int, n: Int) -> Unit =
-  data := makeBytes(n)
-  copyBytes(data, 0, src, start, n)
-  return Str(bytes: data)
+    todo
+  # True when `a[aStart..aStart+n]` and `b[bStart..bStart+n]` hold the same
+  # bytes (the memcmp analog; `n == 0` is always true). Traps if out of range.
-fun testBytesOf(s: Str) -> []Byte =
+  fun equal(a: []Byte, aStart: Int, b: []Byte, bStart: Int, n: Int) -> Bool =
-  out := makeBytes(s.length())
-  copyStrToBytes(out, 0, s, 0, s.length())
-  return out
+    todo
-test "bytesEqual: equal, differ at first, differ at last, n == 0, offsets"
+test "ByteSlice.equal: equal, differ at first, differ at last, n == 0, offsets"
-  a := testBytesOf("hello world")
+  a := "hello world".bytes
-  b := testBytesOf("hello world")
+  b := "hello world".bytes
-  assert bytesEqual(a, 0, b, 0, 11)
+  assert ByteSlice.equal(a, 0, b, 0, 11)
-  c := testBytesOf("jello world")
+  c := "jello world".bytes
-  assert !bytesEqual(a, 0, c, 0, 11)
+  assert !ByteSlice.equal(a, 0, c, 0, 11)
-  d := testBytesOf("hello worlD")
+  d := "hello worlD".bytes
-  assert !bytesEqual(a, 0, d, 0, 11)
+  assert !ByteSlice.equal(a, 0, d, 0, 11)
-  assert bytesEqual(a, 0, d, 0, 10)
+  assert ByteSlice.equal(a, 0, d, 0, 10)
-  assert bytesEqual(a, 3, c, 3, 0)
+  assert ByteSlice.equal(a, 3, c, 3, 0)
-  assert bytesEqual(a, 6, testBytesOf("xxworld"), 2, 5)
+  assert ByteSlice.equal(a, 6, "xxworld".bytes, 2, 5)
-  assert !bytesEqual(a, 6, testBytesOf("xxwurld"), 2, 5)
+  assert !ByteSlice.equal(a, 6, "xxwurld".bytes, 2, 5)

plum-std/Float.plum CHANGED Viewed

@@ -183,5 +183,5 @@ primitive Float =
     carry := scaled >= 1000000
     whole_part := if carry then int_part + 1 else int_part
     frac := if carry then 0 else scaled
-    s := intToStr(whole_part) + "." + trimmedFracDigits(frac, 6)
+    s := Int.intToStr(whole_part) + "." + Int.trimmedFracDigits(frac, 6)
     return if neg then "-" + s else s

plum-std/Http.plum CHANGED Viewed

@@ -28,9 +28,6 @@ record Response(status: Int, headers: Map[Str, Str], body: Str) =
   fun json(self) -> error{InvalidJson}!Json =
     return try Json.fromStr(self.body)
-fun emptyHeaders() -> Map[Str, Str] =
-  return Map[Str, Str]()
 # 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"`
@@ -44,102 +41,106 @@ fun emptyHeaders() -> Map[Str, Str] =
 # when the body itself is arbitrary binary data.
 extern fun rawHttpRequest(method: Str, url: Str, headers: Str, body: Str) -> Str
+primitive Http =
+  fun emptyHeaders() -> Map[Str, Str] =
+    return Map[Str, Str]()
-# Packs `headers` into the `"Key: Value"`-per-line format `rawHttpRequest`
+  # Packs `headers` into the `"Key: Value"`-per-line format `rawHttpRequest`
-# expects for its own `headers` argument.
+  # expects for its own `headers` argument.
-fun encodeHeaders(headers: Map[Str, Str]) -> Str =
+  fun encodeHeaders(headers: Map[Str, Str]) -> Str =
-  buf := Buffer()
+    buf := Buffer()
-  for k, v := range headers
+    for k, v := range headers
-    if buf.length() > 0
+      if buf.length() > 0
-      buf.write("\n")
+        buf.write("\n")
-    buf.write(k)
+      buf.write(k)
-    buf.write(": ")
+      buf.write(": ")
-    buf.write(v)
+      buf.write(v)
-  return buf.toStr()
+    return buf.toStr()
-# The reverse of `encodeHeaders`, for the response headers `rawHttpRequest`
+  # The reverse of `encodeHeaders`, for the response headers `rawHttpRequest`
-# packs into its result.
+  # packs into its result.
-fun decodeHeaders(raw: Str) -> Map[Str, Str] =
+  fun decodeHeaders(raw: Str) -> Map[Str, Str] =
-  result := emptyHeaders()
+    result := emptyHeaders()
-  if raw == ""
+    if raw == ""
+      return result
+    for line := range raw.split("\n", 0)
+      idx := line.indexOf(": ")
+      if idx >= 0
+        key := line.sub(0, idx)
+        val := line.sub(idx + 2, line.length())
+        result.set(key, val)
     return result
-  for line := range raw.split("\n", 0)
-    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
+  # Performs a single HTTP request and waits for the full response. Fails
-# only for a transport-level problem (DNS failure, connection refused, TLS
+  # only for a transport-level problem (DNS failure, connection refused, TLS
-# error, ...) — an HTTP-level error status (404, 500, ...) is still a
+  # error, ...) — an HTTP-level error status (404, 500, ...) is still a
-# successful round trip, returned as a `Response` with that status (check
+  # successful round trip, returned as a `Response` with that status (check
-# `Response.ok()`). Fails with `HttpFailed` for a transport error and
+  # `Response.ok()`). Fails with `HttpFailed` for a transport error and
-# `BadResponse` for a reply whose status line can't be read.
+  # `BadResponse` for a reply whose status line can't be read.
-fun request(method: Str, url: Str, headers: Map[Str, Str], body: Str) -> HttpError!Response =
+  fun request(method: Str, url: Str, headers: Map[Str, Str], body: Str) -> HttpError!Response =
-  raw := rawHttpRequest(method, url, encodeHeaders(headers), body)
+    raw := rawHttpRequest(method, url, encodeHeaders(headers), body)
-  sep := raw.indexOf("\x00")
+    sep := raw.indexOf("\x00")
-  meta := if sep >= 0 then raw.sub(0, sep) else raw
+    meta := if sep >= 0 then raw.sub(0, sep) else raw
-  resp_body := if sep >= 0 then raw.sub(sep + 1, raw.length()) else ""
+    resp_body := if sep >= 0 then raw.sub(sep + 1, raw.length()) else ""
-  parts := meta.split("\x01", 3)
+    parts := meta.split("\x01", 3)
-  flag := parts.get(0) catch ""
+    flag := parts.get(0) catch ""
-  if flag != "1"
+    if flag != "1"
-    return error.HttpFailed
+      return error.HttpFailed
-  status := Int.parse(parts.get(1) catch "") catch return error.BadResponse
+    status := Int.parse(parts.get(1) catch "") catch return error.BadResponse
-  return Response(status: status, headers: decodeHeaders(parts.get(2) catch ""), body: resp_body)
+    return Response(status: status, headers: decodeHeaders(parts.get(2) catch ""), body: resp_body)
-fun get(url: Str, headers: Map[Str, Str]) -> HttpError!Response =
+  fun get(url: Str, headers: Map[Str, Str]) -> HttpError!Response =
-  return request("GET", url, headers, "")
+    return request("GET", url, headers, "")
-fun head(url: Str, headers: Map[Str, Str]) -> HttpError!Response =
+  fun head(url: Str, headers: Map[Str, Str]) -> HttpError!Response =
-  return request("HEAD", url, headers, "")
+    return request("HEAD", url, headers, "")
-fun delete(url: Str, headers: Map[Str, Str]) -> HttpError!Response =
+  fun delete(url: Str, headers: Map[Str, Str]) -> HttpError!Response =
-  return request("DELETE", url, headers, "")
+    return request("DELETE", url, headers, "")
-fun post(url: Str, headers: Map[Str, Str], body: Str) -> HttpError!Response =
+  fun post(url: Str, headers: Map[Str, Str], body: Str) -> HttpError!Response =
-  return request("POST", url, headers, body)
+    return request("POST", url, headers, body)
-fun put(url: Str, headers: Map[Str, Str], body: Str) -> HttpError!Response =
+  fun put(url: Str, headers: Map[Str, Str], body: Str) -> HttpError!Response =
-  return request("PUT", url, headers, body)
+    return request("PUT", url, headers, body)
-fun patch(url: Str, headers: Map[Str, Str], body: Str) -> HttpError!Response =
+  fun patch(url: Str, headers: Map[Str, Str], body: Str) -> HttpError!Response =
-  return request("PATCH", url, headers, body)
+    return request("PATCH", url, headers, body)
-# Convenience wrapper: sends `body` as a JSON `Str`, adding a
+  # Convenience wrapper: sends `body` as a JSON `Str`, adding a
-# `Content-Type: application/json` header, and parses the response back as
+  # `Content-Type: application/json` header, and parses the response back as
-# JSON via `Response.json()`.
+  # JSON via `Response.json()`.
-fun postJson(url: Str, headers: Map[Str, Str], body: Json) -> HttpError!Response =
+  fun postJson(url: Str, headers: Map[Str, Str], body: Json) -> HttpError!Response =
-  headers.set("Content-Type", "application/json")
+    headers.set("Content-Type", "application/json")
-  return post(url, headers, body.toStr())
+    return post(url, headers, body.toStr())
 test "encodeHeaders/decodeHeaders round-trip a header map"
-  h := emptyHeaders()
+  h := Http.emptyHeaders()
   h.set("Content-Type", "application/json")
   h.set("Accept", "*/*")
-  decoded := decodeHeaders(encodeHeaders(h))
+  decoded := Http.decodeHeaders(Http.encodeHeaders(h))
   assert decoded.get("Content-Type")! == "application/json"
   assert decoded.get("Accept")! == "*/*"
 test "decodeHeaders returns an empty map for an empty string"
-  assert decodeHeaders("").isEmpty() == true
+  assert Http.decodeHeaders("").isEmpty() == true
 test "get performs a real HTTP round trip"
-  resp := get("https://httpbin.org/get", emptyHeaders())!
+  resp := Http.get("https://httpbin.org/get", Http.emptyHeaders())!
   assert resp.ok() == true
   assert resp.status == 200
 test "get reports a non-2xx status without failing the request"
-  resp := get("https://httpbin.org/status/404", emptyHeaders())!
+  resp := Http.get("https://httpbin.org/status/404", Http.emptyHeaders())!
   assert resp.ok() == false
   assert resp.status == 404
 test "post sends a body and the server echoes it back"
-  resp := post("https://httpbin.org/post", emptyHeaders(), "hello world")!
+  resp := Http.post("https://httpbin.org/post", Http.emptyHeaders(), "hello world")!
   assert resp.ok() == true
   j := resp.json()!
   assert j.asMap()!.get("data")!.asStr()! == "hello world"
 test "request fails for an unreachable host"
-  resp := get("http://this-host-does-not-exist.invalid/", emptyHeaders()) catch Response(status: 0, headers: emptyHeaders(), body: "")
+  resp := Http.get("http://this-host-does-not-exist.invalid/", Http.emptyHeaders()) catch Response(status: 0, headers: Http.emptyHeaders(), body: "")
   assert resp.status == 0

plum-std/Int.plum CHANGED Viewed

@@ -146,60 +146,60 @@ primitive Int =
       i = i - 1
       yield cur
-# ---- free-function helpers (no `self` to dispatch on) ----
-# Plain decimal rendering of an `Int` — factored out of `Float.toStr` so the
-# `Float` branch can reuse it (via `intToStr(whole_part)`) without
-# re-dispatching back through `Float.toStr` itself.
-fun intToStr(n: Int) -> Str =
-  if n == 0
-    return "0"
-  neg := n < 0
-  v := if neg then -n else n
-  s := digitsToStr(v)
-  return if neg then "-" + s else s
-# Builds the decimal digits of a positive Int, most significant first, by
-# peeling off one digit at a time from the least significant end (so the
-# recursion emits digits in reverse call order — the leading, smallest-place
-# digit is appended last).
-fun digitsToStr(n: Int) -> Str =
-  if n == 0
-    return ""
-  return digitsToStr(n / 10) + digitChar(n % 10)
-fun digitChar(d: Int) -> Str =
-  match d
-    0 => "0"
-    1 => "1"
-    2 => "2"
-    3 => "3"
-    4 => "4"
-    5 => "5"
-    6 => "6"
-    7 => "7"
-    8 => "8"
-    9 => "9"
-    _ => "0"
-# Renders `n`'s digits most-significant-first, always emitting exactly as many
-# digits as `place_value` has powers of ten (leading zeros included) — used to
-# render a fractional part at a fixed width regardless of its own leading zeros.
-fun fixedFracDigits(n: Int, place_value: Int) -> Str =
-  if place_value == 0
-    return ""
-  return digitChar(n / place_value % 10) + fixedFracDigits(n, place_value / 10)
-fun pow10(n: Int) -> Int =
-  if n <= 0
-    return 1
-  return 10 * pow10(n - 1)
-# `fixedFracDigits(n, pow10(digits - 1))`, minus however many trailing-zero
-# digits `n` has — but always at least one digit ("0" if `n` is 0 outright).
-fun trimmedFracDigits(n: Int, digits: Int) -> Str =
-  if n == 0 || digits <= 1
-    return digitChar(n % 10)
-  if n % 10 == 0
-    return trimmedFracDigits(n / 10, digits - 1)
-  return fixedFracDigits(n, pow10(digits - 1))
+  # ---- static helpers (no `self`) ----
+  # Plain decimal rendering of an `Int` — factored out of `Float.toStr` so the
+  # `Float` branch can reuse it (via `intToStr(whole_part)`) without
+  # re-dispatching back through `Float.toStr` itself.
+  fun intToStr(n: Int) -> Str =
+    if n == 0
+      return "0"
+    neg := n < 0
+    v := if neg then -n else n
+    s := digitsToStr(v)
+    return if neg then "-" + s else s
+  # Builds the decimal digits of a positive Int, most significant first, by
+  # peeling off one digit at a time from the least significant end (so the
+  # recursion emits digits in reverse call order — the leading, smallest-place
+  # digit is appended last).
+  fun digitsToStr(n: Int) -> Str =
+    if n == 0
+      return ""
+    return digitsToStr(n / 10) + digitChar(n % 10)
+  fun digitChar(d: Int) -> Str =
+    match d
+      0 => "0"
+      1 => "1"
+      2 => "2"
+      3 => "3"
+      4 => "4"
+      5 => "5"
+      6 => "6"
+      7 => "7"
+      8 => "8"
+      9 => "9"
+      _ => "0"
+  # Renders `n`'s digits most-significant-first, always emitting exactly as many
+  # digits as `place_value` has powers of ten (leading zeros included) — used to
+  # render a fractional part at a fixed width regardless of its own leading zeros.
+  fun fixedFracDigits(n: Int, place_value: Int) -> Str =
+    if place_value == 0
+      return ""
+    return digitChar(n / place_value % 10) + fixedFracDigits(n, place_value / 10)
+  fun pow10(n: Int) -> Int =
+    if n <= 0
+      return 1
+    return 10 * pow10(n - 1)
+  # `fixedFracDigits(n, pow10(digits - 1))`, minus however many trailing-zero
+  # digits `n` has — but always at least one digit ("0" if `n` is 0 outright).
+  fun trimmedFracDigits(n: Int, digits: Int) -> Str =
+    if n == 0 || digits <= 1
+      return digitChar(n % 10)
+    if n % 10 == 0
+      return trimmedFracDigits(n / 10, digits - 1)
+    return fixedFracDigits(n, pow10(digits - 1))

plum-std/Json.plum CHANGED Viewed

@@ -77,6 +77,82 @@ enum Json =
       Map => self
       _ => error.WrongJsonType
+  # `Map` has no built-in `toStr`/`join` (unlike `List`, which uses `join` for
+  # `Json.toStr`'s `JsonList` case above) — a static taking the
+  # `Buffer` as a captured-by-reference parameter instead of a closure sidesteps
+  # `libs/std/list.plum`'s `join` note on closures: reassigning a CAPTURED
+  # variable inside a closure body doesn't persist across that closure's own
+  # repeated calls, but mutating a heap object's fields THROUGH a captured
+  # reference (as `appendJsonPair` does to `buf`) does.
+  fun jsonMapToStr(pairs: Map[Str, Json]) -> Str =
+    buf := Buffer()
+    for k, v := range pairs
+      appendJsonPair(buf, k, v)
+    return buf.toStr()
+  fun appendJsonPair(buf: Buffer, k: Str, v: Json) -> Unit =
+    if !buf.isEmpty()
+      buf.write(",")
+    buf.write("\"")
+    buf.write(escapeJsonStr(k))
+    buf.write("\":")
+    buf.write(v.toStr())
+  fun escapeJsonStr(s: Str) -> Str =
+    buf := Buffer()
+    len := s.length()
+    i := 0
+    while i < len
+      b := s.byteAt(i)
+      if b == 34
+        buf.write("\\\"")
+      else if b == 92
+        buf.write("\\\\")
+      else if b == 10
+        buf.write("\\n")
+      else if b == 13
+        buf.write("\\r")
+      else if b == 9
+        buf.write("\\t")
+      else if b == 8
+        buf.write("\\b")
+      else if b == 12
+        buf.write("\\f")
+      else if b < 0x20
+        buf.write("\\u00")
+        buf.write(hexByteStr(b))
+      else
+        # Copies a whole UTF-8 codepoint at once: copying a lone continuation
+        # byte as its own "character" would corrupt any non-ASCII text.
+        n := s.codePointByteLength(i)
+        buf.write(s.sub(i, i + n))
+        i = i + n - 1
+      i = i + 1
+    return buf.toStr()
+  fun hexByteStr(b: Int) -> Str =
+    hexDigitChar(b / 16) + hexDigitChar(b % 16)
+  fun hexDigitChar(d: Int) -> Str =
+    match d
+      0 => "0"
+      1 => "1"
+      2 => "2"
+      3 => "3"
+      4 => "4"
+      5 => "5"
+      6 => "6"
+      7 => "7"
+      8 => "8"
+      9 => "9"
+      10 => "a"
+      11 => "b"
+      12 => "c"
+      13 => "d"
+      14 => "e"
+      15 => "f"
+      _ => "0"
 # The outcome of `Json.parse`: the document, or where and why parsing failed.
 record JsonParsed(value: Json)
@@ -147,7 +223,7 @@ record JsonParser(src: Str, pos: Int, text: Str) =
   fun parseLiteral(self, lit: Str, value: Json) -> error{InvalidJson}!Json =
     n := lit.length()
-    if !matchesAt(self.src, lit, self.pos, n)
+    if !Str.matchesAt(self.src, lit, self.pos, n)
       self.note("invalid literal, expected '{lit}'")
       return error.InvalidJson
     self.pos = self.pos + n
@@ -331,109 +407,26 @@ record JsonParser(src: Str, pos: Int, text: Str) =
       self.advance()
     return pairs
-# `Map` has no built-in `toStr`/`join` (unlike `List`, which uses `join` for
-# `Json.toStr`'s `JsonList` case above) — a plain free function taking the
-# `Buffer` as a captured-by-reference parameter instead of a closure sidesteps
-# `libs/std/list.plum`'s `join` note on closures: reassigning a CAPTURED
-# variable inside a closure body doesn't persist across that closure's own
-# repeated calls, but mutating a heap object's fields THROUGH a captured
-# reference (as `appendJsonPair` does to `buf`) does.
-fun jsonMapToStr(pairs: Map[Str, Json]) -> Str =
-  buf := Buffer()
-  for k, v := range pairs
-    appendJsonPair(buf, k, v)
-  return buf.toStr()
-fun appendJsonPair(buf: Buffer, k: Str, v: Json) -> Unit =
-  if !buf.isEmpty()
-    buf.write(",")
-  buf.write("\"")
-  buf.write(escapeJsonStr(k))
-  buf.write("\":")
-  buf.write(v.toStr())
-fun exponentIndex(text: Str) -> Int =
+  fun exponentIndex(text: Str) -> Int =
-  e := text.indexOf("e")
+    e := text.indexOf("e")
-  if e >= 0 then e else text.indexOf("E")
+    if e >= 0 then e else text.indexOf("E")
-fun escapeJsonStr(s: Str) -> Str =
-  buf := Buffer()
-  len := s.length()
-  i := 0
-  while i < len
-    b := s.byteAt(i)
-    if b == 34
-      buf.write("\\\"")
-    else if b == 92
-      buf.write("\\\\")
-    else if b == 10
-      buf.write("\\n")
-    else if b == 13
-      buf.write("\\r")
-    else if b == 9
-      buf.write("\\t")
-    else if b == 8
-      buf.write("\\b")
-    else if b == 12
-      buf.write("\\f")
-    else if b < 0x20
-      buf.write("\\u00")
-      buf.write(hexByteStr(b))
-    else
-      # Copies a whole UTF-8 codepoint at once: copying a lone continuation
-      # byte as its own "character" would corrupt any non-ASCII text.
-      n := s.codePointByteLength(i)
-      buf.write(s.sub(i, i + n))
-      i = i + n - 1
-    i = i + 1
-  return buf.toStr()
-fun hexByteStr(b: Int) -> Str =
-  hexDigitChar(b / 16) + hexDigitChar(b % 16)
-fun hexDigitChar(d: Int) -> Str =
-  match d
-    0 => "0"
-    1 => "1"
-    2 => "2"
-    3 => "3"
-    4 => "4"
-    5 => "5"
-    6 => "6"
-    7 => "7"
-    8 => "8"
-    9 => "9"
-    10 => "a"
-    11 => "b"
-    12 => "c"
-    13 => "d"
-    14 => "e"
-    15 => "f"
-    _ => "0"
-fun hexDigitValue(b: Int) -> Int =
-  if b >= 48 && b <= 57
-    return b - 48
-  if b >= 97 && b <= 102
-    return b - 97 + 10
-  if b >= 65 && b <= 70
-    return b - 65 + 10
-  return -1
-fun isSpace(c: Int) -> Bool =
-  c == 32 || c >= 9 && c <= 13
-fun isDigit(c: Int) -> Bool =
-  c >= 48 && c <= 57
-# ---- regression tests ----
+  fun hexDigitValue(b: Int) -> Int =
+    if b >= 48 && b <= 57
+      return b - 48
+    if b >= 97 && b <= 102
+      return b - 97 + 10
+    if b >= 65 && b <= 70
+      return b - 65 + 10
+    return -1
+  fun isSpace(c: Int) -> Bool =
+    c == 32 || c >= 9 && c <= 13
+  fun isDigit(c: Int) -> Bool =
+    c >= 48 && c <= 57
-fun parseFloatValue(s: Str) -> Float =
-  v := Json.fromStr(s) catch e
+# ---- regression tests ----
-    return -1.0f
-  v.asFloat() catch -1.0f
 test "parses null, true, and false"
   assert Json.fromStr("null")!.isNull()
@@ -441,11 +434,11 @@ test "parses null, true, and false"
   assert !Json.fromStr("false")!.asBool()!
 test "parses integers, decimals, negatives, and exponents"
-  assert parseFloatValue("42") == 42.0f
+  assert Json.fromStr("42")!.asFloat()! == 42.0f
-  assert parseFloatValue("-7") == -7.0f
+  assert Json.fromStr("-7")!.asFloat()! == -7.0f
-  assert parseFloatValue("3.5") == 3.5f
+  assert Json.fromStr("3.5")!.asFloat()! == 3.5f
-  assert parseFloatValue("1e2") == 100.0f
+  assert Json.fromStr("1e2")!.asFloat()! == 100.0f
-  assert parseFloatValue("1.5e-2") == 0.015f
+  assert Json.fromStr("1.5e-2")!.asFloat()! == 0.015f
 test "parses a plain string, with escapes"
   assert Json.fromStr("\"hello\"")!.asStr()! == "hello"

plum-std/List.plum CHANGED Viewed

@@ -234,69 +234,46 @@ record List[T](data: Array[T], size: Int) =
 # ---- regression tests ----
-fun optSumForListTest(o: error{OutOfBounds}!Int) -> Int =
+test "list add set remove at remove clear reverse all work correctly"
-  o catch -1000
-fun exerciseList() -> Int =
-  l = List(1, 2, 3, 4, 5)
+  l := List(1, 2, 3, 4, 5)
-  a = l.length()
+  assert l.length() == 5
-  b = optSumForListTest(l.get(0))
+  assert l.get(0)! == 1
-  c = optSumForListTest(l.get(4))
+  assert l.get(4)! == 5
-  oldVal = optSumForListTest(l.set(2, 30))
+  assert l.set(2, 30)! == 3
-  d = optSumForListTest(l.get(2))
+  assert l.get(2)! == 30
   l.removeAt(0)
-  e = l.length()
+  assert l.length() == 4
-  f = optSumForListTest(l.get(0))
+  assert l.get(0)! == 2
   l.remove(30)
-  g = l.length()
+  assert l.length() == 3
   l.reverse()
-  h = optSumForListTest(l.get(0))
+  assert l.get(0)! == 5
   l.clear()
-  i = l.length()
+  assert l.length() == 0
-  a + b + c + oldVal + d + e + f + g + h + i
-fun removeAllNodesOneAtATime() -> Int =
+test "removing every node in a loop leaves an empty correctly functioning list"
-  l = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+  l := List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
-  i = 0
+  i := 0
   while i < 10
     l.removeAt(0)
     i = i + 1
-  afterLoopLength = l.length()
+  assert l.length() == 0
-  isEmpty = optSumForListTest(l.get(0))
+  assert {l.get(0) catch -1000} == -1000
   l.add(42)
-  afterReAdd = optSumForListTest(l.get(0))
+  assert l.get(0)! == 42
-  afterLoopLength + isEmpty + afterReAdd
-fun exerciseListInit() -> Int =
+test "List[Int]() with no args runs init() and produces a working empty list"
   l := List[Int]()
-  before := l.length()
+  assert l.length() == 0
   l.add(7)
-  before + l.length() + optSumForListTest(l.get(0))
-fun exerciseListInitWithValues() -> Int =
-  l := List(10, 20, 30)
-  l.length() + optSumForListTest(l.get(0)) + optSumForListTest(l.get(2))
-test "list add set remove at remove clear reverse all work correctly"
-  # add(1,2,3,4,5): a=length=5, b=get(0)=1, c=get(4)=5
-  # set(2,30): oldVal=3, d=get(2)=30 -> list [1,2,30,4,5]
-  # removeAt(0): e=length=4, f=get(0)=2 -> list [2,30,4,5]
-  # remove(30): g=length=3 -> list [2,4,5]
-  # reverse(): h=get(0)=5 -> list [5,4,2]
-  # clear(): i=length=0
-  # 5+1+5+3+30+4+2+3+5+0 = 58
-  assert exerciseList() == 58
+  assert l.length() == 1
-test "removing every node in a loop leaves an empty correctly functioning list"
-  # afterLoopLength=0, isEmpty(get(0) on empty list)=-1000, afterReAdd=42
-  # 0 + -1000 + 42 = -958
-  assert removeAllNodesOneAtATime() == -958
-test "List[Int]() with no args runs init() and produces a working empty list"
-  assert exerciseListInit() == 8
+  assert l.get(0)! == 7
 test "List(values) with positional args runs init(values) directly, infers T from args"
+  l := List(10, 20, 30)
-  assert exerciseListInitWithValues() == 43
+  assert l.length() == 3
+  assert l.get(0)! == 10
+  assert l.get(2)! == 30
 test "list equals compares elementwise"
   a = List(1, 2, 3)
@@ -308,8 +285,8 @@ test "list equals compares elementwise"
 test "list sort orders elements correctly"
   l = List(3, 1, 4, 1, 5)
   sorted = l.sort(|a, b| a < b)
-  assert optSumForListTest(sorted.get(0)) == 1
+  assert {sorted.get(0) catch -1000} == 1
-  assert optSumForListTest(sorted.get(4)) == 5
+  assert {sorted.get(4) catch -1000} == 5
 test "list join renders elements correctly with separator"
   l = List(1, 2, 3)
@@ -338,7 +315,7 @@ test "list_get_set_push_pop: push 1000, get(999), pop until empty, get on empty
     i = i + 1
   assert l.length() == 1000
   assert l.get(999)! == 999
-  assert optSumForListTest(l.get(1000)) == -1000
+  assert {l.get(1000) catch -1000} == -1000
   assert l.set(500, 7)! == 500
   assert l.get(500)! == 7
   assert l.pop()! == 999
@@ -347,7 +324,7 @@ test "list_get_set_push_pop: push 1000, get(999), pop until empty, get on empty
     l.pop()!
   assert l.length() == 0
   assert {l.pop() catch -1} == -1
-  assert optSumForListTest(l.get(0)) == -1000
+  assert {l.get(0) catch -1000} == -1000
   e := l.get(0)
   assert {e catch -1} == -1

plum-std/Os.plum CHANGED Viewed

@@ -8,20 +8,6 @@ import std/Float
 # What the file functions that may hit either problem can fail with.
 error IoError = IoFailed | NoSuchPath
-# NOTE: the original file modeled `stdin`/`stdout`/`stderr` as bare top-level
-# variable bindings and a `File(...)` constructor, but this language has no
-# top-level `let` and `File` is never defined anywhere in the stdlib. Reduced
-# to the underlying path so this at least parses; a real `File` type is
-# still needed here.
-fun stdin() -> Str =
-  "/dev/stdin"
-fun stdout() -> Str =
-  "/dev/stdout"
-fun stderr() -> Str =
-  "/dev/stderr"
 # Writes the specified data, followed by the current line terminator, to the
 # standard output stream. `extern` means this compiles to a genuine wasm import
 # (`plum::printLn`) instead of a Plum body — printing isn't expressible in wasm
@@ -57,261 +43,276 @@ extern fun rawChmod(path: Str, mode: Int) -> Int
 # an empty file — `exists`/`readdir` below both check existence first).
 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) -> error{NoSuchPath}!Str =
-  if !exists(path)
-    return error.NoSuchPath
-  return rawReadFile(path)
-# Writes `data` to `path`, replacing its previous contents (or creating it).
-fun writeFile(path: Str, data: Str) -> error{IoFailed}!Unit =
-  if rawWriteFile(path, data) != 1
-    return error.IoFailed
-fun exists(path: Str) -> Bool =
-  return rawExists(path) == 1
-fun mkdir(path: Str) -> error{IoFailed}!Unit =
-  if rawMkdir(path) != 1
-    return error.IoFailed
-# Removes the file (not directory) at `path`.
-fun remove(path: Str) -> IoError!Unit =
-  if !exists(path)
-    return error.NoSuchPath
-  if rawRemove(path) != 1
-    return error.IoFailed
-# Whether `path` exists and is reachable — this VM has no notion of a
-# process' effective uid/gid, so (unlike POSIX `access(2)`) there is no mode
-# argument to check permission bits against.
-fun access(path: Str) -> Bool =
-  return exists(path)
-# Appends `data` to the file at `path`, creating it (with just `data` as its
-# 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) -> IoError!Unit =
-  if exists(path)
-    existing := try readFile(path)
-    try writeFile(path, existing + data)
-    return
-  try writeFile(path, data)
-# Unix permission bits only (e.g. `0o644`) — this VM has no Windows ACL
-# equivalent to fall back to.
-fun chmod(path: Str, mode: Int) -> error{IoFailed}!Unit =
-  if rawChmod(path, mode) != 1
-    return error.IoFailed
-# There is no host primitive for changing file ownership (it needs a uid/gid
-# syscall this VM doesn't expose), unlike the permission-bits-only `chmod`.
-fun chown(path: Str, uid: Int, gid: Int) =
-  todo
-fun copyFile(src: Str, dest: Str) -> IoError!Unit =
-  data := try readFile(src)
-  try writeFile(dest, data)
-fun cp(src: Str, dest: Str) -> IoError!Unit =
-  try 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) -> error{IoFailed}!Unit =
-  try chmod(path, mode)
-# See `chown` — no uid/gid syscall exposed by this VM.
-fun lchown(path: Str, uid: Int, gid: Int) =
-  todo
-# Setting a file's atime/mtime needs a syscall (`utimensat`/`SetFileTime`)
-# this VM doesn't expose (`std::fs` itself has no equivalent either).
-fun lutimes(path: Str, atime: Int, mtime: Int) =
-  todo
-fun link(existing_path: Str, new_path: Str) -> error{IoFailed}!Unit =
-  if rawLink(existing_path, new_path) != 1
-    return error.IoFailed
-# Would need a real `Stat` struct type (size/mode/mtime/uid/gid/...) to
-# return anything useful — no such type exists in the stdlib yet.
-fun lstat(path: Str) =
-  todo
-# 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) -> error{IoFailed}!Str =
-  path := prefix + Uuid.v4().toStr()
-  if exists(path)
-    return mkdtemp(prefix)
-  try mkdir(path)
-  return path
-# Would need a host-side open-file-descriptor table (this VM's other file
-# ops are all one-shot: open+read/write+close in a single host call) plus a
-# `File` handle type — neither exists yet.
-fun open(path: Str, flags: Int) =
-  todo
-# See `open` — same missing handle-table/type problem, for directories.
-fun opendir(path: Str) =
-  todo
-# The names of `path`'s directory entries (not full paths).
-fun readdir(path: Str) -> error{NoSuchPath}!List[Str] =
-  if !exists(path)
-    return error.NoSuchPath
-  # skipping empty names handles both a genuinely empty directory (whose
-  # joined `""` would otherwise split into one bogus `""` entry) and
-  # `rawReadDir`'s "unreadable" fallback (already ruled out by the `exists`
-  # check above) the same way — no directory entry is ever named `""`.
-  names := List[Str]()
-  for n := range rawReadDir(path).split("\n", 0)
-    if n != ""
-      names.push(n)
-  return names
-fun readlink(path: Str) -> error{NoSuchPath}!Str =
-  if !exists(path)
-    return error.NoSuchPath
-  return rawReadlink(path)
-fun realpath(path: Str) -> error{NoSuchPath}!Str =
-  if !exists(path)
-    return error.NoSuchPath
-  return rawRealpath(path)
-fun rename(old_path: Str, new_path: Str) -> IoError!Unit =
-  if !exists(old_path)
-    return error.NoSuchPath
-  if rawRename(old_path, new_path) != 1
-    return error.IoFailed
-# Removes an empty directory. (`remove` above covers plain files.)
-fun rmdir(path: Str) -> IoError!Unit =
-  if !exists(path)
-    return error.NoSuchPath
-  if rawRemoveDir(path) != 1
-    return error.IoFailed
-# See `lstat` — needs a `Stat` struct type.
-fun stat(path: Str) =
-  todo
-# Needs a filesystem-info struct type, same gap as `stat`.
-fun statfs(path: Str) =
-  todo
-fun symlink(target: Str, path: Str) -> error{IoFailed}!Unit =
-  if rawSymlink(target, path) != 1
-    return error.IoFailed
-# Resizes the file at `path` to exactly `len` bytes — truncated if shorter,
-# zero-padded if longer.
-fun truncate(path: Str, len: Int) -> IoError!Unit =
-  if !exists(path)
-    return error.NoSuchPath
-  if rawTruncate(path, len) != 1
-    return error.IoFailed
-# See `lutimes` — same missing syscall.
-fun utimes(path: Str, atime: Int, mtime: Int) =
-  todo
-# Would need an async/callback mechanism to deliver filesystem change events
-# into a running Plum program — nothing like that exists in this VM (every
-# host call here is a synchronous, one-shot request/response).
-fun watch(filename: Str) =
-  todo
+primitive Os =
+  # NOTE: the original file modeled `stdin`/`stdout`/`stderr` as bare top-level
+  # variable bindings and a `File(...)` constructor, but this language has no
+  # top-level `let` and `File` is never defined anywhere in the stdlib. Reduced
+  # to the underlying path so this at least parses; a real `File` type is
+  # still needed here.
+  fun stdin() -> Str =
+    "/dev/stdin"
+  fun stdout() -> Str =
+    "/dev/stdout"
+  fun stderr() -> Str =
+    "/dev/stderr"
+  # 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) -> error{NoSuchPath}!Str =
+    if !exists(path)
+      return error.NoSuchPath
+    return rawReadFile(path)
+  # Writes `data` to `path`, replacing its previous contents (or creating it).
+  fun writeFile(path: Str, data: Str) -> error{IoFailed}!Unit =
+    if rawWriteFile(path, data) != 1
+      return error.IoFailed
+  fun exists(path: Str) -> Bool =
+    return rawExists(path) == 1
+  fun mkdir(path: Str) -> error{IoFailed}!Unit =
+    if rawMkdir(path) != 1
+      return error.IoFailed
+  # Removes the file (not directory) at `path`.
+  fun remove(path: Str) -> IoError!Unit =
+    if !exists(path)
+      return error.NoSuchPath
+    if rawRemove(path) != 1
+      return error.IoFailed
+  # Whether `path` exists and is reachable — this VM has no notion of a
+  # process' effective uid/gid, so (unlike POSIX `access(2)`) there is no mode
+  # argument to check permission bits against.
+  fun access(path: Str) -> Bool =
+    return exists(path)
+  # Appends `data` to the file at `path`, creating it (with just `data` as its
+  # 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) -> IoError!Unit =
+    if exists(path)
+      existing := try readFile(path)
+      try writeFile(path, existing + data)
+      return
+    try writeFile(path, data)
+  # Unix permission bits only (e.g. `0o644`) — this VM has no Windows ACL
+  # equivalent to fall back to.
+  fun chmod(path: Str, mode: Int) -> error{IoFailed}!Unit =
+    if rawChmod(path, mode) != 1
+      return error.IoFailed
+  # There is no host primitive for changing file ownership (it needs a uid/gid
+  # syscall this VM doesn't expose), unlike the permission-bits-only `chmod`.
+  fun chown(path: Str, uid: Int, gid: Int) =
+    todo
+  fun copyFile(src: Str, dest: Str) -> IoError!Unit =
+    data := try readFile(src)
+    try writeFile(dest, data)
+  fun cp(src: Str, dest: Str) -> IoError!Unit =
+    try 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) -> error{IoFailed}!Unit =
+    try chmod(path, mode)
+  # See `chown` — no uid/gid syscall exposed by this VM.
+  fun lchown(path: Str, uid: Int, gid: Int) =
+    todo
+  # Setting a file's atime/mtime needs a syscall (`utimensat`/`SetFileTime`)
+  # this VM doesn't expose (`std::fs` itself has no equivalent either).
+  fun lutimes(path: Str, atime: Int, mtime: Int) =
+    todo
+  fun link(existing_path: Str, new_path: Str) -> error{IoFailed}!Unit =
+    if rawLink(existing_path, new_path) != 1
+      return error.IoFailed
+  # Would need a real `Stat` struct type (size/mode/mtime/uid/gid/...) to
+  # return anything useful — no such type exists in the stdlib yet.
+  fun lstat(path: Str) =
+    todo
+  # 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) -> error{IoFailed}!Str =
+    path := prefix + Uuid.v4().toStr()
+    if exists(path)
+      return mkdtemp(prefix)
+    try mkdir(path)
+    return path
+  # Would need a host-side open-file-descriptor table (this VM's other file
+  # ops are all one-shot: open+read/write+close in a single host call) plus a
+  # `File` handle type — neither exists yet.
+  fun open(path: Str, flags: Int) =
+    todo
+  # See `open` — same missing handle-table/type problem, for directories.
+  fun opendir(path: Str) =
+    todo
+  # The names of `path`'s directory entries (not full paths).
+  fun readdir(path: Str) -> error{NoSuchPath}!List[Str] =
+    if !exists(path)
+      return error.NoSuchPath
+    # skipping empty names handles both a genuinely empty directory (whose
+    # joined `""` would otherwise split into one bogus `""` entry) and
+    # `rawReadDir`'s "unreadable" fallback (already ruled out by the `exists`
+    # check above) the same way — no directory entry is ever named `""`.
+    names := List[Str]()
+    for n := range rawReadDir(path).split("\n", 0)
+      if n != ""
+        names.push(n)
+    return names
+  fun readlink(path: Str) -> error{NoSuchPath}!Str =
+    if !exists(path)
+      return error.NoSuchPath
+    return rawReadlink(path)
+  fun realpath(path: Str) -> error{NoSuchPath}!Str =
+    if !exists(path)
+      return error.NoSuchPath
+    return rawRealpath(path)
+  fun rename(old_path: Str, new_path: Str) -> IoError!Unit =
+    if !exists(old_path)
+      return error.NoSuchPath
+    if rawRename(old_path, new_path) != 1
+      return error.IoFailed
+  # Removes an empty directory. (`remove` above covers plain files.)
+  fun rmdir(path: Str) -> IoError!Unit =
+    if !exists(path)
+      return error.NoSuchPath
+    if rawRemoveDir(path) != 1
+      return error.IoFailed
+  # See `lstat` — needs a `Stat` struct type.
+  fun stat(path: Str) =
+    todo
+  # Needs a filesystem-info struct type, same gap as `stat`.
+  fun statfs(path: Str) =
+    todo
+  fun symlink(target: Str, path: Str) -> error{IoFailed}!Unit =
+    if rawSymlink(target, path) != 1
+      return error.IoFailed
+  # Resizes the file at `path` to exactly `len` bytes — truncated if shorter,
+  # zero-padded if longer.
+  fun truncate(path: Str, len: Int) -> IoError!Unit =
+    if !exists(path)
+      return error.NoSuchPath
+    if rawTruncate(path, len) != 1
+      return error.IoFailed
+  # See `lutimes` — same missing syscall.
+  fun utimes(path: Str, atime: Int, mtime: Int) =
+    todo
+  # Would need an async/callback mechanism to deliver filesystem change events
+  # into a running Plum program — nothing like that exists in this VM (every
+  # host call here is a synchronous, one-shot request/response).
+  fun watch(filename: Str) =
+    todo
 test "writeFile/readFile/appendFile/remove round-trip on a real file"
-  dir := mkdtemp("/tmp/plum_os_test_")!
+  dir := Os.mkdtemp("/tmp/plum_os_test_")!
   path := dir + "/a.txt"
-  writeFile(path, "hello")!
+  Os.writeFile(path, "hello")!
-  assert readFile(path)! == "hello"
+  assert Os.readFile(path)! == "hello"
-  appendFile(path, " world")!
+  Os.appendFile(path, " world")!
-  assert readFile(path)! == "hello world"
+  assert Os.readFile(path)! == "hello world"
-  assert exists(path) == true
+  assert Os.exists(path) == true
-  remove(path)!
+  Os.remove(path)!
-  assert exists(path) == false
+  assert Os.exists(path) == false
-  rmdir(dir)!
+  Os.rmdir(dir)!
 test "copyFile/cp/rename move and duplicate file contents correctly"
-  dir := mkdtemp("/tmp/plum_os_test_")!
+  dir := Os.mkdtemp("/tmp/plum_os_test_")!
   a := dir + "/a.txt"
   b := dir + "/b.txt"
   c := dir + "/c.txt"
-  writeFile(a, "data")!
+  Os.writeFile(a, "data")!
-  copyFile(a, b)!
+  Os.copyFile(a, b)!
-  assert readFile(b)! == "data"
+  assert Os.readFile(b)! == "data"
-  rename(b, c)!
+  Os.rename(b, c)!
-  assert exists(b) == false
+  assert Os.exists(b) == false
-  assert readFile(c)! == "data"
+  assert Os.readFile(c)! == "data"
-  remove(a)!
+  Os.remove(a)!
-  remove(c)!
+  Os.remove(c)!
-  rmdir(dir)!
+  Os.rmdir(dir)!
 test "readdir lists the entries created in a fresh directory"
-  dir := mkdtemp("/tmp/plum_os_test_")!
+  dir := Os.mkdtemp("/tmp/plum_os_test_")!
-  assert readdir(dir)!.length() == 0
+  assert Os.readdir(dir)!.length() == 0
-  writeFile(dir + "/only.txt", "x")!
+  Os.writeFile(dir + "/only.txt", "x")!
-  names := readdir(dir)!
+  names := Os.readdir(dir)!
   assert names.length() == 1
   assert names.join(",") == "only.txt"
-  remove(dir + "/only.txt")!
+  Os.remove(dir + "/only.txt")!
-  rmdir(dir)!
+  Os.rmdir(dir)!
 test "symlink/readlink/realpath resolve a linked file correctly"
-  dir := mkdtemp("/tmp/plum_os_test_")!
+  dir := Os.mkdtemp("/tmp/plum_os_test_")!
   target := dir + "/target.txt"
   link_path := dir + "/link.txt"
-  writeFile(target, "linked")!
+  Os.writeFile(target, "linked")!
-  symlink(target, link_path)!
+  Os.symlink(target, link_path)!
-  assert readlink(link_path)! == target
+  assert Os.readlink(link_path)! == target
-  assert readFile(link_path)! == "linked"
+  assert Os.readFile(link_path)! == "linked"
-  realpath(link_path)!
+  Os.realpath(link_path)!
-  remove(link_path)!
+  Os.remove(link_path)!
-  remove(target)!
+  Os.remove(target)!
-  rmdir(dir)!
+  Os.rmdir(dir)!
 test "truncate resizes a file's contents"
-  dir := mkdtemp("/tmp/plum_os_test_")!
+  dir := Os.mkdtemp("/tmp/plum_os_test_")!
   path := dir + "/a.txt"
-  writeFile(path, "hello world")!
+  Os.writeFile(path, "hello world")!
-  truncate(path, 5)!
+  Os.truncate(path, 5)!
-  assert readFile(path)! == "hello"
+  assert Os.readFile(path)! == "hello"
-  remove(path)!
+  Os.remove(path)!
-  rmdir(dir)!
+  Os.rmdir(dir)!
 test "chmod changes a file's permission bits"
-  dir := mkdtemp("/tmp/plum_os_test_")!
+  dir := Os.mkdtemp("/tmp/plum_os_test_")!
   path := dir + "/a.txt"
-  writeFile(path, "x")!
+  Os.writeFile(path, "x")!
-  chmod(path, 384)! # 0o600
+  Os.chmod(path, 384)! # 0o600
-  remove(path)!
+  Os.remove(path)!
-  rmdir(dir)!
+  Os.rmdir(dir)!
 test "link creates a second name for the same file"
-  dir := mkdtemp("/tmp/plum_os_test_")!
+  dir := Os.mkdtemp("/tmp/plum_os_test_")!
   a := dir + "/a.txt"
   b := dir + "/b.txt"
-  writeFile(a, "shared")!
+  Os.writeFile(a, "shared")!
-  link(a, b)!
+  Os.link(a, b)!
-  assert readFile(b)! == "shared"
+  assert Os.readFile(b)! == "shared"
-  remove(a)!
+  Os.remove(a)!
-  remove(b)!
+  Os.remove(b)!
-  rmdir(dir)!
+  Os.rmdir(dir)!
 test "readFile/remove/rmdir report errors for missing paths"
-  assert {readFile("/tmp/plum_os_test_does_not_exist.txt") catch "gone"} == "gone"
+  assert {Os.readFile("/tmp/plum_os_test_does_not_exist.txt") catch "gone"} == "gone"
   failed := 0
-  remove("/tmp/plum_os_test_does_not_exist.txt") catch e
+  Os.remove("/tmp/plum_os_test_does_not_exist.txt") catch e
     failed = failed + 1
-  rmdir("/tmp/plum_os_test_does_not_exist_dir") catch e
+  Os.rmdir("/tmp/plum_os_test_does_not_exist_dir") catch e
     failed = failed + 1
   assert failed == 2

plum-std/Str.plum CHANGED Viewed

@@ -146,9 +146,9 @@ record Str(bytes: []Byte) =
       return self
     if n == 0
       return o
-    out := makeBytes(n + m)
+    out := ByteSlice.make(n + m)
-    copyBytes(out, 0, self.bytes, 0, n)
+    ByteSlice.copy(out, 0, self.bytes, 0, n)
-    copyBytes(out, n, o.bytes, 0, m)
+    ByteSlice.copy(out, n, o.bytes, 0, m)
     return Str(bytes: out)
   # `a == b` / `a != b`: CONTENT equality (never reference equality).
@@ -156,7 +156,7 @@ record Str(bytes: []Byte) =
     n := self.length()
     if n != o.length()
       return false
-    return bytesEqual(self.bytes, 0, o.bytes, 0, n)
+    return ByteSlice.equal(self.bytes, 0, o.bytes, 0, n)
   fun toStr(self) -> Str =
     self
@@ -280,7 +280,7 @@ record Str(bytes: []Byte) =
     en := if e > len then len else e
     if s >= en
       return ""
-    return bytesToStr(self.bytes, s, en - s)
+    return fromBytes(self.bytes, s, en - s)
   fun toLower(self) -> Str =
     mapCase(self, false)
@@ -290,15 +290,15 @@ record Str(bytes: []Byte) =
   # along with the string's, corrupting any non-ASCII text.
   fun reverse(self) -> Str =
     n := self.length()
-    out := makeBytes(n)
+    out := ByteSlice.make(n)
     i := 0
     while i < n
       cl := self.codePointByteLength(i)
       if i + cl > n
         cl = n - i
-      copyBytes(out, n - i - cl, self.bytes, i, cl)
+      ByteSlice.copy(out, n - i - cl, self.bytes, i, cl)
       i = i + cl
-    return bytesToStr(out, 0, n)
+    return fromBytes(out, 0, n)
   fun camelCase(self) -> Str =
     caseConvert(self, "", 2)
@@ -414,235 +414,235 @@ record Str(bytes: []Byte) =
   fun words(self) -> Str =
     caseConvert(self, " ", 0)
+  # Copies out `n` bytes of `src` starting at `start` into a fresh, independent
+  # `Str`: it never aliases `src`, so mutating `src` afterwards can't change an
+  # already-returned `Str`.
+  fun fromBytes(src: []Byte, start: Int, n: Int) -> Str =
+    data := ByteSlice.make(n)
+    ByteSlice.copy(data, 0, src, start, n)
+    return Str(bytes: data)
-# A new 1-byte Str holding `b`'s low 8 bits, the counterpart to `byteAt`.
+  # A new 1-byte Str holding `b`'s low 8 bits, the counterpart to `byteAt`.
-fun byteToStr(b: Int) -> Str =
+  fun byteToStr(b: Int) -> Str =
-  out := makeBytes(1)
+    out := ByteSlice.make(1)
-  out.set(0, Byte(b))
+    out.set(0, Byte(b))
-  return Str(bytes: out)
+    return Str(bytes: out)
-fun isAsciiUpper(b: Int) -> Bool =
+  fun isAsciiUpper(b: Int) -> Bool =
-  b >= 65 && b <= 90 # 'A'..'Z'
+    b >= 65 && b <= 90 # 'A'..'Z'
-fun isAsciiLower(b: Int) -> Bool =
+  fun isAsciiLower(b: Int) -> Bool =
-  b >= 97 && b <= 122 # 'a'..'z'
+    b >= 97 && b <= 122 # 'a'..'z'
-fun isAsciiDigit(b: Int) -> Bool =
+  fun isAsciiDigit(b: Int) -> Bool =
-  b >= 48 && b <= 57 # '0'..'9'
+    b >= 48 && b <= 57 # '0'..'9'
-# Byte 0x80+ is either a UTF-8 continuation byte or the lead byte of a
+  # Byte 0x80+ is either a UTF-8 continuation byte or the lead byte of a
-# multi-byte character — never an ASCII separator — so it's treated as
+  # multi-byte character — never an ASCII separator — so it's treated as
-# "part of a word" here. Without this, `caseConvert` (backing `words`/
+  # "part of a word" here. Without this, `caseConvert` (backing `words`/
-# `camelCase`/`snakeCase`/`kebabCase`/`startCase`) would treat every
+  # `camelCase`/`snakeCase`/`kebabCase`/`startCase`) would treat every
-# non-ASCII character as a word BOUNDARY, shredding any text that isn't
+  # non-ASCII character as a word BOUNDARY, shredding any text that isn't
-# pure ASCII into a separate "word" per byte.
+  # pure ASCII into a separate "word" per byte.
-fun isWordByte(b: Int) -> Bool =
+  fun isWordByte(b: Int) -> Bool =
-  isAsciiUpper(b) || isAsciiLower(b) || isAsciiDigit(b) || b >= 0x80
+    isAsciiUpper(b) || isAsciiLower(b) || isAsciiDigit(b) || b >= 0x80
-fun toLowerByte(b: Int) -> Int =
+  fun toLowerByte(b: Int) -> Int =
-  if isAsciiUpper(b) then b + 32 else b
+    if isAsciiUpper(b) then b + 32 else b
-fun toUpperByte(b: Int) -> Int =
+  fun toUpperByte(b: Int) -> Int =
-  if isAsciiLower(b) then b - 32 else b
+    if isAsciiLower(b) then b - 32 else b
-fun isCamelBoundary(prev_byte: Int, cur_byte: Int) -> Bool =
+  fun isCamelBoundary(prev_byte: Int, cur_byte: Int) -> Bool =
-  isAsciiLower(prev_byte) && isAsciiUpper(cur_byte)
+    isAsciiLower(prev_byte) && isAsciiUpper(cur_byte)
-# true if `s.byteAt(offset)..offset+subLen` equals `sub` exactly (and is in
+  # true if `s.byteAt(offset)..offset+subLen` equals `sub` exactly (and is in
-# bounds — out-of-range always reports no match rather than trapping, so every
+  # bounds — out-of-range always reports no match rather than trapping, so every
-# caller can test candidate positions/lengths freely).
+  # caller can test candidate positions/lengths freely).
-fun matchesAt(s: Str, sub: Str, offset: Int, sub_len: Int) -> Bool =
+  fun matchesAt(s: Str, sub: Str, offset: Int, sub_len: Int) -> Bool =
-  if offset < 0 || offset + sub_len > s.length()
+    if offset < 0 || offset + sub_len > s.length()
-    return false
-  j := 0
-  while j < sub_len
-    if s.byteAt(offset + j) != sub.byteAt(j)
       return false
-    j = j + 1
-  return true
-# Encodes a single Unicode codepoint (its raw integer value) as its own
-# UTF-8 `Str` (1-4 bytes) — the reverse of `Str.codePointAt`. `b0`/`b1`/`b2`
-# are declared ONCE up front and reassigned per branch (rather than
-# redeclared with `:=` in each `if`) — `if` bodies share one flat scope with
-# the rest of the function here (there's no per-branch isolation), so a
-# second `:=` for the same name would be a compile error.
-fun codePointToStr(cp: Int) -> Str =
-  if cp < 0x80
-    return byteToStr(cp)
-  b0 := 0xC0 | {cp >> 6}
-  b1 := 0x80 | {cp & 0x3F}
-  if cp < 0x800
-    return byteToStr(b0) + byteToStr(b1)
-  b0 = 0xE0 | {cp >> 12}
-  b1 = 0x80 | {{cp >> 6} & 0x3F}
-  b2 := 0x80 | {cp & 0x3F}
-  if cp < 0x10000
-    return byteToStr(b0) + byteToStr(b1) + byteToStr(b2)
-  b0 = 0xF0 | {cp >> 18}
-  b1 = 0x80 | {{cp >> 12} & 0x3F}
-  b2 = 0x80 | {{cp >> 6} & 0x3F}
-  b3 := 0x80 | {cp & 0x3F}
-  return byteToStr(b0) + byteToStr(b1) + byteToStr(b2) + byteToStr(b3)
-fun isTrimByte(b: Int) -> Bool =
-  b == 32 || b == 9 || b == 10 || b == 13
-fun trimStartIndex(s: Str) -> Int =
-  n := s.length()
-  i := 0
-  while i < n && isTrimByte(s.byteAt(i))
-    i = i + 1
-  return i
-# Exclusive end index of `s` with trailing whitespace dropped.
-fun trimEndIndex(s: Str) -> Int =
-  n := s.length()
-  while n > 0 && isTrimByte(s.byteAt(n - 1))
-    n = n - 1
-  return n
-fun htmlEntity(b: Int) -> Str =
-  match b
-    38 => "&amp;"
-    60 => "&lt;"
-    62 => "&gt;"
-    34 => "&quot;"
-    39 => "&#39;"
-    _ => ""
-fun escapeHtml(s: Str) -> Str =
-  n := s.length()
-  buf := Buffer()
-  i := 0
-  while i < n
-    b := s.byteAt(i)
-    ent := htmlEntity(b)
-    if ent.length() == 0
+    j := 0
+    while j < sub_len
+      if s.byteAt(offset + j) != sub.byteAt(j)
+        return false
+      j = j + 1
+    return true
+  # Encodes a single Unicode codepoint (its raw integer value) as its own
+  # UTF-8 `Str` (1-4 bytes) — the reverse of `Str.codePointAt`. `b0`/`b1`/`b2`
+  # are declared ONCE up front and reassigned per branch (rather than
+  # redeclared with `:=` in each `if`) — `if` bodies share one flat scope with
+  # the rest of the function here (there's no per-branch isolation), so a
+  # second `:=` for the same name would be a compile error.
+  fun codePointToStr(cp: Int) -> Str =
+    if cp < 0x80
+      return byteToStr(cp)
+    b0 := 0xC0 | {cp >> 6}
+    b1 := 0x80 | {cp & 0x3F}
+    if cp < 0x800
+      return byteToStr(b0) + byteToStr(b1)
+    b0 = 0xE0 | {cp >> 12}
+    b1 = 0x80 | {{cp >> 6} & 0x3F}
+    b2 := 0x80 | {cp & 0x3F}
+    if cp < 0x10000
+      return byteToStr(b0) + byteToStr(b1) + byteToStr(b2)
+    b0 = 0xF0 | {cp >> 18}
+    b1 = 0x80 | {{cp >> 12} & 0x3F}
+    b2 = 0x80 | {{cp >> 6} & 0x3F}
+    b3 := 0x80 | {cp & 0x3F}
+    return byteToStr(b0) + byteToStr(b1) + byteToStr(b2) + byteToStr(b3)
+  fun isTrimByte(b: Int) -> Bool =
+    b == 32 || b == 9 || b == 10 || b == 13
+  fun trimStartIndex(s: Str) -> Int =
+    n := s.length()
+    i := 0
+    while i < n && isTrimByte(s.byteAt(i))
+      i = i + 1
+    return i
+  # Exclusive end index of `s` with trailing whitespace dropped.
+  fun trimEndIndex(s: Str) -> Int =
+    n := s.length()
+    while n > 0 && isTrimByte(s.byteAt(n - 1))
+      n = n - 1
+    return n
+  fun htmlEntity(b: Int) -> Str =
+    match b
+      38 => "&amp;"
+      60 => "&lt;"
+      62 => "&gt;"
+      34 => "&quot;"
+      39 => "&#39;"
+      _ => ""
+  fun escapeHtml(s: Str) -> Str =
+    n := s.length()
+    buf := Buffer()
+    i := 0
+    while i < n
+      b := s.byteAt(i)
+      ent := htmlEntity(b)
+      if ent.length() == 0
+        buf.writeByte(Byte(b))
+      else
+        buf.write(ent)
+      i = i + 1
+    return buf.toStr()
+  fun isRegExpMetaByte(b: Int) -> Bool =
+    b == 94 || b == 36 || b == 92 || b == 46 || b == 42 || b == 43 || b == 63
+      || b == 40 || b == 41 || b == 91 || b == 93 || b == 123 || b == 125 || b == 124
+  fun escapeRegExpStr(s: Str) -> Str =
+    n := s.length()
+    buf := Buffer()
+    i := 0
+    while i < n
+      b := s.byteAt(i)
+      if isRegExpMetaByte(b)
+        buf.writeByte(Byte(92))
       buf.writeByte(Byte(b))
-    else
-      buf.write(ent)
-    i = i + 1
+      i = i + 1
-  return buf.toStr()
+    return buf.toStr()
+  # Length of the HTML entity starting at `i` (and writes its decoded byte
+  # into `buf`), or 0 if none starts there.
+  fun unescapeEntityAt(s: Str, i: Int, buf: Buffer) -> Int =
+    if matchesAt(s, "&amp;", i, 5)
+      buf.writeByte(Byte(38))
+      return 5
+    if matchesAt(s, "&lt;", i, 4)
+      buf.writeByte(Byte(60))
+      return 4
+    if matchesAt(s, "&gt;", i, 4)
+      buf.writeByte(Byte(62))
+      return 4
+    if matchesAt(s, "&quot;", i, 6)
+      buf.writeByte(Byte(34))
+      return 6
+    if matchesAt(s, "&#39;", i, 5)
+      buf.writeByte(Byte(39))
+      return 5
+    return 0
+  fun unescapeHtml(s: Str) -> Str =
+    n := s.length()
+    buf := Buffer()
+    i := 0
+    while i < n
+      k := 0
+      if s.byteAt(i) == 38
+        k = unescapeEntityAt(s, i, buf)
+      if k == 0
+        buf.writeByte(Byte(s.byteAt(i)))
+        k = 1
+      i = i + k
+    return buf.toStr()
+  # Shared walker behind `words`/`camelCase`/`snakeCase`/`kebabCase`/`startCase`:
+  # splits on non-word bytes and on a lower->upper "camel" transition, joining
+  # the surviving words with `sep` and case-mapping each byte per `mode`:
+  #   0 = leave case as-is (words)                        1 = lowercase everything (snake/kebab)
+  #   2 = camelCase (word 1 lowercase, rest Capitalized)  4 = Capitalize every word (startCase)
+  # (`toLower`/`upperCase` use `mapCase` — they map every byte 1:1 including
+  # non-word bytes like spaces/punctuation, which this function drops.)
-fun isRegExpMetaByte(b: Int) -> Bool =
+  fun caseConvert(s: Str, sep: Str, mode: Int) -> Str =
+    n := s.length()
+    buf := Buffer()
+    word_index := 0
+    prev_byte := 0
+    i := 0
+    while i < n
+      b := s.byteAt(i)
+      if !isWordByte(b)
+        prev_byte = 0
+      else
-  b == 94 || b == 36 || b == 92 || b == 46 || b == 42 || b == 43 || b == 63
+        is_word_start := prev_byte == 0 || isCamelBoundary(prev_byte, b)
+        if is_word_start
+          word_index = word_index + 1
+          if word_index > 1
+            buf.write(sep)
-    || b == 40 || b == 41 || b == 91 || b == 93 || b == 123 || b == 125 || b == 124
+        buf.writeByte(Byte(caseConvertByte(b, mode, is_word_start, word_index)))
+        prev_byte = b
+      i = i + 1
+    return buf.toStr()
+  fun caseConvertByte(b: Int, mode: Int, is_word_start: Bool, word_index: Int) -> Int =
+    match mode
+      0 => b
+      1 => toLowerByte(b)
+      2 => if word_index == 1 then toLowerByte(b) else {if is_word_start then toUpperByte(b) else toLowerByte(b)}
+      4 => if is_word_start then toUpperByte(b) else toLowerByte(b)
+      _ => b
+  # Simple 1:1 byte map — every byte (including non-word bytes like spaces and
+  # punctuation) is preserved; only letters are case-mapped.
-fun escapeRegExpStr(s: Str) -> Str =
+  fun mapCase(s: Str, upper: Bool) -> Str =
-  n := s.length()
+    n := s.length()
-  buf := Buffer()
+    buf := Buffer()
-  i := 0
+    i := 0
-  while i < n
+    while i < n
-    b := s.byteAt(i)
+      b := s.byteAt(i)
-    if isRegExpMetaByte(b)
-      buf.writeByte(Byte(92))
-    buf.writeByte(Byte(b))
+      buf.writeByte(Byte(if upper then toUpperByte(b) else toLowerByte(b)))
-    i = i + 1
+      i = i + 1
-  return buf.toStr()
+    return buf.toStr()
-# Length of the HTML entity starting at `i` (and writes its decoded byte
-# into `buf`), or 0 if none starts there.
-fun unescapeEntityAt(s: Str, i: Int, buf: Buffer) -> Int =
-  if matchesAt(s, "&amp;", i, 5)
-    buf.writeByte(Byte(38))
-    return 5
-  if matchesAt(s, "&lt;", i, 4)
-    buf.writeByte(Byte(60))
-    return 4
-  if matchesAt(s, "&gt;", i, 4)
-    buf.writeByte(Byte(62))
-    return 4
-  if matchesAt(s, "&quot;", i, 6)
-    buf.writeByte(Byte(34))
-    return 6
-  if matchesAt(s, "&#39;", i, 5)
-    buf.writeByte(Byte(39))
-    return 5
-  return 0
-fun unescapeHtml(s: Str) -> Str =
-  n := s.length()
-  buf := Buffer()
-  i := 0
-  while i < n
-    k := 0
-    if s.byteAt(i) == 38
-      k = unescapeEntityAt(s, i, buf)
-    if k == 0
-      buf.writeByte(Byte(s.byteAt(i)))
-      k = 1
-    i = i + k
-  return buf.toStr()
-# Shared walker behind `words`/`camelCase`/`snakeCase`/`kebabCase`/`startCase`:
-# splits on non-word bytes and on a lower->upper "camel" transition, joining
-# the surviving words with `sep` and case-mapping each byte per `mode`:
-#   0 = leave case as-is (words)                        1 = lowercase everything (snake/kebab)
-#   2 = camelCase (word 1 lowercase, rest Capitalized)  4 = Capitalize every word (startCase)
-# (`toLower`/`upperCase` use `mapCase` — they map every byte 1:1 including
-# non-word bytes like spaces/punctuation, which this function drops.)
-fun caseConvert(s: Str, sep: Str, mode: Int) -> Str =
-  n := s.length()
-  buf := Buffer()
-  word_index := 0
-  prev_byte := 0
-  i := 0
-  while i < n
-    b := s.byteAt(i)
-    if !isWordByte(b)
-      prev_byte = 0
-    else
-      is_word_start := prev_byte == 0 || isCamelBoundary(prev_byte, b)
-      if is_word_start
-        word_index = word_index + 1
-        if word_index > 1
-          buf.write(sep)
-      buf.writeByte(Byte(caseConvertByte(b, mode, is_word_start, word_index)))
-      prev_byte = b
-    i = i + 1
-  return buf.toStr()
-fun caseConvertByte(b: Int, mode: Int, is_word_start: Bool, word_index: Int) -> Int =
-  match mode
-    0 => b
-    1 => toLowerByte(b)
-    2 => if word_index == 1 then toLowerByte(b) else {if is_word_start then toUpperByte(b) else toLowerByte(b)}
-    4 => if is_word_start then toUpperByte(b) else toLowerByte(b)
-    _ => b
-# Simple 1:1 byte map — every byte (including non-word bytes like spaces and
-# punctuation) is preserved; only letters are case-mapped.
-fun mapCase(s: Str, upper: Bool) -> Str =
-  n := s.length()
-  buf := Buffer()
-  i := 0
-  while i < n
-    b := s.byteAt(i)
-    buf.writeByte(Byte(if upper then toUpperByte(b) else toLowerByte(b)))
-    i = i + 1
-  return buf.toStr()
-# 2-char cells (space padded), one per codepoint U+00C0..U+00FF. `#` = keep
+  # 2-char cells (space padded), one per codepoint U+00C0..U+00FF. `#` = keep
-# the original character (`×`, `÷`).
+  # the original character (`×`, `÷`).
-fun deburrLatin1() -> Str =
+  fun deburrLatin1() -> Str =
-  "A A A A A A AEC E E E E I I I I D N O O O O O # O U U U U Y Thssa a a a a a aec e e e e i i i i d n o o o o o # o u u u u y thy "
+    "A A A A A A AEC E E E E I I I I D N O O O O O # O U U U U Y Thssa a a a a a aec e e e e i i i i d n o o o o o # o u u u u y thy "
-# Same layout for U+0100..U+017F (Latin Extended-A).
-fun deburrLatinExtA() -> Str =
-  "A a A a A a C c C c C c C c D d D d E e E e E e E e E e G g G g G g G g H h H h I i I i I i I i I i IJijJ j K k k L l L l L l L l L l N n N n N n n N n O o O o O o OEoeR r R r R r S s S s S s S s T t T t T t U u U u U u U u U u U u W w Y y Y Z z Z z Z z s "
+  # Same layout for U+0100..U+017F (Latin Extended-A).
+  fun deburrLatinExtA() -> Str =
+    "A a A a A a C c C c C c C c D d D d E e E e E e E e E e G g G g G g G g H h H h I i I i I i I i I i IJijJ j K k k L l L l L l L l L l N n N n N n n N n O o O o O o OEoeR r R r R r S s S s S s S s T t T t T t U u U u U u U u U u U u W w Y y Y Z z Z z Z z s "
 # ---- string interpolation regression tests ----
 # `"{expr}"` interpolation is a compiler/codegen feature (not a Str method
 # above), but Str is what it produces, so its regression coverage lives here.
-fun bigAscii(n: Int, b: Int) -> Str =
-  buf := Buffer()
-  i := 0
-  while i < n
-    buf.writeByte(Byte(b))
-    i = i + 1
-  return buf.toStr()
 test "split divides on every occurrence of the separator"
   parts := "a,b,c".split(",", 0)
   assert parts.length() == 3
@@ -727,7 +727,7 @@ test "escape/unescape round-trip HTML-sensitive characters"
 # ---- large-input (linear-time, no stack growth) regression tests ----
 test "sub of a 200000-byte string is a single copy"
-  s := bigAscii(200000, 97)
+  s := "a".repeat(200000)
   r := s.sub(10, 199990)
   assert r.length() == 199980
   assert s.sub(0, 200000).length() == 200000
@@ -745,7 +745,7 @@ test "reverse of a 100000-char string"
   assert r.byteAt(0) == 97
 test "escape and unescape of a 100000-char string"
-  s := bigAscii(100000, 60)
+  s := "<".repeat(100000)
   e := s.escape()
   assert e.length() == 400000
   assert e.unescape() == s

plum-std/Testing.plum CHANGED Viewed

@@ -8,10 +8,10 @@ import std/Str
 # Small jest/rspec-style assertion helpers for use inside `test` blocks, e.g.
 #
 #   test "add works"
-#     assert expectEq(add(1, 2), 3)
+#     assert Testing.expectEq(add(1, 2), 3)
-#     assert expectTrue(isEven(4))
+#     assert Testing.expectTrue(isEven(4))
 #
-# These are plain functions returning `Bool` (`assert` only takes a bare
+# These are statics returning `Bool` (`assert` only takes a bare
 # boolean expression — see `plum-core/parser.rs`'s `assert` rule), not a new
 # grammar form. They exist purely to make the condition read like an
 # assertion instead of a raw comparison.
@@ -30,85 +30,84 @@ import std/Str
 # those types, prefer the type's own `equals(self, other)` method (e.g.
 # `Uuid.equals`, `Time.equals`) directly in `assert` instead.
+primitive Testing =
-fun expectTrue(cond: Bool) -> Bool =
+  fun expectTrue(cond: Bool) -> Bool =
-  cond
+    cond
-fun expectFalse(cond: Bool) -> Bool =
+  fun expectFalse(cond: Bool) -> Bool =
-  !cond
+    !cond
-fun expectEq(a: T, b: T) -> Bool =
+  fun expectEq(a: T, b: T) -> Bool =
-  a == b
+    a == b
-fun expectNotEq(a: T, b: T) -> Bool =
+  fun expectNotEq(a: T, b: T) -> Bool =
-  a != b
+    a != b
-# See the module-level CAVEAT above — this is `expectEq` under a name that
+  # See the module-level CAVEAT above — this is `expectEq` under a name that
-# reads better at a class/struct call site; it does NOT do structural
+  # reads better at a class/struct call site; it does NOT do structural
-# (field-by-field) comparison.
+  # (field-by-field) comparison.
-fun expectObject(a: T, b: T) -> Bool =
+  fun expectObject(a: T, b: T) -> Bool =
-  a == b
+    a == b
-# Elementwise `List[T]` comparison — see the module-level CAVEAT above for
+  # Elementwise `List[T]` comparison — see the module-level CAVEAT above for
-# what `List.equals`'s own `==` means when `T` is a class/enum.
+  # what `List.equals`'s own `==` means when `T` is a class/enum.
-fun expectArray(a: List[T], b: List[T]) -> Bool =
+  fun expectArray(a: List[T], b: List[T]) -> Bool =
-  a.equals(b)
+    a.equals(b)
-fun expectSuccess(r: !T) -> Bool =
+  fun expectSuccess(r: !T) -> Bool =
-  r catch e
+    r catch e
-    return false
+      return false
-  true
+    true
-fun expectFailure(r: !T) -> Bool =
+  fun expectFailure(r: !T) -> Bool =
-  r catch e
+    r catch e
-    return true
+      return true
-  false
+    false
-# True when `r` failed with the error named `name`.
+  # True when `r` failed with the error named `name`.
-fun expectFailureNamed(r: !T, name: Str) -> Bool =
+  fun expectFailureNamed(r: !T, name: Str) -> Bool =
-  r catch e
+    r catch e
-    return e.name() == name
+      return e.name() == name
-  false
+    false
-fun makeSuccessForTestingTest() -> error{Bad}!Int =
-  return 5
-fun makeFailureForTestingTest() -> error{Bad}!Int =
-  return error.Bad
 test "expectTrue and expectFalse"
-  assert expectTrue(1 == 1)
+  assert Testing.expectTrue(1 == 1)
-  assert expectFalse(1 == 2)
+  assert Testing.expectFalse(1 == 2)
 test "expectEq and expectNotEq"
-  assert expectEq(2 + 2, 4)
+  assert Testing.expectEq(2 + 2, 4)
-  assert expectEq("ab" + "c", "abc")
+  assert Testing.expectEq("ab" + "c", "abc")
-  assert expectNotEq(2 + 2, 5)
+  assert Testing.expectNotEq(2 + 2, 5)
 test "list equality via the List.equals method"
   a := List(1, 2, 3)
   b := List(1, 2, 3)
   c := List(1, 2)
   assert a.equals(b)
-  assert expectFalse(a.equals(c))
+  assert Testing.expectFalse(a.equals(c))
 test "error unions are inspected with catch and !"
+  ok: error{Bad}!Int := 5
+  bad: error{Bad}!Int := error.Bad
-  assert makeSuccessForTestingTest()! == 5
+  assert ok! == 5
-  assert {makeFailureForTestingTest() catch -1} == -1
+  assert {bad catch -1} == -1
 test "expectArray compares two List[T]s elementwise"
   a := List(1, 2, 3)
   b := List(1, 2, 3)
   c := List(1, 2)
-  assert expectArray(a, b)
+  assert Testing.expectArray(a, b)
-  assert expectFalse(expectArray(a, c))
+  assert Testing.expectFalse(Testing.expectArray(a, c))
   d := List("x", "y")
   e := List("x", "y")
-  assert expectArray(d, e)
+  assert Testing.expectArray(d, e)
 test "expectSuccess/expectFailure check the right variant"
+  ok: error{Bad}!Int := 5
+  bad: error{Bad}!Int := error.Bad
-  assert expectSuccess(makeSuccessForTestingTest())
+  assert Testing.expectSuccess(ok)
-  assert expectFalse(expectSuccess(makeFailureForTestingTest()))
-  assert expectFailure(makeFailureForTestingTest())
-  assert expectFalse(expectFailure(makeSuccessForTestingTest()))
+  assert Testing.expectFalse(Testing.expectSuccess(bad))
+  assert Testing.expectFailure(bad)
+  assert Testing.expectFalse(Testing.expectFailure(ok))
-  assert expectFailureNamed(makeFailureForTestingTest(), "Bad")
+  assert Testing.expectFailureNamed(bad, "Bad")
-  assert expectFalse(expectFailureNamed(makeSuccessForTestingTest(), "Bad"))
+  assert Testing.expectFalse(Testing.expectFailureNamed(ok, "Bad"))

plum-std/Time.plum CHANGED Viewed

@@ -80,38 +80,38 @@ record Time(value: Int) =
       + ":" + self.minute().toStr().padStart("0", 2) + ":" + self.second().toStr().padStart("0", 2)
       + "." + self.millisecond().toStr().padStart("0", 3) + "Z"
+  # Days-since-epoch to proleptic Gregorian year/month/day, via Howard
+  # Hinnant's `civil_from_days` (http://howardhinnant.github.io/date_algorithms.html) —
+  # pure integer math, valid for the whole range representable by `Int`, and
+  # exact (no floating-point rounding).
+  fun civilFromDays(z: Int) -> Civil =
+    zz := z + 719468
+    era := if zz >= 0 then zz / 146097 else { zz - 146096 } / 146097
+    doe := zz - era * 146097
+    yoe := { doe - doe / 1460 + doe / 36524 - doe / 146096 } / 365
+    y := yoe + era * 400
+    doy := doe - { 365 * yoe + yoe / 4 - yoe / 100 }
+    mp := { 5 * doy + 2 } / 153
+    d := doy - { 153 * mp + 2 } / 5 + 1
+    m := if mp < 10 then mp + 3 else mp - 9
+    return Civil(year: if m <= 2 then y + 1 else y, month: m, day: d)
+  # Integer division rounding toward negative infinity, unlike `/`'s
+  # round-toward-zero — needed so times before the epoch (negative `value`)
+  # still decompose into the correct calendar day/hour/etc rather than one
+  # past it.
+  fun floorDiv(a: Int, b: Int) -> Int =
+    q := a / b
+    r := a % b
+    return if { { r < 0 && b > 0 } || { r > 0 && b < 0 } } then q - 1 else q
+  fun floorMod(a: Int, b: Int) -> Int =
+    r := a % b
+    return if { { r < 0 && b > 0 } || { r > 0 && b < 0 } } then r + b else r
 # A Gregorian calendar date, decomposed from a day count by `civilFromDays`.
 record Civil(year: Int, month: Int, day: Int)
-# Days-since-epoch to proleptic Gregorian year/month/day, via Howard
-# Hinnant's `civil_from_days` (http://howardhinnant.github.io/date_algorithms.html) —
-# pure integer math, valid for the whole range representable by `Int`, and
-# exact (no floating-point rounding).
-fun civilFromDays(z: Int) -> Civil =
-  zz := z + 719468
-  era := if zz >= 0 then zz / 146097 else { zz - 146096 } / 146097
-  doe := zz - era * 146097
-  yoe := { doe - doe / 1460 + doe / 36524 - doe / 146096 } / 365
-  y := yoe + era * 400
-  doy := doe - { 365 * yoe + yoe / 4 - yoe / 100 }
-  mp := { 5 * doy + 2 } / 153
-  d := doy - { 153 * mp + 2 } / 5 + 1
-  m := if mp < 10 then mp + 3 else mp - 9
-  return Civil(year: if m <= 2 then y + 1 else y, month: m, day: d)
-# Integer division rounding toward negative infinity, unlike `/`'s
-# round-toward-zero — needed so times before the epoch (negative `value`)
-# still decompose into the correct calendar day/hour/etc rather than one
-# past it.
-fun floorDiv(a: Int, b: Int) -> Int =
-  q := a / b
-  r := a % b
-  return if { { r < 0 && b > 0 } || { r > 0 && b < 0 } } then q - 1 else q
-fun floorMod(a: Int, b: Int) -> Int =
-  r := a % b
-  return if { { r < 0 && b > 0 } || { r > 0 && b < 0 } } then r + b else r
 # A span of time, stored as milliseconds. Negative values are meaningful
 # (e.g. the result of `Time.since` when `self` is earlier than `other`).
 record Duration(value: Int) =

plum-std/Uuid.plum CHANGED Viewed

@@ -78,36 +78,36 @@ record Uuid(value: Str) =
       + hexDigits(node, 12)
     return Uuid(value: s)
-# The numeric value (0-15) of an ASCII hex digit byte, or -1 if it isn't one.
+  # The numeric value (0-15) of an ASCII hex digit byte, or -1 if it isn't one.
-fun hexValue(byte: Int) -> Int =
+  fun hexValue(byte: Int) -> Int =
-  # '0'-'9'
+    # '0'-'9'
-  if byte >= 48 && byte <= 57
+    if byte >= 48 && byte <= 57
-    return byte - 48
+      return byte - 48
-  # 'a'-'f'
+    # 'a'-'f'
-  if byte >= 97 && byte <= 102
+    if byte >= 97 && byte <= 102
-    return byte - 97 + 10
+      return byte - 97 + 10
-  # 'A'-'F'
+    # 'A'-'F'
-  if byte >= 65 && byte <= 70
+    if byte >= 65 && byte <= 70
-    return byte - 65 + 10
+      return byte - 65 + 10
-  return -1
+    return -1
-fun hexDigit(n: Int) -> Str =
+  fun hexDigit(n: Int) -> Str =
-  d := n & 0xF
+    d := n & 0xF
-  if d < 10
+    if d < 10
-    return digitChar(d)
+      return Int.digitChar(d)
-  match d
+    match d
-    10 => "a"
+      10 => "a"
-    11 => "b"
+      11 => "b"
-    12 => "c"
+      12 => "c"
-    13 => "d"
+      13 => "d"
-    14 => "e"
+      14 => "e"
-    _ => "f"
+      _ => "f"
-# The low `count` hex digits of `n`, most-significant first.
+  # The low `count` hex digits of `n`, most-significant first.
-fun hexDigits(n: Int, count: Int) -> Str =
+  fun hexDigits(n: Int, count: Int) -> Str =
-  if count <= 0
+    if count <= 0
-    return ""
+      return ""
-  return hexDigits(n >> 4, count - 1) + hexDigit(n)
+    return hexDigits(n >> 4, count - 1) + hexDigit(n)
 test "nil is the all-zero UUID and is recognized as such"
   assert Uuid.nil().toStr() == "00000000-0000-0000-0000-000000000000"

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

@@ -2735,25 +2735,26 @@ fn compileIntrinsicFnBody(f: &ast::Fn, subst: &Subst) -> Option<Vec<u8>> {
             Instruction::End.encode(&mut body);
             Some(body)
         }
-        // makeBytes(n: Int) -> []Byte — a fresh, zero-filled byte slice of length `n`.
+        // ByteSlice.make(n: Int) -> []Byte — a fresh, zero-filled byte slice of length `n`.
+        // A static keeps a placeholder `self` in local 0, so its params start at 1.
-        (None, "makeBytes") => {
+        (Some("ByteSlice"), "make") => {
             let mut body = vec![0u8];
-            Instruction::LocalGet(0).encode(&mut body); // n
+            Instruction::LocalGet(1).encode(&mut body); // n
             Instruction::I32WrapI64.encode(&mut body);
             Instruction::ArrayNewDefault(byte_array_type_idx).encode(&mut body);
             Instruction::End.encode(&mut body);
             Some(body)
         }
-        // copyBytes(dst: []Byte, dstStart: Int, src: []Byte, srcStart: Int, n: Int) -> Unit
+        // ByteSlice.copy(dst: []Byte, dstStart: Int, src: []Byte, srcStart: Int, n: Int) -> Unit
-        (None, "copyBytes") => {
+        (Some("ByteSlice"), "copy") => {
             let mut body = vec![0u8];
-            Instruction::LocalGet(0).encode(&mut body); // dst
+            Instruction::LocalGet(1).encode(&mut body); // dst
-            Instruction::LocalGet(1).encode(&mut body); // dstStart
+            Instruction::LocalGet(2).encode(&mut body); // dstStart
             Instruction::I32WrapI64.encode(&mut body);
-            Instruction::LocalGet(2).encode(&mut body); // src
+            Instruction::LocalGet(3).encode(&mut body); // src
-            Instruction::LocalGet(3).encode(&mut body); // srcStart
+            Instruction::LocalGet(4).encode(&mut body); // srcStart
             Instruction::I32WrapI64.encode(&mut body);
-            Instruction::LocalGet(4).encode(&mut body); // n
+            Instruction::LocalGet(5).encode(&mut body); // n
             Instruction::I32WrapI64.encode(&mut body);
             Instruction::ArrayCopy {
                 array_type_index_dst: byte_array_type_idx,
@@ -2763,38 +2764,38 @@ fn compileIntrinsicFnBody(f: &ast::Fn, subst: &Subst) -> Option<Vec<u8>> {
             Instruction::End.encode(&mut body);
             Some(body)
         }
-        // bytesEqual(a: []Byte, aStart: Int, b: []Byte, bStart: Int, n: Int) -> Bool
+        // ByteSlice.equal(a: []Byte, aStart: Int, b: []Byte, bStart: Int, n: Int) -> Bool
         // — the memcmp analog: a tight loop with early exit on mismatch.
-        // Locals: 5 = i (i32), 6 = n (i32), 7 = aStart (i32), 8 = bStart (i32).
+        // Local 0 is the unused static `self` slot; 6 = i, 7 = n, 8 = aStart, 9 = bStart (i32).
-        (None, "bytesEqual") => {
+        (Some("ByteSlice"), "equal") => {
             let mut body = vec![1u8, 4u8, 0x7f];
             let wrap = |b: &mut Vec<u8>, l: u32| {
                 Instruction::LocalGet(l).encode(b);
                 Instruction::I32WrapI64.encode(b);
             };
-            wrap(&mut body, 4);
+            wrap(&mut body, 5);
-            Instruction::LocalSet(6).encode(&mut body);
-            wrap(&mut body, 1);
             Instruction::LocalSet(7).encode(&mut body);
-            wrap(&mut body, 3);
+            wrap(&mut body, 2);
             Instruction::LocalSet(8).encode(&mut body);
+            wrap(&mut body, 4);
+            Instruction::LocalSet(9).encode(&mut body);
             Instruction::Block(BlockType::Result(ValType::I32)).encode(&mut body);
             Instruction::Loop(BlockType::Empty).encode(&mut body);
-            Instruction::LocalGet(5).encode(&mut body);
             Instruction::LocalGet(6).encode(&mut body);
+            Instruction::LocalGet(7).encode(&mut body);
             Instruction::I32GeS.encode(&mut body);
             Instruction::If(BlockType::Empty).encode(&mut body);
             Instruction::I32Const(1).encode(&mut body);
             Instruction::Br(2).encode(&mut body);
             Instruction::End.encode(&mut body);
-            Instruction::LocalGet(0).encode(&mut body);
+            Instruction::LocalGet(1).encode(&mut body);
-            Instruction::LocalGet(7).encode(&mut body);
+            Instruction::LocalGet(8).encode(&mut body);
-            Instruction::LocalGet(5).encode(&mut body);
+            Instruction::LocalGet(6).encode(&mut body);
             Instruction::I32Add.encode(&mut body);
             Instruction::ArrayGetU(byte_array_type_idx).encode(&mut body);
-            Instruction::LocalGet(2).encode(&mut body);
+            Instruction::LocalGet(3).encode(&mut body);
-            Instruction::LocalGet(8).encode(&mut body);
+            Instruction::LocalGet(9).encode(&mut body);
-            Instruction::LocalGet(5).encode(&mut body);
+            Instruction::LocalGet(6).encode(&mut body);
             Instruction::I32Add.encode(&mut body);
             Instruction::ArrayGetU(byte_array_type_idx).encode(&mut body);
             Instruction::I32Ne.encode(&mut body);
@@ -2802,10 +2803,10 @@ fn compileIntrinsicFnBody(f: &ast::Fn, subst: &Subst) -> Option<Vec<u8>> {
             Instruction::I32Const(0).encode(&mut body);
             Instruction::Br(2).encode(&mut body);
             Instruction::End.encode(&mut body);
-            Instruction::LocalGet(5).encode(&mut body);
+            Instruction::LocalGet(6).encode(&mut body);
             Instruction::I32Const(1).encode(&mut body);
             Instruction::I32Add.encode(&mut body);
-            Instruction::LocalSet(5).encode(&mut body);
+            Instruction::LocalSet(6).encode(&mut body);
             Instruction::Br(0).encode(&mut body);
             Instruction::End.encode(&mut body); // loop
             Instruction::Unreachable.encode(&mut body);