nomen-lang 0.0.11 → 0.0.13

package/core/System/Map.nm

@@ -1,7 +1,9 @@
 /**
- * An ordered key-value map with `set`/`get`/`has`/`remove`
+ * An ordered key-value map with `set`/`get`/`has`/`remove`. Keys must be
+ * `Hashable` (hashed to a `uint` via `key.hash()`) and `Equatable` (compared
+ * with `==`); values may be any type.
  **/
-pub struct Map<TK, TV> {
+pub struct Map<TK: Hashable + Equatable, TV> {
 	var length = 0
 	var Buffer<TK> keys = Buffer<TK>()
 	var Buffer<TV> values = Buffer<TV>()
@@ -20,8 +22,8 @@ pub struct Map<TK, TV> {
 	pub func set = (ref self, mov TK key, mov TV value) {
 		var int cap = self.keys.cap
 		if cap == 0 {
-			cap = self.keys.alloc_int(8)
-			self.values.alloc_int(8)
+			cap = self.keys.alloc_T(8)
+			self.values.alloc_T(8)
 			self.used.alloc(8)
 		}
 		if self.length * 4 >= cap * 3 {
@@ -31,11 +33,11 @@ pub struct Map<TK, TV> {
 		var int idx = self.find_slot(key, cap)
 		if self.used.load(idx) == 0 {
 			self.used.store(idx, 1)
-			self.keys.store_int(idx, key)
-			self.values.store_int(idx, value)
+			self.keys.store_T(idx, key)
+			self.values.store_T(idx, value)
 			self.length += 1
 		} else {
-			self.values.store_int(idx, value)
+			self.values.replace_T(idx, value)
 		}
 	}
 
@@ -48,7 +50,7 @@ pub struct Map<TK, TV> {
 		if self.used.load(idx) == 0 {
 			return 0
 		}
-		return self.values.load_int(idx)
+		return self.values.load_T(idx)
 	}
 
 	pub func has = (self, TK key, out bool) {
@@ -89,7 +91,7 @@ pub struct Map<TK, TV> {
 			if self.used.load(k) == 0 {
 				break
 			}
-			var int home = self.keys.load_int(k) % cap
+			var int home = (self.keys.load_T(k).hash() as int) % cap
 			if home < 0 {
 				home = home + cap
 			}
@@ -102,26 +104,23 @@ pub struct Map<TK, TV> {
 				dk = dk + cap
 			}
 			if dgap < dk {
-				self.keys.store_int(gap, self.keys.load_int(k))
-				self.values.store_int(gap, self.values.load_int(k))
+				self.keys.store_T(gap, self.keys.load_T(k))
+				self.values.store_T(gap, self.values.load_T(k))
 				self.used.store(gap, 1)
 				gap = k
 			}
 		}
 		self.used.store(gap, 0)
-		self.keys.store_int(gap, 0)
-		self.values.store_int(gap, 0)
 		self.length = self.length - 1
 	}
 
 	func find_slot = (self, TK key, int cap, out int: out >= 0 && out < cap) {
-		var int k = key
-		var int idx = k % cap
+		var int idx = (key.hash() as int) % cap
 		if idx < 0 {
 			idx = idx + cap
 		}
 		while self.used.load(idx) != 0 {
-			if self.keys.load_int(idx) == k {
+			if self.keys.load_T(idx) == key {
 				return idx
 			}
 			idx += 1
@@ -138,15 +137,26 @@ pub struct Map<TK, TV> {
 		var Buffer<int> old_used = mov self.used swap Buffer<int>()
 		var int old_cap = old_keys.cap
 
-		self.keys.alloc_int(new_cap)
-		self.values.alloc_int(new_cap)
+		self.keys.alloc_T(new_cap)
+		self.values.alloc_T(new_cap)
 		self.used.alloc(new_cap)
 		self.length = 0
 
 		var i = 0
 		while i < old_cap; i += 1 {
 			if old_used.load(i) != 0 {
-				self.set(old_keys.load_int(i), old_values.load_int(i))
+				// move_T (not load_T) relinquishes the old slot, so each
+				// key/value is owned by exactly one buffer (the new self)
+				// afterwards. load_T would leave the old slot referencing
+				// the same class pointer — a double-free when old_keys is
+				// destroyed. The results are bound to locals so an
+				// owning-element copy (e.g. a `Buffer<string>` slot, which
+				// store_T strdup's) is freed here once the new buffer has
+				// made its own copy — passing them inline would orphan the
+				// move_T results.
+				var TK k = old_keys.move_T(i)
+				var TV v = old_values.move_T(i)
+				self.set(mov k, mov v)
 			}
 		}
 	}

package/core/System/Option.nm

@@ -0,0 +1,4 @@
+pub enum Option<T> {
+    case some(T value)
+    case none
+}

package/core/System/Result.nm

@@ -0,0 +1,4 @@
+pub enum Result<T, E> {
+    case ok(T value)
+    case error(E error)
+}

package/core/System/Set.nm

@@ -1,7 +1,9 @@
 /**
- * An ordered set of unique values (`add`/`has`/`get`/`remove`)
+ * 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 `==`).
  **/
-pub struct Set<T> {
+pub struct Set<T: Hashable + Equatable> {
 	var length = 0
 	var Buffer<T> slots = Buffer<T>()
 	var used = Buffer<int>()
@@ -9,7 +11,7 @@ pub struct Set<T> {
 	pub func add = (ref self, mov T value) {
 		var int cap = self.slots.cap
 		if cap == 0 {
-			cap = self.slots.alloc_int(8)
+			cap = self.slots.alloc_T(8)
 			self.used.alloc(8)
 		}
 		if self.length * 4 >= cap * 3 {
@@ -19,7 +21,7 @@ pub struct Set<T> {
 		var int idx = self.find_slot(value, cap)
 		if self.used.load(idx) == 0 {
 			self.used.store(idx, 1)
-			self.slots.store_int(idx, value)
+			self.slots.store_T(idx, value)
 			self.length += 1
 		}
 	}
@@ -42,7 +44,7 @@ pub struct Set<T> {
 		if self.used.load(idx) == 0 {
 			return 0
 		}
-		return self.slots.load_int(idx)
+		return self.slots.load_T(idx)
 	}
 
 	pub func remove = (ref self, T value) {
@@ -54,20 +56,55 @@ pub struct Set<T> {
 		if self.used.load(idx) == 0 {
 			return
 		}
-		self.used.store(idx, 0)
-		self.slots.store_int(idx, 0)
+		// Backward-shift deletion for linear probing. `gap` is the empty slot
+		// walking forward through the cluster; `k` scans ahead of it. An entry
+		// at k shifts into the gap only if the gap still lies within its valid
+		// probe range ([home, k) cyclically); otherwise the entry stays put and
+		// we keep scanning, because a later entry may still belong behind the
+		// gap. This is the subtle point: k advances independently of the gap,
+		// so entries past a non-moveable one are not stranded behind an empty
+		// slot (which would make find_slot miss them). No tombstones, so
+		// find_slot/get/has/add are unchanged, and the cost is the local cluster
+		// length — not a full O(cap) rehash on every delete.
+		var int gap = idx
+		var int k = idx
+		while true {
+			k += 1
+			if k >= cap {
+				k = 0
+			}
+			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 dgap = gap - home
+			if dgap < 0 {
+				dgap = dgap + cap
+			}
+			var int dk = k - home
+			if dk < 0 {
+				dk = dk + cap
+			}
+			if dgap < dk {
+				self.slots.store_T(gap, self.slots.load_T(k))
+				self.used.store(gap, 1)
+				gap = k
+			}
+		}
+		self.used.store(gap, 0)
 		self.length = self.length - 1
-		self.rehash(cap)
 	}
 
 	func find_slot = (self, T value, int cap, out int: out >= 0 && out < cap) {
-		var int v = value
-		var int idx = v % cap
+		var int idx = (value.hash() as int) % cap
 		if idx < 0 {
 			idx = idx + cap
 		}
 		while self.used.load(idx) != 0 {
-			if self.slots.load_int(idx) == v {
+			if self.slots.load_T(idx) == value {
 				return idx
 			}
 			idx += 1
@@ -83,14 +120,23 @@ pub struct Set<T> {
 		var Buffer<int> old_used = mov self.used swap Buffer<int>()
 		var int old_cap = old_slots.cap
 
-		self.slots.alloc_int(new_cap)
+		self.slots.alloc_T(new_cap)
 		self.used.alloc(new_cap)
 		self.length = 0
 
 		var i = 0
 		while i < old_cap; i += 1 {
 			if old_used.load(i) != 0 {
-				self.add(old_slots.load_int(i))
+				// move_T (not load_T) relinquishes the old slot, so each value
+				// is owned by exactly one buffer (the new self) afterwards.
+				// load_T would leave the old slot referencing the same class
+				// pointer — a double-free when old_slots is destroyed. The
+				// result is bound to a local so an owning-element copy (e.g. a
+				// `Buffer<string>` slot, which store_T strdup's) is freed here
+				// once the new buffer has made its own copy — passing it inline
+				// would orphan the move_T result.
+				var T v = old_slots.move_T(i)
+				self.add(mov v)
 			}
 		}
 	}

package/core/System/String.nm

@@ -1,7 +1,33 @@
 /**
  * A UTF-8 text string — a heap-owned, length-tracked sequence of bytes
  **/
-pub struct string: Stringable {
+pub struct string: Stringable, Hashable, Equatable {
+	pub func hash = (self, out uint) {
+		```
+		#arch: c
+		unsigned long h = 5381;
+		for (const char* p = self; *p; p++) {
+			h = h * 33 + (unsigned long)(unsigned char)*p;
+		}
+		return h;
+		```
+		```
+		#arch: aarch64
+		// x19 = self (char*), result in x0 (djb2 hash)
+		mov x0, #5381
+		mov x3, x19
+		.Lstring_hash_loop:
+		ldrb w1, [x3]
+		cbz w1, .Lstring_hash_done
+		mov x2, #33
+		mul x0, x0, x2
+		add x0, x0, x1
+		add x3, x3, #1
+		b .Lstring_hash_loop
+		.Lstring_hash_done:
+		```
+	}
+
 	pub func to_string = (self, out string) {
 		```
 		#arch: c

package/core/System/Test.nm

@@ -129,9 +129,7 @@ pub class Tester {
 	// Assert that a nullable value holds a value.
 	//
 	// Nomen has no generic methods, so there is one overload per nullable
-	// type the compiler can compare against `null`. Nullable *struct* values
-	// (`Point?`) are not supported by the backend yet — use
-	// `t.expect(p != null, "...")` once that gap closes.
+	// type the compiler can compare against `null`.
 	pub func assert = (ref self, int? value, string message) {
 		self.expect(value != null, message)
 	}

package/core/System/Text/JsonTree.nm

@@ -32,12 +32,15 @@ pub struct JsonTree {
 		self.count = idx + 1
 		var default = JsonNode()
 		self.nodes.store_T(idx, default)
-		// The default node's `text` points at the shared empty-string literal.
-		// NULL it in the slab so reset() can safely free only strdup'd texts
-		// (set_text writes a heap pointer; unset nodes stay NULL). idx is x1.
+		// store_T deep-copies the owning `text` field (strdup of the shared
+		// empty-string literal) into the slot. JsonTree manages node texts
+		// manually (set_text strdup's into the slab; free_text/release frees
+		// them; NULL means "no text"), so the slot must start NULL — free the
+		// strdup'd default and NULL it, or reset() would leak it. idx is x1.
 		```
 		#arch: c
 		JsonNode *nodes = (JsonNode*)(unsigned long long)self->nodes.data;
+		free(nodes[idx].text);
 		nodes[idx].text = 0;
 		```
 		```
@@ -51,7 +54,12 @@ pub struct JsonTree {
 		madd x1, x1, x3, xzr
 		add x0, x0, x1
 		add x0, x0, #16
+		ldr x1, [x0]
 		str xzr, [x0]
+		cbz x1, .Lalloc_node_text_skip
+		mov x0, x1
+		bl _free
+		.Lalloc_node_text_skip:
 		```
 		return idx
 	}

package/core/System/Text/Regex.nm

@@ -254,6 +254,9 @@ func add_class_chars = (string pattern, int start, int end, ref StringBuilder sb
 
 // Match pattern[pat_pos..pat_end) against input starting at in_pos.
 // Returns the end position in input after a successful match, or -1.
+// Return contract: a successful match never reads past in_len, so the result
+// is always <= in_len (and -1 on failure). This lets callers prove an index
+// bounded by the result is also bounded by the input length.
 func match_here = (
 	string pattern,
 	int pat_pos,
@@ -261,7 +264,7 @@ func match_here = (
 	string input,
 	int in_pos,
 	int in_len,
-	out int
+	out int: out <= in_len
 ) {
 	// Handle top-level alternation: a '|' at bracket/paren depth 0 splits the
 	// range into alternatives. Char classes and escapes are skipped so a '|' or

package/core/System/bool.nm

@@ -1,7 +1,18 @@
 /**
  * A boolean value (`true` or `false`)
  **/
-pub struct bool: Stringable {
+pub struct bool: Stringable, Hashable, Equatable {
+	pub func hash = (self, out uint) {
+		```
+		#arch: c
+		return (unsigned long)self;
+		```
+		```
+		#arch: aarch64
+		mov x0, x19
+		```
+	}
+
 	/** 
 	 * Converts this boolean to a string value (`"true"` or `"false"`)
 	 *

package/core/System/char.nm

@@ -1,7 +1,18 @@
 /**
  * A single character
  **/
-pub struct char: Stringable {
+pub struct char: Stringable, Hashable, Equatable {
+	pub func hash = (self, out uint) {
+		```
+		#arch: c
+		return (unsigned long)self;
+		```
+		```
+		#arch: aarch64
+		mov x0, x19
+		```
+	}
+
 	pub func to_string = (self, out string) {
 		```
 		#arch: c

package/core/System/int.nm

@@ -1,7 +1,18 @@
 /**
  * A signed integer — the default integer type
  **/
-pub struct int: Stringable {
+pub struct int: Stringable, Hashable, Equatable {
+	pub func hash = (self, out uint) {
+		```
+		#arch: c
+		return (unsigned long)self;
+		```
+		```
+		#arch: aarch64
+		mov x0, x19
+		```
+	}
+
 	pub func to_string = (self, out string) {
 		```
 		#arch: c

package/core/System/int64.nm

@@ -1,7 +1,18 @@
 /**
  * A 64-bit signed integer
  **/
-pub struct int64: Stringable {
+pub struct int64: Stringable, Hashable, Equatable {
+	pub func hash = (self, out uint) {
+		```
+		#arch: c
+		return (unsigned long)self;
+		```
+		```
+		#arch: aarch64
+		mov x0, x19
+		```
+	}
+
 	pub func to_string = (self, out string) {
 		```
 		#arch: c

package/core/System/int8.nm

@@ -1,7 +1,18 @@
 /**
  * An 8-bit signed integer
  **/
-pub struct int8: Stringable {
+pub struct int8: Stringable, Hashable, Equatable {
+	pub func hash = (self, out uint) {
+		```
+		#arch: c
+		return (unsigned long)self;
+		```
+		```
+		#arch: aarch64
+		mov x0, x19
+		```
+	}
+
 	pub func to_string = (self, out string) {
 		```
 		#arch: c

package/core/System/uint.nm

@@ -1,7 +1,18 @@
 /**
  * An unsigned integer
  **/
-pub struct uint: Stringable {
+pub struct uint: Stringable, Hashable, Equatable {
+	pub func hash = (self, out uint) {
+		```
+		#arch: c
+		return (unsigned long)self;
+		```
+		```
+		#arch: aarch64
+		mov x0, x19
+		```
+	}
+
 	pub func to_string = (self, out string) {
 		```
 		#arch: c

package/core/System/uint64.nm

@@ -1,7 +1,18 @@
 /**
  * A 64-bit unsigned integer
  **/
-pub struct uint64: Stringable {
+pub struct uint64: Stringable, Hashable, Equatable {
+	pub func hash = (self, out uint) {
+		```
+		#arch: c
+		return (unsigned long)self;
+		```
+		```
+		#arch: aarch64
+		mov x0, x19
+		```
+	}
+
 	pub func to_string = (self, out string) {
 		```
 		#arch: c

package/core/System/uint8.nm

@@ -1,7 +1,18 @@
 /**
  * An 8-bit unsigned integer
  **/
-pub struct uint8: Stringable {
+pub struct uint8: Stringable, Hashable, Equatable {
+	pub func hash = (self, out uint) {
+		```
+		#arch: c
+		return (unsigned long)self;
+		```
+		```
+		#arch: aarch64
+		mov x0, x19
+		```
+	}
+
 	pub func to_string = (self, out string) {
 		```
 		#arch: c

package/core/docs/System/Init.md

@@ -2,7 +2,8 @@
 
 ## `struct Init`
 
-Program startup state — the argument count and argument list passed to `main`
+Program startup state — the argument count and argument list passed to `main`,
+plus `is_tty` (whether stdout is a terminal, for renderer selection).
 
 ## `func parse_intparse_int(string s) -> int`
 

package/core/docs/System/Option.md

@@ -0,0 +1,23 @@
+# Option
+
+## `enum Option<T>`
+
+A generic optional type with a `some(T value)` case and a `none` case.
+Monomorphized per concrete type argument (e.g. `Option<int>`).
+
+```
+func find_first_even = (int[] xs, out Option<int>) {
+    for x of xs {
+        if x % 2 == 0 {
+            return .some(x)
+        }
+    }
+    return .none
+}
+
+const found = find_first_even([1, 3, 4])
+match found {
+    case .some(v) -> Console.write("\\{v}")
+    case .none -> Console.write("none")
+}
+```

package/core/docs/System/Result.md

@@ -0,0 +1,19 @@
+# Result
+
+## `enum Result<T, E>`
+
+A generic result type with an `ok(T value)` success case and an
+`error(E error)` failure case. Monomorphized per concrete type-argument pair
+(e.g. `Result<int, string>`).
+
+```
+func parse_age = (string s, out Result<int, string>) {
+    return .error("not a number")
+}
+
+const result = parse_age("x")
+match result {
+    case .ok(age) -> Console.write("\\{age}")
+    case .error(msg) -> Console.write("error: \\{msg}")
+}
+```