nomen-lang 0.8.0 → 0.10.0

package/core/System/Stream/File.nm

@@ -57,13 +57,13 @@ pub struct File {
 				return FileError.already_exists
 			}
 		} else {
-				return FileError.other
-			}
+			return FileError.other
+		}
 	}
 
 	// 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

@@ -49,8 +49,8 @@ pub struct Http {
 				return HttpError.connect
 			}
 		} else {
-				return HttpError.other
-			}
+			return HttpError.other
+		}
 	}
 
 	// Shared socket round-trip used by get/post. `method` is the request
@@ -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/String.nm

@@ -276,21 +276,26 @@ pub mv struct string: Stringable, Hashable, Equatable {
 	}
 
 	// Replace all non-overlapping occurrences of needle with replacement,
-	// left to right. Same edge behavior as replace_first.
+	// left to right. Same edge behavior as replace_first. Literal bytes
+	// between matches are copied in bulk runs (one `append_string_view` per
+	// run) — the old loop appended per byte.
 	pub func replace_all = (self, view string needle, view string replacement, out string) {
 		var sb = StringBuilder()
 		var i = 0
 		var int n = self.length
 		var int nlen = needle.length
-		while i < n {
-			if nlen > 0 && i + nlen <= n && match_at(self, needle, i) {
+		var run_start = 0
+		while nlen > 0 && i + nlen <= n {
+			if match_at(self, needle, i) {
+				sb.append_string_view(self.slice(run_start, i))
 				sb.append_string_view(replacement)
 				i = i + nlen
+				run_start = i
 			} else {
-				sb.append_char(self.at(i))
-				i = i + 1
+				i += 1
 			}
 		}
+		sb.append_string_view(self.slice(run_start, n))
 		return sb.to_string()
 	}
 

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;
@@ -83,13 +83,224 @@ pub struct StringBuilder {
 		```
 	}
 
-	// Append a null-terminated string. `unsafe` Nomen single-sourced for
+	// Append a base-10 integer WITHOUT materializing a string: the digits are
+	// written straight into the buffer (one capacity check, no malloc and no
+	// snprintf). The `sb.append(i.to_string())` shape's two snprintf passes
+	// 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) {
+		```
+		#arch: c
+		long v = n;
+		char tmp[24];
+		int pos = 24;
+		// Magnitude via the two's-complement negate (u stays correct for
+		// INT64_MIN, whose positive counterpart is not representable).
+		unsigned long long u = v < 0 ? (unsigned long long)(-(v + 1)) + 1ULL : (unsigned long long)v;
+		do {
+			tmp[--pos] = (char)('0' + (int)(u % 10));
+			u /= 10;
+		} while (u != 0);
+		if (v < 0) tmp[--pos] = '-';
+		long sl = 24 - pos;
+		long idx = self->len;
+		if (idx + sl + 1 > self->cap) {
+			long nc = self->cap;
+			if (nc == 0) nc = 16;
+			while (nc < idx + sl + 1) nc *= 2;
+			self->data = (unsigned long long)realloc((void*)(unsigned long long)self->data, nc);
+			self->cap = nc;
+		}
+		memcpy((void*)((unsigned long long)self->data + (unsigned long long)idx), tmp + pos, (size_t)sl);
+		self->len = idx + sl;
+		```
+		```
+		#arch: aarch64
+		// x19 = self, x1 = n. Format into a 24-byte scratch at [sp+40..64)
+		// (20 chars for INT64_MIN), then copy into the buffer
+		// (capacity-checked inline, like append_char). Saves live below the
+		// scratch: [sp]=pos, [sp+8]=sl, [sp+16]=idx, [sp+24]=new_cap.
+		sub sp, sp, #64
+		mov x9, x1                 // v = n
+		mov x10, x9
+		cmp x9, #0
+		b.ge .Lsb_ai_pos
+		neg x10, x10               // magnitude (wraps correctly for INT64_MIN)
+		.Lsb_ai_pos:
+		add x11, sp, #64           // pos = end of scratch
+		mov x12, x11
+		.Lsb_ai_digit:
+		mov x13, #10
+		udiv x14, x10, x13
+		msub x15, x14, x13, x10    // rem = v - q*10
+		add x15, x15, #48
+		sub x12, x12, #1
+		strb w15, [x12]
+		mov x10, x14
+		cbnz x10, .Lsb_ai_digit
+		cmp x9, #0
+		b.ge .Lsb_ai_store
+		sub x12, x12, #1
+		mov w15, #45               // '-'
+		strb w15, [x12]
+		.Lsb_ai_store:
+		sub x1, x11, x12           // sl = end - pos
+		ldr x2, [x19, #16]         // len
+		add x3, x2, x1
+		add x3, x3, #1             // needed
+		ldr x4, [x19, #24]         // cap
+		cmp x4, x3
+		b.ge .Lsb_ai_copy
+		mov x5, #16
+		cmp x4, #0
+		csel x5, x5, x4, eq
+		.Lsb_ai_grow:
+		cmp x5, x3
+		b.ge .Lsb_ai_realloc
+		lsl x5, x5, #1
+		b .Lsb_ai_grow
+		.Lsb_ai_realloc:
+		str x12, [sp, #0]          // pos
+		str x1, [sp, #8]           // sl
+		str x2, [sp, #16]          // idx
+		str x5, [sp, #24]          // new_cap
+		ldr x0, [x19, #8]
+		mov x1, x5
+		bl _realloc
+		str x0, [x19, #8]
+		ldr x5, [sp, #24]
+		str x5, [x19, #24]
+		ldr x12, [sp, #0]
+		ldr x1, [sp, #8]
+		ldr x2, [sp, #16]
+		.Lsb_ai_copy:
+		ldr x0, [x19, #8]          // data
+		add x0, x0, x2             // dst = data + idx
+		mov x3, x1
+		.Lsb_ai_cl:
+		cbz x3, .Lsb_ai_done
+		ldrb w4, [x12]
+		strb w4, [x0]
+		add x12, x12, #1
+		add x0, x0, #1
+		sub x3, x3, #1
+		b .Lsb_ai_cl
+		.Lsb_ai_done:
+		add x2, x2, x1             // len += sl
+		str x2, [x19, #16]
+		add sp, sp, #64
+		```
+	}
+
+	// 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) {
+		```
+		#arch: c
+		char tmp[360];
+		int sl = snprintf(tmp, sizeof(tmp), "%f", f);
+		long idx = self->len;
+		if (idx + sl + 1 > self->cap) {
+			long nc = self->cap;
+			if (nc == 0) nc = 16;
+			while (nc < idx + sl + 1) nc *= 2;
+			self->data = (unsigned long long)realloc((void*)(unsigned long long)self->data, nc);
+			self->cap = nc;
+		}
+		memcpy((void*)((unsigned long long)self->data + (unsigned long long)idx), tmp, (size_t)sl);
+		self->len = idx + sl;
+		```
+		```
+		#arch: aarch64
+		// x19 = self, x1 = f (raw bits — float params ride integer
+		// registers). Scratch [sp+16..sp+376); [sp+0] is snprintf's
+		// variadic slot, reused after the call for `sl`; [sp+8] = idx across
+		// the grow call; [sp+376] = new_cap.
+		sub sp, sp, #384
+		fmov d0, x1                // f bits (capture before x1 is reused)
+		str d0, [sp, #0]           // variadic double slot
+		add x0, sp, #16
+		mov x1, #360
+		adr x2, .Lsb_af_fmt
+		bl _snprintf
+		str x0, [sp, #0]           // sl
+		ldr x2, [x19, #16]         // idx = len
+		add x3, x2, x0
+		add x3, x3, #1             // needed
+		ldr x4, [x19, #24]         // cap
+		cmp x4, x3
+		b.ge .Lsb_af_copy
+		mov x5, #16
+		cmp x4, #0
+		csel x5, x5, x4, eq
+		.Lsb_af_grow:
+		cmp x5, x3
+		b.ge .Lsb_af_realloc
+		lsl x5, x5, #1
+		b .Lsb_af_grow
+		.Lsb_af_realloc:
+		str x2, [sp, #8]           // idx
+		str x5, [sp, #376]         // new_cap (above the scratch)
+		ldr x0, [x19, #8]
+		mov x1, x5
+		bl _realloc
+		str x0, [x19, #8]
+		ldr x5, [sp, #376]
+		str x5, [x19, #24]
+		ldr x2, [sp, #8]
+		.Lsb_af_copy:
+		ldr x0, [x19, #8]          // data
+		add x0, x0, x2             // dst = data + idx
+		add x4, sp, #16            // src = scratch
+		ldr x1, [sp, #0]           // sl
+		mov x3, x1
+		.Lsb_af_cl:
+		cbz x3, .Lsb_af_done
+		ldrb w5, [x4]
+		strb w5, [x0]
+		add x4, x4, #1
+		add x0, x0, #1
+		sub x3, x3, #1
+		b .Lsb_af_cl
+		.Lsb_af_done:
+		add x2, x2, x1             // len += sl
+		str x2, [x19, #16]
+		add sp, sp, #384
+		b .Lsb_af_after
+		.Lsb_af_fmt: .asciz "%f"
+		.p2align 2
+		.Lsb_af_after:
+		```
+	}
+
+	// Append a borrowed view without materializing it.
+	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) {
+		self.append_int(n)
+	}
+
+	// Append a float without materializing a string (see `append_float`).
+	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) {
+		self.append_char(c)
+	}
+
 	// both backends: the fat pair's pointer half feeds memcpy directly, and
 	// the tracked length replaces the strlen the old C body paid.
 	// `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)
@@ -103,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)
@@ -116,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)
@@ -135,14 +346,14 @@ 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 {
 				return false
 			}
 			var int start = self.len - sl
-			var int i = 0
+			var i = 0
 			while i < sl; i += 1 {
 				if (self.data as ptr char)[start + i] != (suffix as ptr char)[i] {
 					return false
@@ -154,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
@@ -167,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
 		}
@@ -180,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;
@@ -248,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;