nomen-lang 0.8.0 → 0.10.0

package/core/System/Tree.nm

@@ -13,7 +13,7 @@ pub mv struct Tree<T>: Enumerable {
 	var parents = Buffer<int>()
 	var count = 0
 
-	pub func add = (ref self, mv T value) {
+	pub func add = (ref self { lefts, parents, rights, values }, mv T value) {
 		const int idx = self.count
 		self.values.grow_int(idx + 1)
 		const int v = value
@@ -27,12 +27,12 @@ pub mv struct Tree<T>: Enumerable {
 		self.count = self.count + 1
 	}
 
-	pub func set_left = (ref self, int idx, int left) {
+	pub func set_left = (ref self { lefts, parents }, int idx, int left) {
 		self.lefts.store_int(idx, left)
 		self.parents.store_int(left, idx)
 	}
 
-	pub func set_right = (ref self, int idx, int right) {
+	pub func set_right = (ref self { parents, rights }, int idx, int right) {
 		self.rights.store_int(idx, right)
 		self.parents.store_int(right, idx)
 	}
@@ -57,6 +57,22 @@ pub mv struct Tree<T>: Enumerable {
 		return self.values.load_int(idx)
 	}
 
+	// Bounds-checked access: `fallback` when idx is outside [0, self.count).
+	pub func at_or = (self, int idx, T fallback, out T) {
+		if idx >= 0 && idx < self.count {
+			return self.at(idx)
+		}
+		return fallback
+	}
+
+	// Bounds-checked access that traps when idx is outside [0, self.count).
+	pub func at_or_panic = (self, int idx, out T) {
+		if idx >= 0 && idx < self.count {
+			return self.at(idx)
+		}
+		panic("index out of range")
+	}
+
 	pub func count_nodes = (self, int idx, out int) {
 		if idx == -1 {
 			return 0

package/core/System/float.nm

@@ -5,37 +5,51 @@ pub struct float: Stringable {
 	pub func to_string = (self, mv out string) {
 		```
 		#arch: c
-		int length = snprintf(NULL, 0, "%f", self);
-		char* str = malloc(length + 1);
-		snprintf(str, length + 1, "%f", self);
-		// Fat-string ABI: snprintf already counted the bytes.
+		// Single snprintf into a stack scratch (360 bytes covers "%f" of the
+		// largest double: 309 integer digits + '.' + 6 decimals + sign), then
+		// one malloc + memcpy — no sizing pass, no second format.
+		char tmp[360];
+		int length = snprintf(tmp, sizeof(tmp), "%f", self);
+		char* str = (char*)malloc((size_t)length + 1);
+		memcpy(str, tmp, (size_t)length);
+		str[length] = 0;
 		return (nomen_string){ str, length };
 		```
 		```
 		#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
+		// x19 = self (the double). Render into a 360-byte scratch at
+		// [sp+16]; [sp+0] is snprintf's variadic stack slot (Darwin passes
+		// variadic args on the stack), reused after the call for the
+		// length; [sp+8] holds buf.
+		sub sp, sp, #400
+		add x0, sp, #16
+		mov x1, #360
 		adr x2, .Lfmt_float_f
 		fmov d0, x19
+		str d0, [sp, #0]           // variadic double slot
 		bl _snprintf
+		str x0, [sp, #0]           // length
 		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_float_f
-		fmov d0, x19
-		bl _snprintf
-		mov x1, x0
-		ldr x0, [sp, #72]
-		add sp, sp, #128
+		str x0, [sp, #8]           // buf
+		ldr x1, [sp, #0]
+		add x2, sp, #16            // src
+		mov x3, x1
+		.Lft_cl:
+		cbz x3, .Lft_done
+		ldrb w4, [x2]
+		strb w4, [x0]
+		add x2, x2, #1
+		add x0, x0, #1
+		sub x3, x3, #1
+		b .Lft_cl
+		.Lft_done:
+		ldr x0, [sp, #8]
+		add x2, x0, x1
+		strb wzr, [x2]             // buf[length] = 0
+		ldr x0, [sp, #8]
+		ldr x1, [sp, #0]
+		add sp, sp, #400
 		b .Lend_float_to_string
 		.Lfmt_float_f: .asciz "%f"
 		.p2align 2

package/core/System/int.nm

@@ -2,6 +2,17 @@
  * A signed integer — the default integer type
  **/
 pub struct int: Stringable, Hashable, Equatable {
+
+	// The divisor contract (SPEC, Division and Modulo by Zero): scalar
+	// arithmetic lowers natively, so these declarations are the contract
+	// signatures the checker enforces at every `/` and `%` site.
+	func #op_div = (self, int divisor: divisor != 0, out int) {
+		return self / divisor
+	}
+
+	func #op_mod = (self, int divisor: divisor != 0, out int) {
+		return self % divisor
+	}
 	pub func hash = (self, out uint) {
 		return self as uint
 	}
@@ -9,39 +20,80 @@ pub struct int: Stringable, Hashable, Equatable {
 	pub func to_string = (self, mv out string) {
 		```
 		#arch: c
-		int length = snprintf(NULL, 0, "%ld", self);
-		char* str = malloc(length + 1);
-		snprintf(str, length + 1, "%ld", self);
-		// Fat-string ABI: snprintf already counted the bytes.
-		return (nomen_string){ str, length };
+		// Single pass: render the digits into a stack scratch (24 bytes
+		// covers INT64_MIN's sign + 19 digits + slack), then one malloc and
+		// one memcpy. The old body paid two snprintf passes over the value.
+		long v = self;
+		char tmp[24];
+		int pos = 24;
+		// Magnitude via the two's-complement negate (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 len = 24 - pos;
+		char* str = (char*)malloc((size_t)len + 1);
+		memcpy(str, tmp + pos, (size_t)len);
+		str[len] = 0;
+		return (nomen_string){ str, len };
 		```
 		```
 		#arch: aarch64
-		sub sp, sp, #128
-		str x0, [sp, #0]
-		str x1, [sp, #8]
-		str x2, [sp, #16]
-		str x3, [sp, #24]
-		mov x0, xzr
-		mov x1, xzr
-		adr x2, .Lfmt_int_ld
-		mov x3, x19
-		bl _snprintf
-		add x0, x0, #1
-		str x0, [sp, #64]
+		// x19 = self (the value). Render digits into a 24-byte scratch, then
+		// malloc(len + 1) + copy. [sp]=len, [sp+8]=buf, [sp+16]=pos across
+		// the malloc call.
+		sub sp, sp, #48
+		mov x9, x19
+		mov x10, x9
+		cmp x9, #0
+		b.ge .Lit_pos
+		neg x10, x10               // magnitude (wraps correctly for INT64_MIN)
+		.Lit_pos:
+		add x11, sp, #48
+		mov x12, x11
+		.Lit_digit:
+		mov x13, #10
+		udiv x14, x10, x13
+		msub x15, x14, x13, x10
+		add x15, x15, #48
+		sub x12, x12, #1
+		strb w15, [x12]
+		mov x10, x14
+		cbnz x10, .Lit_digit
+		cmp x9, #0
+		b.ge .Lit_store
+		sub x12, x12, #1
+		mov w15, #45               // '-'
+		strb w15, [x12]
+		.Lit_store:
+		sub x1, x11, x12           // len
+		str x12, [sp, #16]         // pos
+		str x1, [sp, #0]           // len
+		add x0, x1, #1
 		bl _malloc
-		str x0, [sp, #72]
-		ldr x0, [sp, #72]
-		ldr x1, [sp, #64]
-		adr x2, .Lfmt_int_ld
-		mov x3, x19
-		bl _snprintf
-		mov x1, x0
-		ldr x0, [sp, #72]
-		add sp, sp, #128
+		str x0, [sp, #8]           // buf
+		ldr x1, [sp, #0]
+		ldr x12, [sp, #16]
+		mov x3, x1
+		.Lit_cl:
+		cbz x3, .Lit_done
+		ldrb w4, [x12]
+		strb w4, [x0]
+		add x12, x12, #1
+		add x0, x0, #1
+		sub x3, x3, #1
+		b .Lit_cl
+		.Lit_done:
+		ldr x0, [sp, #8]
+		add x2, x0, x1
+		strb wzr, [x2]             // buf[len] = 0
+		ldr x0, [sp, #8]
+		ldr x1, [sp, #0]
+		add sp, sp, #48
 		b .Lend_int_to_string
-		.Lfmt_int_ld: .asciz "%ld"
-		.p2align 2
 		.Lend_int_to_string:
 		```
 	}

package/core/System/int16.nm

@@ -2,6 +2,17 @@
  * A 16-bit signed integer
  **/
 pub struct int16: Stringable, Hashable, Equatable {
+
+	// The divisor contract (SPEC, Division and Modulo by Zero): scalar
+	// arithmetic lowers natively, so these declarations are the contract
+	// signatures the checker enforces at every `/` and `%` site.
+	func #op_div = (self, int16 divisor: divisor != 0, out int16) {
+		return self / divisor
+	}
+
+	func #op_mod = (self, int16 divisor: divisor != 0, out int16) {
+		return self % divisor
+	}
 	pub func hash = (self, out uint) {
 		return self as uint
 	}

package/core/System/int32.nm

@@ -2,6 +2,17 @@
  * A 32-bit signed integer
  **/
 pub struct int32: Stringable, Hashable, Equatable {
+
+	// The divisor contract (SPEC, Division and Modulo by Zero): scalar
+	// arithmetic lowers natively, so these declarations are the contract
+	// signatures the checker enforces at every `/` and `%` site.
+	func #op_div = (self, int32 divisor: divisor != 0, out int32) {
+		return self / divisor
+	}
+
+	func #op_mod = (self, int32 divisor: divisor != 0, out int32) {
+		return self % divisor
+	}
 	pub func hash = (self, out uint) {
 		return self as uint
 	}

package/core/System/int64.nm

@@ -2,6 +2,17 @@
  * A 64-bit signed integer
  **/
 pub struct int64: Stringable, Hashable, Equatable {
+
+	// The divisor contract (SPEC, Division and Modulo by Zero): scalar
+	// arithmetic lowers natively, so these declarations are the contract
+	// signatures the checker enforces at every `/` and `%` site.
+	func #op_div = (self, int64 divisor: divisor != 0, out int64) {
+		return self / divisor
+	}
+
+	func #op_mod = (self, int64 divisor: divisor != 0, out int64) {
+		return self % divisor
+	}
 	pub func hash = (self, out uint) {
 		return self as uint
 	}

package/core/System/int8.nm

@@ -2,6 +2,17 @@
  * An 8-bit signed integer
  **/
 pub struct int8: Stringable, Hashable, Equatable {
+
+	// The divisor contract (SPEC, Division and Modulo by Zero): scalar
+	// arithmetic lowers natively, so these declarations are the contract
+	// signatures the checker enforces at every `/` and `%` site.
+	func #op_div = (self, int8 divisor: divisor != 0, out int8) {
+		return self / divisor
+	}
+
+	func #op_mod = (self, int8 divisor: divisor != 0, out int8) {
+		return self % divisor
+	}
 	pub func hash = (self, out uint) {
 		return self as uint
 	}

package/core/System/uint.nm

@@ -2,6 +2,17 @@
  * An unsigned integer
  **/
 pub struct uint: Stringable, Hashable, Equatable {
+
+	// The divisor contract (SPEC, Division and Modulo by Zero): scalar
+	// arithmetic lowers natively, so these declarations are the contract
+	// signatures the checker enforces at every `/` and `%` site.
+	func #op_div = (self, uint divisor: divisor != 0, out uint) {
+		return self / divisor
+	}
+
+	func #op_mod = (self, uint divisor: divisor != 0, out uint) {
+		return self % divisor
+	}
 	pub func hash = (self, out uint) {
 		return self
 	}

package/core/System/uint16.nm

@@ -2,6 +2,17 @@
  * A 16-bit unsigned integer
  **/
 pub struct uint16: Stringable, Hashable, Equatable {
+
+	// The divisor contract (SPEC, Division and Modulo by Zero): scalar
+	// arithmetic lowers natively, so these declarations are the contract
+	// signatures the checker enforces at every `/` and `%` site.
+	func #op_div = (self, uint16 divisor: divisor != 0, out uint16) {
+		return self / divisor
+	}
+
+	func #op_mod = (self, uint16 divisor: divisor != 0, out uint16) {
+		return self % divisor
+	}
 	pub func hash = (self, out uint) {
 		return self as uint
 	}

package/core/System/uint32.nm

@@ -2,6 +2,17 @@
  * A 32-bit unsigned integer
  **/
 pub struct uint32: Stringable, Hashable, Equatable {
+
+	// The divisor contract (SPEC, Division and Modulo by Zero): scalar
+	// arithmetic lowers natively, so these declarations are the contract
+	// signatures the checker enforces at every `/` and `%` site.
+	func #op_div = (self, uint32 divisor: divisor != 0, out uint32) {
+		return self / divisor
+	}
+
+	func #op_mod = (self, uint32 divisor: divisor != 0, out uint32) {
+		return self % divisor
+	}
 	pub func hash = (self, out uint) {
 		return self as uint
 	}

package/core/System/uint64.nm

@@ -2,6 +2,17 @@
  * A 64-bit unsigned integer
  **/
 pub struct uint64: Stringable, Hashable, Equatable {
+
+	// The divisor contract (SPEC, Division and Modulo by Zero): scalar
+	// arithmetic lowers natively, so these declarations are the contract
+	// signatures the checker enforces at every `/` and `%` site.
+	func #op_div = (self, uint64 divisor: divisor != 0, out uint64) {
+		return self / divisor
+	}
+
+	func #op_mod = (self, uint64 divisor: divisor != 0, out uint64) {
+		return self % divisor
+	}
 	pub func hash = (self, out uint) {
 		return self as uint
 	}

package/core/System/uint8.nm

@@ -2,6 +2,17 @@
  * An 8-bit unsigned integer
  **/
 pub struct uint8: Stringable, Hashable, Equatable {
+
+	// The divisor contract (SPEC, Division and Modulo by Zero): scalar
+	// arithmetic lowers natively, so these declarations are the contract
+	// signatures the checker enforces at every `/` and `%` site.
+	func #op_div = (self, uint8 divisor: divisor != 0, out uint8) {
+		return self / divisor
+	}
+
+	func #op_mod = (self, uint8 divisor: divisor != 0, out uint8) {
+		return self % divisor
+	}
 	pub func hash = (self, out uint) {
 		return self as uint
 	}

package/core/docs/System/StringBuilder.md

@@ -8,5 +8,11 @@ A growable byte buffer for incrementally building strings (O(1) amortized append
 
 - `ensure(int needed)`
 - `append_char(char c)`
+- `append_int(int n)`
+- `append_float(float f)`
 - `append_string(string s)`
+- `append(view string s)`
+- `append(int n)`
+- `append(float f)`
+- `append(char c)`
 - `to_string() -> string`

package/core/docs/System/Text/JsonTree.md

@@ -2,12 +2,11 @@
 
 ## `struct JsonTree`
 
-A flat, buffer-backed pool of JSON tree nodes — the parsed representation `Json.parse` produces
+A flat, pool-backed set of JSON tree nodes — the parsed representation `Json.parse` produces
 
 **Members:**
 
 - `alloc_node() -> int`
-- `free_text(int idx)`
 - `reset()`
 - `set_text(int idx, string text)`
 - `set_kind(int idx, int val)`
@@ -16,6 +15,8 @@ A flat, buffer-backed pool of JSON tree nodes — the parsed representation `Jso
 - `set_val(int idx, int val)`
 - `get_kind(int idx) -> int`
 - `get_text(int idx) -> string`
+- `get_text_view(int idx) -> view string`
+- `take_text(int idx, ref StringBuilder sb)`
 - `get_child(int idx) -> int`
 - `get_next(int idx) -> int`
 - `get_val(int idx) -> int`