nomen-lang 0.5.0 → 0.6.1

package/core/System/Text/Regex.nm

@@ -65,7 +65,12 @@ pub struct Regex {
 	// group that did not participate in the match) and return true. Return
 	// false with `out` untouched when nothing matches. A group that repeats
 	// (`(a)+`) reports its LAST iteration.
-	pub func captures = (string pattern, string input, ref List<string> dst, out bool) {		var int pat_len = pattern.length
+	pub func captures = (
+		string pattern,
+		string input,
+		ref List<string> dst,
+		out bool
+	) { var int pat_len = pattern.length
 		var int len = input.length
 		var string charset = first_byte_set(pattern, pat_len)
 		var int clen = charset.length
@@ -83,7 +88,7 @@ pub struct Regex {
 			if end >= 0 {
 				var string whole = input.substring(i, end)
 				dst.push(whole)
-				var int g = 1
+				var g = 1
 				while g <= groups; g += 1 {
 					var int at = last_capture_index(caps, g)
 					if at >= 0 {
@@ -166,7 +171,12 @@ pub struct Regex {
 	}
 
 	// Replace all non-overlapping occurrences of pattern in input with replacement.
-	pub func replace_all = (string pattern, string input, string replacement, out string) {		var sb = StringBuilder()
+	pub func replace_all = (
+		string pattern,
+		string input,
+		string replacement,
+		out string
+	) { var sb = StringBuilder()
 		var int pat_len = pattern.length
 		var int len = input.length
 		var string charset = first_byte_set(pattern, pat_len)
@@ -241,7 +251,7 @@ pub struct Regex {
 func fold_pattern = (string pattern, move out string) {
 	var int n = pattern.length
 	var sb = StringBuilder()
-	var int i = 0
+	var i = 0
 	while i < n; i += 1 {
 		var char c = pattern.at(i)
 		if (c as int) == 92 {
@@ -412,7 +422,13 @@ func first_byte_set = (string pattern, int pat_len, out string) {
 // byte(s) of each alternative to sb. Alternations at depth 0 are split on '|'.
 // 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) {
+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
@@ -453,10 +469,10 @@ func collect_first_bytes = (string pattern, int pat_pos, int pat_end, ref String
 //
 // 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.
+// (recursively over the group's own top-level alternatives), and ANY leading
+// atom — literal, escaped, class, or 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 {
@@ -474,9 +490,17 @@ func alt_first_bytes = (string pattern, int start, int end, ref StringBuilder sb
 					if shorthand_members(e, ref sb) < 0 {
 						return -1
 					}
+				} else {
+					sb.append_char(e)
+				}
+				// A '?'/'*' quantifier makes the atom nullable — the first
+				// byte can also come from whatever follows it.
+				var int cont = nullable_quant_after(pattern, i + 2, end)
+				if cont < 0 {
 					return 0
 				}
-				sb.append_char(e)
+				i = cont
+				continue
 			}
 			return 0
 		}
@@ -493,7 +517,12 @@ func alt_first_bytes = (string pattern, int start, int end, ref StringBuilder sb
 				}
 			}
 			add_class_chars(pattern, i + 1, a_end - 1, ref sb)
-			return 0
+			var int cont = nullable_quant_after(pattern, a_end, end)
+			if cont < 0 {
+				return 0
+			}
+			i = cont
+			continue
 		}
 		if c == '(' {
 			var int a_end = atom_end_pos(pattern, i, end)
@@ -502,27 +531,11 @@ func alt_first_bytes = (string pattern, int start, int end, ref StringBuilder sb
 			if collect_first_bytes(pattern, i + 1, a_end - 1, ref sb) < 0 {
 				return -1
 			}
-			// A '?'/'*' quantifier makes the group nullable — the first byte
-			// can also come from whatever follows it. A second '?' marks the
-			// quantifier lazy and is skipped either way.
-			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 after < end {
-						if pattern.at(after) == '?' {
-							after += 1
-						}
-					}
-				}
-			}
-			if nullable == 0 {
+			var int cont = nullable_quant_after(pattern, a_end, end)
+			if cont < 0 {
 				return 0
 			}
-			i = after
+			i = cont
 			continue
 		}
 		if c == '^' || c == '$' {
@@ -536,9 +549,40 @@ func alt_first_bytes = (string pattern, int start, int end, ref StringBuilder sb
 			return -1
 		}
 		sb.append_char(c)
-		return 0
+		var int cont = nullable_quant_after(pattern, i + 1, end)
+		if cont < 0 {
+			return 0
+		}
+		i = cont
+		continue
+	}
+	// An empty alternative (nothing left after nullable atoms — or nothing at
+	// all) can match at any position — indeterminable.
+	return -1
+}
+
+// If the atom ending at `after` carries a nullable quantifier ('?' or '*',
+// optionally marked lazy by a second '?'), return the position just past the
+// quantifier; otherwise return -1. Callers keep scanning from the returned
+// position: a nullable leading atom means the alternative's match can also
+// START with whatever follows, so those bytes belong in the first-byte set
+// too. ('+' is NOT nullable — the atom must match once — so it leaves the
+// atom's own bytes as the whole first set.)
+func nullable_quant_after = (string pattern, int after, int end, out int) {
+	var int j = after
+	if j >= end {
+		return -1
+	}
+	var char q = pattern.at(j)
+	if q == '?' || q == '*' {
+		j += 1
+		if j < end {
+			if pattern.at(j) == '?' {
+				j += 1
+			}
+		}
+		return j
 	}
-	// An empty alternative can match at any position — indeterminable.
 	return -1
 }
 
@@ -568,7 +612,7 @@ func add_class_chars = (string pattern, int start, int end, ref StringBuilder sb
 			}
 		} else {
 			sb.append_char(pattern.at(i))
-				i += 1
+			i += 1
 		}
 	}
 }
@@ -613,7 +657,15 @@ func match_here = (
 				}
 				if (c as int) == 124 {
 					if depth == 0 {
-						var int left = match_here(pattern, pat_pos, i, input, in_pos, in_len, ref caps)
+						var int left = match_here(
+							pattern,
+							pat_pos,
+							i,
+							input,
+							in_pos,
+							in_len,
+							ref caps,
+						)
 						if left >= 0 {
 							return left
 						}
@@ -655,7 +707,7 @@ func match_here = (
 	if a_end < pat_end {
 		var char q = pattern.at(a_end)
 		if q == '*' || q == '+' || q == '?' {
-			var int lazy = 0
+			var lazy = 0
 			var int rest = a_end + 1
 			if rest < pat_end {
 				if pattern.at(rest) == '?' {
@@ -664,12 +716,47 @@ func match_here = (
 				}
 			}
 			if q == '*' {
-				return match_star(pattern, pat_pos, a_end, rest, pat_end, input, in_pos, 0, lazy, in_len, ref caps)
+				return match_star(
+					pattern,
+					pat_pos,
+					a_end,
+					rest,
+					pat_end,
+					input,
+					in_pos,
+					0,
+					lazy,
+					in_len,
+					ref caps,
+				)
 			}
 			if q == '+' {
-				return match_star(pattern, pat_pos, a_end, rest, pat_end, input, in_pos, 1, lazy, in_len, ref caps)
+				return match_star(
+					pattern,
+					pat_pos,
+					a_end,
+					rest,
+					pat_end,
+					input,
+					in_pos,
+					1,
+					lazy,
+					in_len,
+					ref caps,
+				)
 			}
-			return match_optional(pattern, pat_pos, a_end, rest, pat_end, input, in_pos, lazy, in_len, ref caps)
+			return match_optional(
+				pattern,
+				pat_pos,
+				a_end,
+				rest,
+				pat_end,
+				input,
+				in_pos,
+				lazy,
+				in_len,
+				ref caps,
+			)
 		}
 	}
 
@@ -768,7 +855,15 @@ func match_single_atom = (
 			old_start = caps.at(at + 1)
 			old_end = caps.at(at + 2)
 		}
-		var int next = match_here(pattern, atom_start + 1, atom_end - 1, input, in_pos, in_len, ref caps)
+		var int next = match_here(
+			pattern,
+			atom_start + 1,
+			atom_end - 1,
+			input,
+			in_pos,
+			in_len,
+			ref caps,
+		)
 		if next >= 0 {
 			record_capture(ref caps, g, in_pos, next)
 			return next
@@ -958,7 +1053,15 @@ func match_star_group = (
 				return stop
 			}
 		}
-		var int next = match_single_atom(pattern, atom_start, atom_end, input, in_pos, in_len, ref caps)
+		var int next = match_single_atom(
+			pattern,
+			atom_start,
+			atom_end,
+			input,
+			in_pos,
+			in_len,
+			ref caps,
+		)
 		if next >= 0 {
 			if next != in_pos {
 				var new_min = 0
@@ -1035,7 +1138,15 @@ func match_optional = (
 		if skip >= 0 {
 			return skip
 		}
-		var int next = match_single_atom(pattern, atom_start, atom_end, input, in_pos, in_len, ref caps)
+		var int next = match_single_atom(
+			pattern,
+			atom_start,
+			atom_end,
+			input,
+			in_pos,
+			in_len,
+			ref caps,
+		)
 		if next >= 0 {
 			return match_here(pattern, rest, pat_end, input, next, in_len, ref caps)
 		}
@@ -1136,8 +1247,8 @@ func char_in_class = (
 // groups).
 func capture_count = (string pattern, out int) {
 	var int n = pattern.length
-	var int count = 0
-	var int i = 0
+	var count = 0
+	var i = 0
 	while i < n; i += 1 {
 		var char c = pattern.at(i)
 		if (c as int) == 92 {
@@ -1159,8 +1270,8 @@ func capture_count = (string pattern, out int) {
 // open_pos: one more than the number of capture opens before it in the
 // pattern (the whole match is group 0).
 func group_index_at = (string pattern, int open_pos, out int) {
-	var int count = 0
-	var int i = 0
+	var count = 0
+	var i = 0
 	while i < open_pos; i += 1 {
 		var char c = pattern.at(i)
 		if (c as int) == 92 {
@@ -1198,7 +1309,7 @@ func record_capture = (ref List<int> caps, int group, int start, int end) {
 // has no entry. Entries are (group, start, end) triples.
 func last_capture_index = (List<int> caps, int group, out int) {
 	var int best = -1
-	var int i = 0
+	var i = 0
 	while i < caps.length; i += 3 {
 		if caps.at(i) == group {
 			best = i
@@ -1211,11 +1322,11 @@ func last_capture_index = (List<int> caps, int group, out int) {
  * A Regex.find result: whether the pattern matched, where, and what
  **/
 pub struct RegexMatch {
-	var bool found = false
-	var int start = 0
-	var int end = 0
-	var int length = 0
-	var string text = ""
+	var found = false
+	var start = 0
+	var end = 0
+	var length = 0
+	var text = ""
 }
 
 // Whether the escaped character c (the byte after a backslash) is a
@@ -1233,7 +1344,14 @@ func backref_group = (char c, out int) {
 // Match the text capture group `group` last matched, at in_pos. Returns the
 // position after the span, or -1 when the group has no span here (it did not
 // participate) or the text differs.
-func match_backref = (string input, int group, int in_pos, int in_len, ref List<int> caps, out int) {
+func match_backref = (
+	string input,
+	int group,
+	int in_pos,
+	int in_len,
+	ref List<int> caps,
+	out int
+) {
 	var int at = last_capture_index(caps, group)
 	if at < 0 {
 		return -1
@@ -1246,7 +1364,7 @@ func match_backref = (string input, int group, int in_pos, int in_len, ref List<
 	if in_pos + len > in_len {
 		return -1
 	}
-	var int i = 0
+	var i = 0
 	while i < len; i += 1 {
 		if input.at(in_pos + i) != input.at(s + i) {
 			return -1
@@ -1372,22 +1490,22 @@ func shorthand_members = (char c, ref StringBuilder sb, out int) {
 		return -1
 	}
 	if kind == 100 {
-		var int code = 48
+		var code = 48
 		while code <= 57; code += 1 {
 			sb.append_char(code as char)
 		}
 		return 0
 	}
 	if kind == 119 {
-		var int code = 48
+		var code = 48
 		while code <= 57; code += 1 {
 			sb.append_char(code as char)
 		}
-		var int upper = 65
+		var upper = 65
 		while upper <= 90; upper += 1 {
 			sb.append_char(upper as char)
 		}
-		var int lower = 97
+		var lower = 97
 		while lower <= 122; lower += 1 {
 			sb.append_char(lower as char)
 		}
@@ -1395,7 +1513,7 @@ func shorthand_members = (char c, ref StringBuilder sb, out int) {
 		return 0
 	}
 	// \s: tab, LF, VT, FF, CR, space
-	var int w = 9
+	var w = 9
 	while w <= 13; w += 1 {
 		sb.append_char(w as char)
 	}

package/core/System/Text/Utf8.nm

@@ -45,8 +45,8 @@ pub struct Utf8 {
 		if b0 < 0xF0 {
 			// E0 forbids second bytes below A0 (overlong); ED forbids
 			// AA-BF (surrogate halves).
-			var int lo = 0x80
-			var int hi = 0xBF
+			var lo = 0x80
+			var hi = 0xBF
 			if b0 == 0xE0 {
 				lo = 0xA0
 			}
@@ -68,8 +68,8 @@ pub struct Utf8 {
 		}
 		// F0 forbids second bytes below 90 (overlong); F4 forbids above 8F
 		// (past U+10FFFF).
-		var int lo = 0x80
-		var int hi = 0xBF
+		var lo = 0x80
+		var hi = 0xBF
 		if b0 == 0xF0 {
 			lo = 0x90
 		}
@@ -138,8 +138,8 @@ pub struct Utf8 {
 	// Count the code points in text (one pass; malformed bytes each count
 	// as one U+FFFD).
 	pub func char_count = (view string text, out int) {
-		var int n = 0
-		var int pos = 0
+		var n = 0
+		var pos = 0
 		var int len = text.length
 		while pos < len {
 			pos = pos + Utf8.width_at(text, pos)

package/core/System/Thread.nm

@@ -21,7 +21,9 @@
 // The pool infrastructure (types, worker loop, submit, shutdown, cancel
 // thread-local) lives in build_spawn_node and is emitted as file-scope C
 // on the first spawn — not in Thread's own methods — so that Thread can be
-// generic without duplicating the pool per instantiation.
+// generic without duplicating the pool per instantiation. The construction
+// (`Thread(fn(args))`, the deferred-call special form) is compiler-emitted;
+// `.start()` / `.detach()` are regular methods over the runtime seam.
 //
 // MUST-START: a Thread value that is destroyed without ever being started
 // is a programming error — #destroy reports it and aborts. start/detach
@@ -30,10 +32,23 @@
 //
 // See ASYNC.md for the design.
 
+// The launch surface's return type (ASYNC.md: the dependency is
+// declared by the library file, not inferred from user-source tokens).
+import Task
+
 /**
  * A deferred function call, startable on the shared worker pool
  **/
-pub class Thread<T> : Sendable {
+pub class Thread<T> : Sendable, Spawnable<T> {
+	// The construction hook (ASYNC.md): declares this class's
+	// construction as the deferred-call special form — the single argument
+	// is a call (args packed eagerly, call deferred) or a zero-arg function
+	// value. The compiler matches this member, never the class name; the
+	// construction itself is compiler-generated (pack the args, allocate the
+	// future machinery, build the instance), so the body is a declaration.
+	#spawn = () {
+	}
+
 	// The packed task closure (a `struct nomen_closure *`); owned by this
 	// value until start/detach/nursery.start transfers it to the runtime.
 	pub var uint64 task = 0
@@ -43,6 +58,107 @@ pub class Thread<T> : Sendable {
 	pub var uint64 future = 0
 	// Must-start flag: set by .start() / .detach() / nursery.start.
 	pub var started = false
+	// LEXICAL NURSERY CAPTURE (ASYNC.md): the tracking slots of the
+	// `async` block that lexically encloses the CONSTRUCTION, or 0 when the
+	// construction is outside any block. `.start()` registers the future
+	// through these stored pointers, so registration follows the scope that
+	// created the deferred call — not the one that happens to start it — and
+	// works through an indirect receiver. The pointers address the block's
+	// own futures list slots (the block cannot exit until every registered
+	// task has finished, so a started-before-exit task never registers into
+	// dead storage).
+	pub var uint64 nursery_futures = 0
+	pub var uint64 nursery_count = 0
+	pub var uint64 nursery_cap = 0
+
+	// Start the deferred call on the shared worker pool and yield the
+	// Task<T> handle. Consumes the instance's launch machinery (submit, then
+	// register with the construction-time nursery, if any) and zeroes the
+	// fields, so #destroy becomes a no-op afterwards. The future's refs
+	// account for the trampoline, the returned handle, and the nursery (when
+	// captured).
+	pub func start = (ref self, move out Task<T>) {
+		```
+		#arch: c
+		struct nomen_future *_f = (struct nomen_future *)self->future;
+		_f->refs = self->nursery_futures ? 3 : 2;
+		__nomen_pool_submit((struct nomen_closure *)self->task);
+		if (self->nursery_futures) {
+			__nomen_nursery_track((void **)self->nursery_futures, (int *)self->nursery_count, (int *)self->nursery_cap, _f);
+		}
+		```
+		```
+		#arch: aarch64
+		// x19 = self. f = self->future (#32); nursery_futures at #48.
+		ldr x0, [x19, #32]
+		ldr x1, [x19, #48]
+		mov w2, #2
+		cbz x1, .Lnomen_start_refs
+		mov w2, #3
+		.Lnomen_start_refs:
+		str w2, [x0, #116]
+		// __nomen_pool_submit(self->task)
+		ldr x0, [x19, #8]
+		bl ___nomen_pool_submit
+		// if (self->nursery_futures) __nomen_nursery_track(futures, count, cap, f)
+		ldr x0, [x19, #48]
+		cbz x0, .Lnomen_start_notrack
+		ldr x1, [x19, #56]
+		ldr x2, [x19, #64]
+		ldr x3, [x19, #32]
+		bl ___nomen_nursery_track
+		.Lnomen_start_notrack:
+		```
+		// The handle is a fresh heap Task built through the internal #init;
+		// the caller owns it (a discarded statement form is reclaimed at
+		// scope exit, releasing its refs share).
+		var t = Task<T>()
+		t.result_slot = self.result_slot
+		t.cancel_flag = self.cancel_flag
+		t.future = self.future
+		// Transfer the handles out of the instance: the runtime owns
+		// everything now, and #destroy must not touch (or must-start-abort).
+		self.task = 0
+		self.future = 0
+		self.result_slot = 0
+		self.cancel_flag = 0
+		self.started = true
+		return t
+	}
+
+	// Run the deferred call on a dedicated detached pthread — the daemon
+	// form. Never a pool worker, never joined; process exit kills it
+	// mid-execution BY DESIGN. The unused future (a Thread always carries
+	// the full machinery) is released — first detaching the closure from it,
+	// so the daemon runner owns the closure now.
+	pub func detach = (ref self) {
+		```
+		#arch: c
+		struct nomen_future *_uf = (struct nomen_future *)self->future;
+		if (_uf) {
+			_uf->owner_args = NULL;
+			__nomen_future_release(_uf);
+		}
+		__nomen_task_detach((struct nomen_closure *)self->task);
+		```
+		```
+		#arch: aarch64
+		// if (self->future) { owner_args = NULL; release it }
+		ldr x0, [x19, #32]
+		cbz x0, .Lnomen_detach_nofut
+		str xzr, [x0, #136]
+		bl ___nomen_future_release
+		.Lnomen_detach_nofut:
+		// __nomen_task_detach(self->task)
+		ldr x0, [x19, #8]
+		bl ___nomen_task_detach
+		```
+		self.task = 0
+		self.future = 0
+		self.result_slot = 0
+		self.cancel_flag = 0
+		self.started = true
+	}
 
 	// Destroying an unstarted Thread is a programming error (the wrapped
 	// call would silently never run) — report it and abort. A started

package/core/System/Tree.nm

@@ -7,7 +7,7 @@
  * A tree of values connected by parent/child links
  **/
 pub struct Tree<T>: Enumerable {
-	var Buffer<T> values = Buffer<T>()
+	var values = Buffer<T>()
 	var lefts = Buffer<int>()
 	var rights = Buffer<int>()
 	var parents = Buffer<int>()