nomen-lang 0.9.0 → 0.11.0

package/core/System/Graph.nm

@@ -14,7 +14,7 @@ pub mv struct Graph<T>: Enumerable {
 	var node_count = 0
 	var edge_count = 0
 
-	pub func add_node = (ref self, mv T value) {
+	pub func add_node = (ref self { head_edge, values }, mv T value) {
 		var int idx = self.node_count
 		self.values.grow(idx + 1)
 		self.values.store(idx, value)
@@ -23,7 +23,7 @@ pub mv struct Graph<T>: Enumerable {
 		self.node_count = self.node_count + 1
 	}
 
-	pub func add_edge = (ref self, int from, int to) {
+	pub func add_edge = (ref self { edge_next, edge_target, head_edge }, int from, int to) {
 		var int e = self.edge_count
 		self.edge_target.grow_int(e + 1)
 		self.edge_target.store_int(e, to)

package/core/System/LinkedList.nm

@@ -13,13 +13,15 @@ pub mv struct LinkedList<T>: Enumerable {
 	var int head = -1
 	var count = 0
 
-	pub func add = (ref self, mv T value) {
+	pub func add = (ref self { nexts, prevs, values }, mv T value) {
 		var int idx = self.count
 		self.values.grow(idx + 1)
 		// The value arrives owned (`mv T value`): move a value-struct element
-		// into the fresh slot (the caller's storage zeroes, no deep copy);
-		// strings keep the deep-copying store (their pair arrives by value).
-		if T_IS_VALUE_STRUCT {
+		// that OWNS resources into the fresh slot (the caller's storage
+		// zeroes, no deep copy). A non-owning value struct is a legal bare
+		// argument, so it keeps the copying store; strings keep the
+		// deep-copying store too (their pair arrives by value).
+		if T_TAKES_OWNERSHIP {
 			self.values.store_take(idx, value)
 		} else {
 			self.values.store(idx, value)
@@ -34,14 +36,14 @@ pub mv struct LinkedList<T>: Enumerable {
 		}
 	}
 
-	pub func set_next = (ref self, int idx, int next) {
+	pub func set_next = (ref self { nexts, prevs }, int idx, int next) {
 		self.nexts.store_int(idx, next)
 		if next >= 0 && next < self.prevs.cap {
 			self.prevs.store_int(next, idx)
 		}
 	}
 
-	pub func set_previous = (ref self, int idx, int prev) {
+	pub func set_previous = (ref self { nexts, prevs }, int idx, int prev) {
 		self.prevs.store_int(idx, prev)
 		if prev >= 0 && prev < self.nexts.cap {
 			self.nexts.store_int(prev, idx)

package/core/System/List.nm

@@ -5,13 +5,16 @@ pub mv struct List<T>: Viewable {
 	var length = 0
 	var items = Buffer<T>()
 
-	pub func push = (ref self, mv T value) {
+	pub func push = (ref self { items }, mv T value) {
 		if self.length < self.items.cap {
 			// The value arrives owned (`mv T value`): a value-struct element
-			// moves into the fresh slot (store_take — the caller's storage
-			// zeroes, no deep copy); strings and scalars keep the
-			// deep-copying store.
-			if T_IS_VALUE_STRUCT {
+			// that OWNS resources moves into the fresh slot (store_take — the
+			// caller's storage zeroes, no deep copy). A non-owning value
+			// struct (a handle pair) is a legal bare argument (the checker
+			// does not demand `mv`), so taking it would silently zero the
+			// caller's copy — it keeps the copying store, like strings and
+			// scalars.
+			if T_TAKES_OWNERSHIP {
 				self.items.store_take(self.length, value)
 			} else {
 				self.items.store(self.length, value)
@@ -20,7 +23,7 @@ pub mv struct List<T>: Viewable {
 			return
 		}
 		self.reserve(1)
-		if T_IS_VALUE_STRUCT {
+		if T_TAKES_OWNERSHIP {
 			self.items.store_take(self.length, value)
 		} else {
 			self.items.store(self.length, value)
@@ -38,7 +41,7 @@ pub mv struct List<T>: Viewable {
 	// #4). Sound for extra=1 by the same proof as push's old inline growth:
 	// length + 1 > cap grows to exactly the capacity push would have grown
 	// to.
-	internal func reserve = (ref self, int extra: extra >= 0, out int) {
+	internal func reserve = (ref self { items }, int extra: extra >= 0, out int) {
 		if self.length + extra <= self.items.cap {
 			return self.items.cap
 		}
@@ -52,7 +55,7 @@ pub mv struct List<T>: Viewable {
 		return self.items.cap
 	}
 
-	pub func pop = (ref self, mv out T) {
+	pub func pop = (ref self { items }, mv out T) {
 		if self.length <= 0 {
 			return self.items.move(0)
 		}
@@ -91,7 +94,7 @@ pub mv struct List<T>: Viewable {
 		return self.items.slice(start, end)
 	}
 
-	pub func set = (ref self, int i: i >= 0 && i < self.length, mv T value) {
+	pub func set = (ref self { items }, int i: i >= 0 && i < self.length, mv T value) {
 		self.items.replace(i, value)
 	}
 
@@ -99,7 +102,7 @@ pub mv struct List<T>: Viewable {
 	// for indices that can't be proven at compile time (cross-module calls
 	// can never discharge `set`'s parameter constraint) and out-of-range is
 	// a bug, not a case.
-	pub func set_or_panic = (ref self, int i, mv T value) {
+	pub func set_or_panic = (ref self { items }, int i, mv T value) {
 		if i >= 0 && i < self.length {
 			self.set(i, value)
 			return
@@ -111,7 +114,7 @@ pub mv struct List<T>: Viewable {
 	// lowering's destination primitive, the in-place push contract). reserve must have
 	// run, so the slot exists. Offsets mirror the mono layout: length @8,
 	// items.data @24 (the Buffer mono is {_vt, data, cap} = 24 bytes).
-	internal func append_slot_ptr = (ref self, out ptr T) {
+	internal func append_slot_ptr = (ref self { items }, out ptr T) {
 		```
 		#arch: c
 		// Byte math + void* — the body must compile for EVERY element kind
@@ -139,7 +142,7 @@ pub mv struct List<T>: Viewable {
 	// rules. The length constraint is the caller's proof obligation — the
 	// handler desugar's synthesized loops satisfy it from the loop
 	// condition, exactly like `.at`.
-	internal func slot_ptr = (ref self, int i: i >= 0 && i < self.length, out ptr T) {
+	internal func slot_ptr = (ref self { items }, int i: i >= 0 && i < self.length, out ptr T) {
 		return self.items.slot_ptr(i)
 	}
 
@@ -150,7 +153,7 @@ pub mv struct List<T>: Viewable {
 	// resources are reclaimed when the binding's scope ends — binding the
 	// result in a nested block is the way to free an owning element at a
 	// chosen point (its #destroy runs at the block's closing brace).
-	pub func remove_at_or_panic = (ref self, int i, mv out T) {
+	pub func remove_at_or_panic = (ref self { items }, int i, mv out T) {
 		if i < 0 || i >= self.length {
 			panic("index out of range")
 		}

package/core/System/Map.nm

@@ -39,7 +39,7 @@ pub mv struct Map<TK: Hashable + Equatable, TV> {
 		}
 	}
 
-	pub func set = (ref self, mv TK key, mv TV value) {
+	pub func set = (ref self { hashes, keys, used, values }, mv TK key, mv TV value) {
 		var int cap = self.keys.cap
 		if cap == 0 {
 			// alloc_T: for Buffer<TK> it is T_SIZE-aware (string keys are
@@ -59,15 +59,17 @@ pub mv struct Map<TK: Hashable + Equatable, TV> {
 		if self.used.load_u32(idx) == 0 {
 			self.used.store_u32(idx, 1)
 			// Both arrive owned (`mv TK key, mv TV value`): a value-struct
-			// key/value moves into its fresh slot (the caller's storage
-			// zeroes, no deep copy); strings keep the deep-copying store
-			// (their pair arrives by value).
-			if TK_IS_VALUE_STRUCT {
+			// key/value that OWNS resources moves into its fresh slot
+			// (store_take — the caller's storage zeroes, no deep copy). A
+			// non-owning value struct is a legal bare argument and keeps the
+			// copying store; strings keep the deep-copying store too (their
+			// pair arrives by value).
+			if TK_TAKES_OWNERSHIP {
 				self.keys.store_take(idx, key)
 			} else {
 				self.keys.store(idx, key)
 			}
-			if TV_IS_VALUE_STRUCT {
+			if TV_TAKES_OWNERSHIP {
 				self.values.store_take(idx, value)
 			} else {
 				self.values.store(idx, value)
@@ -92,7 +94,7 @@ pub mv struct Map<TK: Hashable + Equatable, TV> {
 	// primitive: the raw pointer must not cross the library boundary, and
 	// the caller must overwrite the slot before it is read or destroyed
 	// again (both paths leave it owning nothing).
-	internal func set_slot_ptr = (ref self, TK key, out ptr TV) {
+	internal func set_slot_ptr = (ref self { hashes, keys, used, values }, TK key, out ptr TV) {
 		var int cap = self.keys.cap
 		if cap == 0 {
 			// alloc_T: for Buffer<TK> it is T_SIZE-aware (string keys are
@@ -195,7 +197,7 @@ pub mv struct Map<TK: Hashable + Equatable, TV> {
 		return self.used.load_u32(idx) != 0
 	}
 
-	pub func remove = (ref self, TK key) {
+	pub func remove = (ref self { hashes, keys, used, values }, TK key) {
 		var int cap = self.keys.cap
 		if cap == 0 {
 			return
@@ -330,7 +332,7 @@ pub mv struct Map<TK: Hashable + Equatable, TV> {
 	// the other half of the Swiss-table trick; the old form re-inserted via
 	// `self.set(mv k, mv v)`, re-hashing every key and re-comparing keys on
 	// every probed slot.
-	func rehash = (ref self, int new_cap) {
+	func rehash = (ref self { hashes, keys, used, values }, int new_cap) {
 		var Buffer<TK> old_keys = mv self.keys swap Buffer<TK>()
 		var Buffer<TV> old_values = mv self.values swap Buffer<TV>()
 		var Buffer<int> old_used = mv self.used swap Buffer<int>()

package/core/System/Random.nm

@@ -44,7 +44,7 @@ pub mv struct Random {
 	// operators, and hex literals all lower directly; the aarch64 64-bit
 	// arithmetic folds (PERF_PLAN item 15) keep the emission within a few
 	// instructions of a hand-written `#arch` body.
-	pub func next = (ref self, out uint64) {
+	pub func next = (ref self {}, out uint64) {
 		self.state = self.state + 0x9E3779B97F4A7C15
 		var uint64 z = self.state
 		z = (z ^ (z >> 30)) * 0xBF58476D1CE4E5B9
@@ -54,7 +54,7 @@ pub mv struct Random {
 
 	// The next value in [0, bound). A bound of 0 returns 0. Slight modulo
 	// bias for very large bounds — irrelevant at demo scale.
-	pub func below = (ref self, uint64 bound, out uint64) {
+	pub func below = (ref self {}, uint64 bound, out uint64) {
 		if bound == 0 {
 			return 0
 		}
@@ -63,7 +63,7 @@ pub mv struct Random {
 
 	// The next value in [lo, hi], both ends inclusive. A hi <= lo
 	// returns lo.
-	pub func range = (ref self, uint64 lo, uint64 hi, out uint64) {
+	pub func range = (ref self {}, uint64 lo, uint64 hi, out uint64) {
 		if hi <= lo {
 			return lo
 		}

package/core/System/Set.nm

@@ -20,7 +20,7 @@ pub mv struct Set<T: Hashable + Equatable> {
 	var used = Buffer<int>()
 	var hashes = Buffer<int>()
 
-	pub func add = (ref self, mv T value) {
+	pub func add = (ref self { hashes, slots, used }, mv T value) {
 		var int cap = self.slots.cap
 		if cap == 0 {
 			cap = self.slots.alloc(8)
@@ -37,10 +37,12 @@ pub mv struct Set<T: Hashable + Equatable> {
 			self.used.store_u32(idx, 1)
 			// The value arrives owned (`mv T value`): a value-struct element
 			// moves into the fresh slot (store_take — the caller's storage is
-			// zeroed, no deep copy); a string's by-value pair keeps the
-			// deep-copying store (the caller still owns its buffer), and a
-			// class/trait handle is a pointer store either way.
-			if T_IS_VALUE_STRUCT {
+			// zeroed, no deep copy) when it OWNS resources; a non-owning value
+			// struct is a legal bare argument and keeps the copying store, a
+			// string's by-value pair keeps the deep-copying store (the caller
+			// still owns its buffer), and a class/trait handle is a pointer
+			// store either way.
+			if T_TAKES_OWNERSHIP {
 				self.slots.store_take(idx, value)
 			} else {
 				self.slots.store(idx, value)
@@ -98,7 +100,7 @@ pub mv struct Set<T: Hashable + Equatable> {
 		return self.slots.load(idx)
 	}
 
-	pub func remove = (ref self, T value) {
+	pub func remove = (ref self { hashes, slots, used }, T value) {
 		var int cap = self.slots.cap
 		if cap == 0 {
 			return
@@ -222,7 +224,7 @@ pub mv struct Set<T: Hashable + Equatable> {
 	// compares (values arrive unique — they came from a valid set). The old
 	// form re-inserted via `self.add(mv v)`, re-hashing every value and
 	// re-comparing values on every probed slot.
-	func rehash = (ref self, int new_cap) {
+	func rehash = (ref self { hashes, slots, used }, int new_cap) {
 		var Buffer<T> old_slots = mv self.slots swap Buffer<T>()
 		var Buffer<int> old_used = mv self.used swap Buffer<int>()
 		var Buffer<int> old_hashes = mv self.hashes swap Buffer<int>()

package/core/System/StableList.nm

@@ -40,7 +40,7 @@ pub mv struct StableList<T> {
 	// slab is always null, so its field destroy reclaims nothing.
 	var stage = Buffer<T>()
 
-	pub func push = (ref self, mv T value) {
+	pub func push = (ref self { chunks, items, stage }, mv T value) {
 		if self.items.cap == 0 {
 			self.items.alloc(256)
 		}
@@ -75,7 +75,7 @@ pub mv struct StableList<T> {
 	// and constructs the callee's result directly into the append slot
 	// (the in-place push contract). Byte-identical policy for extra=1: the same
 	// alloc/dir-grow/first-touch sequence push's inline branches performed.
-	internal func reserve = (ref self, int extra: extra >= 0, out int) {
+	internal func reserve = (ref self { chunks, items, stage }, int extra: extra >= 0, out int) {
 		if self.items.cap == 0 {
 			self.items.alloc(256)
 		}
@@ -93,7 +93,7 @@ pub mv struct StableList<T> {
 	// Calloc the directory chunk's slab on first touch (zero words mark
 	// empty chunks) — push's tail store and the in-place append both rely on
 	// the slab existing before a slot address is taken from it.
-	internal func ensure_chunk = (ref self, int dir_index) {
+	internal func ensure_chunk = (ref self { chunks, items, stage }, int dir_index) {
 		```
 		#arch: c
 		if (((unsigned long long*)self->chunks.data)[dir_index] == 0) {
@@ -130,7 +130,7 @@ pub mv struct StableList<T> {
 	// call's result straight through this address (sole ownership transfers
 	// into the slot — the chunk slab is calloc'd on first touch by
 	// `reserve`'s `ensure_chunk` before the slot address is taken).
-	internal func append_slot_ptr = (ref self, out ptr T) {
+	internal func append_slot_ptr = (ref self { chunks, items, stage }, out ptr T) {
 		```
 		#arch: c
 		unsigned long long idx = (unsigned long long)self->length;
@@ -236,7 +236,7 @@ pub mv struct StableList<T> {
 	// invalidation for this type, so the alias stays live and writes through
 	// it land in the list. The length constraint is the caller's proof
 	// obligation, exactly like `.at`.
-	internal func slot_ptr = (ref self, int i: i >= 0 && i < self.length, out ptr T) {
+	internal func slot_ptr = (ref self { items }, int i: i >= 0 && i < self.length, out ptr T) {
 		if i < self.items.cap {
 			return self.items.slot_ptr(i)
 		}
@@ -303,13 +303,13 @@ pub mv struct StableList<T> {
 	// nothing.
 	// (The old `stage` relay field is gone — push's tail path stores into
 	// the chunk through a `Buffer.init_view` view.)
-	func #destroy = (ref self) {
+	func #destroy = (ref self { chunks, items, stage }) {
 		self.destroy_tails()
 	}
 
 	// Raw: destroy directory chunks 1.. — per chunk, `filled` slots + the
 	// slab, via `T_buffer_destroy` on a cap=filled view.
-	internal func destroy_tails = (ref self) {
+	internal func destroy_tails = (ref self { chunks, items, stage }) {
 		```
 		#arch: c
 		long n_dir = (self->length - 1L) / 256L;

package/core/System/Stream/File.nm

@@ -63,7 +63,7 @@ pub struct File {
 
 	// Open the file at `path` with a C mode string ("r", "w", "a", …).
 	// Stores the handle and records errno (0 on success) in `error`.
-	func raw_open = (ref self, string path, string mode) {
+	func raw_open = (ref self {}, string path, string mode) {
 		```
 		#arch: c
 		#scope: file
@@ -99,7 +99,7 @@ pub struct File {
 
 	// Open the file at `path` with a C mode string ("r", "w", "a", …).
 	// `.ok(true)` on success; `.error(FileError)` otherwise.
-	pub func open = (ref self, string path, string mode, out Result<bool, FileError>) {
+	pub func open = (ref self {}, string path, string mode, out Result<bool, FileError>) {
 		self.raw_open(path, mode)
 		if self.error == 0 {
 			return Result.ok(true)
@@ -110,7 +110,7 @@ pub struct File {
 	// Close the handle, recording errno in `error` (0 on success). Also
 	// performed automatically by #destroy; calling close explicitly releases
 	// the resource early.
-	func raw_close = (ref self) {
+	func raw_close = (ref self {}) {
 		```
 		#arch: c
 		if (self->handle) {
@@ -147,7 +147,7 @@ pub struct File {
 	// Close the handle. Also performed automatically by #destroy; calling
 	// close explicitly releases the resource early. Closing an unopened (or
 	// already closed) File is `.ok(true)`.
-	pub func close = (ref self, out Result<bool, FileError>) {
+	pub func close = (ref self {}, out Result<bool, FileError>) {
 		self.raw_close()
 		if self.error == 0 {
 			return Result.ok(true)
@@ -158,7 +158,7 @@ pub struct File {
 	// Read every byte from the current position to EOF and return it. Sets
 	// `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, mv out string) {
+	func raw_read_all = (ref self {}, mv out string) {
 		```
 		#arch: c
 		FILE *f = (FILE*)(unsigned long long)self->handle;
@@ -222,7 +222,7 @@ pub struct File {
 	// Read every byte from the current position to EOF. `.ok(text)` with the
 	// remaining bytes (and `eof` set), or `.error(FileError)` — including
 	// `not_open` when the handle was never opened.
-	pub func readAll = (ref self, out Result<string, FileError>) {
+	pub func readAll = (ref self {}, out Result<string, FileError>) {
 		const string body = self.raw_read_all()
 		if self.error == 0 {
 			return Result.ok(body)
@@ -231,7 +231,7 @@ pub struct File {
 	}
 
 	// Write a string at the current position.
-	func raw_write_all = (ref self, string data) {
+	func raw_write_all = (ref self {}, string data) {
 		```
 		#arch: c
 		FILE *f = (FILE*)(unsigned long long)self->handle;
@@ -261,7 +261,7 @@ pub struct File {
 	// Write a string at the current position. `.ok(true)`, or
 	// `.error(FileError)` — including `not_open` when the handle was never
 	// opened.
-	pub func writeAll = (ref self, string data, out Result<bool, FileError>) {
+	pub func writeAll = (ref self {}, string data, out Result<bool, FileError>) {
 		self.raw_write_all(data)
 		if self.error == 0 {
 			return Result.ok(true)
@@ -272,7 +272,7 @@ 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 — `mv out string` transfers it.
-	func raw_read_line = (ref self, mv out string) {
+	func raw_read_line = (ref self {}, mv out string) {
 		```
 		#arch: c
 		FILE *f = (FILE*)(unsigned long long)self->handle;
@@ -364,7 +364,7 @@ pub struct File {
 
 	// Read up to the next '\n' (the newline is not included). `.ok(text)`
 	// and `eof` set at end of file, or `.error(FileError)`.
-	pub func readLine = (ref self, out Result<string, FileError>) {
+	pub func readLine = (ref self {}, out Result<string, FileError>) {
 		const string line = self.raw_read_line()
 		if self.error == 0 {
 			return Result.ok(line)
@@ -373,7 +373,7 @@ pub struct File {
 	}
 
 	// Write a string followed by '\n'.
-	func raw_write_line = (ref self, string data) {
+	func raw_write_line = (ref self {}, string data) {
 		```
 		#arch: c
 		FILE *f = (FILE*)(unsigned long long)self->handle;
@@ -405,7 +405,7 @@ pub struct File {
 	}
 
 	// Write a string followed by '\n'. `.ok(true)`, or `.error(FileError)`.
-	pub func writeLine = (ref self, string data, out Result<bool, FileError>) {
+	pub func writeLine = (ref self {}, string data, out Result<bool, FileError>) {
 		self.raw_write_line(data)
 		if self.error == 0 {
 			return Result.ok(true)
@@ -416,7 +416,7 @@ 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 — `mv out string` transfers it.
-	func raw_read_chunk = (ref self, int size, mv out string) {
+	func raw_read_chunk = (ref self {}, int size, mv out string) {
 		```
 		#arch: c
 		FILE *f = (FILE*)(unsigned long long)self->handle;
@@ -468,7 +468,7 @@ pub struct File {
 
 	// Read up to `size` bytes from the current position. `.ok(text)`
 	// (`eof` set if fewer bytes remained), or `.error(FileError)`.
-	pub func readChunk = (ref self, int size, out Result<string, FileError>) {
+	pub func readChunk = (ref self {}, int size, out Result<string, FileError>) {
 		const string chunk = self.raw_read_chunk(size)
 		if self.error == 0 {
 			return Result.ok(chunk)
@@ -477,7 +477,7 @@ pub struct File {
 	}
 
 	// Write the first `size` bytes of `data` at the current position.
-	func raw_write_chunk = (ref self, string data, int size) {
+	func raw_write_chunk = (ref self {}, string data, int size) {
 		```
 		#arch: c
 		FILE *f = (FILE*)(unsigned long long)self->handle;
@@ -505,7 +505,7 @@ pub struct File {
 
 	// Write the first `size` bytes of `data` at the current position.
 	// `.ok(true)`, or `.error(FileError)`.
-	pub func writeChunk = (ref self, string data, int size, out Result<bool, FileError>) {
+	pub func writeChunk = (ref self {}, string data, int size, out Result<bool, FileError>) {
 		self.raw_write_chunk(data, size)
 		if self.error == 0 {
 			return Result.ok(true)

package/core/System/Stream/Http.nm

@@ -58,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, mv 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://") {
@@ -145,7 +145,7 @@ pub struct Http {
 	// Issue a GET request to `url`. `.ok(body)` with the response body and
 	// `self.status` set to the response's status code, or
 	// `.error(HttpError)` (`status` is 0).
-	pub func get = (ref self, string url, out Result<string, HttpError>) {
+	pub func get = (ref self {}, string url, out Result<string, HttpError>) {
 		const string response = self.raw_exchange("GET", url, "")
 		if self.error == 0 {
 			return Result.ok(response)
@@ -156,7 +156,7 @@ pub struct Http {
 	// Issue a POST request to `url` with `body` as the payload.
 	// `.ok(body)` with the response body and `self.status` set to the
 	// response's status code, or `.error(HttpError)` (`status` is 0).
-	pub func post = (ref self, string url, string body, out Result<string, HttpError>) {
+	pub func post = (ref self {}, string url, string body, out Result<string, HttpError>) {
 		const string response = self.raw_exchange("POST", url, body)
 		if self.error == 0 {
 			return Result.ok(response)

package/core/System/Stream/Tcp.nm

@@ -59,7 +59,7 @@ pub mv struct Tcp {
 		```
 	}
 
-	pub func close = (ref self) {
+	pub func close = (ref self {}) {
 		Tcp.close_fd(self.fd)
 		self.fd = -1
 	}
@@ -81,7 +81,7 @@ pub mv struct Tcp {
 	// 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, mv 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 {
@@ -114,18 +114,18 @@ pub mv struct Tcp {
 
 	// Send every byte of `data`. Parks the fiber while the send buffer is
 	// full. Returns false on error or cancellation.
-	pub func send = (ref self, string data, out bool) {
+	pub func send = (ref self {}, string data, out bool) {
 		return Tcp.send_all(self.fd, data)
 	}
 
 	// 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, mv 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, mv out string) {
+	pub func recv_all = (ref self {}, mv out string) {
 		return Tcp.recv_until_close(self.fd)
 	}