nomen-lang 0.3.0 → 0.5.0

package/core/System/Fiber.nm

@@ -0,0 +1,121 @@
+// Fiber — a stackful coroutine (ASYNC.md Phase 1). Fibers multiplex
+// over the worker pool's threads: a parked fiber frees its worker instead of
+// blocking it, so thousands of waiting tasks cost stacks (~64 KB each), not
+// threads (~MB each).
+//
+// `Fiber(fn(args)).start()` mirrors `Thread(fn(args)).start()` — same eager
+// arg packing into a task closure, same future, same Task<T> handle — but
+// the wrapped call runs on a fiber stack under the fiber scheduler. While
+// it waits (Task.result/wait, Channel.receive), the fiber parks and the
+// worker moves on; `Fiber.yield()` cooperatively hands the worker to the
+// next runnable fiber.
+//
+// Like Thread, a Fiber construction is a real value: it can be stored and
+// started later (`var f = Fiber(work(n))`, then `f.start()` or
+// `f.start_on(buf)`), and destroying an unstarted Fiber is a programming
+// error that #destroy reports and aborts on (must-start — the library
+// pattern from ASYNC.md).
+//
+// `Fiber(fn(args)).start_on(buf)` runs the fiber on a caller-provided
+// fixed-size array stack (>= 16 KB) — the embedded/no-heap path.
+//
+// `Fiber.set_cooperative(true)` (before the first spawn) runs fibers on the
+// calling thread and never starts worker threads — a cooperative,
+// single-threaded runtime for bare-metal targets.
+//
+// The constructor, `.start`, and `.start_on` are compiler-special-cased
+// (they need the per-site spawn/trampoline machinery), so they are NOT
+// regular methods declared here. The runtime (scheduler, context switch)
+// lives in the build's emitted companion C — see build_fiber_spawn.
+
+/**
+ * A stackful coroutine: lightweight, cooperatively scheduled, parks instead of blocking
+ **/
+pub class Fiber<T> : Sendable {
+	// The packed task closure (a `struct nomen_closure *`); owned by this
+	// value until start/start_on/nursery.start transfers it to the runtime.
+	pub var uint64 task = 0
+	// Result-slot / cancel-flag / future handles for the (single) launch.
+	pub var uint64 result_slot = 0
+	pub var uint64 cancel_flag = 0
+	pub var uint64 future = 0
+	// Must-start flag: set by .start() / .start_on(buf) / nursery.start.
+	pub var started = false
+
+	// Destroying an unstarted Fiber is a programming error (the wrapped
+	// call would silently never run) — report it and abort. A started
+	// Fiber owns nothing: the launch transferred the task closure, result
+	// slot, cancel flag, and future to the runtime, and cleared the fields.
+	pub func #destroy = () {
+		```
+		#arch: c
+		if (!self->started) {
+			__nomen_spawn_must_start_abort();
+		}
+		if (self->future) {
+			__nomen_future_release((struct nomen_future *)self->future);
+			self->future = 0;
+			self->result_slot = 0;
+			self->cancel_flag = 0;
+		}
+		```
+		```
+		#arch: aarch64
+		// if (!self->started) __nomen_spawn_must_start_abort()
+		ldrb w0, [x19, #40]
+		cbnz w0, .Lfb_started
+		bl ___nomen_spawn_must_start_abort
+		.Lfb_started:
+		// if (self->future) { release it (an unstarted task's future is
+		// unshared — refs == 1 — so this tears down slot + flag + future);
+		// zero the fields }
+		ldr x0, [x19, #32]
+		cbz x0, .Lfb_done
+		bl ___nomen_future_release
+		str xzr, [x19, #32]
+		str xzr, [x19, #16]
+		str xzr, [x19, #24]
+		.Lfb_done:
+		```
+	}
+
+	// Hand the worker to the next runnable fiber. No-op outside a fiber.
+	pub func yield = () {
+		```
+		#arch: c
+		__nomen_fiber_yield();
+		```
+		```
+		#arch: aarch64
+		bl ___nomen_fiber_yield
+		```
+	}
+
+	// Is the calling code running inside a fiber? True when Fiber.yield or
+	// fiber parking would take effect.
+	pub func is_fiber = (out bool) {
+		```
+		#arch: c
+		return __nomen_fiber_is_active();
+		```
+		```
+		#arch: aarch64
+		bl ___nomen_fiber_is_active
+		```
+	}
+
+	// Run fibers on the calling thread and never start worker threads. Must
+	// be called before the first fiber spawn; intended for single-threaded
+	// (bare-metal) targets. In cooperative mode a fiber that parks on an
+	// event only another thread could fire will never resume.
+	pub func set_cooperative = (bool on) {
+		```
+		#arch: c
+		__nomen_fiber_set_cooperative(on ? 1 : 0);
+		```
+		```
+		#arch: aarch64
+		bl ___nomen_fiber_set_cooperative
+		```
+	}
+}

package/core/System/Graph.nm

@@ -16,8 +16,8 @@ pub struct Graph<T>: Enumerable {
 
 	pub func add_node = (ref self, move T value) {
 		var int idx = self.node_count
-		self.values.grow_T(idx + 1)
-		self.values.store_T(idx, value)
+		self.values.grow(idx + 1)
+		self.values.store(idx, value)
 		self.head_edge.grow_int(idx + 1)
 		self.head_edge.store_int(idx, -1)
 		self.node_count = self.node_count + 1
@@ -50,11 +50,11 @@ pub struct Graph<T>: Enumerable {
 	}
 
 	pub func first = (self: self.node_count > 0, out T) {
-		return self.values.load_T(0)
+		return self.values.load(0)
 	}
 
 	pub func at = (self, int idx: idx >= 0 && idx < self.node_count, out T) {
-		return self.values.load_T(idx)
+		return self.values.load(idx)
 	}
 
 	pub func node_length = (self, out int) {

package/core/System/LinkedList.nm

@@ -15,8 +15,8 @@ pub struct LinkedList<T>: Enumerable {
 
 	pub func add = (ref self, move T value) {
 		var int idx = self.count
-		self.values.grow_T(idx + 1)
-		self.values.store_T(idx, value)
+		self.values.grow(idx + 1)
+		self.values.store(idx, value)
 		self.nexts.grow_int(idx + 1)
 		self.nexts.store_int(idx, -1)
 		self.prevs.grow_int(idx + 1)
@@ -50,11 +50,11 @@ pub struct LinkedList<T>: Enumerable {
 	}
 
 	pub func first = (self: self.count > 0, out T) {
-		return self.values.load_T(0)
+		return self.values.load(0)
 	}
 
 	pub func at = (self, int idx: idx >= 0 && idx < self.count, out T) {
-		return self.values.load_T(idx)
+		return self.values.load(idx)
 	}
 
 	// Bounds-checked access: `fallback` when idx is outside [0, self.count).

package/core/System/List.nm

@@ -12,23 +12,23 @@ pub struct List<T>: Viewable {
 			if old_cap >= 4 {
 				new_cap = old_cap * 2
 			}
-			self.items.grow_T(new_cap)
+			self.items.grow(new_cap)
 		}
-		self.items.store_T(self.length, value)
+		self.items.store(self.length, value)
 		self.length += 1
 	}
 
 	pub func pop = (ref self, move out T) {
 		if self.length <= 0 {
-			return self.items.move_T(0)
+			return self.items.move(0)
 		}
 		var int idx = self.length - 1
 		self.length = idx
-		return self.items.move_T(idx)
+		return self.items.move(idx)
 	}
 
 	pub inline func at = (self, int i: i >= 0 && i < self.length, out T) {
-		return self.items.load_T(i)
+		return self.items.load(i)
 	}
 
 	// Bounds-checked access: `fallback` when i is outside [0, self.length) —
@@ -58,7 +58,7 @@ pub struct List<T>: Viewable {
 	}
 
 	pub func set = (ref self, int i: i >= 0 && i < self.length, move T value) {
-		self.items.replace_T(i, value)
+		self.items.replace(i, value)
 	}
 
 	// A deep copy: a fresh List<T> with an independent copy of every element.

package/core/System/Map.nm

@@ -30,22 +30,22 @@ pub struct Map<TK: Hashable + Equatable, TV> {
 			// 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_T(8)
-			self.values.alloc_T(8)
-			self.used.alloc(8)
+			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)
 		}
 	}
 
@@ -55,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`
@@ -69,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
@@ -83,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) {
@@ -95,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) {
@@ -104,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
@@ -124,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
@@ -142,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
 	}
 
@@ -156,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
@@ -174,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
@@ -191,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/Mutex.nm

@@ -3,6 +3,12 @@
 // Default stance in Nomen is "no shared mutable state" — communicate by moving
 // Sendable values (or via Channel<T>). Mutex exists for when you genuinely
 // need shared mutability. See ASYNC.md.
+//
+// A fiber that would block on a contended lock parks instead of blocking its
+// worker (both models), and unlock wakes the parked fibers. Cancellation
+// while waiting never returns without the lock — a waiter keeps waiting and
+// observes the cancel flag at its next checkpoint after acquiring — so a
+// matching unlock is always sound.
 
 /**
  * A pthread-backed mutual-exclusion lock for protecting shared mutable state
@@ -10,69 +16,59 @@
 pub class Mutex: Sendable {
 	pub var uint64 handle = 0
 
-	pub func #init = (self) {
-		```
-		#arch: c
-		#scope: file
-		#include <pthread.h>
-		```
-		```
-		#arch: c
-		self->handle = (unsigned long long)malloc(sizeof(pthread_mutex_t));
-		pthread_mutex_init((pthread_mutex_t *)self->handle, NULL);
-		```
-		```
-		#arch: aarch64
-		mov x0, #64
-		bl _malloc
-		str x0, [x19, #8]
-		mov x1, #0
-		bl _pthread_mutex_init
-		```
-	}
+pub func #init = (self) {
+	```
+	#arch: c
+	self->handle = (unsigned long long)__nomen_mutex_create();
+	```
+	```
+	#arch: aarch64
+	bl ___nomen_mutex_create
+	str x0, [x19, #8]
+	```
+}
 
-	pub func lock = (self) {
-		```
-		#arch: c
-		pthread_mutex_lock((pthread_mutex_t *)self->handle);
-		```
-		```
-		#arch: aarch64
-		ldr x0, [x19, #8]
-		bl _pthread_mutex_lock
-		```
-	}
+pub func lock = (self) {
+	```
+	#arch: c
+	// Fibers park instead of blocking the worker (both models); other
+	// contexts take the pthread lock directly.
+	__nomen_mutex_lock((void *)self->handle);
+	```
+	```
+	#arch: aarch64
+	ldr x0, [x19, #8]
+	bl ___nomen_mutex_lock
+	```
+}
 
-	pub func unlock = (self) {
-		```
-		#arch: c
-		pthread_mutex_unlock((pthread_mutex_t *)self->handle);
-		```
-		```
-		#arch: aarch64
-		ldr x0, [x19, #8]
-		bl _pthread_mutex_unlock
-		```
-	}
+pub func unlock = (self) {
+	```
+	#arch: c
+	__nomen_mutex_unlock_wake((void *)self->handle);
+	```
+	```
+	#arch: aarch64
+	ldr x0, [x19, #8]
+	bl ___nomen_mutex_unlock_wake
+	```
+}
 
-	pub func #destroy = () {
-		```
-		#arch: c
-		if (self->handle) {
-			pthread_mutex_destroy((pthread_mutex_t *)self->handle);
-			free((void *)self->handle);
-			self->handle = 0;
-		}
-		```
-		```
-		#arch: aarch64
-		ldr x0, [x19, #8]
-		cbz x0, .Lmutex_destroy_end
-		bl _pthread_mutex_destroy
-		ldr x0, [x19, #8]
-		bl _free
-		str xzr, [x19, #8]
-		.Lmutex_destroy_end:
-		```
+pub func #destroy = () {
+	```
+	#arch: c
+	if (self->handle) {
+		__nomen_mutex_dispose((void *)self->handle);
+		self->handle = 0;
 	}
+	```
+	```
+	#arch: aarch64
+	ldr x0, [x19, #8]
+	cbz x0, .Lmutex_destroy_end
+	bl ___nomen_mutex_dispose
+	str xzr, [x19, #8]
+	.Lmutex_destroy_end:
+	```
+}
 }

package/core/System/Nursery.nm

@@ -5,18 +5,19 @@
 // An `async` block names its nursery (`async pool { }`), binding a Nursery
 // variable in scope. That variable is passed to helper functions with `ref`
 // and is the receiver of `pool.spawn(fn(args))`. The Nursery wraps the
-// per-invocation tracking state of the `async { }` block — a pointer to the
-// futures array and a pointer to the count slot, both on the async block's
-// stack frame — so it is only valid for the lifetime of its enclosing block
-// (which is exactly the structured-concurrency invariant: the block cannot
-// exit until every spawned task, including those spawned through a passed
-// Nursery, has finished).
+// per-invocation tracking state of the `async { }` block — pointers to the
+// futures list's storage slot, the registered count, and the capacity (the
+// list starts empty and grows by realloc; the compiler's registration helper
+// writes through these pointers) — so it is only valid for the lifetime of
+// its enclosing block (which is exactly the structured-concurrency
+// invariant: the block cannot exit until every spawned task, including those
+// spawned through a passed Nursery, has finished).
 //
 // Config rides on the declaration: `async pool = Nursery(timeout: 2000) { }`.
 //
 // `name.spawn(fn(args))` is special-cased by the compiler (it needs the spawn
-// trampoline machinery), so it is NOT a regular method declared here. The two
-// fields are the full runtime contract.
+// trampoline machinery), so it is NOT a regular method declared here. The
+// three fields are the full runtime contract.
 
 /**
  * The capability for spawning into a caller's `async` block; owns and tracks its tasks
@@ -24,4 +25,5 @@
 pub struct Nursery: Sendable {
 	pub var uint64 futures_ptr = 0
 	pub var uint64 count_ptr = 0
+	pub var uint64 cap_ptr = 0
 }

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)
 			}
 		}