748850d | plum | pyrossh

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

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

748850d — Peter John 2026-11-01T21:01:25+05:30

T9: Json + README

Files changed (2) hide show

README.md +121 -50
plum-std/Json.plum +35 -31

README.md CHANGED Viewed

@@ -18,9 +18,12 @@ import std/Seq
 error ParseError = BadNum | Negative       # a named error set
+struct Circle(r: Float)                    # small copy-semantics value type
+record Rect(w: Float, h: Float)            # reference type
-enum Shape =                               # a sum type; payload fields are named
+enum Shape =                               # a union: a Circle or a Rect
-  | Circle(r: Float)
+  | Circle
-  | Rect(w: Float, h: Float)
+  | Rect
   SIDES_MAX = 4                            # associated constant: Shape.SIDES_MAX
@@ -74,7 +77,7 @@ test "glance"
 | group an expression | `{1 + 2} * 3` (braces; parentheses are for calls) |
 | a conditional expression | `if c then a else b` (there is no `?:` ternary) |
 | loop | `while c`, `for x := range src`, `for i := range n` |
-| a sum type / record | `enum Shape = \| Circle(r: Float) \| Rect(w: Float, h: Float)` |
+| a union of types | `enum Shape = Circle \| Rectangle` |
 | a small value type | `struct Vec2(x: Float, y: Float)` |
 | a record (reference type) | `record User(name: Str, age: Int)` |
 | a method / static / constant | `fun area(self)` / `fun origin()` / `NAME = expr` inside the type body |
@@ -300,7 +303,7 @@ todo            # traps at runtime — marks a body as not yet implemented
 ### Pattern `if`
-`if Pattern := expr` tests one case and binds the pattern's names for that branch only. It uses the same patterns as `match` (constructor patterns with nested fields, literals, `_`, bare variant or error names), and reads like any other `if`/`else if`/`else` chain. A `, cond` after the value adds more conditions that already see the bindings. It works in `else if`, inline (`if Circle(r) := s then r else 0.0`) and in `while`:
+`if Pattern := expr` tests one case and binds the pattern's names for that branch only. It uses the same patterns as `match` (constructor patterns with nested fields, literals, `_`, bare member, tag or error names), and reads like any other `if`/`else if`/`else` chain. A `, cond` after the value adds more conditions that already see the bindings. It works in `else if`, inline (`if Circle(r) := s then r else 0.0`) and in `while`:
 ```plum
 fun draw(shape: Shape) =
@@ -312,6 +315,16 @@ fun draw(shape: Shape) =
     drawOther(shape)
 ```
+A bare member name narrows the value inside the branch, so the member's own fields and methods are available:
+```plum
+fun width(s: Shape) -> Float =
+  if Rectangle := s
+    s.w
+  else
+    0.0
+```
 ```plum
 while Busy(task) := worker.state      # loops while the pattern matches
   task.step()
@@ -366,7 +379,7 @@ A function without a return type returns `Unit`; the last expression of a body i
 ## Types: struct, record and enum
-`enum` is a sum type: a value that is one of several variants. `struct` and `record` are product types: one variant named like the type, with named fields. A `struct` is a value type and a `record` is a reference type.
+`enum` is a union: a value that is one of several member types. `struct` and `record` are product types with named fields. A `struct` is a value type and a `record` is a reference type.
 ```plum
 struct Vec2(x: Float, y: Float) =
@@ -378,23 +391,6 @@ struct Vec2(x: Float, y: Float) =
 record User(name: Str, age: Int)
 record Pair[K, V](key: K, val: V)
-enum Color =
-  | Red
-  | Green
-  | Blue
-enum Maybe =
-  | Just(Int) # unnamed positional payload — Just(5)
-  | Nothing
-enum Shape =
-  | Circle(radius: Int) # named payload fields — Circle(radius: 5) or Circle(5)
-  | Square(x: Int, y: Int)
-enum Step(n: Int) = # a shared field on every variant ...
-  | ReadMin(10) # ... each variant supplies its own value for it
-  | ReadMax(20)
 ```
 The header ends with `=` only when an indented body follows: `struct Vec2(x: Float, y: Float)` with no body has no `=`.
@@ -412,22 +408,98 @@ u2.age = 4         # u.age is now 4: a record is shared
 The other declaration forms are `struct` and `record` (below), `error Name = A | B` ([Error handling](#error-handling)) and `primitive Name =` ([Constants, statics and `primitive`](#constants-statics-and-primitive)).
-### Methods, `self` and field access
+### Enums
+An `enum` lists the types it can hold. A member is a declared `struct` or `record`, a built-in (`Int`, `Float`, `Bool`, `Byte`), a std type (`Str`, `List[Json]`, `Map[Str, Json]`), or a bare name that is not a declared type, which becomes a payload-less tag. A short list fits on one line; a longer one, or one with methods, goes on indented `|` lines:
+```plum
+struct Circle(r: Float)
+record Rectangle(w: Float, h: Float)
+enum Shape = Circle | Rectangle
+enum Color =
+  | Red
+  | Green
+  | Blue
+enum Json =
+  | JsonNull
+  | Bool
+  | Float
+  | Str
+  | List[Json]
+  | Map[Str, Json]
+```
-A `fun` declared indented directly inside an `enum` body is a method; its first parameter is `self`:
+`Red`, `Green`, `Blue` and `JsonNull` are tags: values with no payload. Every other member is an existing type, and the enum adds no new constructor for it.
+A member converts to its enum wherever the enum is expected: an argument, a `return`, a tail expression, `push`, a `T?` or a `!T` slot. Nothing is written at the call site:
 ```plum
-enum Cat =
-  | Cat(name: Str, age: Int)
+fun make(big: Bool) -> Shape =
+  if big
+    Rectangle(w: 10.0, h: 10.0)
+  else
+    Circle(r: 1.0)
+fun label(j: Json) -> Str =
+  "json"
+fun use() -> Str =
+  label(2.5)
+```
+A pattern names a member to take the value apart (`Circle(r)`) or, written as just the member's name, to narrow the subject to that type. In an arm that names `Float`, the subject is a `Float`; the narrowed subject must be a local, a parameter or `self`:
+```plum
+fun show(j: Json) -> Str =
+  match j
+    JsonNull => "null"
+    Bool => if j then "true" else "false"
+    Float => j.toStr()
+    Str => "\"{j}\""
+    List => "list"
+    Map => "map"
+```
+A method that every member defines is callable on the enum itself, and the call goes to the member's own method (auto-dispatch):
+```plum
+fun areaOf(s: Shape) -> Float =
+  s.area()
+```
+One type can be a member of several enums. A `Circle` is a `Shape` and also a `Round`, and converts to whichever the context asks for:
+```plum
+enum Round = Circle | Oval
+record Oval(a: Float)
+```
+A discriminant enum gives every tag a shared number:
+```plum
+enum Step(n: Int) =
+  | ReadMin(10)    # each tag supplies its own value for the shared field
+  | ReadMax(20)
+```
+### Methods, `self` and field access
+A `fun` declared indented directly inside an `enum`, `struct` or `record` body is a method; its first parameter is `self`:
+```plum
+record Cat(name: Str, age: Int) =
   fun getAge(self) -> Int =
     self.age
   fun birthday(self) -> Int =
     self.age + 1
-enum Wrapper =
-  | Wrapper(inner: Cat, tag: Int)
+record Wrapper(inner: Cat, tag: Int)
 fun main() -> Int =
   c := Cat(name: "Whiskers", age: 3)
@@ -436,11 +508,11 @@ fun main() -> Int =
   a + w.inner.age # chained field access
 ```
-A named field of any enum can be read with `.field`, even on a multi-variant enum (the field must have a unique owning variant; a checked downcast does the access).
+A field of a `struct` or `record` is read with `.field`. On a union it is read after narrowing (`if Rectangle := s`, then `s.w`).
 ### Constructing values
-Construct a record-shaped enum value by calling its name with `field: value` pairs (any order; every field required), or positionally:
+Construct a `struct` or `record` by calling its name with `field: value` pairs (any order; every field required), or positionally:
 ```plum
 cat := Cat(name: "Whiskers", age: 3)
@@ -463,9 +535,9 @@ match n
     else
       2
-match maybe
+match shape
-  Just(v) => v
+  Circle(r) => r
-  Nothing => 0
+  Rectangle(w, h) => w * h
 match book
   FantasyBook(title, _, hasMythicalCreatures) when hasMythicalCreatures =>
@@ -473,14 +545,18 @@ match book
   FantasyBook(title, _, _) => "Fantasy book \"{title}\" has no mythical creatures"
 ```
-Patterns can be literals, a bare identifier (binds), a bare capitalized name (an enum variant, or an error name when matching an error value, also written `error.Name`; compared), a constructor pattern (`Just(v)`, binding its argument, possibly nested), or `_` (wildcard). `match a, b, ...` supports multiple subjects, and a case can carry a `when <expr>` guard. A `match` over an enum must be exhaustive; to test just one case, use [pattern `if`](#pattern-if) (`if Circle(r) := shape`). See [`plum-examples/match.plum`](plum-examples/match.plum), [`plum-examples/dop_visitor.plum`](plum-examples/dop_visitor.plum) and [`plum-examples/oop_visitor.plum`](plum-examples/oop_visitor.plum).
+Patterns can be literals, a bare identifier (binds), a bare capitalized name (a member or tag of an enum, or an error name when matching an error value, also written `error.Name`; compared), a constructor pattern (`Circle(r)`, binding its fields, possibly nested), a bare member name (`Float`, which narrows the subject to that type), or `_` (wildcard). `match a, b, ...` supports multiple subjects, and a case can carry a `when <expr>` guard. A `match` over an enum must be exhaustive; to test just one case, use [pattern `if`](#pattern-if) (`if Circle(r) := shape`). See [`plum-examples/match.plum`](plum-examples/match.plum), [`plum-examples/dop_visitor.plum`](plum-examples/dop_visitor.plum) and [`plum-examples/oop_visitor.plum`](plum-examples/oop_visitor.plum).
 Mixed kinds of value live in one enum with a `match self` method per operation:
 ```plum
+struct Circle(r: Float)
+record Rect(w: Float, h: Float)
 enum Shape =
-  | Circle(r: Float)
+  | Circle
-  | Rect(w: Float, h: Float)
+  | Rect
   fun area(self) -> Float =
     match self
@@ -492,7 +568,7 @@ See [`plum-examples/shapes.plum`](plum-examples/shapes.plum) and [`plum-examples
 ### `struct` and `record`
-`struct` declares a small, copy-semantics value type (a vector, a color, a rectangle) that is flattened into wasm locals instead of being heap-allocated. `record` declares a reference type. Both have one variant named like the type:
+`struct` declares a small, copy-semantics value type (a vector, a color, a rectangle) that is flattened into wasm locals instead of being heap-allocated. `record` declares a reference type. Both are declared with named fields:
 ```plum
 struct Vec2(x: Float, y: Float) =
@@ -509,14 +585,13 @@ A `struct` has no generics; its fields are only `Int`, `Float`, `Bool` or other
 ## Generics
 ```plum
-enum Box[T] =
-  | Box(value: T)
+record Box[T](value: T)
 fun wrap(value: T) -> Bool =
   true
 ```
-A free function's generic parameters are its single-uppercase-letter type names (`T`, `U`); a type declares its own with `enum Box[T]`. Generic types, methods, and free functions are duck-typed and compiled once per distinct instantiation. See [How generics compile](#how-generics-compile).
+A free function's generic parameters are its single-uppercase-letter type names (`T`, `U`); a type declares its own with `record Box[T]`. Generic types, methods, and free functions are duck-typed and compiled once per distinct instantiation. See [How generics compile](#how-generics-compile).
 ### How generics compile
@@ -537,8 +612,7 @@ in outer[Plain] (called at main.plum:9:3):
 - **Explicit behavior values.** When a generic needs behavior that is not a method on `T`, pass it explicitly, like a Zig comptime parameter or a Haskell dictionary:
 ```plum
-enum Num[T] =
-  | Num(add: fn(T, T) -> T, zero: T)
+record Num[T](add: fn(T, T) -> T, zero: T)
 fun sumWith(xs: List[T], num: Num[T]) -> T =
   acc := num.zero
@@ -746,8 +820,7 @@ See [`plum-examples/seq.plum`](plum-examples/seq.plum) (one test per adapter and
 An optional is `T?`: a `T`, or `null`. It is its own type, not an error: it carries no error name, and `catch` and `try` do not apply to it. A plain `T` in a `T?` slot is the present value, and `null` is the absent value wherever a `T?` is expected (a call or constructor argument, a `return`, a tail, a list element, a parameter default such as `n: Int? = null`). `null` with nothing to say what it is an optional of is an error (`x := null`: `cannot infer the type of null`). For a reference type (a class, enum, `Str`, `List`, ...) a `T?` is stored as a nullable reference, so a present value costs no allocation; for `Int`, `Float`, `Bool` and structs it is the value plus a present flag. A doubled `T??` is not allowed.
 ```plum
-enum Person =
-  | Person(name: Str, age: Int)
+record Person(name: Str, age: Int)
 fun find(n: Int) -> Person? =
   if n > 0
@@ -786,11 +859,9 @@ fun total(xs: List[Int?]) -> Int =
 `obj?.field` / `obj?.method(args)` (safe navigation, Groovy/Kotlin-style) reaches into an optional (or an error union) without unwrapping it -- a present value maps the field or method access over the inner value and re-wraps it, null (or an error) passes through untouched. A field that is itself a `T?` flattens, so a chain is one `?` value, not a nested one:
 ```plum
-enum Target =
-  | Target(name: Str)
+record Target(name: Str)
-enum User =
-  | User(name: Str, target: Target?)
+record User(name: Str, target: Target?)
 fun targetName(u: User?) -> Str? =
   u?.target?.name
@@ -903,7 +974,7 @@ A stored value (`r := f()`) is handled later with `try r`, `r!` or `r catch ...`
 enum Failure =
   | Timeout
   | Refused
-  | BadRequest(Str)
+  | BadRequest
 ```
 An error union can have an optional as its success value: `!T?` (`error{Bad}!Int?`). `try x` gives the `T?`, and `?:` then handles the null: `v := try parse(s)` followed by `v ?: 0`. An error union can also be the success type of another (`List[!Int].get(i)` is a `!!Int`): unwrap it one level at a time with `!`, `try` or `catch`. See [`plum-examples/error_propagation.plum`](plum-examples/error_propagation.plum).

plum-std/Json.plum CHANGED Viewed

@@ -8,16 +8,16 @@ import std/Str
 import std/Buffer
 # A parsed JSON value. Numbers are always stored as `Float` (JSON doesn't
-# distinguish integers from floats the way Plum does), and `JsonList`/
+# distinguish integers from floats the way Plum does), and `List[Json]`/
-# `JsonMap` nest `Json` itself — the same self-referential shape `List[T]`
+# `Map[Str, Json]` nest `Json` itself — the same self-referential shape `List[T]`
 # already uses internally for `Node[T].next: Link[Node[T]]`.
 enum Json =
   | JsonNull
-  | JsonBool(Bool)
+  | Bool
-  | JsonFloat(Float)
+  | Float
-  | JsonStr(Str)
+  | Str
-  | JsonList(List[Json])
+  | List[Json]
-  | JsonMap(Map[Str, Json])
+  | Map[Str, Json]
   # Parses `s` as a single JSON document, requiring the whole string (aside
   # from surrounding whitespace) to be consumed. Called as `Json.fromStr(s)`,
@@ -41,11 +41,11 @@ enum Json =
   fun toStr(self) -> Str =
     match self
       JsonNull => "null"
-      JsonBool(b) => if b then "true" else "false"
+      Bool => if self then "true" else "false"
-      JsonFloat(f) => f.toStr()
+      Float => self.toStr()
-      JsonStr(s) => "\"" + escapeJsonStr(s) + "\""
+      Str => "\"" + escapeJsonStr(self) + "\""
-      JsonList(items) => "[" + items.join(",") + "]"
+      List => "[" + self.join(",") + "]"
-      JsonMap(pairs) => "{{" + jsonMapToStr(pairs) + "}}"
+      Map => "{{" + jsonMapToStr(self) + "}}"
   fun isNull(self) -> Bool =
     match self
@@ -54,33 +54,35 @@ enum Json =
   fun asBool(self) -> error{WrongJsonType}!Bool =
     match self
-      JsonBool(b) => b
+      Bool => self
       _ => error.WrongJsonType
   fun asFloat(self) -> error{WrongJsonType}!Float =
     match self
-      JsonFloat(f) => f
+      Float => self
       _ => error.WrongJsonType
   fun asStr(self) -> error{WrongJsonType}!Str =
     match self
-      JsonStr(s) => s
+      Str => self
       _ => error.WrongJsonType
   fun asList(self) -> error{WrongJsonType}!List[Json] =
     match self
-      JsonList(items) => items
+      List => self
       _ => error.WrongJsonType
   fun asMap(self) -> error{WrongJsonType}!Map[Str, Json] =
     match self
-      JsonMap(pairs) => pairs
+      Map => self
       _ => error.WrongJsonType
 # The outcome of `Json.parse`: the document, or where and why parsing failed.
-enum JsonParse =
-  | JsonParsed(value: Json)
+record JsonParsed(value: Json)
-  | JsonParseFailed(pos: Int, text: Str)
+record JsonParseFailed(pos: Int, text: Str)
+enum JsonParse = JsonParsed | JsonParseFailed
 # A recursive-descent parser over a `Str` source, tracking its read position
 # in `pos`. It reads directly from a `Str`, the same way every other stdlib
@@ -132,9 +134,9 @@ record JsonParser(src: Str, pos: Int, text: Str) =
     if c == 123
       return self.parseObject()
     if c == 116
-      return self.parseLiteral("true", JsonBool(true))
+      return self.parseLiteral("true", true)
     if c == 102
-      return self.parseLiteral("false", JsonBool(false))
+      return self.parseLiteral("false", false)
     if c == 110
       return self.parseLiteral("null", JsonNull)
     if c == 45 || isDigit(c)
@@ -186,14 +188,14 @@ record JsonParser(src: Str, pos: Int, text: Str) =
       f := Float.parse(text) catch e
         self.note("invalid number")
         return error.InvalidJson
-      return JsonFloat(f)
+      return f
     mv := Float.parse(text.sub(0, e_index)) catch e
       self.note("invalid number")
       return error.InvalidJson
     ev := Int.parse(text.sub(e_index + 1, text.length())) catch e
       self.note("invalid number")
       return error.InvalidJson
-    return JsonFloat(mv * 10.pow(Float(ev)))
+    return mv * 10.pow(Float(ev))
   fun parseString(self) -> error{InvalidJson}!Json =
     self.advance()
@@ -206,7 +208,7 @@ record JsonParser(src: Str, pos: Int, text: Str) =
       return error.InvalidJson
     if c == 34
       self.advance()
-      return JsonStr(buf.toStr())
+      return buf.toStr()
     if c == 92
       return self.parseEscape(buf)
     n := self.src.codePointByteLength(self.pos)
@@ -295,7 +297,7 @@ record JsonParser(src: Str, pos: Int, text: Str) =
     items := List[Json]()
     if self.peek() == 93
       self.advance()
-      return JsonList(items)
+      return items
     return self.parseArrayItems(items)
   fun parseArrayItems(self, items: List[Json]) -> error{InvalidJson}!Json =
@@ -309,7 +311,7 @@ record JsonParser(src: Str, pos: Int, text: Str) =
       return self.parseArrayItems(items)
     if c == 93
       self.advance()
-      return JsonList(items)
+      return items
     self.note("expected ',' or ']'")
     return error.InvalidJson
@@ -319,7 +321,7 @@ record JsonParser(src: Str, pos: Int, text: Str) =
     pairs := Map[Str, Json]()
     if self.peek() == 125
       self.advance()
-      return JsonMap(pairs)
+      return pairs
     return self.parseObjectItems(pairs)
   fun parseObjectItems(self, pairs: Map[Str, Json]) -> error{InvalidJson}!Json =
@@ -346,13 +348,13 @@ record JsonParser(src: Str, pos: Int, text: Str) =
       return self.parseObjectItems(pairs)
     if c == 125
       self.advance()
-      return JsonMap(pairs)
+      return pairs
     self.note("expected ',' or '}}'")
     return error.InvalidJson
 fun jsonStrValue(j: Json) -> Str =
   match j
-    JsonStr(s) => s
+    Str => j
     _ => ""
 # `Map` has no built-in `toStr`/`join` (unlike `List`, which uses `join` for
@@ -458,6 +460,8 @@ fun isDigit(c: Int) -> Bool =
 # ---- regression tests ----
+fun jsonOf(s: Str) -> Json = s
 fun parseFloatValue(s: Str) -> Float =
   v := Json.fromStr(s) catch e
     return -1.0f
@@ -523,5 +527,5 @@ test "round-trips a value through toStr and back"
   assert again.toStr() == v.toStr()
 test "toStr escapes special characters in strings"
-  v := JsonStr("a\"b\\c\nd")
+  v := jsonOf("a\"b\\c\nd")
   assert v.toStr() == "\"a\\\"b\\\\c\\nd\""