nomen-lang 0.0.17 → 0.0.19

package/core/System/Array.nm

@@ -30,7 +30,7 @@ pub struct Array<T>: Viewable {
 		```
 	}
 
-	pub func at = (self, int index: index >= 0 && index < self.length, out T) {
+	pub inline func at = (self, int index: index >= 0 && index < self.length, out T) {
 		```
 		#arch: c
 		T* _data = (T*)((char*)self + sizeof(*self));
@@ -160,6 +160,26 @@ pub struct Array<T>: Viewable {
 		```
 	}
 
+	// Bounds-checked accessors — the runtime-checked escape hatch for
+	// indices the constraint checker can't prove (see PERF.md gap 5). Unlike
+	// every other Array method these have Nomen-level bodies: the method-call
+	// receiver conventions for Array receivers (first-element pointer on
+	// aarch64, struct Array_<T>* on C) are passed through unchanged, and the
+	// bodies read self.length / self.at through them.
+	pub func at_or = (self, int index, T fallback, out T) {
+		if index >= 0 && index < self.length {
+			return self.at(index)
+		}
+		return fallback
+	}
+
+	pub func at_or_panic = (self, int index, out T) {
+		if index >= 0 && index < self.length {
+			return self.at(index)
+		}
+		panic("index out of range")
+	}
+
 	pub func at_end = (self, out T) {
 		```
 		#arch: c

package/core/System/Buffer.nm

@@ -553,6 +553,78 @@ pub struct Buffer<T> {
 		```
 	}
 
+	// Move slot src into slot dst: overwrite dst with src's bytes and zero
+	// src, so exactly ONE slot owns the value afterwards. The
+	// ownership-transferring primitive behind backward-shift deletion
+	// (Map/Set.remove) — unlike store_T, which gives the slot its own deep
+	// copy and leaves the source slot intact, a shift transfers the source's
+	// heap pointers wholesale. For owning elements (string / value structs
+	// with string fields) the build replaces this body with a specialized
+	// version that also reclaims dst's previous value first (see
+	// owning_buffer_specialize.ts); this raw form is correct for
+	// trivially-destructible elements only.
+	inline func shift_T = (ref self, int dst: dst >= 0 && dst < self.cap, int src: src >= 0 && src < self.cap) {
+		```
+		#arch: c
+		T* _slots = (T*)(unsigned long long)self->data;
+		if (dst != src) {
+			_slots[dst] = _slots[src];
+			memset((void*)&_slots[src], 0, T_SIZE);
+		}
+		```
+		```
+		#arch: aarch64
+		// x19 = self, x1 = dst, x2 = src
+		ldr x4, [x19, #8]
+		mov x3, #T_SIZE
+		madd x5, x1, x3, x4
+		madd x6, x2, x3, x4
+		cmp x5, x6
+		b.eq .Lbuffer_shift_T_end
+		cmp x3, #8
+		b.gt .Lbuffer_shift_T_copy
+		// Width-matched move: an 8-byte access on a sub-8 element would
+		// clobber the following slot (and run past the slab's end).
+		cmp x3, #1
+		b.eq .Lbuffer_shift_T_1
+		cmp x3, #2
+		b.eq .Lbuffer_shift_T_2
+		cmp x3, #4
+		b.eq .Lbuffer_shift_T_4
+		ldr x7, [x6]
+		str x7, [x5]
+		str xzr, [x6]
+		b .Lbuffer_shift_T_end
+		.Lbuffer_shift_T_1:
+		ldrb w7, [x6]
+		strb w7, [x5]
+		strb wzr, [x6]
+		b .Lbuffer_shift_T_end
+		.Lbuffer_shift_T_2:
+		ldrh w7, [x6]
+		strh w7, [x5]
+		strh wzr, [x6]
+		b .Lbuffer_shift_T_end
+		.Lbuffer_shift_T_4:
+		ldr w7, [x6]
+		str w7, [x5]
+		str wzr, [x6]
+		b .Lbuffer_shift_T_end
+		.Lbuffer_shift_T_copy:
+		mov x0, x5
+		mov x1, x6
+		mov x2, x3
+		stp x5, x6, [sp, #-16]!
+		bl _memcpy
+		ldp x5, x6, [sp], #16
+		mov x0, x6
+		mov x1, #0
+		mov x2, x3
+		bl _memset
+		.Lbuffer_shift_T_end:
+		```
+	}
+
 	// A non-owning (ptr, len) slice [start, end) over this buffer's element
 	// storage, returned as a `view T`. It borrows from self: it may not outlive
 	// self's scope and is invalidated if self is reassigned. This is the single

package/core/System/ClassBuffer.nm

@@ -299,6 +299,51 @@ pub struct ClassBuffer<T> {
 		```
 	}
 
+	// Move slot src into slot dst: reclaim dst's previous instance (destroy +
+	// free), take over src's pointer, and zero src — exactly one slot owns the
+	// instance afterwards. The class-buffer counterpart of Buffer.shift_T,
+	// used by Map/Set.remove's backward-shift so shifting entries neither
+	// duplicates nor orphans owned instances.
+	func shift_T = (ref self, int dst: dst >= 0 && dst < self.cap, int src: src >= 0 && src < self.cap) {
+		```
+		#arch: c
+		long *slots = (long*)(unsigned long long)self->data;
+		if (dst != src) {
+			if (slots[dst]) {
+				T_destroy((void*)slots[dst]);
+				free((void*)slots[dst]);
+			}
+			slots[dst] = slots[src];
+			slots[src] = 0;
+		}
+		```
+		```
+		#arch: aarch64
+		stp x20, x21, [sp, #-16]!
+		str x22, [sp, #-16]!
+		ldr x9, [x19, #8]
+		lsl x3, x1, #3
+		add x20, x9, x3
+		lsl x3, x2, #3
+		add x21, x9, x3
+		cmp x20, x21
+		b.eq .Lcb_shift_T_done
+		ldr x0, [x20]
+		cbz x0, .Lcb_shift_T_move
+		mov x22, x0
+		bl T_destroy
+		mov x0, x22
+		bl _free
+		.Lcb_shift_T_move:
+		ldr x9, [x21]
+		str x9, [x20]
+		str xzr, [x21]
+		.Lcb_shift_T_done:
+		ldr x22, [sp], #16
+		ldp x20, x21, [sp], #16
+		```
+	}
+
 	// A non-owning (ptr, len) slice [start, end) over this buffer's class
 	// pointers, returned as a `view T` (T is a class, so each element is an
 	// 8-byte pointer). Borrows from self — invalidated on reassignment. Mirrors

package/core/System/List.nm

@@ -27,7 +27,7 @@ pub struct List<T>: Viewable {
 		return self.items.move_T(idx)
 	}
 
-	pub func at = (self, int i: i >= 0 && i < self.length, out T) {
+	pub inline func at = (self, int i: i >= 0 && i < self.length, out T) {
 		return self.items.load_T(i)
 	}
 

package/core/System/Map.nm

@@ -134,8 +134,13 @@ pub struct Map<TK: Hashable + Equatable, TV> {
 				dk = dk + cap
 			}
 			if dgap < dk {
-				self.keys.store_T(gap, self.keys.load_T(k))
-				self.values.store_T(gap, self.values.load_T(k))
+				// shift_T (not store_T): transfers the entry's owned pointers
+				// wholesale and reclaims the displaced slot's value. store_T
+				// would strdup a fresh copy into gap while leaving the source
+				// slot's pointer stranded at the vacated slot — leaked once
+				// used.store marks it empty (the buffer destroy skips it).
+				self.keys.shift_T(gap, k)
+				self.values.shift_T(gap, k)
 				self.used.store(gap, 1)
 				gap = k
 			}

package/core/System/Set.nm

@@ -117,7 +117,12 @@ pub struct Set<T: Hashable + Equatable> {
 				dk = dk + cap
 			}
 			if dgap < dk {
-				self.slots.store_T(gap, self.slots.load_T(k))
+				// shift_T (not store_T): transfers the entry wholesale and
+				// reclaims the displaced slot's value — store_T would strdup a
+				// fresh copy into gap while stranding the source slot's
+				// pointer at the vacated slot (leaked once used.store marks it
+				// empty; the buffer destroy skips unused slots).
+				self.slots.shift_T(gap, k)
 				self.used.store(gap, 1)
 				gap = k
 			}

package/core/docs/System/Array.md

@@ -7,6 +7,8 @@ A fixed-length array of values, created with a literal (`[1, 2, 3]`) and address
 **Members:**
 
 - `at(int index) -> T`
+- `at_or(int index, T fallback) -> T`
+- `at_or_panic(int index) -> T`
 - `first() -> T`
 - `set(int index, T value)`
 - `at_end() -> T`