nomen-lang 0.5.0 → 0.6.0

package/core/System/Arena.nm

@@ -36,17 +36,17 @@ pub struct Arena<T> {
 	// Slot payloads. T = value struct/primitive routes to Buffer<T>; T =
 	// class/trait routes to ClassBuffer<T> (monomorphize rewrites the field),
 	// so slot ownership follows the usual element rules.
-	var Buffer<T> values = Buffer<T>()
+	var values = Buffer<T>()
 	// Per-slot generation, bumped on every free. Slots are calloc'd, so a
 	// fresh slot's generation is 0.
-	var Buffer<int> generations = Buffer<int>()
+	var generations = Buffer<int>()
 	// Freed slot indices available for reuse (LIFO free list). A raw Buffer
 	// plus an explicit count: a `List<int>` field would need its own
 	// monomorphization from inside a generic struct body.
-	var Buffer<int> free_indices = Buffer<int>()
-	var int free_count = 0
+	var free_indices = Buffer<int>()
+	var free_count = 0
 	// High-water mark: every index < count has a slot (live or free).
-	var int count = 0
+	var count = 0
 
 	/**
 	 * A fresh arena with no slots.
@@ -78,7 +78,7 @@ pub struct Arena<T> {
 		}
 		self.values.grow(index + 1)
 		self.values.store(index, value)
-		var ArenaRef<T> handle = ArenaRef<T>()
+		var handle = ArenaRef<T>()
 		handle.index = index
 		handle.generation = self.generations.load_int(index)
 		return handle

package/core/System/Buffer.nm

@@ -37,7 +37,7 @@ pub struct Buffer<T> {
 		if new_cap == 0 {
 			new_cap = 8
 		}
-		while new_cap < needed; new_cap *= 2 {}
+		while new_cap < needed; new_cap *= 2 { }
 		self.data = realloc(self.data, new_cap * 4)
 		memset(self.data + self.cap * 4, 0, (new_cap - self.cap) * 4)
 		self.cap = new_cap
@@ -107,7 +107,7 @@ pub struct Buffer<T> {
 		if new_cap == 0 {
 			new_cap = 4
 		}
-		while new_cap < needed; new_cap *= 2 {}
+		while new_cap < needed; new_cap *= 2 { }
 		self.data = realloc(self.data, new_cap * 8)
 		memset(self.data + self.cap * 8, 0, (new_cap - self.cap) * 8)
 		self.cap = new_cap
@@ -204,7 +204,7 @@ pub struct Buffer<T> {
 		if new_cap == 0 {
 			new_cap = 4
 		}
-		while new_cap < needed; new_cap *= 2 {}
+		while new_cap < needed; new_cap *= 2 { }
 		self.data = realloc(self.data, new_cap * T_SIZE)
 		memset(self.data + self.cap * T_SIZE, 0, (new_cap - self.cap) * T_SIZE)
 		self.cap = new_cap
@@ -382,7 +382,7 @@ pub struct Buffer<T> {
 	// this raw form is correct for trivially-copyable elements only. NOT
 	// `inline`: the body calls through the fn pointer, so splicing the raw
 	// block into a caller would bypass the per-element specializations.
-	func modify = (ref self, int i: i >= 0 && i < self.cap, func (T, out T) f) {
+	func modify = (ref self, int i: i >= 0 && i < self.cap, func(T, out T) f) {
 		```
 		#arch: c
 		((T*)(unsigned long long)self->data)[i] = ((T (*)(void *, T))f->code)(f->env, ((T*)(unsigned long long)self->data)[i]);
@@ -520,7 +520,11 @@ pub struct Buffer<T> {
 	// version that also reclaims dst's previous value first (see
 	// owning_buffer_specialize.ts); this raw form is correct for
 	// trivially-destructible elements only.
-	inline func shift = (ref self, int dst: dst >= 0 && dst < self.cap, int src: src >= 0 && src < self.cap) {
+	inline func shift = (
+		ref self,
+		int dst: dst >= 0 && dst < self.cap,
+		int src: src >= 0 && src < self.cap
+	) {
 		```
 		#arch: c
 		T* _slots = (T*)(unsigned long long)self->data;
@@ -587,7 +591,12 @@ pub struct Buffer<T> {
 	// self's scope and is invalidated if self is reassigned. This is the single
 	// primitive every other slice (Array<T>, List<T>, user containers) builds
 	// on — higher layers just `return self.items.slice(start, end)`.
-	func slice = (self, int start: start >= 0, int end: end >= start && end <= self.cap, out view T) {
+	func slice = (
+		self,
+		int start: start >= 0,
+		int end: end >= start && end <= self.cap,
+		out view T
+	) {
 		```
 		#arch: c
 		nomen_view _r;

package/core/System/Channel.nm

@@ -180,6 +180,8 @@ pub class Channel: Sendable {
 		str x2, [x19, #32]        // tail = node
 		ldr x0, [x19, #16]        // not_empty_cv
 		bl _pthread_cond_signal
+		add x0, x19, #40          // &self->waiters — wake parked fibers
+		bl ___nomen_fiber_waitq_wake
 		ldr x0, [x19, #8]         // self->mu
 		bl _pthread_mutex_unlock
 		add sp, sp, #32

package/core/System/ClassBuffer.nm

@@ -37,7 +37,7 @@ pub struct ClassBuffer<T> {
 		if new_cap == 0 {
 			new_cap = 4
 		}
-		while new_cap < needed; new_cap *= 2 {}
+		while new_cap < needed; new_cap *= 2 { }
 		self.data = realloc(self.data, new_cap * 8)
 		memset(self.data + self.cap * 8, 0, (new_cap - self.cap) * 8)
 		self.cap = new_cap
@@ -73,7 +73,7 @@ pub struct ClassBuffer<T> {
 		if new_cap == 0 {
 			new_cap = 4
 		}
-		while new_cap < needed; new_cap *= 2 {}
+		while new_cap < needed; new_cap *= 2 { }
 		self.data = realloc(self.data, new_cap * 8)
 		memset(self.data + self.cap * 8, 0, (new_cap - self.cap) * 8)
 		self.cap = new_cap
@@ -150,7 +150,7 @@ pub struct ClassBuffer<T> {
 	// unless `f` returned it. Storing the returned instance raw is sound:
 	// the slot takes sole ownership and `f`'s return is not retained
 	// elsewhere. NOT `inline`: the body calls through the fn pointer.
-	func modify = (ref self, int i: i >= 0 && i < self.cap, func (T, out T) f) {
+	func modify = (ref self, int i: i >= 0 && i < self.cap, func(T, out T) f) {
 		```
 		#arch: c
 		long *slots = (long*)(unsigned long long)self->data;
@@ -299,7 +299,11 @@ pub struct ClassBuffer<T> {
 	// instance afterwards. The class-buffer counterpart of Buffer.shift,
 	// used by Map/Set.remove's backward-shift so shifting entries neither
 	// duplicates nor orphans owned instances.
-	func shift = (ref self, int dst: dst >= 0 && dst < self.cap, int src: src >= 0 && src < self.cap) {
+	func shift = (
+		ref self,
+		int dst: dst >= 0 && dst < self.cap,
+		int src: src >= 0 && src < self.cap
+	) {
 		```
 		#arch: c
 		long *slots = (long*)(unsigned long long)self->data;
@@ -343,7 +347,12 @@ pub struct ClassBuffer<T> {
 	// pointers, returned as a `view T` (T is a class, so each element is an
 	// 8-byte pointer). Borrows from self — invalidated on reassignment. Mirrors
 	// Buffer.slice; ClassBuffer stores 8-byte slots, so the element width is 8.
-	func slice = (self, int start: start >= 0, int end: end >= start && end <= self.cap, out view T) {
+	func slice = (
+		self,
+		int start: start >= 0,
+		int end: end >= start && end <= self.cap,
+		out view T
+	) {
 		```
 		#arch: c
 		nomen_view _r;

package/core/System/Controls/Button.nm

@@ -1,7 +1,7 @@
 /**
  * A push-button control that triggers an action when clicked
  **/
-pub class Button : Control {
+pub class Button: Control {
 	var uint64 handle = 0
 
 	pub func #init = (self, Window window, string title) {
@@ -162,7 +162,7 @@ pub class Button : Control {
 
 	pub func intrinsic_size = (self, out Size) {
 		var [w, h] = native_intrinsic(self.handle)
-		var Size s = Size()
+		var s = Size()
 		s.width = w
 		s.height = h
 		return s

package/core/System/Controls/CheckBox.nm

@@ -1,7 +1,7 @@
 /**
  * A toggle control with a title and checked/hidden state
  **/
-pub class CheckBox : Control {
+pub class CheckBox: Control {
 	var uint64 handle = 0
 
 	pub func #init = (self, Window window) {
@@ -199,7 +199,7 @@ pub class CheckBox : Control {
 	// ── Control trait conformance ──
 	pub func intrinsic_size = (self, out Size) {
 		var [w, h] = native_intrinsic(self.handle)
-		var Size s = Size()
+		var s = Size()
 		s.width = w
 		s.height = h
 		return s

package/core/System/Controls/Container.nm

@@ -248,7 +248,7 @@ pub func native_intrinsic = (uint64 handle, out [int, int]) {
  * so a `Container` can also be driven polymorphically as a `Control` (passed to
  * a `Control`-taking function, stored in a `ClassBuffer<Control>`, etc.).
  **/
-pub class Container : Control {
+pub class Container: Control {
 	var kinds = Buffer<int>()
 	// Per-leaf requested size, stored as a (kind, value) pair per axis. The
 	// kind is one of LEN_* (auto/fixed/percent/fill); the value is the pixel
@@ -1358,7 +1358,7 @@ pub class Container : Control {
 			constraints.max_height,
 		)
 		var int h = self.rh.load_int(self.root)
-		var Size s = Size()
+		var s = Size()
 		s.width = w
 		s.height = h
 		return s
@@ -1371,7 +1371,7 @@ pub class Container : Control {
 	pub func intrinsic_size = (self, out Size) {
 		var int w = self.measure_node(self.root, 0, INF, 0, INF)
 		var int h = self.rh.load_int(self.root)
-		var Size s = Size()
+		var s = Size()
 		s.width = w
 		s.height = h
 		return s

package/core/System/Controls/TextBox.nm

@@ -1,7 +1,7 @@
 /**
  * An editable single-line text input control
  **/
-pub class TextBox : Control {
+pub class TextBox: Control {
 	var uint64 handle = 0
 
 	pub func #init = (self, Window window) {
@@ -203,7 +203,7 @@ pub class TextBox : Control {
 	// ── Control trait conformance ──
 	pub func intrinsic_size = (self, out Size) {
 		var [w, h] = native_intrinsic(self.handle)
-		var Size s = Size()
+		var s = Size()
 		s.width = w
 		s.height = h
 		return s

package/core/System/Fiber.nm

@@ -23,15 +23,25 @@
 // 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.
+// The constructor and `.start_on(buf)` are compiler-special-cased (they
+// need the per-site spawn/trampoline machinery and the buffer's compile-time
+// byte size); `.start()` is a regular method over the runtime seam — it
+// reads the packed handles from the instance's fields and drives the
+// scheduler. The runtime (scheduler, context switch) lives in the build's
+// emitted companion C — see build_fiber_spawn.
+
+// The launch surface's return type (ASYNC.md: the dependency is
+// declared by the library file, not inferred from user-source tokens).
+import Task
 
 /**
  * A stackful coroutine: lightweight, cooperatively scheduled, parks instead of blocking
  **/
-pub class Fiber<T> : Sendable {
+pub class Fiber<T> : Sendable, Spawnable<T> {
+	// The construction hook (see Thread.nm): the deferred-call special form.
+	#spawn = () {
+	}
+
 	// 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
@@ -41,6 +51,76 @@ pub class Fiber<T> : Sendable {
 	pub var uint64 future = 0
 	// Must-start flag: set by .start() / .start_on(buf) / nursery.start.
 	pub var started = false
+	// LEXICAL NURSERY CAPTURE (ASYNC.md): the tracking slots of the
+	// `async` block that lexically encloses the CONSTRUCTION, or 0 when the
+	// construction is outside any block. `.start()` registers the future
+	// through these stored pointers — registration follows the scope that
+	// created the deferred call, not the one that happens to start it. See
+	// Thread.nm's matching fields.
+	pub var uint64 nursery_futures = 0
+	pub var uint64 nursery_count = 0
+	pub var uint64 nursery_cap = 0
+
+	// Start the deferred call on the fiber scheduler and yield the Task<T>
+	// handle. Same shape as Thread.start: consume the machinery, register
+	// with the construction-time nursery (if captured), transfer the handles
+	// out of the instance (started; #destroy no-ops), return the handle.
+	// While the fiber waits, it parks and frees its worker instead of
+	// blocking it.
+	pub func start = (ref self, move out Task<T>) {
+		```
+		#arch: c
+		struct nomen_future *_f = (struct nomen_future *)self->future;
+		_f->refs = self->nursery_futures ? 3 : 2;
+		__nomen_fiber_spawn((struct nomen_closure *)self->task, _f);
+		if (self->nursery_futures) {
+			__nomen_nursery_track((void **)self->nursery_futures, (int *)self->nursery_count, (int *)self->nursery_cap, _f);
+		}
+		```
+		```
+		#arch: aarch64
+		// x19 = self. f = self->future (#32); nursery_futures at #48.
+		ldr x0, [x19, #32]
+		ldr x1, [x19, #48]
+		mov w2, #2
+		cbz x1, .Lnomen_fstart_refs
+		mov w2, #3
+		.Lnomen_fstart_refs:
+		str w2, [x0, #116]
+		// __nomen_fiber_spawn(self->task, f)
+		ldr x0, [x19, #8]
+		ldr x1, [x19, #32]
+		bl ___nomen_fiber_spawn
+		// if (self->nursery_futures) __nomen_nursery_track(futures, count, cap, f)
+		ldr x0, [x19, #48]
+		cbz x0, .Lnomen_fstart_notrack
+		ldr x1, [x19, #56]
+		ldr x2, [x19, #64]
+		ldr x3, [x19, #32]
+		bl ___nomen_nursery_track
+		.Lnomen_fstart_notrack:
+		```
+		var t = Task<T>()
+		t.result_slot = self.result_slot
+		t.cancel_flag = self.cancel_flag
+		t.future = self.future
+		// Transfer the handles out of the instance: the runtime owns
+		// everything now, and #destroy must not touch (or must-start-abort).
+		self.task = 0
+		self.future = 0
+		self.result_slot = 0
+		self.cancel_flag = 0
+		self.started = true
+		return t
+	}
+
+	// Run the deferred call fire-and-forget (the Spawnable daemon role).
+	// The fiber is launched exactly like start, but the handle is dropped
+	// immediately: the future's refs are released as the discarded Task is
+	// reclaimed, and the fiber completes into the void — nothing joins it.
+	pub func detach = (ref self) {
+		self.start()
+	}
 
 	// Destroying an unstarted Fiber is a programming error (the wrapped
 	// call would silently never run) — report it and abort. A started

package/core/System/Graph.nm

@@ -7,7 +7,7 @@
  * A graph of values connected by edges
  **/
 pub struct Graph<T>: Enumerable {
-	var Buffer<T> values = Buffer<T>()
+	var values = Buffer<T>()
 	var head_edge = Buffer<int>()
 	var edge_target = Buffer<int>()
 	var edge_next = Buffer<int>()

package/core/System/LinkedList.nm

@@ -7,7 +7,7 @@
  * A doubly-linked list of values
  **/
 pub struct LinkedList<T>: Enumerable {
-	var Buffer<T> values = Buffer<T>()
+	var values = Buffer<T>()
 	var nexts = Buffer<int>()
 	var prevs = Buffer<int>()
 	var int head = -1

package/core/System/List.nm

@@ -3,7 +3,7 @@
  **/
 pub struct List<T>: Viewable {
 	var length = 0
-	var Buffer<T> items = Buffer<T>()
+	var items = Buffer<T>()
 
 	pub func push = (ref self, move T value) {
 		if self.length >= self.items.cap {
@@ -70,8 +70,8 @@ pub struct List<T>: Viewable {
 	// never re-checked, so it can't rely on check-time call-arg hoisting for
 	// struct element types.
 	pub func copy = (self, out List<T>) {
-		var List<T> dst = List<T>()
-		var int i = 0
+		var dst = List<T>()
+		var i = 0
 		while i < self.length {
 			var T v = self.at(i)
 			dst.push(v)

package/core/System/Map.nm

@@ -10,8 +10,8 @@
  **/
 pub struct Map<TK: Hashable + Equatable, TV> {
 	var length = 0
-	var Buffer<TK> keys = Buffer<TK>()
-	var Buffer<TV> values = Buffer<TV>()
+	var keys = Buffer<TK>()
+	var values = Buffer<TV>()
 	var used = Buffer<int>()
 
 	// Variadic-tuple constructor: Map<string, int>(["a", 1], ["b", 2]) or

package/core/System/Mutex.nm

@@ -16,7 +16,7 @@
 pub class Mutex: Sendable {
 	pub var uint64 handle = 0
 
-pub func #init = (self) {
+	pub func #init = (self) {
 	```
 	#arch: c
 	self->handle = (unsigned long long)__nomen_mutex_create();
@@ -26,9 +26,9 @@ pub func #init = (self) {
 	bl ___nomen_mutex_create
 	str x0, [x19, #8]
 	```
-}
+	}
 
-pub func lock = (self) {
+	pub func lock = (self) {
 	```
 	#arch: c
 	// Fibers park instead of blocking the worker (both models); other
@@ -40,9 +40,9 @@ pub func lock = (self) {
 	ldr x0, [x19, #8]
 	bl ___nomen_mutex_lock
 	```
-}
+	}
 
-pub func unlock = (self) {
+	pub func unlock = (self) {
 	```
 	#arch: c
 	__nomen_mutex_unlock_wake((void *)self->handle);
@@ -52,9 +52,9 @@ pub func unlock = (self) {
 	ldr x0, [x19, #8]
 	bl ___nomen_mutex_unlock_wake
 	```
-}
+	}
 
-pub func #destroy = () {
+	pub func #destroy = () {
 	```
 	#arch: c
 	if (self->handle) {
@@ -70,5 +70,5 @@ pub func #destroy = () {
 	str xzr, [x19, #8]
 	.Lmutex_destroy_end:
 	```
-}
+	}
 }

package/core/System/Option.nm

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

package/core/System/Random.nm

@@ -0,0 +1,67 @@
+// Random — a small, fast pseudo-random generator (splitmix64).
+//
+// Splitmix64 steps a 64-bit state by the golden ratio, then runs two
+// multiply-xor rounds. Streams from nearby seeds are fully decorrelated
+// (each seed is its own stream), so `Random()` — seeded from the wall
+// clock — is safe to construct repeatedly in quick succession (e.g. one
+// per spawned task, all starting within the same microsecond).
+//
+// Not cryptographically secure; `below`/`range` have slight modulo bias
+// for very large bounds.
+//
+//	var Random rng = Random()
+//	var uint64 roll = rng.below(6)          // 0..5
+//	var uint64 ms = rng.range(1000, 10000)  // 1000..10000, inclusive
+//
+import Time
+
+/**
+ * A fast splitmix64 pseudo-random number generator
+ **/
+pub class Random {
+	// The raw 64-bit generator state (seeded from the wall clock by the
+	// no-arg constructor, or an explicit seed for reproducible sequences).
+	pub var uint64 state = 0
+
+	// Seed from the wall clock (nanoseconds since the epoch).
+	pub func #init = (self) {
+		self.state = Time.now_ns()
+	}
+
+	// Seed from an explicit value — reproducible sequences for tests.
+	pub func #init = (self, uint64 seed) {
+		self.state = seed
+	}
+
+	// The next 64-bit value (splitmix64: golden-ratio step, then two
+	// multiply-xor rounds). Pure Nomen — the 64-bit arithmetic, bitwise
+	// operators, and hex literals all lower directly. The aarch64 codegen is
+	// a little looser than a hand-written `#arch` body would be (constant
+	// materialization, field reloads, non-immediate shift counts); see
+	// FOLLOWUP.md if this ever needs to be hot.
+	pub func next = (ref self, out uint64) {
+		self.state = self.state + 0x9E3779B97F4A7C15
+		var uint64 z = self.state
+		z = (z ^ (z >> 30)) * 0xBF58476D1CE4E5B9
+		z = (z ^ (z >> 27)) * 0x94D049BB133111EB
+		return z ^ (z >> 31)
+	}
+
+	// The next value in [0, bound). A bound of 0 returns 0. Slight modulo
+	// bias for very large bounds — irrelevant at demo scale.
+	pub func below = (ref self, uint64 bound, out uint64) {
+		if bound == 0 {
+			return 0
+		}
+		return self.next() % bound
+	}
+
+	// The next value in [lo, hi], both ends inclusive. A hi <= lo
+	// returns lo.
+	pub func range = (ref self, uint64 lo, uint64 hi, out uint64) {
+		if hi <= lo {
+			return lo
+		}
+		return lo + self.below(hi - lo + 1)
+	}
+}

package/core/System/Result.nm

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

package/core/System/Set.nm

@@ -9,7 +9,7 @@
  **/
 pub struct Set<T: Hashable + Equatable> {
 	var length = 0
-	var Buffer<T> slots = Buffer<T>()
+	var slots = Buffer<T>()
 	var used = Buffer<int>()
 
 	pub func add = (ref self, move T value) {

package/core/System/Spawnable.nm

@@ -0,0 +1,18 @@
+// Spawnable — the trait role of a deferred-work LAUNCHER (the C# shape;
+// see docs/ASYNC.md, "Design decisions"). A Spawnable class packs a deferred unit of work
+// (the construction special form) and its `start` submits it, yielding the
+// library-owned `Task<T>` handle — so the await half is guaranteed by the
+// return type and each type carries exactly one role: `Thread<T>`/`Fiber<T>`
+// are spawnable, `Task<T>` is awaitable. `Awaitable` stays non-generic (its
+// `wait` does not mention T); `Spawnable` is generic because `start`'s
+// return type does.
+//
+// `detach` is the daemon role: run the work unjoinable, statement only.
+
+/**
+ * A class that can launch a deferred call and hand back its Task<T> handle
+ **/
+pub trait Spawnable<T> {
+	func start = (ref self, move out Task<T>)
+	func detach = (ref self)
+}

package/core/System/Stream/File.nm

@@ -39,7 +39,7 @@ pub struct File {
 	pub var eof = false
 	// errno of the last operation; 0 = success. Raw #arch bodies set it,
 	// the Result-returning wrappers map it to FileError.
-	var int error = 0
+	var error = 0
 
 	// Maps an errno to its FileError case.
 	func error_of = (int err, out FileError) {
@@ -569,7 +569,7 @@ pub struct File {
 	// (static) Read the entire contents of `path` in one open/read/close.
 	pub func read_all = (string path, out Result<string, FileError>) {
 		var Result<string, FileError> result = .error(FileError.other)
-		var File f = File()
+		var f = File()
 		match f.open(path, "r") {
 			case .ok(did) {
 				match f.readAll() {
@@ -594,7 +594,7 @@ pub struct File {
 	// be deliberate).
 	pub func write_all = (string path, string data, out Result<bool, FileError>) {
 		var Result<bool, FileError> result = .error(FileError.other)
-		var File f = File()
+		var f = File()
 		match f.open(path, "w") {
 			case .ok(did) {
 				match f.writeAll(data) {

package/core/System/Stream/Http.nm

@@ -28,13 +28,13 @@
 pub struct Http {
 	// HTTP status code from the most recent request (e.g. 200). 0 when the
 	// request failed (the `error` side of the get/post Result says why).
-	pub var int status = 0
+	pub var status = 0
 
 	// Internal failure code from the most recent request: 0 = success,
 	// 1 = DNS resolution, 2 = socket creation, 3 = connect, 6 = send failed.
 	// Mirrors Tcp's codes on the connect path; the Result-returning wrappers
 	// map it to HttpError.
-	var int error = 0
+	var error = 0
 
 	// Maps the raw failure code to its HttpError case.
 	func error_of = (int err, out HttpError) {
@@ -61,7 +61,7 @@ pub struct Http {
 	// on failure).
 	func raw_exchange = (ref self, string method, string url, string body, move out string) {
 		// Parse the URL: [http://]host[:port][/path]
-		var int host_start = 0
+		var host_start = 0
 		if url.starts_with("http://") {
 			host_start = 7
 		}
@@ -77,13 +77,13 @@ pub struct Http {
 				name_end = colon
 			}
 		}
-		var int port = 80
+		var port = 80
 		if name_end != host_end {
 			var string port_text = url.substring(name_end + 1, host_end)
 			port = int.parse(port_text)
 		}
 		var string host = url.substring(host_start, name_end)
-		var string path = "/"
+		var path = "/"
 		if slash >= 0 {
 			path = url.substring(slash, url.length)
 		}