nomen-lang 0.2.3 → 0.4.0

package/core/System/Map.nm

@@ -27,22 +27,25 @@ pub struct Map<TK: Hashable + Equatable, TV> {
 	pub func set = (ref self, move TK key, move TV value) {
 		var int cap = self.keys.cap
 		if cap == 0 {
-			cap = self.keys.alloc_T(8)
-			self.values.alloc_T(8)
-			self.used.alloc(8)
+			// alloc_T: for Buffer<TK> it is T_SIZE-aware (string keys are
+			// 16-byte slots); for ClassBuffer<TV> it delegates to alloc_int
+			// (one pointer per slot). Both have it for generic parity.
+			cap = self.keys.alloc(8)
+			self.values.alloc(8)
+			self.used.alloc_u32(8)
 		}
 		if self.length * 4 >= cap * 3 {
 			self.rehash(cap * 2)
 			cap = self.keys.cap
 		}
 		var int idx = self.find_slot(key, cap)
-		if self.used.load(idx) == 0 {
-			self.used.store(idx, 1)
-			self.keys.store_T(idx, key)
-			self.values.store_T(idx, value)
+		if self.used.load_u32(idx) == 0 {
+			self.used.store_u32(idx, 1)
+			self.keys.store(idx, key)
+			self.values.store(idx, value)
 			self.length += 1
 		} else {
-			self.values.replace_T(idx, value)
+			self.values.replace(idx, value)
 		}
 	}
 
@@ -52,10 +55,10 @@ pub struct Map<TK: Hashable + Equatable, TV> {
 			return 0
 		}
 		var int idx = self.find_slot(key, cap)
-		if self.used.load(idx) == 0 {
+		if self.used.load_u32(idx) == 0 {
 			return 0
 		}
-		return self.values.load_T(idx)
+		return self.values.load(idx)
 	}
 
 	// Fused lookup-with-fallback: one probe instead of the `has` + `get`
@@ -66,10 +69,10 @@ pub struct Map<TK: Hashable + Equatable, TV> {
 			return fallback
 		}
 		var int idx = self.find_slot(key, cap)
-		if self.used.load(idx) == 0 {
+		if self.used.load_u32(idx) == 0 {
 			return fallback
 		}
-		return self.values.load_T(idx)
+		return self.values.load(idx)
 	}
 
 	// Lookup that traps when the key is absent — for when a missing key is
@@ -80,10 +83,10 @@ pub struct Map<TK: Hashable + Equatable, TV> {
 			panic("key not found")
 		}
 		var int idx = self.find_slot(key, cap)
-		if self.used.load(idx) == 0 {
+		if self.used.load_u32(idx) == 0 {
 			panic("key not found")
 		}
-		return self.values.load_T(idx)
+		return self.values.load(idx)
 	}
 
 	pub func has = (self, TK key, out bool) {
@@ -92,7 +95,7 @@ pub struct Map<TK: Hashable + Equatable, TV> {
 			return false
 		}
 		var int idx = self.find_slot(key, cap)
-		return self.used.load(idx) != 0
+		return self.used.load_u32(idx) != 0
 	}
 
 	pub func remove = (ref self, TK key) {
@@ -101,7 +104,7 @@ pub struct Map<TK: Hashable + Equatable, TV> {
 			return
 		}
 		var int idx = self.find_slot(key, cap)
-		if self.used.load(idx) == 0 {
+		if self.used.load_u32(idx) == 0 {
 			return
 		}
 		// Backward-shift deletion for linear probing. `gap` is the empty slot
@@ -121,10 +124,10 @@ pub struct Map<TK: Hashable + Equatable, TV> {
 			if k >= cap {
 				k = 0
 			}
-			if self.used.load(k) == 0 {
+			if self.used.load_u32(k) == 0 {
 				break
 			}
-			var int home = (self.keys.load_T(k).hash() as int) & (cap - 1)
+			var int home = (self.keys.load(k).hash() as int) & (cap - 1)
 			var int dgap = gap - home
 			if dgap < 0 {
 				dgap = dgap + cap
@@ -139,13 +142,13 @@ pub struct Map<TK: Hashable + Equatable, TV> {
 				// 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)
+				self.keys.shift(gap, k)
+				self.values.shift(gap, k)
+				self.used.store_u32(gap, 1)
 				gap = k
 			}
 		}
-		self.used.store(gap, 0)
+		self.used.store_u32(gap, 0)
 		self.length = self.length - 1
 	}
 
@@ -153,8 +156,8 @@ pub struct Map<TK: Hashable + Equatable, TV> {
 		// 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 {
+		while self.used.load_u32(idx) != 0 {
+			if self.keys.load(idx) == key {
 				return idx
 			}
 			idx += 1
@@ -171,14 +174,14 @@ pub struct Map<TK: Hashable + Equatable, TV> {
 		var Buffer<int> old_used = move self.used swap Buffer<int>()
 		var int old_cap = old_keys.cap
 
-		self.keys.alloc_T(new_cap)
-		self.values.alloc_T(new_cap)
-		self.used.alloc(new_cap)
+		self.keys.alloc(new_cap)
+		self.values.alloc(new_cap)
+		self.used.alloc_u32(new_cap)
 		self.length = 0
 
 		var i = 0
 		while i < old_cap; i += 1 {
-			if old_used.load(i) != 0 {
+			if old_used.load_u32(i) != 0 {
 				// 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
@@ -188,8 +191,8 @@ pub struct Map<TK: Hashable + Equatable, TV> {
 				// 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)
+				var TK k = old_keys.move(i)
+				var TV v = old_values.move(i)
 				self.set(move k, move v)
 			}
 		}

package/core/System/Set.nm

@@ -15,17 +15,17 @@ pub struct Set<T: Hashable + Equatable> {
 	pub func add = (ref self, move T value) {
 		var int cap = self.slots.cap
 		if cap == 0 {
-			cap = self.slots.alloc_T(8)
-			self.used.alloc(8)
+			cap = self.slots.alloc(8)
+			self.used.alloc_u32(8)
 		}
 		if self.length * 4 >= cap * 3 {
 			self.rehash(cap * 2)
 			cap = self.slots.cap
 		}
 		var int idx = self.find_slot(value, cap)
-		if self.used.load(idx) == 0 {
-			self.used.store(idx, 1)
-			self.slots.store_T(idx, value)
+		if self.used.load_u32(idx) == 0 {
+			self.used.store_u32(idx, 1)
+			self.slots.store(idx, value)
 			self.length += 1
 		}
 	}
@@ -36,7 +36,7 @@ pub struct Set<T: Hashable + Equatable> {
 			return false
 		}
 		var int idx = self.find_slot(value, cap)
-		return self.used.load(idx) != 0
+		return self.used.load_u32(idx) != 0
 	}
 
 	pub func get = (self, T key, out T) {
@@ -45,10 +45,10 @@ pub struct Set<T: Hashable + Equatable> {
 			return 0
 		}
 		var int idx = self.find_slot(key, cap)
-		if self.used.load(idx) == 0 {
+		if self.used.load_u32(idx) == 0 {
 			return 0
 		}
-		return self.slots.load_T(idx)
+		return self.slots.load(idx)
 	}
 
 	// Membership lookup with a fallback value: `fallback` when the value is
@@ -59,10 +59,10 @@ pub struct Set<T: Hashable + Equatable> {
 			return fallback
 		}
 		var int idx = self.find_slot(key, cap)
-		if self.used.load(idx) == 0 {
+		if self.used.load_u32(idx) == 0 {
 			return fallback
 		}
-		return self.slots.load_T(idx)
+		return self.slots.load(idx)
 	}
 
 	// Membership lookup that traps when the value is not in the set.
@@ -72,10 +72,10 @@ pub struct Set<T: Hashable + Equatable> {
 			panic("value not found in set")
 		}
 		var int idx = self.find_slot(key, cap)
-		if self.used.load(idx) == 0 {
+		if self.used.load_u32(idx) == 0 {
 			panic("value not found in set")
 		}
-		return self.slots.load_T(idx)
+		return self.slots.load(idx)
 	}
 
 	pub func remove = (ref self, T value) {
@@ -84,7 +84,7 @@ pub struct Set<T: Hashable + Equatable> {
 			return
 		}
 		var int idx = self.find_slot(value, cap)
-		if self.used.load(idx) == 0 {
+		if self.used.load_u32(idx) == 0 {
 			return
 		}
 		// Backward-shift deletion for linear probing. `gap` is the empty slot
@@ -104,10 +104,10 @@ pub struct Set<T: Hashable + Equatable> {
 			if k >= cap {
 				k = 0
 			}
-			if self.used.load(k) == 0 {
+			if self.used.load_u32(k) == 0 {
 				break
 			}
-			var int home = (self.slots.load_T(k).hash() as int) & (cap - 1)
+			var int home = (self.slots.load(k).hash() as int) & (cap - 1)
 			var int dgap = gap - home
 			if dgap < 0 {
 				dgap = dgap + cap
@@ -122,12 +122,12 @@ pub struct Set<T: Hashable + Equatable> {
 				// 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)
+				self.slots.shift(gap, k)
+				self.used.store_u32(gap, 1)
 				gap = k
 			}
 		}
-		self.used.store(gap, 0)
+		self.used.store_u32(gap, 0)
 		self.length = self.length - 1
 	}
 
@@ -135,8 +135,8 @@ pub struct Set<T: Hashable + Equatable> {
 		// 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 {
+		while self.used.load_u32(idx) != 0 {
+			if self.slots.load(idx) == value {
 				return idx
 			}
 			idx += 1
@@ -152,13 +152,13 @@ pub struct Set<T: Hashable + Equatable> {
 		var Buffer<int> old_used = move self.used swap Buffer<int>()
 		var int old_cap = old_slots.cap
 
-		self.slots.alloc_T(new_cap)
-		self.used.alloc(new_cap)
+		self.slots.alloc(new_cap)
+		self.used.alloc_u32(new_cap)
 		self.length = 0
 
 		var i = 0
 		while i < old_cap; i += 1 {
-			if old_used.load(i) != 0 {
+			if old_used.load_u32(i) != 0 {
 				// 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
@@ -167,7 +167,7 @@ pub struct Set<T: Hashable + Equatable> {
 				// `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)
+				var T v = old_slots.move(i)
 				self.add(move v)
 			}
 		}

package/core/System/Stream/Directory.nm

@@ -43,7 +43,7 @@ pub struct Directory {
 		```
 		```
 		#arch: c
-		if (mkdir(path, 0777)) return errno;
+		if (mkdir(path.ptr, 0777)) return errno;
 		return 0;
 		```
 		```
@@ -76,7 +76,7 @@ pub struct Directory {
 	func raw_remove = (string path, out int) {
 		```
 		#arch: c
-		if (rmdir(path)) return errno;
+		if (rmdir(path.ptr)) return errno;
 		return 0;
 		```
 		```
@@ -109,7 +109,7 @@ pub struct Directory {
 		```
 		#arch: c
 		struct stat st;
-		return stat(path, &st) == 0 ? 1 : 0;
+		return stat(path.ptr, &st) == 0 ? 1 : 0;
 		```
 		```
 		#arch: aarch64
@@ -147,7 +147,7 @@ pub struct Directory {
 		```
 		#arch: c
 		Result_string_DirectoryError r;
-		DIR *d = opendir(path);
+		DIR *d = opendir(path.ptr);
 		if (!d) {
 			int e = errno;
 			long de = 4;

package/core/System/Stream/File.nm

@@ -72,7 +72,8 @@ pub struct File {
 		```
 		```
 		#arch: c
-		self->handle = (unsigned long long)fopen(path, mode);
+		// Fat-string ABI: strings pass their ptr half at FFI boundaries.
+		self->handle = (unsigned long long)fopen(path.ptr, mode.ptr);
 		if (self->handle) {
 			self->error = 0;
 		} else {
@@ -236,21 +237,24 @@ pub struct File {
 		#arch: c
 		FILE *f = (FILE*)(unsigned long long)self->handle;
 		if (!f) { self->error = 9; return; }
-		fputs(data, f);
+		// Byte-exact write of the tracked length (fputs stopped at the
+		// first embedded NUL).
+		fwrite(data.ptr, 1, data.len, f);
 		self->error = 0;
 		```
 		```
 		#arch: aarch64
-		// Fat-string ABI: data = (x1, x2).
+		// Fat-string ABI: data = (x1 ptr, x2 len).
 		ldr x3, [x19, #8]
 		cbnz x3, .Lfile_write_all_go
 		mov x0, #9
 		str x0, [x19, #24]
 		b .return_File_raw_write_all
 		.Lfile_write_all_go:
+		// fwrite(ptr, 1, len, f) — byte-exact (fputs truncated at NUL)
 		mov x0, x1
-		mov x1, x3
-		bl _fputs
+		mov x1, #1
+		bl _fwrite
 		str xzr, [x19, #24]
 		```
 	}
@@ -375,22 +379,25 @@ pub struct File {
 		#arch: c
 		FILE *f = (FILE*)(unsigned long long)self->handle;
 		if (!f) { self->error = 9; return; }
-		fputs(data, f);
+		// Byte-exact write of the tracked length (fputs stopped at the
+		// first embedded NUL).
+		fwrite(data.ptr, 1, data.len, f);
 		fputc('\n', f);
 		self->error = 0;
 		```
 		```
 		#arch: aarch64
-		// Fat-string ABI: data = (x1, x2).
+		// Fat-string ABI: data = (x1 ptr, x2 len).
 		ldr x3, [x19, #8]
 		cbnz x3, .Lfile_write_line_go
 		mov x0, #9
 		str x0, [x19, #24]
 		b .return_File_raw_write_line
 		.Lfile_write_line_go:
+		// fwrite(ptr, 1, len, f) — byte-exact (fputs truncated at NUL)
 		mov x0, x1
-		mov x1, x3
-		bl _fputs
+		mov x1, #1
+		bl _fwrite
 		mov w0, #10
 		ldr x1, [x19, #8]
 		bl _fputc
@@ -476,7 +483,7 @@ pub struct File {
 		#arch: c
 		FILE *f = (FILE*)(unsigned long long)self->handle;
 		if (!f) { self->error = 9; return; }
-		fwrite(data, 1, size, f);
+		fwrite(data.ptr, 1, size, f);
 		self->error = 0;
 		```
 		```
@@ -513,7 +520,7 @@ pub struct File {
 		```
 		#arch: c
 		struct stat st;
-		return stat(path, &st) == 0 ? 1 : 0;
+		return stat(path.ptr, &st) == 0 ? 1 : 0;
 		```
 		```
 		#arch: aarch64
@@ -532,7 +539,7 @@ pub struct File {
 	func raw_delete = (string path, out int) {
 		```
 		#arch: c
-		if (remove(path)) return errno;
+		if (remove(path.ptr)) return errno;
 		return 0;
 		```
 		```