nomen-lang 0.7.0 → 0.8.0

package/core/System/List.nm

@@ -73,6 +73,40 @@ pub mv struct List<T>: Viewable {
 		panic("index out of range")
 	}
 
+	// Address of element `i` (library-only): the ELEMENT BORROW primitive —
+	// `ref T x = list.at(i)` (docs/HANDLERS.md Stage 4, dynamic-tree
+	// dispatch) lowers to this, binding the alias to the slot itself rather
+	// than to a bitwise copy. The pointer is valid while the list is
+	// exclusively borrowed and not resized; a `ref self` call on the list
+	// invalidates the borrow through the ordinary borrow-invalidation
+	// rules. The length constraint is the caller's proof obligation — the
+	// handler desugar's synthesized loops satisfy it from the loop
+	// condition, exactly like `.at`.
+	pub func slot_ptr = (ref self, int i: i >= 0 && i < self.length, out ptr T) {
+		return self.items.slot_ptr(i)
+	}
+
+	// Bounds-checked removal that traps when i is outside [0, self.length) —
+	// same contract as at_or_panic/set_or_panic, for indices that can't be
+	// proven at compile time. The element is moved out (later elements
+	// backward-shift into place) and returned: the caller owns it, so its
+	// resources are reclaimed when the binding's scope ends — binding the
+	// result in a nested block is the way to free an owning element at a
+	// chosen point (its #destroy runs at the block's closing brace).
+	pub func remove_at_or_panic = (ref self, int i, mv out T) {
+		if i < 0 || i >= self.length {
+			panic("index out of range")
+		}
+		var T v = self.items.move(i)
+		var int last = self.length - 1
+		var int j = i
+		while j < last; j += 1 {
+			self.items.shift(j, j + 1)
+		}
+		self.length -= 1
+		return v
+	}
+
 	// A deep copy: a fresh List<T> with an independent copy of every element.
 	// For mv element types (strings, mv value structs) each slot in the
 	// copy owns its own heap data (Buffer deep-copies on store), so the source

package/core/System/Map.nm

@@ -17,13 +17,16 @@ pub mv struct Map<TK: Hashable + Equatable, TV> {
 	// Variadic-tuple constructor: Map<string, int>(["a", 1], ["b", 2]) or
 	// Map(["a", 1], ["b", 2]) (type args inferred from the first pair).
 	// Zero pairs yields an empty Map, so this also covers Map<K, V>().
-	// The pair reads are temp-rooted (`pairs.at(i)` is a statement temp):
-	// the element transfer is absorbed by set's mv store (store_T
-	// deep-copies string-field elements), so no explicit mv is spelled.
+	// Each pair is read into a local and its fields are MV-DESTRUCTURED into
+	// bindings, so set's mv store receives an explicit transfer chain — no
+	// temp-rooted read exemption involved. (String bindings lower as the
+	// borrow-copy convention: the slot's owner reclaims heap bytes, and the
+	// callee materializes its own copy.)
 	pub func #init = (self, ...[TK, TV] pairs) {
 		var i = 0
 		while i < pairs.length; i += 1 {
-			self.set(pairs.at(i)._0, pairs.at(i)._1)
+			var [mv k, mv v] = pairs.at(i)
+			self.set(mv k, mv v)
 		}
 	}
 
@@ -155,6 +158,20 @@ pub mv struct Map<TK: Hashable + Equatable, TV> {
 		self.length = self.length - 1
 	}
 
+	// An independent copy: a fresh Map whose every member slab is a fresh
+	// `Buffer.copy` (which deep-copies mv key/value elements), with the same
+	// length and entries. Not available for class/trait keys or values (the
+	// member routes to ClassBuffer, which has no copy — the checker rejects
+	// the call; see the copy gate in check_access_node).
+	pub func copy = (self, out Map<TK, TV>) {
+		var dst = Map<TK, TV>()
+		dst.keys = self.keys.copy()
+		dst.values = self.values.copy()
+		dst.used = self.used.copy()
+		dst.length = self.length
+		return dst
+	}
+
 	func find_slot = (self, TK key, int cap, out int: out >= 0 && out < cap) {
 		// cap is a power of two, so this is `hash mod cap` via a mask —
 		// non-negative for any hash (two's complement), no adjustment.

package/core/System/Set.nm

@@ -131,6 +131,20 @@ pub mv struct Set<T: Hashable + Equatable> {
 		self.length = self.length - 1
 	}
 
+	// An independent copy: a fresh Set whose both member slabs are fresh
+	// `Buffer.copy` calls (which deep-copy mv elements), with the same length
+	// and entries. Not available for class/trait elements (the member routes
+	// to ClassBuffer, which has no copy — the checker rejects the call; the
+	// shape is also unreachable today since `T: Hashable + Equatable` cannot
+	// be a trait without trait-conformance syntax).
+	pub func copy = (self, out Set<T>) {
+		var dst = Set<T>()
+		dst.slots = self.slots.copy()
+		dst.used = self.used.copy()
+		dst.length = self.length
+		return dst
+	}
+
 	func find_slot = (self, T value, int cap, out int: out >= 0 && out < cap) {
 		// cap is a power of two: `hash mod cap` via a mask, non-negative
 		// for any hash — no adjustment needed.