nomen-lang 0.5.0 → 0.6.1

package/core/System/Stream/Tcp.nm

@@ -26,11 +26,11 @@
 /**
  * A non-blocking TCP socket whose waits park the calling fiber
  **/
-pub class Tcp : Sendable {
+pub class Tcp: Sendable {
 	// 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.
-	pub var int error = 0
+	pub var error = 0
 
 	pub func #init = (self, int handle) {
 		self.fd = handle
@@ -66,7 +66,7 @@ pub class Tcp : Sendable {
 	// Create a listening socket bound to `port` on all interfaces.
 	pub func listen = (int port, int backlog, move out Tcp) {
 		var int handle = Tcp.listen_fd(port, backlog)
-		var Tcp t = Tcp(handle)
+		var t = Tcp(handle)
 		if handle < 0 {
 			t.error = 4
 		}
@@ -78,7 +78,7 @@ pub class Tcp : Sendable {
 	// failed.
 	pub func accept = (ref self, move out Tcp) {
 		var int handle = Tcp.accept_fd(self.fd)
-		var Tcp t = Tcp(handle)
+		var t = Tcp(handle)
 		if handle < 0 {
 			t.error = 5
 		}
@@ -91,14 +91,14 @@ pub class Tcp : Sendable {
 	pub func connect = (string host, int port, move out Tcp) {
 		var int handle = Tcp.socket_fd()
 		if handle < 0 {
-			var Tcp bad = Tcp(-1)
+			var bad = Tcp(-1)
 			bad.error = 2
 			return bad
 		}
 		var int err = Tcp.connect_to(handle, host, port)
 		if err != 0 {
 			Tcp.close_fd(handle)
-			var Tcp bad = Tcp(-1)
+			var bad = Tcp(-1)
 			bad.error = err
 			return bad
 		}

package/core/System/String.nm

@@ -248,7 +248,7 @@ pub struct string: Stringable, Hashable, Equatable {
 	// are only ever read.
 	pub func replace_first = (self, view string needle, view string replacement, out string) {
 		var sb = StringBuilder()
-		var int i = 0
+		var i = 0
 		var int n = self.length
 		var int nlen = needle.length
 		var bool replaced = nlen == 0
@@ -269,7 +269,7 @@ pub struct string: Stringable, Hashable, Equatable {
 	// left to right. Same edge behavior as replace_first.
 	pub func replace_all = (self, view string needle, view string replacement, out string) {
 		var sb = StringBuilder()
-		var int i = 0
+		var i = 0
 		var int n = self.length
 		var int nlen = needle.length
 		while i < n {
@@ -391,7 +391,7 @@ pub struct string: Stringable, Hashable, Equatable {
 	// Owned copy of self with leading and trailing ASCII whitespace
 	// (tab, LF, VT, FF, CR, space) removed. All-whitespace yields "".
 	pub func trim = (self, out string) {
-		var int start = 0
+		var start = 0
 		while start < self.length; start += 1 {
 			if !self.at(start).is_ascii_space() {
 				break
@@ -421,7 +421,7 @@ pub struct string: Stringable, Hashable, Equatable {
 
 	// Owned copy of self with leading ASCII whitespace removed.
 	pub func trim_start = (self, out string) {
-		var int start = 0
+		var start = 0
 		while start < self.length; start += 1 {
 			if !self.at(start).is_ascii_space() {
 				break
@@ -435,7 +435,7 @@ pub struct string: Stringable, Hashable, Equatable {
 	// bytes — including UTF-8 sequences — pass through unchanged).
 	pub func to_lowercase = (self, out string) {
 		var sb = StringBuilder()
-		var int i = 0
+		var i = 0
 		while i < self.length; i += 1 {
 			var int code = self.at(i) as int
 			if code > 64 && code < 91 {
@@ -450,7 +450,7 @@ pub struct string: Stringable, Hashable, Equatable {
 	// bytes — including UTF-8 sequences — pass through unchanged).
 	pub func to_uppercase = (self, out string) {
 		var sb = StringBuilder()
-		var int i = 0
+		var i = 0
 		while i < self.length; i += 1 {
 			var int code = self.at(i) as int
 			if code > 96 && code < 123 {
@@ -465,7 +465,7 @@ pub struct string: Stringable, Hashable, Equatable {
 // needle matches text at byte offset pos (caller guarantees pos + len fits;
 // the trailing guard makes the bound explicit so `.at` verifies).
 func match_at = (view string text, view string needle, int pos, out bool) {
-	var int i = 0
+	var i = 0
 	var int nlen = needle.length
 	var int n = text.length
 	while i < nlen && pos + i < n {

package/core/System/StringBuilder.nm

@@ -24,7 +24,7 @@ pub struct StringBuilder {
 		if new_cap == 0 {
 			new_cap = 16
 		}
-		while new_cap < needed; new_cap *= 2 {}
+		while new_cap < needed; new_cap *= 2 { }
 		self.data = realloc(self.data, new_cap)
 		self.cap = new_cap
 	}
@@ -120,6 +120,121 @@ pub struct StringBuilder {
 		}
 	}
 
+	// Read-back: how many bytes the buffer currently holds. (The `len` field
+	// is private; this is the O(1) peek the incremental-builder flow needs —
+	// e.g. recording a mark before appending a section.)
+	pub func length = (self, out int) {
+		return self.len
+	}
+
+	// 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) {
+		unsafe {
+			var int sl = suffix.length
+			if sl > self.len {
+				return false
+			}
+			var int start = self.len - sl
+			var int i = 0
+			while i < sl; i += 1 {
+				if (self.data as ptr char)[start + i] != (suffix as ptr char)[i] {
+					return false
+				}
+			}
+		}
+		return true
+	}
+
+	// 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) {
+		var int n = new_len
+		if n < 0 {
+			n = 0
+		}
+		if n > self.len {
+			n = self.len
+		}
+		self.len = n
+	}
+
+	// Drop the last byte (a no-op when the buffer is empty). The common
+	// chomp-the-trailing-separator shape.
+	pub func chomp = (ref self) {
+		if self.len > 0 {
+			self.len = self.len - 1
+		}
+	}
+
+	// Extract the bytes from `mark` to the end as a fresh owned string and
+	// rewind the buffer to `mark` bytes (capacity kept). The mid-render
+	// 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
+	// owns it by signature, like `Console.read_line`.)
+	func take_since = (ref self, int mark, move out string) {
+		```
+		#arch: c
+		int start = mark;
+		if (start < 0) start = 0;
+		if (start > self->len) start = self->len;
+		int n = self->len - start;
+		char* buf = (char*)malloc((size_t)n + 1);
+		if (n > 0) memcpy(buf, (void*)(unsigned long long)(self->data + start), n);
+		buf[n] = 0;
+		self->len = start;
+		// Fat-string ABI: return the (ptr, len) pair — no strlen.
+		return (nomen_string){ buf, n };
+		```
+		```
+		#arch: aarch64
+		// x19 = self, x1 = mark. Clamp start to [0, len]; malloc(n+1),
+		// copy the tail, null-terminate, rewind len. Live values live in a
+		// 32-byte (16-aligned) frame across the calls (x0-x18 are
+		// caller-saved): [sp]=start, [sp+8]=n, [sp+16]=buf.
+		ldr x2, [x19, #16]          // len
+		mov x3, x1                  // start = mark
+		cmp x3, #0
+		b.ge .Lsb_tk_hi
+		mov x3, #0
+		.Lsb_tk_hi:
+		cmp x3, x2
+		b.le .Lsb_tk_ok
+		mov x3, x2                  // start = min(start, len)
+		.Lsb_tk_ok:
+		sub x4, x2, x3              // n = len - start
+		sub sp, sp, #32
+		str x3, [sp, #0]            // start
+		str x4, [sp, #8]            // n
+		add x0, x4, #1
+		// buf = malloc(n + 1) — bare call line: the audit pass rewrites
+		// `bl _malloc` (line-exact) to the counter-wrapped allocator.
+		bl _malloc
+		str x0, [sp, #16]
+		ldr x1, [sp, #8]            // n
+		cbz x1, .Lsb_tk_copied
+		ldr x0, [sp, #16]           // dst = buf
+		ldr x3, [x19, #8]           // data
+		ldr x4, [sp, #0]            // start
+		add x1, x3, x4              // src = data + start
+		ldr x2, [sp, #8]            // n
+		bl _memcpy
+		.Lsb_tk_copied:
+		ldr x0, [sp, #16]           // buf
+		ldr x1, [sp, #8]            // n
+		add x2, x0, x1
+		strb wzr, [x2]              // buf[n] = 0
+		ldr x3, [sp, #0]            // start
+		str x3, [x19, #16]          // len = start
+		ldr x0, [sp, #16]           // return pair: (buf, n)
+		ldr x1, [sp, #8]
+		add sp, sp, #32
+		```
+	}
+
 	// Finalize: null-terminate, return the byte buffer as a string, and
 	// release ownership (sets `data` to 0 so the destructor won't free it).
 	func to_string = (ref self, out string) {

package/core/System/Task.nm

@@ -24,6 +24,14 @@ pub class Task<T> : Sendable, Awaitable {
 	pub var uint64 cancel_flag = 0
 	pub var uint64 future = 0
 
+	// INTERNAL (library-only): constructs a zeroed handle. `Thread.start` /
+	// `Fiber.start` build the Task they return through this — a user can
+	// wait/result/cancel a handle, but never constructs a bare one (it would
+	// reference no task at all). The auto-free pass reclaims the returned
+	// handle via #destroy, exactly like a spawn-yielded Task.
+	internal #init = () {
+	}
+
 	// 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).
@@ -160,6 +168,24 @@ pub class Task<T> : Sendable, Awaitable {
 		```
 	}
 
+	// Has the task finished? A poll — never blocks. True once the task's
+	// future has completed; false while it may still be running (and for a
+	// 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) {
+		```
+		#arch: c
+		return __nomen_future_is_done((struct nomen_future *)self->future);
+		```
+		```
+		#arch: aarch64
+		// x0 = self->future; result in x0.
+		ldr x0, [x19, #40]
+		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) {
@@ -354,14 +380,18 @@ pub class Task<T> : Sendable, Awaitable {
 		```
 		#arch: c
 		if (self->future) {
-		#if T_NEEDS_STRDUP
-			// T is the fat nomen_string here (the guard is 0 for every other
-			// T, and the preprocessor removes this region before parsing).
-			if (self->result_slot) {
-				T _s = *(T *)self->result_slot;
-				if (_s.ptr) free(_s.ptr);
-			}
-		#endif
+	#if T_NEEDS_STRDUP
+		// T is the fat nomen_string here (the guard is 0 for every other
+		// T, and the preprocessor removes this region before parsing).
+		if (self->result_slot) {
+			T _s = *(T *)self->result_slot;
+			if (_s.ptr) free(_s.ptr);
+			// Zero the cell: the future's last release also frees an
+			// unconsumed fat result, keyed on a non-NULL ptr (see
+			// __nomen_future_release) — this free must be the only one.
+			memset((void *)self->result_slot, 0, sizeof(T));
+		}
+	#endif
 			__nomen_future_release((struct nomen_future *)self->future);
 			self->future = 0;
 			self->result_slot = 0;
@@ -383,6 +413,10 @@ pub class Task<T> : Sendable, Awaitable {
 		cbz x8, .Ldestroy_nofree
 		ldr x0, [x8]
 		cbz x0, .Ldestroy_nofree
+		// Mark consumed BEFORE the free (x8 is caller-saved and dead after
+		// the call): the future's last release also frees an unconsumed
+		// fat result, keyed on a non-NULL cell (see __nomen_future_release).
+		stp xzr, xzr, [x8]
 		bl _free
 		.Ldestroy_nofree:
 		ldr x0, [x19, #40]

package/core/System/Test.nm

@@ -48,17 +48,17 @@
  **/
 pub class Tester {
 	// Has the *current* test recorded a failure? Reset by `begin_test`.
-	pub var bool has_failed = false
+	pub var has_failed = false
 
 	// Assertion tallies for the current test.
-	var int passed = 0
-	var int failed = 0
+	var passed = 0
+	var failed = 0
 
 	// Tallies for the whole file, so `done` records stay per-test while the
 	// process still knows whether anything failed overall.
-	var int total_failed = 0
+	var total_failed = 0
 
-	var string current = ""
+	var current = ""
 	var uint64 started = 0
 
 	// Benchmark capture state. `bench`/`bench_n` record the label and sample
@@ -66,9 +66,9 @@ pub class Tester {
 	// function and drives the actual timing loop (Nomen can't store or call a
 	// function pointer, so the harness measures `bench_fn` itself). `bench_fn`
 	// is reconstructed by the harness from the call site, not stored here.
-	var bool bench_pending = false
-	var string bench_label = ""
-	var int bench_samples = 1000
+	var bench_pending = false
+	var bench_label = ""
+	var bench_samples = 1000
 
 	// (harness) Start timing `name` and clear the per-test state. Called by
 	// the `main` that `nomen test` generates — not by test code.
@@ -188,7 +188,7 @@ pub class Tester {
 	 * (default 1000, override with `bench_n`) and computes min / median /
 	 * mean / max / stddev over the per-iteration durations.
 	 **/
-	pub func bench = (ref self, string label, func () body) {
+	pub func bench = (ref self, string label, func() body) {
 		if self.has_failed {
 			return
 		}
@@ -202,7 +202,7 @@ pub class Tester {
 	 * for slow functions (where the default 1000 would dominate the suite) or
 	 * for reproducible sample counts.
 	 **/
-	pub func bench_n = (ref self, string label, func () body, int samples) {
+	pub func bench_n = (ref self, string label, func() body, int samples) {
 		if self.has_failed {
 			return
 		}
@@ -219,7 +219,16 @@ pub class Tester {
 	 * If a test has already recorded a failure, benchmarks are skipped and
 	 * this is a no-op.
 	 **/
-	pub func record_bench = (ref self, string label, int n, int min, int median, int max, float mean, float stddev) {
+	pub func record_bench = (
+		ref self,
+		string label,
+		int n,
+		int min,
+		int median,
+		int max,
+		float mean,
+		float stddev
+	) {
 		if self.has_failed {
 			return
 		}

package/core/System/Text/CharIndex.nm

@@ -22,18 +22,18 @@ pub struct CharRun {
  **/
 pub struct CharIndex {
 	var view string source
-	var List<CharRun> runs = List<CharRun>()
-	var int char_count = 0
+	var runs = List<CharRun>()
+	var char_count = 0
 
 	pub func #init = (self, view string source) {
 		self.source = source
-		var int pos = 0
+		var pos = 0
 		var int len = source.length
-		var int chars = 0
+		var chars = 0
 		var int open_at = -1
-		var int open_width = 0
-		var int open_start = 0
-		var int open_count = 0
+		var open_width = 0
+		var open_start = 0
+		var open_count = 0
 		while pos < len {
 			var int w = Utf8.width_at(source, pos)
 			switch {
@@ -122,7 +122,7 @@ pub struct CharIndex {
 	// Rightmost run whose key (char_start when by_char, else byte_index) is
 	// <= target, or -1 when all runs start after it.
 	func rightmost_run = (self, int target, bool by_char, out int) {
-		var int lo = 0
+		var lo = 0
 		var int hi = self.runs.length - 1
 		var int found = -1
 		while lo <= hi {

package/core/System/Text/Chars.nm

@@ -9,7 +9,7 @@
  **/
 pub struct Chars {
 	var view string source
-	var int byte_pos = 0
+	var byte_pos = 0
 
 	pub func #init = (self, view string source) {
 		self.source = source

package/core/System/Text/JsonTree.nm

@@ -23,7 +23,7 @@ struct JsonNode {
  * A flat, buffer-backed pool of JSON tree nodes — the parsed representation `Json.parse` produces
  **/
 pub struct JsonTree {
-	var Buffer<JsonNode> nodes = Buffer<JsonNode>()
+	var nodes = Buffer<JsonNode>()
 	var count = 0
 
 	func alloc_node = (ref self, out int) {