nomen-lang 0.9.0 → 0.10.0

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)
 	}
 

package/core/System/StringBuilder.nm

@@ -18,7 +18,7 @@ pub struct StringBuilder {
 	// this doesn't even require an unsafe context.
 	// `internal`: capacity plumbing for the builder's own appenders; not
 	// part of the user surface.
-	internal func ensure = (ref self, int needed) {
+	internal func ensure = (ref self {}, int needed) {
 		if self.cap >= needed {
 			return
 		}
@@ -32,7 +32,7 @@ pub struct StringBuilder {
 	}
 
 	// Append a single byte (char).
-	pub inline func append_char = (ref self, char c) {
+	pub inline func append_char = (ref self {}, char c) {
 		```
 		#arch: c
 		int idx = self->len;
@@ -89,7 +89,7 @@ pub struct StringBuilder {
 	// plus the intermediate string's malloc/free collapse to a few
 	// instructions against the buffer. The raw body is spliced per call site
 	// (labels renamed by the splicer), so the digit loop is truly inline.
-	pub inline func append_int = (ref self, int n) {
+	pub inline func append_int = (ref self {}, int n) {
 		```
 		#arch: c
 		long v = n;
@@ -196,7 +196,7 @@ pub struct StringBuilder {
 	// Append a float with the SAME text `float.to_string` produces ("%f"):
 	// one snprintf into a stack scratch, then a bulk copy into the buffer —
 	// no sizing pass and no intermediate string allocation.
-	pub inline func append_float = (ref self, float f) {
+	pub inline func append_float = (ref self {}, float f) {
 		```
 		#arch: c
 		char tmp[360];
@@ -276,22 +276,22 @@ pub struct StringBuilder {
 	}
 
 	// Append a borrowed view without materializing it.
-	pub func append = (ref self, view string s) {
+	pub func append = (ref self {}, view string s) {
 		self.append_string_view(s)
 	}
 
 	// Append an int without materializing a string (see `append_int`).
-	pub func append = (ref self, int n) {
+	pub func append = (ref self {}, int n) {
 		self.append_int(n)
 	}
 
 	// Append a float without materializing a string (see `append_float`).
-	pub func append = (ref self, float f) {
+	pub func append = (ref self {}, float f) {
 		self.append_float(f)
 	}
 
 	// Append a single byte. (Overload, so `sb.append(c)` works for chars.)
-	pub func append = (ref self, char c) {
+	pub func append = (ref self {}, char c) {
 		self.append_char(c)
 	}
 
@@ -300,7 +300,7 @@ pub struct StringBuilder {
 	// `internal`: a library-implementation append — user code appends with
 	// `append_char` / `append_string_view`; the library's own structs (Json,
 	// Regex) are on the trusted side of the boundary.
-	internal func append_string = (ref self, string s) {
+	internal func append_string = (ref self {}, string s) {
 		unsafe {
 			var int sl = s.length
 			self.ensure(self.len + sl + 1)
@@ -314,7 +314,7 @@ pub struct StringBuilder {
 	// call. Views lower to the same (ptr, len) fat pair, so the bytes are
 	// memcpy'd straight out of the borrowed buffer (used by
 	// `string.replace_first`/`replace_all`).
-	pub func append_string_view = (ref self, view string s) {
+	pub func append_string_view = (ref self {}, view string s) {
 		unsafe {
 			var int sl = s.length
 			self.ensure(self.len + sl + 1)
@@ -327,7 +327,7 @@ pub struct StringBuilder {
 	// way to start a StringBuilder from a slice without a `to_string()`
 	// copy: the view's bytes are copied once into fresh storage, so the
 	// result is owned and independent of the source.
-	pub func seed = (ref self, view string s) {
+	pub func seed = (ref self {}, view string s) {
 		unsafe {
 			var int sl = s.length
 			self.ensure(sl + 1)
@@ -346,7 +346,7 @@ pub struct StringBuilder {
 	// Whether the buffer's current bytes end with `suffix` (an empty suffix
 	// is always true). Reads the buffer tail in place — no copy of either
 	// side (`view string` avoids materializing the checked suffix).
-	pub func ends_with = (ref self, view string suffix, out bool) {
+	pub func ends_with = (ref self {}, view string suffix, out bool) {
 		unsafe {
 			var int sl = suffix.length
 			if sl > self.len {
@@ -365,7 +365,7 @@ pub struct StringBuilder {
 
 	// Truncate the buffer to `new_len` bytes (clamped to [0, len]). Capacity
 	// is kept, so a subsequent append reuses the storage without a realloc.
-	pub func truncate = (ref self, int new_len) {
+	pub func truncate = (ref self {}, int new_len) {
 		var int n = new_len
 		if n < 0 {
 			n = 0
@@ -378,7 +378,7 @@ pub struct StringBuilder {
 
 	// Drop the last byte (a no-op when the buffer is empty). The common
 	// chomp-the-trailing-separator shape.
-	pub func chomp = (ref self) {
+	pub func chomp = (ref self {}) {
 		if self.len > 0 {
 			self.len = self.len - 1
 		}
@@ -391,7 +391,7 @@ pub struct StringBuilder {
 	// to [0, len]; the returned string is always an independent allocation.
 	// (`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, mv out string) {
+	pub func take_since = (ref self {}, int mark, mv out string) {
 		```
 		#arch: c
 		int start = mark;
@@ -459,7 +459,7 @@ pub struct StringBuilder {
 	// Explicitly `pub`: struct members default to pub, but this is the
 	// builder's primary read-back — the contract should not depend on the
 	// default.
-	pub func to_string = (ref self, out string) {
+	pub func to_string = (ref self {}, out string) {
 		```
 		#arch: c
 		int idx = self->len;

package/core/System/Task.nm

@@ -23,8 +23,6 @@
  * Conforms to `Awaitable`: `.wait()` may park the current execution context.
  **/
 pub mv struct Task<T> : Awaitable {
-	pub var uint64 handle = 0
-	pub var done = false
 	pub var uint64 result_slot = 0
 	pub var uint64 cancel_flag = 0
 	pub var uint64 future = 0
@@ -46,8 +44,6 @@ pub mv struct Task<T> : Awaitable {
 	// 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
@@ -58,7 +54,7 @@ pub mv struct Task<T> : Awaitable {
 		```
 		#arch: aarch64
 		// if (self->future) __nomen_future_wait(self->future)
-		ldr x0, [x19, #40]
+		ldr x0, [x19, #24]
 		cbz x0, .Lwait_done
 		bl ___nomen_future_wait
 		.Lwait_done:
@@ -71,18 +67,22 @@ pub mv struct Task<T> : Awaitable {
 	// trampoline writes the function's return value there before exiting.
 	// The result is MOVED OUT: the slot is zeroed as the value leaves, and
 	// `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, mv out T) {
+	// returns the zero value. An empty handle (never launched, machinery
+	// already destroyed) owns no slot — it also returns the zero value
+	// rather than reading through a null pointer. For tasks with no return
+	// value (void functions), returns the zero value.
+	pub func result = (ref self {}, mv out T) {
 		```
 		#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;
+		}
+		// An empty or already-consumed handle owns no result cell — return
+		// the zero value instead of reading through a null slot.
+		if (!self->result_slot) {
+			T _z;
+			memset(&_z, 0, sizeof(T));
+			return _z;
 		}
 		T _r = *(T *)self->result_slot;
 		memset((void *)self->result_slot, 0, sizeof(T));
@@ -91,72 +91,64 @@ pub mv struct Task<T> : Awaitable {
 		```
 		#arch: aarch64
 		// Wait for completion (same as wait method)
-		ldr x0, [x19, #40]
-		cbz x0, .Lresult_handle
-		bl ___nomen_future_wait
-		b .Lresult_read
-		.Lresult_handle:
-		ldr x0, [x19, #8]
+		ldr x0, [x19, #24]
 		cbz x0, .Lresult_read
-		ldrb w1, [x19, #16]
-		cbnz w1, .Lresult_read
-		sub sp, sp, #16
-		mov x1, sp
-		bl _pthread_join
-		add sp, sp, #16
-		str xzr, [x19, #8]
-		mov w0, #1
-		strb w0, [x19, #16]
+		bl ___nomen_future_wait
 		.Lresult_read:
+		// An empty or already-consumed handle owns no result cell: return
+		// the zero T instead of reading through a null slot.
+		ldr x8, [x19, #8]
+		cbz x8, .Lresult_zero
 		// The result cell is always 16 bytes (see the spawn build phase):
 		// load the full pair — a fat string returns (ptr, len) in x0/x1, a
 		// scalar returns its word in x0 — then zero the cell (the value is
 		// moved out; a second call observes the zero).
-		ldr x8, [x19, #24]
 		ldr x0, [x8]
 		ldr x1, [x8, #8]
 		stp xzr, xzr, [x8]
+		b .Lresult_end
+		.Lresult_zero:
+		mov x0, #0
+		mov x1, #0
+		.Lresult_end:
 		```
 	}
 
 	// Block until the task finishes, then return its result as a uint64.
 	// Convenience for the common case; same as result() for uint64 tasks.
-	pub func result_uint64 = (ref self, out uint64) {
+	// Like result(), it zeroes the cell as the value leaves (one end state
+	// for a consumed handle), and an empty handle returns zero.
+	pub func result_uint64 = (ref self {}, out uint64) {
 		```
 		#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;
 		}
-		return *(unsigned long long *)self->result_slot;
+		if (!self->result_slot) {
+			return 0;
+		}
+		unsigned long long _r = *(unsigned long long *)self->result_slot;
+		*(unsigned long long *)self->result_slot = 0;
+		return _r;
 		```
 		```
 		#arch: aarch64
 		// Wait for completion
-		ldr x0, [x19, #40]
-		cbz x0, .Lru64_handle
-		bl ___nomen_future_wait
-		b .Lru64_read
-		.Lru64_handle:
-		ldr x0, [x19, #8]
+		ldr x0, [x19, #24]
 		cbz x0, .Lru64_read
-		ldrb w1, [x19, #16]
-		cbnz w1, .Lru64_read
-		sub sp, sp, #16
-		mov x1, sp
-		bl _pthread_join
-		add sp, sp, #16
-		str xzr, [x19, #8]
-		mov w0, #1
-		strb w0, [x19, #16]
+		bl ___nomen_future_wait
 		.Lru64_read:
-		// return *(unsigned long long *)self->result_slot
-		ldr x0, [x19, #24]
-		ldr x0, [x0]
+		// An empty or already-consumed handle owns no result cell: return
+		// zero instead of reading through a null slot. Otherwise zero the
+		// cell as the value leaves (matching result()'s end state).
+		ldr x8, [x19, #8]
+		cbz x8, .Lru64_zero
+		ldr x0, [x8]
+		str xzr, [x8]
+		b .Lru64_end
+		.Lru64_zero:
+		mov x0, #0
+		.Lru64_end:
 		```
 	}
 
@@ -165,7 +157,7 @@ pub mv struct Task<T> : Awaitable {
 	// handle whose machinery was already consumed). The missing peek
 	// between wait (blocking) and cancel (cooperative): event loops use it
 	// to notice a finished task without parking the UI thread.
-	pub func is_done = (ref self, out bool) {
+	pub func is_done = (ref self {}, out bool) {
 		```
 		#arch: c
 		return __nomen_future_is_done((struct nomen_future *)self->future);
@@ -173,14 +165,14 @@ pub mv struct Task<T> : Awaitable {
 		```
 		#arch: aarch64
 		// x0 = self->future; result in x0.
-		ldr x0, [x19, #40]
+		ldr x0, [x19, #24]
 		bl ___nomen_future_is_done
 		```
 	}
 
 	// Request that the task stop. Cooperative — the task observes this via
 	// `Task.current_cancelled()` at its own checkpoints. No preemption.
-	pub func cancel = (ref self) {
+	pub func cancel = (ref self {}) {
 		```
 		#arch: c
 		// Sets the flag and wakes any fiber parked on this task's future, so
@@ -195,12 +187,12 @@ pub mv struct Task<T> : Awaitable {
 		#arch: aarch64
 		// if (self->future) __nomen_future_cancel(self->future);
 		// else if (self->cancel_flag) *(self->cancel_flag) = 1
-		ldr x0, [x19, #40]
+		ldr x0, [x19, #24]
 		cbz x0, .Lcancel_flag_path
 		bl ___nomen_future_cancel
 		b .Lcancel_done
 		.Lcancel_flag_path:
-		ldr x0, [x19, #32]
+		ldr x0, [x19, #16]
 		cbz x0, .Lcancel_done
 		mov x1, #1
 		str x1, [x0]
@@ -393,12 +385,12 @@ pub mv struct Task<T> : Awaitable {
 		```
 		#arch: aarch64
 		// if (self->future) { free an unconsumed string result; release; zero fields }
-		ldr x0, [x19, #40]
+		ldr x0, [x19, #24]
 		cbz x0, .Ldestroy_done
 		// An unconsumed string result: the cell still holds (ptr, len) —
 		// result() zeroes it when it moves the value out. The T_FAT dispatch
 		// folds to a constant branch after monomorphization.
-		ldr x8, [x19, #24]
+		ldr x8, [x19, #8]
 		mov x0, #T_FAT
 		cmp x0, #0
 		b.eq .Ldestroy_nofree
@@ -411,11 +403,11 @@ pub mv struct Task<T> : Awaitable {
 		stp xzr, xzr, [x8]
 		bl _free
 		.Ldestroy_nofree:
-		ldr x0, [x19, #40]
+		ldr x0, [x19, #24]
 		bl ___nomen_future_release
-		str xzr, [x19, #40]
 		str xzr, [x19, #24]
-		str xzr, [x19, #32]
+		str xzr, [x19, #8]
+		str xzr, [x19, #16]
 		.Ldestroy_done:
 		```
 	}