nomen-lang 0.0.6 → 0.0.8

package/core/System/Controls/Window.nm

@@ -0,0 +1,280 @@
+/**
+ * A top-level native window that hosts controls and dispatches events
+ **/
+pub class Window: Control {
+	var uint64 handle = 0
+
+	pub func #init = (self, string title, int width, int height) {
+		```
+		#arch: c, aarch64_use_c
+		#platform: macos
+		// Set up NSApplication first
+		id app = ((id(*)(id, SEL))objc_msgSend)((id)objc_getClass("NSApplication"), sel_registerName("sharedApplication"));
+		((void(*)(id, SEL, long))objc_msgSend)(app, sel_registerName("setActivationPolicy:"), 0);
+		((void(*)(id, SEL, BOOL))objc_msgSend)(app, sel_registerName("activateIgnoringOtherApps:"), 1);
+		// Create window
+		unsigned long style = 1 | 2 | 4 | 8;
+		id win = ((id(*)(id, SEL, double, double, double, double, unsigned long, unsigned long, BOOL))objc_msgSend)(
+			((id(*)(id, SEL))objc_msgSend)((id)objc_getClass("NSWindow"), sel_registerName("alloc")),
+			sel_registerName("initWithContentRect:styleMask:backing:defer:"),
+			0.0, 0.0, (double)width, (double)height,
+			style, 2, 0);
+		((id(*)(id, SEL, id))objc_msgSend)(
+			win, sel_registerName("setTitle:"),
+			((id(*)(id, SEL, const char*))objc_msgSend)(
+				(id)objc_getClass("NSString"), sel_registerName("stringWithUTF8String:"), title));
+		((void(*)(id, SEL, double, double))objc_msgSend)(
+			win, sel_registerName("setFrameTopLeftPoint:"), 100.0, 100.0);
+		((void(*)(id, SEL, id))objc_msgSend)(win, sel_registerName("makeKeyAndOrderFront:"), (id)0);
+		// The content view must resize with the window and autoresize its
+		// subviews so each control's autoresizingMask takes effect during a
+		// live resize (AppKit's blocking drag loop bypasses our event loop).
+		id cv = ((id(*)(id, SEL))objc_msgSend)(win, sel_registerName("contentView"));
+		((void(*)(id, SEL, unsigned long))objc_msgSend)(cv, sel_registerName("setAutoresizingMask:"), 18UL);
+		((void(*)(id, SEL, BOOL))objc_msgSend)(cv, sel_registerName("setAutoresizesSubviews:"), 1);
+		self->handle = (uint64_t)win;
+		```
+		```
+		#arch: c, aarch64_use_c
+		#platform: ios
+		id win = ((id(*)(id, SEL))objc_msgSend)(
+			((id(*)(id, SEL))objc_msgSend)(objc_getClass("UIWindow"), sel_registerName("alloc")),
+			sel_registerName("initWithFrame:"),
+			((CGRect(*)(double, double, double, double))CGRectMake)(0, 0, (double)width, (double)height));
+		((void(*)(id, SEL))objc_msgSend)(win, sel_registerName("makeKeyAndVisible"));
+		self->handle = (uint64_t)win;
+		```
+	}
+
+	pub func show = (self) {
+		```
+		#arch: c, aarch64_use_c
+		#platform: macos
+		((void(*)(id, SEL, id))objc_msgSend)((id)self->handle, sel_registerName("makeKeyAndOrderFront:"), 0);
+		```
+		```
+		#arch: c, aarch64_use_c
+		#platform: ios
+		((void(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("makeKeyAndVisible"));
+		```
+	}
+
+	pub func set_title = (self, string title) {
+		```
+		#arch: c, aarch64_use_c
+		#platform: macos
+		((id(*)(id, SEL, id))objc_msgSend)(
+			(id)self->handle, sel_registerName("setTitle:"),
+			((id(*)(id, SEL, const char*))objc_msgSend)(
+				(id)objc_getClass("NSString"), sel_registerName("stringWithUTF8String:"), title));
+		```
+	}
+
+	pub func run = () {
+		```
+		#arch: c, aarch64_use_c
+		#platform: macos
+		((void(*)(id, SEL))objc_msgSend)(
+			((id(*)(id, SEL))objc_msgSend)((id)objc_getClass("NSApplication"), sel_registerName("sharedApplication")), sel_registerName("run"));
+		```
+		```
+		#arch: c, aarch64_use_c
+		#platform: ios
+		UIApplicationMain(0, 0, 0, 0);
+		```
+	}
+
+	// Process pending events without blocking. Returns 1 if a left-mouse-down
+	// was among the events (i.e. a click happened), 0 otherwise. This lets a
+	// manual event loop detect clicks for re-layout without target/action.
+	// Also runs the run loop briefly to process Apple Events (e.g. dock Quit).
+	pub func process_events = (out int) {
+		```
+		#arch: c, aarch64_use_c
+		#platform: macos
+		id app = ((id(*)(id, SEL))objc_msgSend)((id)objc_getClass("NSApplication"), sel_registerName("sharedApplication"));
+		id distant_past = ((id(*)(id, SEL))objc_msgSend)((id)objc_getClass("NSDate"), sel_registerName("distantPast"));
+		id default_mode = ((id(*)(id, SEL, const char*))objc_msgSend)(
+			(id)objc_getClass("NSString"), sel_registerName("stringWithUTF8String:"), "kCFRunLoopDefaultMode");
+		int had_click = 0;
+		while (1) {
+			id event = ((id(*)(id, SEL, unsigned long long, id, id, BOOL))objc_msgSend)(
+				app, sel_registerName("nextEventMatchingMask:untilDate:inMode:dequeue:"),
+				0xFFFFFFFFFFFFFFFFULL, // NSEventMaskAny
+				distant_past,          // untilDate — returns immediately if no events
+				default_mode,          // inMode
+				1);                    // dequeue
+			if (!event) break;
+			((void(*)(id, SEL, id))objc_msgSend)(app, sel_registerName("sendEvent:"), event);
+			long type = ((long(*)(id, SEL))objc_msgSend)(event, sel_registerName("type"));
+			if (type == 1) had_click = 1; // NSLeftMouseDown = 1
+		}
+		// Process run loop sources (Apple Events, timers) so that dock Quit
+		// and other system interactions work without NSApplication.run().
+		CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0, 1);
+		return had_click;
+		```
+		```
+		#arch: c, aarch64_use_c
+		#platform: ios
+		return 0;
+		```
+	}
+
+	// Returns true if the window is still on screen. Use this to exit a
+	// manual event loop when the user closes the window.
+	pub func is_visible = (self, out bool) {
+		```
+		#arch: c, aarch64_use_c
+		#platform: macos
+		BOOL vis = ((BOOL(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("isVisible"));
+		return vis;
+		```
+		```
+		#arch: c, aarch64_use_c
+		#platform: ios
+		BOOL vis = ((BOOL(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("isKeyWindow"));
+		return vis;
+		```
+	}
+
+	// Returns the x coordinate (in the window's content view) of the most
+	// recent mouse-down. Call after process_events returned 1.
+	pub func click_x = (self, out int) {
+		```
+		#arch: c, aarch64_use_c
+		#platform: macos
+		id app = ((id(*)(id, SEL))objc_msgSend)((id)objc_getClass("NSApplication"), sel_registerName("sharedApplication"));
+		id event = ((id(*)(id, SEL))objc_msgSend)(app, sel_registerName("currentEvent"));
+		if (!event) return -1;
+		long type = ((long(*)(id, SEL))objc_msgSend)(event, sel_registerName("type"));
+		if (type != 1) return -1; // NSLeftMouseDown = 1
+		// locationInWindow is a CGPoint inside the event; read it via struct-return
+		CGPoint loc = ((CGPoint(*)(id, SEL))objc_msgSend)(event, sel_registerName("locationInWindow"));
+		return (int)loc.x;
+		```
+		```
+		#arch: c, aarch64_use_c
+		#platform: ios
+		return -1;
+		```
+	}
+
+	// Returns the y coordinate (flipped to top-left origin) of the most
+	// recent mouse-down, in the window's content view.
+	pub func click_y = (self, out int) {
+		```
+		#arch: c, aarch64_use_c
+		#platform: macos
+		id app = ((id(*)(id, SEL))objc_msgSend)((id)objc_getClass("NSApplication"), sel_registerName("sharedApplication"));
+		id event = ((id(*)(id, SEL))objc_msgSend)(app, sel_registerName("currentEvent"));
+		if (!event) return -1;
+		long type = ((long(*)(id, SEL))objc_msgSend)(event, sel_registerName("type"));
+		if (type != 1) return -1; // NSLeftMouseDown = 1
+		CGPoint loc = ((CGPoint(*)(id, SEL))objc_msgSend)(event, sel_registerName("locationInWindow"));
+		id cv = ((id(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("contentView"));
+		CGRect frame = ((CGRect(*)(id, SEL))objc_msgSend)(cv, sel_registerName("frame"));
+		// NSWindow coords are bottom-left origin; flip to top-left for layout math
+		return (int)(frame.size.height - loc.y);
+		```
+		```
+		#arch: c, aarch64_use_c
+		#platform: ios
+		return -1;
+		```
+	}
+
+	// Returns the width of the window's content view.
+	pub func content_width = (self, out int) {
+		```
+		#arch: c, aarch64_use_c
+		#platform: macos
+		id cv = ((id(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("contentView"));
+		CGRect frame = ((CGRect(*)(id, SEL))objc_msgSend)(cv, sel_registerName("frame"));
+		return (int)frame.size.width;
+		```
+		```
+		#arch: c, aarch64_use_c
+		#platform: ios
+		id cv = ((id(*)(id, SEL))objc_msgSend)(
+			((id(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("rootViewController")),
+			sel_registerName("view"));
+		CGRect frame = ((CGRect(*)(id, SEL))objc_msgSend)(cv, sel_registerName("frame"));
+		return (int)frame.size.width;
+		```
+	}
+
+	// Returns the height of the window's content view (for coordinate flipping).
+	pub func content_height = (self, out int) {
+		```
+		#arch: c, aarch64_use_c
+		#platform: macos
+		id cv = ((id(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("contentView"));
+		CGRect frame = ((CGRect(*)(id, SEL))objc_msgSend)(cv, sel_registerName("frame"));
+		return (int)frame.size.height;
+		```
+		```
+		#arch: c, aarch64_use_c
+		#platform: ios
+		id cv = ((id(*)(id, SEL))objc_msgSend)(
+			((id(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("rootViewController")),
+			sel_registerName("view"));
+		CGRect frame = ((CGRect(*)(id, SEL))objc_msgSend)(cv, sel_registerName("frame"));
+		return (int)frame.size.height;
+		```
+	}
+
+	// ── Control trait conformance ──
+	// The window is the layout root: it measures to its content-view size and
+	// applies a frame to the native NSWindow/UIWindow.
+
+	pub func measure = (self, BoxConstraints constraints, out Size) {
+		var s = Size()
+		s.width = self.content_width()
+		s.height = self.content_height()
+		return s
+	}
+
+	pub func intrinsic_size = (self, out Size) {
+		var s = Size()
+		s.width = self.content_width()
+		s.height = self.content_height()
+		return s
+	}
+
+	pub func set_frame = (ref self, int x, int y, int width, int height) {
+		```
+		#arch: c, aarch64_use_c
+		#platform: macos
+		((void(*)(id, SEL, CGRect))objc_msgSend)(
+			(id)self->handle, sel_registerName("setFrame:"),
+			((CGRect(*)(double, double, double, double))CGRectMake)((double)x, (double)y, (double)width, (double)height));
+		```
+		```
+		#arch: c, aarch64_use_c
+		#platform: ios
+		((void(*)(id, SEL, CGRect))objc_msgSend)(
+			(id)self->handle, sel_registerName("setFrame:"),
+			((CGRect(*)(double, double, double, double))CGRectMake)((double)x, (double)y, (double)width, (double)height));
+		```
+	}
+
+	func #destroy = () {
+		```
+		#arch: c, aarch64_use_c
+		#platform: macos
+		if (self->handle) {
+			((void(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("release"));
+			self->handle = 0;
+		}
+		```
+		```
+		#arch: c, aarch64_use_c
+		#platform: ios
+		if (self->handle) {
+			((void(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("release"));
+			self->handle = 0;
+		}
+		```
+	}
+}

package/core/System/Disposable.nm

@@ -0,0 +1,8 @@
+/**
+ * A trait for resources that must be explicitly cleaned up via `dispose`
+ **/
+pub trait Disposable {
+	func dispose = (self) {
+		Console.write("\nboom!")
+	}
+}

package/core/System/Enumerable.nm

@@ -0,0 +1,10 @@
+// Trait for collection types that can be iterated with `for x of collection`.
+// The loop variable receives int indices 0..length-1; use .at(i) to access values.
+/**
+ * A trait for collections that can be iterated with `for x of collection`
+ **/
+pub trait Enumerable {
+	func length = (self, out int) {
+		return 0
+	}
+}

package/core/System/Equatable.nm

@@ -0,0 +1,10 @@
+/**
+ * Marker trait for value equality. A struct that conforms to `Equatable` and
+ * does not define its own `#op_eq` gets a field-by-field equality method
+ * derived automatically, so `==` and `!=` work between two instances. The
+ * derivation only fires when every field is itself equatable (a primitive or
+ * another `Equatable` type); otherwise the struct must supply `#op_eq` by
+ * hand.
+ **/
+pub trait Equatable {
+}

package/core/System/Graph.nm

@@ -0,0 +1,68 @@
+// Arena-backed directed graph. Node values and edges live in flat Buffers;
+// edges are stored as a per-node linked list of edge records (CSR-style), so
+// there is a single owner and cleanup is a flat free. Node and edge identifiers
+// are stable int indices; -1 means "none".
+
+/**
+ * A graph of values connected by edges
+ **/
+pub struct Graph<T>: Enumerable {
+	var Buffer<T> values = Buffer<T>()
+	var head_edge = Buffer<int>()
+	var edge_target = Buffer<int>()
+	var edge_next = Buffer<int>()
+	var node_count = 0
+	var edge_count = 0
+
+	pub func add_node = (ref self, mov T value) {
+		var int idx = self.node_count
+		self.values.grow_int(idx + 1)
+		var int v = value
+		self.values.store_int(idx, v)
+		self.head_edge.grow_int(idx + 1)
+		self.head_edge.store_int(idx, -1)
+		self.node_count = self.node_count + 1
+	}
+
+	pub func add_edge = (ref self, int from, int to) {
+		var int e = self.edge_count
+		self.edge_target.grow_int(e + 1)
+		self.edge_target.store_int(e, to)
+		self.edge_next.grow_int(e + 1)
+		if from >= 0 && from < self.head_edge.cap {
+			self.edge_next.store_int(e, self.head_edge.load_int(from))
+		}
+		if from >= 0 && from < self.head_edge.cap {
+			self.head_edge.store_int(from, e)
+		}
+		self.edge_count = self.edge_count + 1
+	}
+
+	pub func edges_of = (self, int node, out int: out >= -1 && out < self.edge_count) {
+		return self.head_edge.load_int(node)
+	}
+
+	pub func edge_target = (self, int e, out int: out >= 0 && out < self.node_count) {
+		return self.edge_target.load_int(e)
+	}
+
+	pub func next_edge = (self, int e, out int: out >= -1 && out < self.edge_count) {
+		return self.edge_next.load_int(e)
+	}
+
+	pub func first = (self: self.node_count > 0, out T) {
+		return self.values.load_int(0)
+	}
+
+	pub func at = (self, int idx: idx >= 0 && idx < self.node_count, out T) {
+		return self.values.load_int(idx)
+	}
+
+	pub func node_length = (self, out int) {
+		return self.node_count
+	}
+
+	pub func edge_length = (self, out int) {
+		return self.edge_count
+	}
+}

package/core/System/Hashable.nm

@@ -0,0 +1,13 @@
+/**
+ * A trait for values that can be hashed to an unsigned integer. A struct that
+ * conforms to `Hashable` and does not define its own `hash` method gets one
+ * derived automatically by combining each field's value (integer fields are
+ * cast to `uint`, and `Hashable` struct fields call their own `hash`). The
+ * derivation only fires when every field is hashable; otherwise the default
+ * body (which returns `0`) is used.
+ **/
+pub trait Hashable {
+	func hash = (self, out uint) {
+		return 0
+	}
+}

package/core/System/Init.nm

@@ -0,0 +1,21 @@
+/**
+ * Program startup state — the argument count and argument list passed to `main`
+ **/
+pub struct Init {
+	var int argc
+	var string[16] args
+}
+
+/**
+ * Parses a decimal string into an int
+ **/
+pub func parse_int = (string s, out int) {
+	```
+	#arch: c
+	return atoi(s);
+	```
+	```
+	#arch: aarch64
+	bl _atoi
+	```
+}

package/core/System/LinkedList.nm

@@ -0,0 +1,64 @@
+// Arena-backed doubly-linked list. Values and next/prev links live in flat
+// Buffers, so there is a single owner and cleanup is a flat free — no recursive
+// pointer chasing, no borrow lifetimes. Node identifiers are stable int indices
+// (read `count` before `add`); -1 means "no node" / "end".
+
+/**
+ * A doubly-linked list of values
+ **/
+pub struct LinkedList<T>: Enumerable {
+	var Buffer<T> values = Buffer<T>()
+	var nexts = Buffer<int>()
+	var prevs = Buffer<int>()
+	var int head = -1
+	var count = 0
+
+	pub func add = (ref self, mov T value) {
+		var int idx = self.count
+		self.values.grow_int(idx + 1)
+		var int v = value
+		self.values.store_int(idx, v)
+		self.nexts.grow_int(idx + 1)
+		self.nexts.store_int(idx, -1)
+		self.prevs.grow_int(idx + 1)
+		self.prevs.store_int(idx, -1)
+		self.count += 1
+		if self.head == -1 {
+			self.head = idx
+		}
+	}
+
+	pub func set_next = (ref self, int idx, int next) {
+		self.nexts.store_int(idx, next)
+		if next >= 0 && next < self.prevs.cap {
+			self.prevs.store_int(next, idx)
+		}
+	}
+
+	pub func set_previous = (ref self, int idx, int prev) {
+		self.prevs.store_int(idx, prev)
+		if prev >= 0 && prev < self.nexts.cap {
+			self.nexts.store_int(prev, idx)
+		}
+	}
+
+	pub func next_at = (self, int idx, out int: out >= -1 && out < self.count) {
+		return self.nexts.load_int(idx)
+	}
+
+	pub func previous_at = (self, int idx, out int: out >= -1 && out < self.count) {
+		return self.prevs.load_int(idx)
+	}
+
+	pub func first = (self: self.count > 0, out T) {
+		return self.values.load_int(0)
+	}
+
+	pub func at = (self, int idx: idx >= 0 && idx < self.count, out T) {
+		return self.values.load_int(idx)
+	}
+
+	pub func length = (self, out int) {
+		return self.count
+	}
+}

package/core/System/List.nm

@@ -0,0 +1,44 @@
+/**
+ * A growable, ordered list of values (`push`/`pop`/`at`)
+ **/
+pub struct List<T>: Viewable {
+	var length = 0
+	var Buffer<T> items = Buffer<T>()
+
+	pub func push = (ref self, mov T value) {
+		if self.length >= self.items.cap {
+			var new_cap = 4
+			var int old_cap = self.items.cap
+			if old_cap >= 4 {
+				new_cap = old_cap * 2
+			}
+			self.items.grow_int(new_cap)
+		}
+		self.items.store_int(self.length, value)
+		self.length += 1
+	}
+
+	pub func pop = (ref self, mov out T) {
+		if self.length <= 0 {
+			return 0
+		}
+		var int idx = self.length - 1
+		self.length = idx
+		return self.items.move_int(idx)
+	}
+
+	pub func at = (self, int i: i >= 0 && i < self.length, out T) {
+		return self.items.load_int(i)
+	}
+
+	// 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) {
+		return self.items.slice(start, end)
+	}
+
+	pub func set = (ref self, int i: i >= 0 && i < self.length, mov T value) {
+		var int v = value
+		self.items.replace_int(i, v)
+	}
+}

package/core/System/Map.nm

@@ -0,0 +1,153 @@
+/**
+ * An ordered key-value map with `set`/`get`/`has`/`remove`
+ **/
+pub struct Map<TK, TV> {
+	var length = 0
+	var Buffer<TK> keys = Buffer<TK>()
+	var Buffer<TV> values = Buffer<TV>()
+	var used = Buffer<int>()
+
+	// 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>().
+	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)
+		}
+	}
+
+	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)
+			self.used.alloc(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_int(idx, key)
+			self.values.store_int(idx, value)
+			self.length += 1
+		} else {
+			self.values.store_int(idx, value)
+		}
+	}
+
+	pub func get = (self, TK key, out TV) {
+		var int cap = self.keys.cap
+		if cap == 0 {
+			return 0
+		}
+		var int idx = self.find_slot(key, cap)
+		if self.used.load(idx) == 0 {
+			return 0
+		}
+		return self.values.load_int(idx)
+	}
+
+	pub func has = (self, TK key, out bool) {
+		var int cap = self.keys.cap
+		if cap == 0 {
+			return false
+		}
+		var int idx = self.find_slot(key, cap)
+		return self.used.load(idx) != 0
+	}
+
+	pub func remove = (ref self, TK key) {
+		var int cap = self.keys.cap
+		if cap == 0 {
+			return
+		}
+		var int idx = self.find_slot(key, cap)
+		if self.used.load(idx) == 0 {
+			return
+		}
+		// 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/set 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.keys.load_int(k) % 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.keys.store_int(gap, self.keys.load_int(k))
+				self.values.store_int(gap, self.values.load_int(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
+		if idx < 0 {
+			idx = idx + cap
+		}
+		while self.used.load(idx) != 0 {
+			if self.keys.load_int(idx) == k {
+				return idx
+			}
+			idx += 1
+			if idx >= cap {
+				idx = 0
+			}
+		}
+		return idx
+	}
+
+	func rehash = (ref self, int new_cap) {
+		var Buffer<TK> old_keys = mov self.keys swap Buffer<TK>()
+		var Buffer<TV> old_values = mov self.values swap Buffer<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.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))
+			}
+		}
+	}
+}