nomen-lang 0.0.19 → 0.2.0

package/core/System/Task.nm

@@ -64,11 +64,15 @@ pub class Task<T> : Sendable {
 		```
 	}
 
-	// Block until the task finishes, then return its result as T.
-	// The spawn build phase allocates a heap slot (owned by the future) and
-	// the trampoline writes the function's return value there before exiting.
-	// For tasks with no return value (void functions), returns the zero value.
-	pub func result = (ref self, out T) {
+	// Block until the task finishes, then return its result as T. The spawn
+	// build phase allocates a heap slot (owned by the future) sized to hold
+	// 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
+	// returns the zero value. For tasks with no return value (void
+	// functions), returns the zero value.
+	pub func result = (ref self, move out T) {
 		```
 		#arch: c
 		if (self->future) {
@@ -79,7 +83,9 @@ pub class Task<T> : Sendable {
 			self->handle = 0;
 			self->done = 1;
 		}
-		return *(T *)self->result_slot;
+		T _r = *(T *)self->result_slot;
+		memset((void *)self->result_slot, 0, sizeof(T));
+		return _r;
 		```
 		```
 		#arch: aarch64
@@ -101,9 +107,14 @@ pub class Task<T> : Sendable {
 		mov w0, #1
 		strb w0, [x19, #16]
 		.Lresult_read:
-		// return *(T *)self->result_slot
-		ldr x0, [x19, #24]
-		ldr x0, [x0]
+		// 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]
 		```
 	}
 
@@ -236,12 +247,22 @@ pub class Task<T> : Sendable {
 	// Release this handle's reference to the future. The future owns the
 	// result slot and cancel flag; it (and they) are freed only when the
 	// last reference — this handle, the running trampoline, or a tracking
-	// nursery — is released. The Task instance itself is freed by the
-	// auto-free pass after #destroy returns.
+	// nursery — is released. A string result that was never consumed
+	// (`result()` zeroes the slot when it moves the value out) is freed
+	// here, before the future releases the cell. The Task instance itself
+	// is freed by the auto-free pass after #destroy returns.
 	pub func #destroy = () {
 		```
 		#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
 			__nomen_future_release((struct nomen_future *)self->future);
 			self->future = 0;
 			self->result_slot = 0;
@@ -250,9 +271,22 @@ pub class Task<T> : Sendable {
 		```
 		```
 		#arch: aarch64
-		// if (self->future) { release; zero fields }
+		// if (self->future) { free an unconsumed string result; release; zero fields }
 		ldr x0, [x19, #40]
 		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]
+		mov x0, #T_FAT
+		cmp x0, #0
+		b.eq .Ldestroy_nofree
+		cbz x8, .Ldestroy_nofree
+		ldr x0, [x8]
+		cbz x0, .Ldestroy_nofree
+		bl _free
+		.Ldestroy_nofree:
+		ldr x0, [x19, #40]
 		bl ___nomen_future_release
 		str xzr, [x19, #40]
 		str xzr, [x19, #24]

package/core/System/Test.nm

@@ -36,7 +36,7 @@
  *
  * A test function receives the tester by mutable reference:
  *
- *	import System/Test
+ *	import System::Test
  *
  *	pub func test_add = (ref Tester t) {
  *		t.expect(add(1, 1) == 2, "1 + 1 should be 2")

package/core/System/Text/Json.nm

@@ -14,8 +14,9 @@
  **/
 pub struct Json {
 	// Serialize a string to a JSON string literal, escaping the special
-	// characters ", \, newline, tab and carriage return.
-	pub func serialize = (string value, out string) {
+	// characters ", \, newline, tab and carriage return. `move out string`:
+	// returns the StringBuilder's owned heap copy.
+	pub func serialize = (string value, move out string) {
 		var sb = StringBuilder()
 		sb.append_char('"')
 		var i = 0
@@ -49,7 +50,8 @@ pub struct Json {
 	}
 
 	// Deserialize a JSON string literal to the raw, unescaped value.
-	pub func deserialize = (string json, out string) {
+	// `move out string`: returns the StringBuilder's owned heap copy.
+	pub func deserialize = (string json, move out string) {
 		var sb = StringBuilder()
 		var int len = json.length
 		var i = 0

package/core/System/Text/JsonTree.nm

@@ -40,22 +40,25 @@ pub struct JsonTree {
 		```
 		#arch: c
 		JsonNode *nodes = (JsonNode*)(unsigned long long)self->nodes.data;
-		free(nodes[idx].text);
-		nodes[idx].text = 0;
+		free(nodes[idx].text.ptr);
+		nodes[idx].text.ptr = 0;
+		nodes[idx].text.len = 0;
 		```
 		```
 		#arch: aarch64
 		// x19 = self. count is at self+32 and already equals idx+1 here, so
-		// idx = count - 1. nodes.data at self+16, JsonNode size 48, text at +16.
+		// idx = count - 1. nodes.data at self+16, JsonNode size 56 (fat text),
+		// text at +16 (ptr) / +24 (len).
 		ldr x0, [x19, #16]
 		ldr x1, [x19, #32]
 		sub x1, x1, #1
-		mov x3, #48
+		mov x3, #56
 		madd x1, x1, x3, xzr
 		add x0, x0, x1
 		add x0, x0, #16
 		ldr x1, [x0]
 		str xzr, [x0]
+		str xzr, [x0, #8]
 		cbz x1, .Lalloc_node_text_skip
 		mov x0, x1
 		bl _free
@@ -70,13 +73,13 @@ pub struct JsonTree {
 		```
 		#arch: c
 		JsonNode *nodes = (JsonNode*)(unsigned long long)self->nodes.data;
-		if (nodes[idx].text) { free(nodes[idx].text); nodes[idx].text = 0; }
+		if (nodes[idx].text.ptr) { free(nodes[idx].text.ptr); nodes[idx].text.ptr = 0; nodes[idx].text.len = 0; }
 		```
 		```
 		#arch: aarch64
-		// x19 = self, x1 = idx. Compute &nodes[idx].text.
+		// x19 = self, x1 = idx. Compute &nodes[idx].text (JsonNode size 56).
 		ldr x0, [x19, #16]
-		mov x3, #48
+		mov x3, #56
 		madd x1, x1, x3, xzr
 		add x0, x0, x1
 		add x0, x0, #16
@@ -87,6 +90,7 @@ pub struct JsonTree {
 		bl _free
 		ldr x0, [sp], #16
 		str xzr, [x0]
+		str xzr, [x0, #8]
 		.Ljsontree_free_text_skip:
 		```
 	}
@@ -113,33 +117,38 @@ pub struct JsonTree {
 	}
 
 	// strdup directly into the slab — see file header for why this can't
-	// go through load_T/store_T.
+	// go through load_T/store_T. (Under the fat-string ABI the C body is
+	// emitted behind the _raw_ adapter, so `text` arrives as a thin char*;
+	// aarch64 receives the pair x2 = ptr, x3 = len.)
 	func set_text = (ref self, int idx, string text) {
 		```
 		#arch: c
 		JsonNode *nodes = (JsonNode*)(unsigned long long)self->nodes.data;
-		nodes[idx].text = strdup(text);
+		nodes[idx].text.ptr = strdup(text);
+		nodes[idx].text.len = (long)strlen(text);
 		```
 		```
 		#arch: aarch64
-		// x19 = self, x1 = idx, x2 = text
+		// x19 = self, x1 = idx, x2 = text.ptr, x3 = text.len
 		// nodes.data is at self+16 (JsonTree.vt[0] + Buffer.vt[8])
-		// text field is at offset 16 in JsonNode (vt[0] + kind[8])
-		// sizeof(JsonNode) = 48 (vt + 5 fields * 8)
+		// text field is at offset 16 in JsonNode (vt[0] + kind[8]); the fat
+		// field is ptr@+16, len@+24; sizeof(JsonNode) = 56.
 		sub sp, sp, #32
 		str x1, [sp, #0]
-		str x2, [sp, #8]
+		str x3, [sp, #8]
 		mov x0, x2
 		bl _strdup
 		str x0, [sp, #16]
 		ldr x0, [x19, #16]
 		ldr x1, [sp, #0]
-		mov x3, #48
+		mov x3, #56
 		madd x1, x1, x3, xzr
 		add x0, x0, x1
 		add x0, x0, #16
 		ldr x1, [sp, #16]
 		str x1, [x0]
+		ldr x1, [sp, #8]
+		str x1, [x0, #8]
 		add sp, sp, #32
 		```
 	}

package/core/System/Text/Regex.nm

@@ -30,7 +30,9 @@ pub struct Regex {
 	}
 
 	// Return the first substring of input matching pattern, or "" if none.
-	pub func match = (string pattern, string input, out string) {
+	// `move out string`: the built match (or the copied empty literal) is
+	// handed to the caller as an owned value.
+	pub func match = (string pattern, string input, move out string) {
 		var match_result = ""
 		var int pat_len = pattern.length
 		var int len = input.length
@@ -124,101 +126,159 @@ pub struct Regex {
 	}
 }
 
-// Scan input[pos..len) for the next byte that appears in charset (null-terminated).
+// Scan input[pos..len) for the next byte that appears in charset.
 // Returns the index of the match, or len if none found / charset is empty.
 func find_next_byte = (string input, int pos, int len, string charset, out int) {
-	```
-	#arch: c
-	if (pos >= len || charset[0] == 0) return len;
-	char* found = strpbrk(input + pos, charset);
-	if (found == NULL) return len;
-	return (int)(found - input);
-	```
-	```
-	#arch: aarch64
-	// Free function: x0 = input, x1 = pos, x2 = len, x3 = charset
-	sub sp, sp, #32
-	str x0, [sp, #0]            // input
-	str x2, [sp, #8]            // len (default return)
-	cmp x1, x2
-	b.ge .Lfnb_default
-	ldrb w9, [x3]
-	cbz w9, .Lfnb_default
-	add x0, x0, x1              // x0 = input + pos
-	mov x1, x3                  // x1 = charset
-	bl _strpbrk
-	cbz x0, .Lfnb_default
-	ldr x9, [sp, #0]            // input
-	sub x0, x0, x9              // result = found - input
-	b .Lfnb_end
-	.Lfnb_default:
-	ldr x0, [sp, #8]            // return len
-	.Lfnb_end:
-	add sp, sp, #32
-	```
+	if pos >= len {
+		return len
+	}
+	if charset.length == 0 {
+		return len
+	}
+	var i = pos
+	while i < len && i < input.length; i += 1 {
+		var j = 0
+		while j < charset.length; j += 1 {
+			if input.at(i) == charset.at(j) {
+				return i
+			}
+		}
+	}
+	return len
 }
 
 // Extract the set of possible first bytes from a pattern into a charset string.
-// Returns "" if every byte is possible (e.g. pattern starts with '.', '^', '(').
+// Returns "" if every byte is possible (e.g. pattern starts with '.', '(' with
+// an unbounded repeat, or an alternative whose first set can't be determined).
 func first_byte_set = (string pattern, int pat_len, out string) {
 	if pat_len == 0 {
 		return ""
 	}
 	var sb = StringBuilder()
-	collect_first_bytes(pattern, 0, pat_len, ref sb)
+	if collect_first_bytes(pattern, 0, pat_len, ref sb) < 0 {
+		// Some alternative's first-byte set is indeterminable — a wildcard
+		// '.', an empty alternative, or similar. The charset is a PREFILTER
+		// (candidate positions via strpbrk): under-approximating it would
+		// skip positions where a match can start, so disable it entirely.
+		return ""
+	}
 	return sb.to_string()
 }
 
 // Walk top-level alternatives of pattern[pat_pos..pat_end), appending the first
 // byte(s) of each alternative to sb. Alternations at depth 0 are split on '|'.
-func collect_first_bytes = (string pattern, int pat_pos, int pat_end, ref StringBuilder sb) {
+// Returns -1 when any alternative's first-byte set can't be determined (the
+// caller must then disable the prefilter), 0 otherwise.
+func collect_first_bytes = (string pattern, int pat_pos, int pat_end, ref StringBuilder sb, out int) {
 	var depth = 0
 	var int i = pat_pos
 	var int alt_start = pat_pos
 	while i < pat_end {
 		var char c = pattern.at(i)
-		switch {
-			case (c as int) == 92 {
-				// escaped literal: '\x' → first byte is x
-				if i == alt_start {
-					if i + 1 < pat_end {
-						sb.append_char(pattern.at(i + 1))
+		if (c as int) == 92 {
+			i += 2
+		} else {
+			if c == '[' {
+				i = atom_end_pos(pattern, i, pat_end)
+			} else {
+				if c == '(' {
+					depth = depth + 1
+				}
+				if c == ')' {
+					if depth > 0 {
+						depth -= 1
 					}
 				}
-				i += 2
-			}
-			case c == '[' {
-				if i == alt_start {
-					var int a_end = atom_end_pos(pattern, i, pat_end)
-					add_class_chars(pattern, i + 1, a_end - 1, ref sb)
+				if (c as int) == 124 {
+					if depth == 0 {
+						if alt_first_bytes(pattern, alt_start, i, ref sb) < 0 {
+							return -1
+						}
+						alt_start = i + 1
+					}
 				}
-				i = atom_end_pos(pattern, i, pat_end)
-			}
-			case c == '(' {
-				depth = depth + 1
 				i += 1
 			}
-			case c == ')' {
-				if depth > 0 {
-					depth -= 1
-				}
-				i += 1
+		}
+	}
+	return alt_first_bytes(pattern, alt_start, pat_end, ref sb)
+}
+
+// Append the set of bytes that can start a match of the alternative occupying
+// pattern[start..end) to sb. Returns -1 when the set can't be determined (the
+// caller must disable the prefilter), 0 when it was appended.
+//
+// Handles the shapes the engine's matcher can produce: a leading anchor is
+// zero-width (skipped), a leading group contributes its CONTENT's first bytes
+// (recursively over the group's own top-level alternatives), and a group
+// quantified with '?'/'*' is nullable — what FOLLOWS it can also be first, so
+// the scan continues past it. A wildcard '.' or an empty alternative makes the
+// set indeterminable.
+func alt_first_bytes = (string pattern, int start, int end, ref StringBuilder sb, out int) {
+	var int i = start
+	while i < end {
+		var char c = pattern.at(i)
+		if (c as int) == 92 {
+			// escaped literal: first byte is the escaped char
+			if i + 1 < end {
+				sb.append_char(pattern.at(i + 1))
 			}
-			case (c as int) == 124 {
-				if depth == 0 {
-					alt_start = i + 1
+			return 0
+		}
+		if c == '[' {
+			var int a_end = atom_end_pos(pattern, i, end)
+			// A NEGATED class can match any byte outside its member set —
+			// not expressible as an inclusion charset, and under-approximating
+			// (the member bytes alone) would make strpbrk skip valid match
+			// positions. Disable the prefilter instead.
+			var int cs = i + 1
+			if cs < a_end - 1 {
+				if pattern.at(cs) == '^' {
+					return -1
 				}
-				i += 1
 			}
-			case i == alt_start && depth == 0 && c != '^' && c != '$' && c != '.' {
-				sb.append_char(c)
-				i += 1
+			add_class_chars(pattern, i + 1, a_end - 1, ref sb)
+			return 0
+		}
+		if c == '(' {
+			var int a_end = atom_end_pos(pattern, i, end)
+			// The group's first bytes are the union of its content's
+			// top-level alternatives' first bytes.
+			if collect_first_bytes(pattern, i + 1, a_end - 1, ref sb) < 0 {
+				return -1
 			}
-			else {
-				i += 1
+			// A '?'/'*' quantifier makes the group nullable — the first byte
+			// can also come from whatever follows it.
+			var int after = a_end
+			var int nullable = 0
+			if after < end {
+				var char q = pattern.at(after)
+				if q == '?' || q == '*' {
+					nullable = 1
+					after += 1
+				}
 			}
+			if nullable == 0 {
+				return 0
+			}
+			i = after
+			continue
+		}
+		if c == '^' || c == '$' {
+			// zero-width assertions never consume a byte
+			i += 1
+			continue
 		}
+		if c == '.' {
+			// wildcard (any byte except '\n') — not expressible as an
+			// inclusion set; the prefilter must be disabled.
+			return -1
+		}
+		sb.append_char(c)
+		return 0
 	}
+	// An empty alternative can match at any position — indeterminable.
+	return -1
 }
 
 // Append the members of character class [start..end) to sb. Ranges (a-z) are

package/core/System/Tree.nm

@@ -13,7 +13,7 @@ pub struct Tree<T>: Enumerable {
 	var parents = Buffer<int>()
 	var count = 0
 
-	pub func add = (ref self, mov T value) {
+	pub func add = (ref self, move T value) {
 		const int idx = self.count
 		self.values.grow_int(idx + 1)
 		const int v = value

package/core/System/bool.nm

@@ -3,14 +3,7 @@
  **/
 pub struct bool: Stringable, Hashable, Equatable {
 	pub func hash = (self, out uint) {
-		```
-		#arch: c
-		return (unsigned long)self;
-		```
-		```
-		#arch: aarch64
-		mov x0, x19
-		```
+		return self as uint
 	}
 
 	/** 
@@ -19,7 +12,7 @@ pub struct bool: Stringable, Hashable, Equatable {
 	 * @param self: the boolean
 	 * @out string: the boolean as a string value (`"true"` or `"false"`)
 	 **/
-	pub func to_string = (self, out string) {
+	pub func to_string = (self, move out string) {
 		```
 		#arch: c
 		int length = snprintf(NULL, 0, "%s", self ? "true" : "false");
@@ -49,6 +42,7 @@ pub struct bool: Stringable, Hashable, Equatable {
 		adr x2, .Lfmt_bool_true
 		mov x3, x19
 		bl _snprintf
+		mov x1, x0
 		ldr x0, [sp, #72]
 		add sp, sp, #128
 		b .Lend_bool_to_string
@@ -65,6 +59,7 @@ pub struct bool: Stringable, Hashable, Equatable {
 		adr x2, .Lfmt_bool_false
 		mov x3, x19
 		bl _snprintf
+		mov x1, x0
 		ldr x0, [sp, #72]
 		add sp, sp, #128
 		b .Lend_bool_to_string

package/core/System/char.nm

@@ -3,17 +3,10 @@
  **/
 pub struct char: Stringable, Hashable, Equatable {
 	pub func hash = (self, out uint) {
-		```
-		#arch: c
-		return (unsigned long)self;
-		```
-		```
-		#arch: aarch64
-		mov x0, x19
-		```
+		return self as uint
 	}
 
-	pub func to_string = (self, out string) {
+	pub func to_string = (self, move out string) {
 		```
 		#arch: c
 		int length = snprintf(NULL, 0, "%c", self);
@@ -42,6 +35,7 @@ pub struct char: Stringable, Hashable, Equatable {
 		adr x2, .Lfmt_char_c
 		mov x3, x19
 		bl _snprintf
+		mov x1, x0
 		ldr x0, [sp, #72]
 		add sp, sp, #128
 		b .Lend_char_to_string

package/core/System/float.nm

@@ -2,7 +2,7 @@
  * A double-precision (64-bit) floating-point number
  **/
 pub struct float: Stringable {
-	pub func to_string = (self, out string) {
+	pub func to_string = (self, move out string) {
 		```
 		#arch: c
 		int length = snprintf(NULL, 0, "%f", self);
@@ -32,6 +32,7 @@ pub struct float: Stringable {
 		adr x2, .Lfmt_float_f
 		fmov d0, x19
 		bl _snprintf
+		mov x1, x0
 		ldr x0, [sp, #72]
 		add sp, sp, #128
 		b .Lend_float_to_string

package/core/System/float32.nm

@@ -0,0 +1,44 @@
+/**
+ * A signed double-precision (64-bit) floating-point number
+ **/
+pub struct float32: Stringable {
+	pub func to_string = (self, move out string) {
+		```
+		#arch: c
+		int length = snprintf(NULL, 0, "%f", self);
+		char* str = malloc(length + 1);
+		snprintf(str, length + 1, "%f", self);
+		return str;
+		```
+		```
+		#arch: aarch64
+		sub sp, sp, #128
+		str x0, [sp, #0]
+		str x1, [sp, #8]
+		str x2, [sp, #16]
+		str x3, [sp, #24]
+		str d0, [sp, #64]
+		mov x0, xzr
+		mov x1, xzr
+		adr x2, .Lfmt_float32_f
+		fmov d0, x19
+		bl _snprintf
+		add x0, x0, #1
+		str x0, [sp, #64]
+		bl _malloc
+		str x0, [sp, #72]
+		ldr x0, [sp, #72]
+		ldr x1, [sp, #64]
+		adr x2, .Lfmt_float32_f
+		fmov d0, x19
+		bl _snprintf
+		mov x1, x0
+		ldr x0, [sp, #72]
+		add sp, sp, #128
+		b .Lend_float32_to_string
+		.Lfmt_float32_f: .asciz "%f"
+		.p2align 2
+		.Lend_float32_to_string:
+		```
+	}
+}

package/core/System/float64.nm

@@ -0,0 +1,44 @@
+/**
+ * A signed double-precision (64-bit) floating-point number
+ **/
+pub struct float64: Stringable {
+	pub func to_string = (self, move out string) {
+		```
+		#arch: c
+		int length = snprintf(NULL, 0, "%f", self);
+		char* str = malloc(length + 1);
+		snprintf(str, length + 1, "%f", self);
+		return str;
+		```
+		```
+		#arch: aarch64
+		sub sp, sp, #128
+		str x0, [sp, #0]
+		str x1, [sp, #8]
+		str x2, [sp, #16]
+		str x3, [sp, #24]
+		str d0, [sp, #64]
+		mov x0, xzr
+		mov x1, xzr
+		adr x2, .Lfmt_float64_f
+		fmov d0, x19
+		bl _snprintf
+		add x0, x0, #1
+		str x0, [sp, #64]
+		bl _malloc
+		str x0, [sp, #72]
+		ldr x0, [sp, #72]
+		ldr x1, [sp, #64]
+		adr x2, .Lfmt_float64_f
+		fmov d0, x19
+		bl _snprintf
+		mov x1, x0
+		ldr x0, [sp, #72]
+		add sp, sp, #128
+		b .Lend_float64_to_string
+		.Lfmt_float64_f: .asciz "%f"
+		.p2align 2
+		.Lend_float64_to_string:
+		```
+	}
+}

package/core/System/int.nm

@@ -3,17 +3,10 @@
  **/
 pub struct int: Stringable, Hashable, Equatable {
 	pub func hash = (self, out uint) {
-		```
-		#arch: c
-		return (unsigned long)self;
-		```
-		```
-		#arch: aarch64
-		mov x0, x19
-		```
+		return self as uint
 	}
 
-	pub func to_string = (self, out string) {
+	pub func to_string = (self, move out string) {
 		```
 		#arch: c
 		int length = snprintf(NULL, 0, "%ld", self);
@@ -42,6 +35,7 @@ pub struct int: Stringable, Hashable, Equatable {
 		adr x2, .Lfmt_int_ld
 		mov x3, x19
 		bl _snprintf
+		mov x1, x0
 		ldr x0, [sp, #72]
 		add sp, sp, #128
 		b .Lend_int_to_string