nomen-lang 0.6.13 → 0.7.0

package/core/System/Math.nm

@@ -28,5 +28,5 @@ pub struct Math {
 	}
 
 	// libm natural logarithm — extern.
-	extern func log = (float x, out float)
+	foreign func log = (float x, out float)
 }

package/core/System/Mutex.nm

@@ -10,16 +10,28 @@
 // observes the cancel flag at its next checkpoint after acquiring — so a
 // matching unlock is always sound.
 
+// Mutex is an OWNING STRUCT (STRUCT_PLAN_3 Phase R, tranche 3 — the shape
+// menu): the single field is an opaque handle, so the value is movable and
+// its `#destroy` closes what the handle names. Moving a Mutex transfers the
+// handle; there is no aliasing copy to misuse. Sharing one across tasks
+// rides the checked region borrows (`async { }`) — the lock/unlock methods
+// take the receiver bare (struct receivers travel by address), so a locked
+// section mutates the kernel object the handle names, never the binding.
+
 /**
  * A pthread-backed mutual-exclusion lock for protecting shared mutable state
  **/
-pub class Mutex: Sendable {
+pub mv struct Mutex {
 	pub var uint64 handle = 0
 
 	pub func #init = (self) {
+	// The constructor's `self` is the INLINE instance (a local value in the
+	// C lowering — methods take the pointer form, the ctor does not), so the
+	// C body uses the `.` accessor; the aarch64 body writes through x19 =
+	// &instance as always.
 	```
 	#arch: c
-	self->handle = (unsigned long long)__nomen_mutex_create();
+	self.handle = (unsigned long long)__nomen_mutex_create();
 	```
 	```
 	#arch: aarch64

package/core/System/Random.nm

@@ -15,10 +15,16 @@
 //
 import Time
 
+// Random is an OWNING STRUCT (STRUCT_PLAN_3 Phase R, tranche 3 — the shape
+// menu): bindings mv instead of alias. The state is a bare uint64, so the
+// value is freely movable (and trivially copyable in principle — `mv`
+// is the uniform spelling for the launch/IO primitives; a `ref Random`
+// parameter is the read-only borrow that keeps one stream per binding).
+
 /**
  * A fast splitmix64 pseudo-random number generator
  **/
-pub class Random {
+pub mv struct Random {
 	// The raw 64-bit generator state (seeded from the wall clock by the
 	// no-arg constructor, or an explicit seed for reproducible sequences).
 	pub var uint64 state = 0

package/core/System/Result.nm

@@ -1,4 +1,4 @@
-pub must_use enum Result<T, E> {
+pub checked enum Result<T, E> {
 	case ok(T value)
 	case error(E error)
 }

package/core/System/Sendable.nm

@@ -1,9 +1,9 @@
-// Marker trait for types whose values are safe to move across task boundaries.
+// Marker trait for types whose values are safe to mv across task boundaries.
 // See ASYNC.md for the design. Auto-derivable in a follow-up; for now, structs
 // opt in explicitly with `: Sendable`.
 
 /**
- * A marker trait for values that are safe to move across task boundaries
+ * A marker trait for values that are safe to mv across task boundaries
  **/
 pub trait Sendable {
 }

package/core/System/Set.nm

@@ -7,12 +7,12 @@
  * slot indexing is a mask (`hash & (cap - 1)`) — correct for negative hashes
  * too (two's-complement `&` already lands in `[0, cap)`).
  **/
-pub struct Set<T: Hashable + Equatable> {
+pub mv struct Set<T: Hashable + Equatable> {
 	var length = 0
 	var slots = Buffer<T>()
 	var used = Buffer<int>()
 
-	pub func add = (ref self, move T value) {
+	pub func add = (ref self, mv T value) {
 		var int cap = self.slots.cap
 		if cap == 0 {
 			cap = self.slots.alloc(8)
@@ -148,8 +148,8 @@ pub struct Set<T: Hashable + Equatable> {
 	}
 
 	func rehash = (ref self, int new_cap) {
-		var Buffer<T> old_slots = move self.slots swap Buffer<T>()
-		var Buffer<int> old_used = move self.used swap Buffer<int>()
+		var Buffer<T> old_slots = mv self.slots swap Buffer<T>()
+		var Buffer<int> old_used = mv self.used swap Buffer<int>()
 		var int old_cap = old_slots.cap
 
 		self.slots.alloc(new_cap)
@@ -163,12 +163,12 @@ pub struct Set<T: Hashable + Equatable> {
 				// is owned by exactly one buffer (the new self) afterwards.
 				// load_T would leave the old slot referencing the same class
 				// pointer — a double-free when old_slots is destroyed. The
-				// result is bound to a local so an owning-element copy (e.g. a
+				// result is bound to a local so a mv-element copy (e.g. a
 				// `Buffer<string>` slot, which store_T strdup's) is freed here
 				// once the new buffer has made its own copy — passing it inline
 				// would orphan the move_T result.
 				var T v = old_slots.move(i)
-				self.add(move v)
+				self.add(mv v)
 			}
 		}
 	}

package/core/System/Spawnable.nm

@@ -1,18 +1,18 @@
 // Spawnable — the trait role of a deferred-work LAUNCHER (the C# shape;
-// see docs/ASYNC.md, "Design decisions"). A Spawnable class packs a deferred unit of work
-// (the construction special form) and its `start` submits it, yielding the
-// library-owned `Task<T>` handle — so the await half is guaranteed by the
-// return type and each type carries exactly one role: `Thread<T>`/`Fiber<T>`
-// are spawnable, `Task<T>` is awaitable. `Awaitable` stays non-generic (its
-// `wait` does not mention T); `Spawnable` is generic because `start`'s
-// return type does.
+// see docs/ASYNC.md, "Design decisions"). A Spawnable type packs a deferred
+// unit of work (the construction special form) and its `start` submits it,
+// yielding the library-owned `Task<T>` handle — so the await half is
+// guaranteed by the return type and each type carries exactly one role:
+// `Thread<T>`/`Fiber<T>` are spawnable, `Task<T>` is awaitable.
+// `Awaitable` stays non-generic (its `wait` does not mention T);
+// `Spawnable` is generic because `start`'s return type does.
 //
 // `detach` is the daemon role: run the work unjoinable, statement only.
 
 /**
- * A class that can launch a deferred call and hand back its Task<T> handle
+ * A type that can launch a deferred call and hand back its Task<T> handle
  **/
 pub trait Spawnable<T> {
-	func start = (ref self, move out Task<T>)
+	func start = (ref self, mv out Task<T>)
 	func detach = (ref self)
 }

package/core/System/Stream/Directory.nm

@@ -28,10 +28,9 @@ pub struct Directory {
 			case err == 66 {
 				return DirectoryError.not_empty
 			}
-			else {
+		} else {
 				return DirectoryError.other
 			}
-		}
 	}
 
 	// (static) Create a directory at `path`; returns errno (0 on success).

package/core/System/Stream/File.nm

@@ -56,10 +56,9 @@ pub struct File {
 			case err == 17 {
 				return FileError.already_exists
 			}
-			else {
+		} else {
 				return FileError.other
 			}
-		}
 	}
 
 	// Open the file at `path` with a C mode string ("r", "w", "a", …).
@@ -157,9 +156,9 @@ pub struct File {
 	}
 
 	// Read every byte from the current position to EOF and return it. Sets
-	// `eof` and `error`. Declared `move out string`: the raw body mallocs a
+	// `eof` and `error`. Declared `mv out string`: the raw body mallocs a
 	// fresh buffer and hands ownership to the caller.
-	func raw_read_all = (ref self, move out string) {
+	func raw_read_all = (ref self, mv out string) {
 		```
 		#arch: c
 		FILE *f = (FILE*)(unsigned long long)self->handle;
@@ -272,8 +271,8 @@ pub struct File {
 
 	// Read up to the next '\n' (the newline is not included). Sets `eof`
 	// when the end of the file is reached and `error` on failure. The raw
-	// body mallocs a fresh buffer — `move out string` transfers it.
-	func raw_read_line = (ref self, move out string) {
+	// body mallocs a fresh buffer — `mv out string` transfers it.
+	func raw_read_line = (ref self, mv out string) {
 		```
 		#arch: c
 		FILE *f = (FILE*)(unsigned long long)self->handle;
@@ -416,8 +415,8 @@ pub struct File {
 
 	// Read up to `size` bytes from the current position. Sets `eof` if fewer
 	// than `size` bytes remain and `error` on failure. The raw body mallocs a
-	// fresh buffer — `move out string` transfers it.
-	func raw_read_chunk = (ref self, int size, move out string) {
+	// fresh buffer — `mv out string` transfers it.
+	func raw_read_chunk = (ref self, int size, mv out string) {
 		```
 		#arch: c
 		FILE *f = (FILE*)(unsigned long long)self->handle;
@@ -590,7 +589,7 @@ pub struct File {
 
 	// (static) Write `data` to `path` (replacing any existing contents) in
 	// one open/write/close. A write failure is reported as `.error`, not
-	// silently swallowed (the `must_use` Result discard check forces this to
+	// silently swallowed (the `checked` Result discard check forces this to
 	// be deliberate).
 	pub func write_all = (string path, string data, out Result<bool, FileError>) {
 		var Result<bool, FileError> result = .error(FileError.other)

package/core/System/Stream/Http.nm

@@ -48,10 +48,9 @@ pub struct Http {
 			case err == 3 {
 				return HttpError.connect
 			}
-			else {
+		} else {
 				return HttpError.other
 			}
-		}
 	}
 
 	// Shared socket round-trip used by get/post. `method` is the request
@@ -59,7 +58,7 @@ pub struct Http {
 	// (sends `body` and the Content-* headers). Sets self->status (0 on
 	// failure) and self->error, and returns the response body (empty string
 	// on failure).
-	func raw_exchange = (ref self, string method, string url, string body, move out string) {
+	func raw_exchange = (ref self, string method, string url, string body, mv out string) {
 		// Parse the URL: [http://]host[:port][/path]
 		var host_start = 0
 		if url.starts_with("http://") {

package/core/System/Stream/Tcp.nm

@@ -23,10 +23,15 @@
 // linked companion on aarch64) — OS socket/DNS interop, where hand-written
 // per-target assembly is not practical.
 
+// Tcp is an OWNING STRUCT (STRUCT_PLAN_3 Phase R, tranche 3 — the shape
+// menu): the fields are the fd and an error code — the fd is the handle, so
+// the value is movable and `#destroy` closes it. A moved Tcp transfers the
+// socket; there is no aliasing copy to double-close.
+
 /**
  * A non-blocking TCP socket whose waits park the calling fiber
  **/
-pub class Tcp: Sendable {
+pub mv struct Tcp {
 	// The underlying file descriptor, -1 when closed/failed.
 	pub var int fd = -1
 	// 0 = ok; 1 = DNS, 2 = socket, 3 = connect, 4 = listen, 5 = closed.
@@ -64,7 +69,7 @@ pub class Tcp: Sendable {
 	// ---- listening ----
 
 	// Create a listening socket bound to `port` on all interfaces.
-	pub func listen = (int port, int backlog, move out Tcp) {
+	pub func listen = (int port, int backlog, mv out Tcp) {
 		var int handle = Tcp.listen_fd(port, backlog)
 		var t = Tcp(handle)
 		if handle < 0 {
@@ -76,7 +81,7 @@ pub class Tcp: Sendable {
 	// Accept the next connection, parking the fiber while the backlog is
 	// empty. The returned socket is -1 if the listener was cancelled or
 	// failed.
-	pub func accept = (ref self, move out Tcp) {
+	pub func accept = (ref self, mv out Tcp) {
 		var int handle = Tcp.accept_fd(self.fd)
 		var t = Tcp(handle)
 		if handle < 0 {
@@ -88,7 +93,7 @@ pub class Tcp: Sendable {
 	// ---- connecting ----
 
 	// Connect to `host`:`port`. Check `fd >= 0` (or `error == 0`) for success.
-	pub func connect = (string host, int port, move out Tcp) {
+	pub func connect = (string host, int port, mv out Tcp) {
 		var int handle = Tcp.socket_fd()
 		if handle < 0 {
 			var bad = Tcp(-1)
@@ -115,12 +120,12 @@ pub class Tcp: Sendable {
 
 	// Receive up to `max` bytes. Parks the fiber until data arrives; returns
 	// the empty string at end-of-stream, on error, or when cancelled.
-	pub func recv = (ref self, int max, move out string) {
+	pub func recv = (ref self, int max, mv out string) {
 		return Tcp.recv_some(self.fd, max)
 	}
 
 	// Receive until the peer closes (how Connection: close HTTP works).
-	pub func recv_all = (ref self, move out string) {
+	pub func recv_all = (ref self, mv out string) {
 		return Tcp.recv_until_close(self.fd)
 	}
 
@@ -326,7 +331,7 @@ pub class Tcp: Sendable {
 		```
 	}
 
-	func recv_some = (int handle, int max, move out string) {
+	func recv_some = (int handle, int max, mv out string) {
 		```
 		#arch: c
 		long cap = max > 0 ? max : 1;
@@ -375,7 +380,7 @@ pub class Tcp: Sendable {
 		```
 	}
 
-	func recv_until_close = (int handle, move out string) {
+	func recv_until_close = (int handle, mv out string) {
 		```
 		#arch: c
 		long cap = 4096, len = 0;

package/core/System/String.nm

@@ -1,7 +1,7 @@
 // FFI: the C library's heap-copy entry point (string.h). The adapter
 // marshals the fat string to the thin char* the C ABI expects; the string
 // result is re-wrapped with its length.
-extern func strdup = (string s, move out string)
+foreign func strdup = (string s, mv out string)
 
 // Raw memory externs — the allocation primitives every `unsafe` Nomen body
 // across core (Buffer, StringBuilder, Array, ...) is built on. This file is
@@ -9,17 +9,20 @@ extern func strdup = (string s, move out string)
 // every core file regardless of pull order. Free externs emit under an
 // `extern_<name>` label that wraps the identically-named C symbol, so these
 // can never collide with it (docs/CORE_RAW.md roadmap items 1+2).
-extern func calloc = (int count, int size, out uint64)
-extern func malloc = (int bytes, out uint64)
-extern func realloc = (uint64 address, int bytes, out uint64)
-extern func free = (uint64 address)
-extern func memcpy = (uint64 dst, uint64 src, int bytes, out uint64)
-extern func memset = (uint64 dst, int value, int bytes, out uint64)
+foreign func calloc = (int count, int size, out uint64)
+foreign func malloc = (int bytes, out uint64)
+foreign func realloc = (uint64 address, int bytes, out uint64)
+foreign func free = (uint64 address)
+foreign func memcpy = (uint64 dst, uint64 src, int bytes, out uint64)
+foreign func memset = (uint64 dst, int value, int bytes, out uint64)
 
 /**
- * A UTF-8 text string — a heap-owned, length-tracked sequence of bytes
+ * A UTF-8 text string — a heap-owned, length-tracked sequence of bytes.
+ * STRUCT_PLAN_3 D3: `string` is OWNING — the fat (ptr, len) pair owns its
+ * bytes, so bindings mv unless a copy is spelled (`.copy()`); `view string`
+ * is the cheap read-only passing form.
  **/
-pub struct string: Stringable, Hashable, Equatable {
+pub mv struct string: Stringable, Hashable, Equatable {
 	pub func hash = (self, out uint) {
 		// djb2 over exactly self.length bytes — matches the byte count of
 		// owned strings and literals (views hash the viewed bytes only).
@@ -31,12 +34,19 @@ pub struct string: Stringable, Hashable, Equatable {
 		return h
 	}
 
-	// Returns an OWNED byte-exact copy of self (`move out string`). Fresh
+	// The uniform mv-type verb: a fresh, owned byte-exact copy of self.
+	// The deep-copy spelling the binding/assignment copy errors name — same
+	// allocation contract as to_string (fresh buffer, never an alias).
+	pub func copy = (self, mv out string) {
+		return self.to_string()
+	}
+
+	// Returns an OWNED byte-exact copy of self (`mv out string`). Fresh
 	// allocation, never an alias of self's storage — the result can outlive
 	// the receiver (e.g. escape a match branch that reclaims the scrutinee
 	// temp). Copies by tracked length, so embedded NULs survive (an extern
 	// strdup boundary would re-synthesize length via strlen and truncate).
-	pub func to_string = (self, move out string) {
+	pub func to_string = (self, mv out string) {
 		```
 		#arch: c
 		// Fat-string ABI: copy self.len bytes; no strlen anywhere.
@@ -90,7 +100,7 @@ pub struct string: Stringable, Hashable, Equatable {
 		panic("index out of range")
 	}
 
-	// A non-owning slice [start, end) into self's buffer. Returns a `view
+	// A non-mv slice [start, end) into self's buffer. Returns a `view
 	// string` (ptr, len) that borrows from self: it may not outlive self's
 	// scope and is invalidated if self is reassigned. Use .to_string() to
 	// materialize an owned copy.

package/core/System/StringBuilder.nm

@@ -178,9 +178,9 @@ pub struct StringBuilder {
 	// measure-and-restart shape: record `length()`, append a section, then
 	// `take_since(mark)` to measure it and re-emit decorated. `mark` clamps
 	// to [0, len]; the returned string is always an independent allocation.
-	// (`move out string` — the raw body mallocs the result, so the caller
+	// (`mv out string` — the raw body mallocs the result, so the caller
 	// owns it by signature, like `Console.read_line`.)
-	pub func take_since = (ref self, int mark, move out string) {
+	pub func take_since = (ref self, int mark, mv out string) {
 		```
 		#arch: c
 		int start = mark;

package/core/System/Task.nm

@@ -11,13 +11,18 @@
 // on the first spawn — not in Task's own methods — so that Task can be
 // generic without duplicating the pool per instantiation.
 //
+// Task is an OWNING STRUCT (STRUCT_PLAN_3 Phase R, tranche 2 — the shape
+// menu): every field is an opaque handle (uint64/bool), so the handle value
+// is movable and its `#destroy` releases the future reference it holds.
+// Moving a Task transfers that reference; there is no aliasing copy.
+//
 // See ASYNC.md for the design.
 
 /**
  * A handle to an asynchronously-running computation, backed by a shared thread pool.
  * Conforms to `Awaitable`: `.wait()` may park the current execution context.
  **/
-pub class Task<T> : Sendable, Awaitable {
+pub mv struct Task<T> : Awaitable {
 	pub var uint64 handle = 0
 	pub var done = false
 	pub var uint64 result_slot = 0
@@ -35,40 +40,27 @@ pub class Task<T> : Sendable, Awaitable {
 	// Block until the task finishes. Idempotent — calling twice is safe, and
 	// a Task captured from a nursery spawn can be waited on here AND joined
 	// by the nursery at block exit (both wait on the same shared future).
-	pub func wait = (ref self) {
+	//
+	// The receiver is a bare VALUE self (matching the Awaitable trait):
+	// waiting never mutates the handle — it parks on the future the handle
+	// names. Struct receivers travel by address regardless (the raw body
+	// reads `self->future`), so the ABI is unchanged; the bare spelling is
+	// what lets the read-only `Awaitable` dispatch form typecheck.
+	// The legacy `pthread_join` fallback is gone — `handle` has been
+	// permanently zero since the pool migration.
+	pub func wait = (self) {
 		```
 		#arch: c
 		if (self->future) {
 			__nomen_future_wait((struct nomen_future *)self->future);
-		} else if (self->handle && !self->done) {
-			void *ret;
-			pthread_join((pthread_t)self->handle, &ret);
-			self->handle = 0;
-			self->done = 1;
 		}
 		```
 		```
 		#arch: aarch64
-		// if (self->future) goto wait_future
+		// if (self->future) __nomen_future_wait(self->future)
 		ldr x0, [x19, #40]
-		cbz x0, .Lwait_handle
-		bl ___nomen_future_wait
-		b .Lwait_done
-		.Lwait_handle:
-		// else if (self->handle && !self->done)
-		ldr x0, [x19, #8]
 		cbz x0, .Lwait_done
-		ldrb w1, [x19, #16]
-		cbnz w1, .Lwait_done
-		// pthread_join((pthread_t)self->handle, &ret)
-		sub sp, sp, #16
-		mov x1, sp
-		bl _pthread_join
-		add sp, sp, #16
-		// self->handle = 0; self->done = 1
-		str xzr, [x19, #8]
-		mov w0, #1
-		strb w0, [x19, #16]
+		bl ___nomen_future_wait
 		.Lwait_done:
 		```
 	}
@@ -78,10 +70,10 @@ pub class Task<T> : Sendable, Awaitable {
 	// the full return value — including the 16-byte fat-string pair — and the
 	// trampoline writes the function's return value there before exiting.
 	// The result is MOVED OUT: the slot is zeroed as the value leaves, and
-	// `move out T` marks the caller as the owner. Call it once; a second call
+	// `mv out T` marks the caller as the owner. Call it once; a second call
 	// returns the zero value. For tasks with no return value (void
 	// functions), returns the zero value.
-	pub func result = (ref self, move out T) {
+	pub func result = (ref self, mv out T) {
 		```
 		#arch: c
 		if (self->future) {
@@ -284,7 +276,7 @@ pub class Task<T> : Sendable, Awaitable {
 	// ---- User-defined async primitive seam (ASYNC.md, "User-defined async
 	// primitives") ----
 	// The construction sugar stores the packed-task machinery in a user
-	// class's plain uint64 fields (task / result_slot / cancel_flag /
+	// spawnable's plain uint64 fields (task / result_slot / cancel_flag /
 	// future); these statics are the library boundary its own launch
 	// methods drive the runtime through — the same calls the generated
 	// Thread/Fiber launch code makes, so a user primitive parks fibers,
@@ -294,7 +286,7 @@ pub class Task<T> : Sendable, Awaitable {
 
 	// Submit a packed task closure (the `task` field's value) to the shared
 	// worker pool. The closure must come from a construction of an
-	// Awaitable-conforming class — it is not callable.
+	// Awaitable-conforming spawnable — it is not callable.
 	pub func pool_submit = (uint64 closure) {
 		```
 		#arch: c

package/core/System/Test.nm

@@ -32,6 +32,12 @@
 //
 // See TESTING.md for the full design.
 
+// Tester is an OWNING STRUCT (STRUCT_PLAN_3 Phase R, tranche 3 — the shape
+// menu): the harness builds exactly one per run, so the single-owner rule
+// costs nothing and the record state moves with the value. The string
+// fields (current/bench_label) are normalized heap-owned by the compiler's
+// struct string machinery, so `#destroy` reclaims them cleanly.
+
 /**
  * Records assertions and benchmarks for one test file.
  *
@@ -47,7 +53,7 @@
  * skipped, so a single root cause reports as a single failure. Check
  * `t.has_failed` to bail out of expensive follow-up work yourself.
  **/
-pub class Tester {
+pub mv struct Tester {
 	// Has the *current* test recorded a failure? Reset by `begin_test`.
 	pub var has_failed = false
 
@@ -94,7 +100,7 @@ pub class Tester {
 		self.has_failed = false
 		self.passed = 0
 		self.failed = 0
-		self.current = name
+		self.current = name.copy()
 		Console.write_line("\\nomen|start|" + name)
 		self.started = Time.now_ns()
 	}
@@ -211,7 +217,7 @@ pub class Tester {
 			return
 		}
 		self.bench_pending = true
-		self.bench_label = label
+		self.bench_label = label.copy()
 		self.bench_samples = 1000
 	}
 
@@ -225,7 +231,7 @@ pub class Tester {
 			return
 		}
 		self.bench_pending = true
-		self.bench_label = label
+		self.bench_label = label.copy()
 		self.bench_samples = samples
 	}
 

package/core/System/Text/CharIndex.nm

@@ -20,7 +20,7 @@ pub struct CharRun {
  * A run-length character-width index (construct with `CharIndex(text)`,
  * then `byte_offset_of` / `char_index_of` / `char_at` in O(log runs))
  **/
-pub struct CharIndex {
+pub mv struct CharIndex {
 	var view string source
 	var runs = List<CharRun>()
 	var char_count = 0
@@ -50,7 +50,7 @@ pub struct CharIndex {
 					pos = pos + w
 					chars = chars + 1
 				}
-				else {
+			} else {
 					if open_at >= 0 {
 						self.runs.push(CharRun(open_at, open_start, open_width, open_count))
 					}
@@ -61,7 +61,6 @@ pub struct CharIndex {
 					pos = pos + w
 					chars = chars + 1
 				}
-			}
 		}
 		if open_at >= 0 {
 			self.runs.push(CharRun(open_at, open_start, open_width, open_count))

package/core/System/Text/Json.nm

@@ -14,9 +14,9 @@
  **/
 pub struct Json {
 	// Serialize a string to a JSON string literal, escaping the special
-	// characters ", \, newline, tab and carriage return. `move out string`:
+	// characters ", \, newline, tab and carriage return. `mv out string`:
 	// returns the StringBuilder's owned heap copy.
-	pub func serialize = (string value, move out string) {
+	pub func serialize = (string value, mv out string) {
 		var sb = StringBuilder()
 		sb.append_char('"')
 		var i = 0
@@ -40,18 +40,17 @@ pub struct Json {
 				case code == 13 {
 					sb.append_string("\x5cr")
 				}
-				else {
+			} else {
 					sb.append_char(c)
 				}
-			}
 		}
 		sb.append_char('"')
 		return sb.to_string()
 	}
 
 	// Deserialize a JSON string literal to the raw, unescaped value.
-	// `move out string`: returns the StringBuilder's owned heap copy.
-	pub func deserialize = (string json, move out string) {
+	// `mv out string`: returns the StringBuilder's owned heap copy.
+	pub func deserialize = (string json, mv out string) {
 		var sb = StringBuilder()
 		var int len = json.length
 		var i = 0
@@ -90,10 +89,9 @@ pub struct Json {
 						case ec == 92 {
 							sb.append_string("\x5c")
 						}
-						else {
+					} else {
 							sb.append_char(e)
 						}
-					}
 				}
 			} else {
 				sb.append_char(c)
@@ -165,10 +163,9 @@ func json_parse_string = (string s, ref Buffer<int> pos, int len, ref JsonTree t
 					case ec == 92 {
 						sb.append_string("\x5c")
 					}
-					else {
+				} else {
 						sb.append_char(e)
 					}
-				}
 			}
 		} else {
 			sb.append_char(c)
@@ -218,11 +215,10 @@ func json_parse_literal = (string s, ref Buffer<int> pos, int len, ref JsonTree
 			tree.set_kind(n, 6)
 			adv = 5
 		}
-		else {
+	} else {
 			tree.set_kind(n, 0)
 			adv = 4
 		}
-	}
 	pos.store_int(0, i + adv)
 	return n
 }