nomen-lang 0.0.19 → 0.2.0

package/core/System/Stream/FileError.nm

@@ -0,0 +1,21 @@
+/**
+ * The failure mode of a file operation.
+ *
+ *	File.write_all("out.txt", "payload")
+ *	var Result<string, FileError> body = File.read_all("out.txt")
+ *	match body {
+ *		case .ok(text) -> Console.write(text)
+ *		case .error(e) -> Console.write("failed")
+ *	}
+ *
+ * Cases map from the underlying errno: `not_found` (ENOENT), `access_denied`
+ * (EACCES), `already_exists` (EEXIST), `not_open` (operating on a `File`
+ * whose open failed or that was already closed), `other` (anything else).
+ **/
+pub enum FileError {
+	case not_found
+	case access_denied
+	case already_exists
+	case not_open
+	case other
+}

package/core/System/Stream/Http.nm

@@ -4,7 +4,8 @@
  * Plain `http://` only — no TLS (an `https://` URL cannot be served; use a
  * TLS proxy or wait for a TLS-capable transport). Construct an instance,
  * call `get`/`post` (which block until the full response is received), then
- * read the `status` field for the response's status code. `status` is 0 when
+ * read the `status` field for the response's status code. Fallible calls
+ * return a `Result` whose error side is an `HttpError`; `status` is 0 when
  * DNS resolution or the connection fails.
  *
  * URLs may carry an explicit port (`http://host:8080/path`); the default is
@@ -14,20 +15,47 @@
  * separator line) is returned.
  *
  *	var Http h = Http()
- *	var string body = h.get("http://example.com/")
- *	var int code     = h.status
- *	var string r     = h.post("http://example.com/submit", "hello=world")
+ *	match h.get("http://example.com/") {
+ *		case .ok(body) -> Console.write(body)
+ *		case .error(e) -> Console.write("request failed")
+ *	}
+ *	var int code = h.status
  **/
 pub struct Http {
-	// HTTP status code from the most recent request (e.g. 200). 0 if DNS or
-	// the connection failed.
+	// 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
 
+	// Internal failure code from the most recent request: 0 = success,
+	// 1 = DNS resolution, 2 = socket creation, 3 = connect. Raw #arch bodies
+	// set it, the Result-returning wrappers map it to HttpError.
+	var int error = 0
+
+	// Maps the raw failure code to its HttpError case.
+	func error_of = (int err, out HttpError) {
+		switch {
+			case err == 1 {
+				return HttpError.dns
+			}
+			case err == 2 {
+				return HttpError.socket
+			}
+			case err == 3 {
+				return HttpError.connect
+			}
+			else {
+				return HttpError.other
+			}
+		}
+	}
+
 	// Shared socket round-trip used by get/post. `method` is the request
 	// method string ("GET" / "POST"); a leading 'P' selects POST semantics
-	// (sends `body` and the Content-* headers). Sets self->status and returns
-	// the response body (empty string on failure).
-	func exchange = (ref self, string method, string url, string body, out string) {
+	// (sends `body` and the Content-* headers). Sets self->status (0 on
+	// failure) and self->error, and returns the response body (empty string
+	// on failure). The raw body mallocs the response — `move out string`
+	// transfers ownership to the caller.
+	func raw_exchange = (ref self, string method, string url, string body, move out string) {
 		```
 		#arch: c
 		#scope: file
@@ -39,8 +67,10 @@ pub struct Http {
 		```
 		```
 		#arch: c
-		const char *scheme = strstr(url, "://");
-		const char *hp = scheme ? scheme + 3 : url;
+		// Fat-string ABI: params are (ptr, len) pairs; consume the .ptr
+		// halves at each FFI boundary.
+		const char *scheme = strstr(url.ptr, "://");
+		const char *hp = scheme ? scheme + 3 : url.ptr;
 		const char *colon = strchr(hp, ':');
 		const char *slash = strchr(hp, '/');
 		char host[256];
@@ -70,33 +100,36 @@ pub struct Http {
 		snprintf(portstr, sizeof(portstr), "%d", port);
 		if (getaddrinfo(host, portstr, &hints, &res) != 0) {
 			self->status = 0;
-			return strdup("");
+			self->error = 1;
+			return (nomen_string){ strdup(""), 0 };
 		}
 		int sock = socket(AF_INET, SOCK_STREAM, 0);
 		if (sock < 0) {
 			freeaddrinfo(res);
 			self->status = 0;
-			return strdup("");
+			self->error = 2;
+			return (nomen_string){ strdup(""), 0 };
 		}
 		if (connect(sock, res->ai_addr, res->ai_addrlen) < 0) {
 			freeaddrinfo(res);
 			close(sock);
 			self->status = 0;
-			return strdup("");
+			self->error = 3;
+			return (nomen_string){ strdup(""), 0 };
 		}
 		freeaddrinfo(res);
 
 		char req[1600];
 		int off = snprintf(req, sizeof(req),
 			"%s %s HTTP/1.1\r\nHost: %s\r\nConnection: close\r\n",
-			method, path, host);
-		if (method[0] == 'P') {
-			int blen = (int)strlen(body);
+			method.ptr, path, host);
+		if (method.ptr[0] == 'P') {
+			int blen = (int)body.len;
 			off += snprintf(req + off, sizeof(req) - off,
 				"Content-Type: application/x-www-form-urlencoded\r\nContent-Length: %d\r\n\r\n",
 				blen);
 			send(sock, req, off, 0);
-			send(sock, body, blen, 0);
+			send(sock, body.ptr, blen, 0);
 		} else {
 			off += snprintf(req + off, sizeof(req) - off, "\r\n");
 			send(sock, req, off, 0);
@@ -120,18 +153,24 @@ pub struct Http {
 			code = atoi(buf + 9);
 		}
 		self->status = code;
+		self->error = 0;
 
 		char *body_start = strstr(buf, "\r\n\r\n");
 		if (body_start) {
 			char *result = strdup(body_start + 4);
+			long rlen = (long)len - (long)(body_start + 4 - buf);
 			free(buf);
-			return result;
+			return (nomen_string){ result, rlen };
 		}
-		return buf;
+		return (nomen_string){ buf, len };
 		```
 		```
 		#arch: aarch64
-		// x0=self(->x19), x1=method, x2=url, x3=body
+		// Fat-string ABI: x0=self(->x19); method=(x1,x2), url=(x3,x4),
+		// body=(x5,x6) — only the ptr halves are consumed below, plus
+		// body.len (stashed at #200) for Content-Length/send.
+		// Struct layout: self->status at [x19, #8], self->error at
+		// [x19, #16] (1 = dns, 2 = socket, 3 = connect; cleared on success).
 		// macOS arm64 passes variadic args on the caller stack at [sp+0..], so
 		// [sp+0..47] is reserved scratch for snprintf variadic args and the
 		// addrinfo hints live above it. Stack frame (2048 bytes):
@@ -146,8 +185,9 @@ pub struct Http {
 		//   #208 host buffer (256)   #464 request buffer (1584)
 		sub sp, sp, #2048
 		str x1, [sp, #128]
-		str x2, [sp, #136]
-		str x3, [sp, #144]
+		str x3, [sp, #136]
+		str x5, [sp, #144]
+		str x6, [sp, #200]           // body len
 		mov x0, #80
 		str x0, [sp, #112]
 		adr x0, .Lhttp_slash
@@ -245,7 +285,7 @@ pub struct Http {
 		add x2, sp, #48
 		add x3, sp, #96
 		bl _getaddrinfo
-		cbnz w0, .Lhttp_fail
+		cbnz w0, .Lhttp_dnsfail
 
 		// sock = socket(AF_INET, SOCK_STREAM, 0)
 		mov x0, #2
@@ -256,6 +296,8 @@ pub struct Http {
 		b.ge .Lhttp_sockok
 		ldr x0, [sp, #96]
 		bl _freeaddrinfo
+		mov x9, #2
+		str x9, [x19, #16]
 		b .Lhttp_fail
 		.Lhttp_sockok:
 		str w0, [sp, #104]
@@ -271,6 +313,8 @@ pub struct Http {
 		bl _freeaddrinfo
 		ldr w0, [sp, #104]
 		bl _close
+		mov x9, #3
+		str x9, [x19, #16]
 		b .Lhttp_fail
 		.Lhttp_connected:
 		ldr x0, [sp, #96]
@@ -297,10 +341,9 @@ pub struct Http {
 		cmp w0, #0x50
 		b.ne .Lhttp_getsend
 
-		// POST: blen = strlen(body); append Content-Length; send headers; send body
-		ldr x0, [sp, #144]
-		bl _strlen
-		str x0, [sp, #160]
+		// POST: blen = body.len (fat half); append Content-Length; send both
+		ldr x9, [sp, #200]
+		str x9, [sp, #160]
 		// snprintf(req+off, 1584-off, reqpost, blen) — blen on stack at [sp+0]
 		ldr x9, [sp, #160]
 		str x9, [sp, #0]
@@ -321,11 +364,9 @@ pub struct Http {
 		ldr x2, [sp, #176]
 		mov x3, xzr
 		bl _send
-		ldr x0, [sp, #144]
-		bl _strlen
-		mov x2, x0
 		ldr w0, [sp, #104]
 		ldr x1, [sp, #144]
+		ldr x2, [sp, #200]
 		mov x3, xzr
 		bl _send
 		b .Lhttp_recv
@@ -394,36 +435,51 @@ pub struct Http {
 		strb wzr, [x0, x1]
 		ldr w0, [sp, #104]
 		bl _close
+		// success: clear error before storing the status code
+		str xzr, [x19, #16]
 		// self->status = atoi(buf + 9)
 		ldr x0, [sp, #160]
 		add x0, x0, #9
 		bl _atoi
 		sxtw x0, w0
 		str x0, [x19, #8]
-		// body_start = strstr(buf, "\r\n\r\n")
+		// body_start = strstr(buf, "\r\n\r\n"); fat returns carry lens.
 		ldr x0, [sp, #160]
 		adr x1, .Lhttp_hdrsep
 		bl _strstr
 		cbz x0, .Lhttp_retbuf
-		// result = strdup(body_start + 4); free(buf); return result
+		// result = strdup(body_start + 4); rlen = len - (body_start+4-buf)
+		add x9, x0, #4
+		ldr x10, [sp, #160]
+		sub x9, x9, x10
+		ldr x10, [sp, #96]
+		sub x9, x10, x9              // rlen
+		str x9, [sp, #168]
 		add x0, x0, #4
 		bl _strdup
+		ldr x1, [sp, #168]
 		str x0, [sp, #112]
 		ldr x0, [sp, #160]
 		bl _free
 		ldr x0, [sp, #112]
 		add sp, sp, #2048
-		b .return_Http_exchange
+		b .return_Http_raw_exchange
 		.Lhttp_retbuf:
 		ldr x0, [sp, #160]
+		ldr x1, [sp, #96]
 		add sp, sp, #2048
-		b .return_Http_exchange
+		b .return_Http_raw_exchange
+		.Lhttp_dnsfail:
+		mov x9, #1
+		str x9, [x19, #16]
+		b .Lhttp_fail
 		.Lhttp_fail:
 		str xzr, [x19, #8]
 		adr x0, .Lhttp_empty
 		bl _strdup
+		mov x1, #0
 		add sp, sp, #2048
-		b .return_Http_exchange
+		b .return_Http_raw_exchange
 
 		.Lhttp_scheme: .asciz "://"
 		.Lhttp_slash: .asciz "/"
@@ -438,16 +494,25 @@ pub struct Http {
 		return ""
 	}
 
-	// Issue a blocking GET request to `url`. Returns the response body and
-	// sets `self.status` to the response's status code (0 on failure).
-	pub func get = (ref self, string url, out string) {
-		return self.exchange("GET", url, "")
+	// Issue a blocking GET request to `url`. `.ok(body)` with the response
+	// body and `self.status` set to the response's status code, or
+	// `.error(HttpError)` (`status` is 0).
+	pub func get = (ref self, string url, out Result<string, HttpError>) {
+		const string response = self.raw_exchange("GET", url, "")
+		if self.error == 0 {
+			return Result.ok(response)
+		}
+		return Result.error(Http.error_of(self.error))
 	}
 
 	// Issue a blocking POST request to `url` with `body` as the payload.
-	// Returns the response body and sets `self.status` to the response's
-	// status code (0 on failure).
-	pub func post = (ref self, string url, string body, out string) {
-		return self.exchange("POST", url, body)
+	// `.ok(body)` with the response body and `self.status` set to the
+	// response's status code, or `.error(HttpError)` (`status` is 0).
+	pub func post = (ref self, string url, string body, out Result<string, HttpError>) {
+		const string response = self.raw_exchange("POST", url, body)
+		if self.error == 0 {
+			return Result.ok(response)
+		}
+		return Result.error(Http.error_of(self.error))
 	}
 }

package/core/System/Stream/HttpError.nm

@@ -0,0 +1,20 @@
+/**
+ * The failure mode of an HTTP request.
+ *
+ *	var Http h = Http()
+ *	var Result<string, HttpError> body = h.get("http://example.com/")
+ *	match body {
+ *		case .ok(text) -> Console.write(text)
+ *		case .error(e) -> Console.write("failed")
+ *	}
+ *
+ * Cases map from the request lifecycle: `dns` (hostname resolution failed),
+ * `socket` (the socket could not be created), `connect` (the connection was
+ * refused or timed out), `other` (anything else).
+ **/
+pub enum HttpError {
+	case dns
+	case socket
+	case connect
+	case other
+}

package/core/System/String.nm

@@ -1,42 +1,31 @@
+// FFI: the C library's heap-copy entry point (string.h). The adapter
+// marshals the fat string to the thin char* the C ABI expects; the string
+// result is re-wrapped with its length.
+extern func strdup = (string s, move out string)
+
 /**
  * A UTF-8 text string — a heap-owned, length-tracked sequence of bytes
  **/
 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;
+		// djb2 over exactly self.length bytes — matches the byte count of
+		// owned strings and literals (views hash the viewed bytes only).
+		var uint h = 5381
+		var i = 0
+		while i < self.length; i += 1 {
+			h = h * 33 + (self.at(i) as uint)
 		}
-		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:
-		```
+		return h
 	}
 
-	pub func to_string = (self, out string) {
-		```
-		#arch: c
-		return strdup(self);
-		```
-		```
-		#arch: aarch64
-		mov x0, x19
-		```
+	// Returns an OWNED copy of self (`move out string`). Both backends hand
+	// back a fresh allocation the caller frees — never an alias of self's
+	// storage — so the result can outlive the receiver (e.g. escape a match
+	// branch that reclaims the scrutinee temp). Goes through the `strdup`
+	// extern: the adapter marshals self.ptr to libc and re-wraps the copy
+	// with its length.
+	pub func to_string = (self, move out string) {
+		return strdup(self)
 	}
 
 	pub func at = (self, int index: index >= 0 && index < self.length, out char) {
@@ -46,8 +35,9 @@ pub struct string: Stringable, Hashable, Equatable {
 		```
 		```
 		#arch: aarch64
-		// x19 = self (pointer), x1 = index
-		ldrb w0, [x19, x1]
+		// Fat-string ABI: x19 = self ptr, x20 = self len; index in x2
+		// (self's pair occupies slots 0-1).
+		ldrb w0, [x19, x2]
 		```
 	}
 
@@ -89,9 +79,10 @@ pub struct string: Stringable, Hashable, Equatable {
 		```
 		#arch: aarch64
 		// view string is (ptr, len), returned in the x0/x1 register pair.
-		// x19 = self (char*), x1 = start, x2 = end (retained through prologue).
-		add x0, x19, x1     // ptr = self + start
-		sub x1, x2, x1      // len = end - start
+		// Fat-string ABI: x19 = self ptr, x20 = self len; start in x2,
+		// end in x3 (self's pair occupies slots 0-1).
+		add x0, x19, x2     // ptr = self + start
+		sub x1, x3, x2      // len = end - start
 		```
 	}
 
@@ -114,10 +105,22 @@ pub struct string: Stringable, Hashable, Equatable {
 		```
 		```
 		#arch: aarch64
-		// x0 = self, x1 = other on entry
-		bl _strcmp
+		// Fat-string ABI: x19/x20 = self (ptr, len); other = (x2 ptr, x3
+		// len). Equal lengths + equal bytes — no NUL scan.
+		stp x20, x21, [sp, #-16]!
+		cmp x20, x3
+		b.ne .Lstring_eq_len_ne
+		mov x0, x19
+		mov x1, x2
+		mov x2, x20
+		bl _memcmp
 		cmp x0, #0
 		cset x0, eq
+		b .Lstring_eq_done
+		.Lstring_eq_len_ne:
+		mov x0, #0
+		.Lstring_eq_done:
+		ldp x20, x21, [sp], #16
 		```
 	}
 
@@ -133,23 +136,29 @@ pub struct string: Stringable, Hashable, Equatable {
 		```
 		```
 		#arch: aarch64
-		stp x20, x21, [sp, #-16]!
-		mov x20, x1
-		bl _strlen
-		mov x21, x0
-		mov x0, x20
-		bl _strlen
-		add x0, x21, x0
+		// Fat-string ABI: x19/x20 = self (ptr, len); other = (x2 ptr, x3
+		// len). Two memcpys of known length — no strlen/strcpy/strcat.
+		// Returns the (buf, total) pair.
+		stp x21, x22, [sp, #-16]!
+		stp x2, x3, [sp, #-16]!      // other (ptr, len)
+		add x0, x20, x3
 		add x0, x0, #1
 		bl _malloc
-		mov x21, x0
-		mov x1, x19
-		bl _strcpy
+		mov x21, x0                  // buf (callee-saved across memcpys)
 		mov x0, x21
-		mov x1, x20
-		bl _strcat
+		mov x1, x19
+		mov x2, x20
+		bl _memcpy                   // left half
+		ldp x1, x2, [sp]             // other ptr, len
+		add x0, x21, x20
+		bl _memcpy                   // right half
+		ldp x1, x2, [sp], #16        // reload other len; pop
+		add x3, x20, x2              // total bytes
+		add x0, x21, x3
+		strb wzr, [x0]               // NUL-terminate for libc consumers
+		mov x1, x3
 		mov x0, x21
-		ldp x20, x21, [sp], #16
+		ldp x21, x22, [sp], #16
 		```
 	}
 
@@ -169,29 +178,34 @@ pub struct string: Stringable, Hashable, Equatable {
 		```
 		```
 		#arch: aarch64
+		// Fat-string ABI: x19/x20 = self (ptr, len); count in x2. memcpy
+		// loop of known stride; returns the (buf, total) pair.
 		stp x20, x21, [sp, #-16]!
-		stp x22, xzr, [sp, #-16]!
-		mov x20, x1
-		bl _strlen
-		mov x21, x0
-		mul x0, x0, x20
-		add x0, x0, #1
+		stp x22, x23, [sp, #-16]!
+		stp x24, x25, [sp, #-16]!
+		mov x21, x20            // self len (stride)
+		mov x22, x2             // count
+		mul x23, x21, x22       // total bytes
+		add x0, x23, #1
 		bl _malloc
-		str x0, [x29, #8]
-		mov x22, x0
-		.Lmul_loop:
-		cbz x20, .Lmul_done
-		mov x0, x22
+		mov x24, x0             // buf
+		mov x25, x0             // cursor
+		.Lstring_mul_loop:
+		cbz x22, .Lstring_mul_done
+		mov x0, x25
 		mov x1, x19
 		mov x2, x21
 		bl _memcpy
-		add x22, x22, x21
-		sub x20, x20, #1
-		b .Lmul_loop
-		.Lmul_done:
-		strb wzr, [x22]
-		ldr x0, [x29, #8]
-		ldp x22, xzr, [sp], #16
+		add x25, x25, x21
+		sub x22, x22, #1
+		b .Lstring_mul_loop
+		.Lstring_mul_done:
+		add x0, x24, x23
+		strb wzr, [x0]          // NUL-terminate for libc consumers
+		mov x1, x23
+		mov x0, x24
+		ldp x24, x25, [sp], #16
+		ldp x22, x23, [sp], #16
 		ldp x20, x21, [sp], #16
 		```
 	}

package/core/System/StringBuilder.nm

@@ -59,7 +59,7 @@ pub struct StringBuilder {
 	}
 
 	// Append a single byte (char).
-	func append_char = (ref self, char c) {
+	pub inline func append_char = (ref self, char c) {
 		```
 		#arch: c
 		int idx = self->len;
@@ -128,15 +128,13 @@ pub struct StringBuilder {
 		```
 		```
 		#arch: aarch64
-		// x19 = self, x1 = s
-		// Save s across strlen/realloc.
-		mov x0, x1
+		// Fat-string ABI: x19 = self; s = (x1 ptr, x2 len). The length is
+		// already in a register — no strlen.
 		sub sp, sp, #32
-		str x0, [sp, #0]
-		bl _strlen
-		str x0, [sp, #8]          // sl
+		str x1, [sp, #0]          // s ptr
+		str x2, [sp, #8]          // sl
 		ldr x1, [x19, #16]        // len
-		add x1, x1, x0            // len + sl
+		add x1, x1, x2            // len + sl
 		add x1, x1, #1            // +1 for null room
 		// inline ensure(x1)
 		ldr x2, [x19, #24]
@@ -157,12 +155,11 @@ pub struct StringBuilder {
 		bl _realloc
 		str x0, [x19, #8]
 		.Lsb_as_copy:
-		// memcpy(data + len, s, sl)
-		ldr x1, [sp, #8]          // sl
+		// memcpy(data + len, s.ptr, sl)
 		ldr x0, [x19, #8]         // data
-		ldr x2, [x19, #16]        // len
-		add x0, x0, x2            // dest = data + len
-		ldr x1, [sp, #0]          // src = s
+		ldr x1, [x19, #16]        // len
+		add x0, x0, x1            // dest = data + len
+		ldr x1, [sp, #0]          // src = s ptr
 		ldr x2, [sp, #8]          // n = sl
 		bl _memcpy
 		// len = len + sl
@@ -221,6 +218,7 @@ pub struct StringBuilder {
 		strb wzr, [x0, x1]        // data[len] = 0
 		// transfer ownership: clear self->data. x0 retains the old ptr.
 		str xzr, [x19, #8]
+		// Fat-string ABI: (x0 = data, x1 = len) is already the return pair.
 		```
 	}