nomen-lang 0.0.15 → 0.0.17

package/core/System/Buffer.nm

@@ -356,7 +356,11 @@ pub struct Buffer<T> {
 		```
 	}
 
-	func load_T = (self, int i: i >= 0 && i < self.cap, out T) {
+	// `inline` splices the (width-folded at monomorphization) raw body at
+	// call sites — the load/store pair behind every container `.at`/`set` is
+	// the hottest path in data-heavy code, and the naked-inline path keeps it
+	// to a handful of instructions with no call overhead.
+	inline func load_T = (self, int i: i >= 0 && i < self.cap, out T) {
 		```
 		#arch: c
 		return ((T*)(unsigned long long)self->data)[i];
@@ -399,7 +403,7 @@ pub struct Buffer<T> {
 		```
 	}
 
-	func store_T = (ref self, int i: i >= 0 && i < self.cap, T val) {
+	inline func store_T = (ref self, int i: i >= 0 && i < self.cap, T val) {
 		```
 		#arch: c
 		((T*)(unsigned long long)self->data)[i] = val;

package/core/System/LinkedList.nm

@@ -57,6 +57,22 @@ pub struct LinkedList<T>: Enumerable {
 		return self.values.load_T(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 length = (self, out int) {
 		return self.count
 	}

package/core/System/List.nm

@@ -31,6 +31,26 @@ pub struct List<T>: Viewable {
 		return self.items.load_T(i)
 	}
 
+	// Bounds-checked access: `fallback` when i is outside [0, self.length) —
+	// for indices that can't be proven at compile time and out-of-range is an
+	// expected case.
+	pub func at_or = (self, int i, T fallback, out T) {
+		if i >= 0 && i < self.length {
+			return self.at(i)
+		}
+		return fallback
+	}
+
+	// Bounds-checked access that traps when i is outside [0, self.length) —
+	// for indices that can't be proven at compile time and out-of-range is a
+	// bug, not a case.
+	pub func at_or_panic = (self, int i, out T) {
+		if i >= 0 && i < self.length {
+			return self.at(i)
+		}
+		panic("index out of range")
+	}
+
 	// A non-owning `view T` over [start, end). Delegates to the backing Buffer's
 	// #arch slice primitive — no #arch code here. Borrows from self.
 	pub func slice = (self, int start: start >= 0, int end: end >= start, out view T) {

package/core/System/Map.nm

@@ -1,7 +1,12 @@
 /**
- * An ordered key-value map with `set`/`get`/`has`/`remove`. Keys must be
+ * An ordered key-value map with `set`/`get`/`get_or`/`has`/`remove`. Keys must be
  * `Hashable` (hashed to a `uint` via `key.hash()`) and `Equatable` (compared
  * with `==`); values may be any type.
+ *
+ * The capacity is always a power of two (initial 8, doubling on rehash), so
+ * bucket indexing is a mask (`hash & (cap - 1)`) instead of a division — and
+ * it is correct for negative hashes too: two's-complement `&` already lands
+ * in `[0, cap)`, which is why no negative adjustment is needed.
  **/
 pub struct Map<TK: Hashable + Equatable, TV> {
 	var length = 0
@@ -53,6 +58,34 @@ pub struct Map<TK: Hashable + Equatable, TV> {
 		return self.values.load_T(idx)
 	}
 
+	// Fused lookup-with-fallback: one probe instead of the `has` + `get`
+	// pair (which probes twice) for the common "default when missing" shape.
+	pub func get_or = (self, TK key, TV fallback, out TV) {
+		var int cap = self.keys.cap
+		if cap == 0 {
+			return fallback
+		}
+		var int idx = self.find_slot(key, cap)
+		if self.used.load(idx) == 0 {
+			return fallback
+		}
+		return self.values.load_T(idx)
+	}
+
+	// Lookup that traps when the key is absent — for when a missing key is
+	// a bug, not a case (and `get`'s 0-for-missing would be ambiguous).
+	pub func get_or_panic = (self, TK key, out TV) {
+		var int cap = self.keys.cap
+		if cap == 0 {
+			panic("key not found")
+		}
+		var int idx = self.find_slot(key, cap)
+		if self.used.load(idx) == 0 {
+			panic("key not found")
+		}
+		return self.values.load_T(idx)
+	}
+
 	pub func has = (self, TK key, out bool) {
 		var int cap = self.keys.cap
 		if cap == 0 {
@@ -91,10 +124,7 @@ pub struct Map<TK: Hashable + Equatable, TV> {
 			if self.used.load(k) == 0 {
 				break
 			}
-			var int home = (self.keys.load_T(k).hash() as int) % cap
-			if home < 0 {
-				home = home + cap
-			}
+			var int home = (self.keys.load_T(k).hash() as int) & (cap - 1)
 			var int dgap = gap - home
 			if dgap < 0 {
 				dgap = dgap + cap
@@ -115,10 +145,9 @@ pub struct Map<TK: Hashable + Equatable, TV> {
 	}
 
 	func find_slot = (self, TK key, int cap, out int: out >= 0 && out < cap) {
-		var int idx = (key.hash() as int) % cap
-		if idx < 0 {
-			idx = idx + 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.
+		var int idx = (key.hash() as int) & (cap - 1)
 		while self.used.load(idx) != 0 {
 			if self.keys.load_T(idx) == key {
 				return idx

package/core/System/Set.nm

@@ -2,6 +2,10 @@
  * An ordered set of unique values (`add`/`has`/`get`/`remove`). Elements must
  * be `Hashable` (hashed to a `uint` via `value.hash()`) and `Equatable`
  * (compared with `==`).
+ *
+ * The capacity is always a power of two (initial 8, doubling on rehash), so
+ * slot indexing is a mask (`hash & (cap - 1)`) — correct for negative hashes
+ * too (two's-complement `&` already lands in `[0, cap)`).
  **/
 pub struct Set<T: Hashable + Equatable> {
 	var length = 0
@@ -47,6 +51,33 @@ pub struct Set<T: Hashable + Equatable> {
 		return self.slots.load_T(idx)
 	}
 
+	// Membership lookup with a fallback value: `fallback` when the value is
+	// not in the set (one probe instead of the `has` + `get` pair).
+	pub func get_or = (self, T key, T fallback, out T) {
+		var int cap = self.slots.cap
+		if cap == 0 {
+			return fallback
+		}
+		var int idx = self.find_slot(key, cap)
+		if self.used.load(idx) == 0 {
+			return fallback
+		}
+		return self.slots.load_T(idx)
+	}
+
+	// Membership lookup that traps when the value is not in the set.
+	pub func get_or_panic = (self, T key, out T) {
+		var int cap = self.slots.cap
+		if cap == 0 {
+			panic("value not found in set")
+		}
+		var int idx = self.find_slot(key, cap)
+		if self.used.load(idx) == 0 {
+			panic("value not found in set")
+		}
+		return self.slots.load_T(idx)
+	}
+
 	pub func remove = (ref self, T value) {
 		var int cap = self.slots.cap
 		if cap == 0 {
@@ -76,10 +107,7 @@ pub struct Set<T: Hashable + Equatable> {
 			if self.used.load(k) == 0 {
 				break
 			}
-			var int home = (self.slots.load_T(k).hash() as int) % cap
-			if home < 0 {
-				home = home + cap
-			}
+			var int home = (self.slots.load_T(k).hash() as int) & (cap - 1)
 			var int dgap = gap - home
 			if dgap < 0 {
 				dgap = dgap + cap
@@ -99,10 +127,9 @@ pub struct Set<T: Hashable + Equatable> {
 	}
 
 	func find_slot = (self, T value, int cap, out int: out >= 0 && out < cap) {
-		var int idx = (value.hash() as int) % cap
-		if idx < 0 {
-			idx = idx + cap
-		}
+		// cap is a power of two: `hash mod cap` via a mask, non-negative
+		// for any hash — no adjustment needed.
+		var int idx = (value.hash() as int) & (cap - 1)
 		while self.used.load(idx) != 0 {
 			if self.slots.load_T(idx) == value {
 				return idx

package/core/System/String.nm

@@ -51,6 +51,24 @@ pub struct string: Stringable, Hashable, Equatable {
 		```
 	}
 
+	// Bounds-checked access: `fallback` when index is outside
+	// [0, self.length).
+	pub func at_or = (self, int index, char fallback, out char) {
+		if index >= 0 && index < self.length {
+			return self.at(index)
+		}
+		return fallback
+	}
+
+	// Bounds-checked access that traps when index is outside
+	// [0, self.length) — out-of-range is a bug, not a case.
+	pub func at_or_panic = (self, int index, out char) {
+		if index >= 0 && index < self.length {
+			return self.at(index)
+		}
+		panic("index out of range")
+	}
+
 	// A non-owning slice [start, end) into self's buffer. Returns a `view
 	// string` (ptr, len) that borrows from self: it may not outlive self's
 	// scope and is invalidated if self is reassigned. Use .to_string() to