nomen-lang 0.0.7 → 0.0.9

package/core/System/Time.nm

@@ -0,0 +1,112 @@
+/**
+ * Wall-clock time and sleeping.
+ *
+ * All members are static — no instance is constructed.
+ *
+ *	const uint64 started = Time.now_ms()       // wall-clock ms since the epoch
+ *	const uint64 unix    = Time.now_unix()     // Unix seconds
+ *	const uint64 t       = Time.now_ns()       // wall-clock ns since the epoch
+ *	Time.sleep_ms(50)                          // sleep 50 ms
+ **/
+pub struct Time {
+	// (static) Wall-clock milliseconds since the Unix epoch.
+	pub func now_ms = (out uint64) {
+		```
+		#arch: c
+		#scope: file
+		#include <time.h>
+		```
+		```
+		#arch: c
+		struct timespec ts;
+		clock_gettime(CLOCK_REALTIME, &ts);
+		return (uint64_t)ts.tv_sec * 1000 + (uint64_t)ts.tv_nsec / 1000000;
+		```
+		```
+		#arch: aarch64
+		sub sp, sp, #160
+		mov x0, #0
+		mov x1, sp
+		bl _clock_gettime
+		ldr x0, [sp, #0]
+		mov x1, #1000
+		mul x0, x0, x1
+		ldr x1, [sp, #8]
+		ldr x2, =1000000
+		udiv x1, x1, x2
+		add x0, x0, x1
+		add sp, sp, #160
+		b .return_Time_now_ms
+		```
+		return 0
+	}
+
+	// (static) Wall-clock nanoseconds since the Unix epoch. Uses the same
+	// CLOCK_REALTIME source as `now_ms` (portable across macOS and Linux,
+	// where the CLOCK_MONOTONIC id differs) but keeps the full nanosecond
+	// resolution, which `Tester.bench` needs to time short function bodies.
+	// Seconds since the epoch times 1e9 stays well inside uint64 range.
+	pub func now_ns = (out uint64) {
+		```
+		#arch: c
+		struct timespec ts;
+		clock_gettime(CLOCK_REALTIME, &ts);
+		return (uint64_t)ts.tv_sec * 1000000000 + (uint64_t)ts.tv_nsec;
+		```
+		```
+		#arch: aarch64
+		sub sp, sp, #160
+		mov x0, #0
+		mov x1, sp
+		bl _clock_gettime
+		ldr x0, [sp, #0]
+		ldr x1, =1000000000
+		mul x0, x0, x1
+		ldr x1, [sp, #8]
+		add x0, x0, x1
+		add sp, sp, #160
+		b .return_Time_now_ns
+		```
+		return 0
+	}
+
+	// (static) Wall-clock seconds since the Unix epoch.
+	pub func now_unix = (out uint64) {
+		```
+		#arch: c
+		return (uint64_t)time(NULL);
+		```
+		```
+		#arch: aarch64
+		mov x0, #0
+		bl _time
+		```
+	}
+
+	// (static) Block the calling task for `ms` milliseconds. Uses nanosleep,
+	// so it is not capped at the 32-bit usleep range.
+	pub func sleep_ms = (uint64 ms) {
+		```
+		#arch: c
+		struct timespec ts;
+		ts.tv_sec = ms / 1000;
+		ts.tv_nsec = (long)(ms % 1000) * 1000000;
+		nanosleep(&ts, NULL);
+		```
+		```
+		#arch: aarch64
+		sub sp, sp, #16
+		mov x1, #1000
+		udiv x2, x0, x1
+		msub x3, x2, x1, x0
+		str x2, [sp, #0]
+		mul x3, x3, x1
+		mul x3, x3, x1
+		str x3, [sp, #8]
+		mov x0, sp
+		mov x1, #0
+		bl _nanosleep
+		add sp, sp, #16
+		```
+	}
+}

package/core/System/Tree.nm

@@ -0,0 +1,70 @@
+// Arena-backed binary tree. Values, left/right child indices, and parent indices
+// live in flat Buffers, so there is a single owner and cleanup is a flat free.
+// Node identifiers are stable int indices (read `count` before `add`); -1 means
+// "no child" / "no parent".
+
+/**
+ * A tree of values connected by parent/child links
+ **/
+pub struct Tree<T>: Enumerable {
+	var Buffer<T> values = Buffer<T>()
+	var lefts = Buffer<int>()
+	var rights = Buffer<int>()
+	var parents = Buffer<int>()
+	var count = 0
+
+	pub func add = (ref self, mov T value) {
+		const int idx = self.count
+		self.values.grow_int(idx + 1)
+		const int v = value
+		self.values.store_int(idx, v)
+		self.lefts.grow_int(idx + 1)
+		self.lefts.store_int(idx, -1)
+		self.rights.grow_int(idx + 1)
+		self.rights.store_int(idx, -1)
+		self.parents.grow_int(idx + 1)
+		self.parents.store_int(idx, -1)
+		self.count = self.count + 1
+	}
+
+	pub func set_left = (ref self, int idx, int left) {
+		self.lefts.store_int(idx, left)
+		self.parents.store_int(left, idx)
+	}
+
+	pub func set_right = (ref self, int idx, int right) {
+		self.rights.store_int(idx, right)
+		self.parents.store_int(right, idx)
+	}
+
+	pub func left = (self, int idx, out int: out >= -1 && out < self.count) {
+		return self.lefts.load_int(idx)
+	}
+
+	pub func right = (self, int idx, out int: out >= -1 && out < self.count) {
+		return self.rights.load_int(idx)
+	}
+
+	pub func parent_of = (self, int idx, out int: out >= -1 && out < self.count) {
+		return self.parents.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 count_nodes = (self, int idx, out int) {
+		if idx == -1 {
+			return 0
+		}
+		return 1 + self.count_nodes(self.left(idx)) + self.count_nodes(self.right(idx))
+	}
+
+	pub func length = (self, out int) {
+		return self.count
+	}
+}

package/core/System/Viewable.nm

@@ -0,0 +1,27 @@
+// Marker trait for containers that can be borrowed as a non-owning `view T`
+// slice via a `slice(start, end, out view T)` method. Conforming types
+// implement slice — almost always by delegating to an internal Buffer's slice
+// (`return self.items.slice(start, end)`), so no #arch code is needed in user
+// types. The resulting view supports `.length` and `.at(i)`; the element type
+// is the one named in the view (e.g. `view User`).
+//
+// Generic trait conformance is now parsed and checked by the compiler
+// (`trait Foo<T>` + `struct C: Foo<ConcreteType>`), so a type MAY parameterise
+// the trait and name its element type: `pub struct UserList: Viewable<User>`.
+// `Viewable` itself stays a plain marker today — the core `Array<T>` and
+// `List<T>` conformers and the SPEC examples all use the bare `: Viewable`
+// form, and migrating them to `: Viewable<Elem>` is a separate library/spec
+// change. The slice method is still declared with its concrete element view:
+//
+//   pub struct UserList: Viewable {
+//       var Buffer<User> items = Buffer<User>()
+//       pub func slice = (self, int start, int end, out view User) {
+//           return self.items.slice(start, end)
+//       }
+//   }
+
+/**
+ * A trait for containers that can be borrowed as a non-owning `view T` slice
+ **/
+pub trait Viewable {
+}

package/core/System/bool.nm

@@ -0,0 +1,66 @@
+/**
+ * A boolean value (`true` or `false`)
+ **/
+pub struct bool: Stringable {
+	/** 
+	 * Converts this boolean to a string value (`"true"` or `"false"`)
+	 *
+	 * @param self: the boolean
+	 * @out string: the boolean as a string value (`"true"` or `"false"`)
+	 **/
+	pub func to_string = (self, out string) {
+		```
+		#arch: c
+		int length = snprintf(NULL, 0, "%s", self ? "true" : "false");
+		char* str = malloc(length + 1);
+		snprintf(str, length + 1, "%s", self ? "true" : "false");
+		return str;
+		```
+		```
+		#arch: aarch64
+		sub sp, sp, #128
+		str x0, [sp, #0]
+		str x1, [sp, #8]
+		str x2, [sp, #16]
+		str x3, [sp, #24]
+		mov x0, xzr
+		mov x1, xzr
+		cbz x19, .Lfalse_bool
+		adr x2, .Lfmt_bool_true
+		mov x3, x19
+		bl _snprintf
+		add x0, x0, #1
+		str x0, [sp, #64]
+		bl _malloc
+		str x0, [sp, #72]
+		ldr x0, [sp, #72]
+		ldr x1, [sp, #64]
+		adr x2, .Lfmt_bool_true
+		mov x3, x19
+		bl _snprintf
+		ldr x0, [sp, #72]
+		add sp, sp, #128
+		b .Lend_bool_to_string
+		.Lfalse_bool:
+		adr x2, .Lfmt_bool_false
+		mov x3, x19
+		bl _snprintf
+		add x0, x0, #1
+		str x0, [sp, #64]
+		bl _malloc
+		str x0, [sp, #72]
+		ldr x0, [sp, #72]
+		ldr x1, [sp, #64]
+		adr x2, .Lfmt_bool_false
+		mov x3, x19
+		bl _snprintf
+		ldr x0, [sp, #72]
+		add sp, sp, #128
+		b .Lend_bool_to_string
+		.Lfmt_bool_true: .asciz "true"
+		.Lfmt_bool_false: .asciz "false"
+		.p2align 2
+		.Lend_bool_to_string:
+		```
+	}
+}

package/core/System/char.nm

@@ -0,0 +1,42 @@
+/**
+ * A single character
+ **/
+pub struct char: Stringable {
+	pub func to_string = (self, out string) {
+		```
+		#arch: c
+		int length = snprintf(NULL, 0, "%c", self);
+		char* str = malloc(length + 1);
+		snprintf(str, length + 1, "%c", self);
+		return str;
+		```
+		```
+		#arch: aarch64
+		sub sp, sp, #128
+		str x0, [sp, #0]
+		str x1, [sp, #8]
+		str x2, [sp, #16]
+		str x3, [sp, #24]
+		mov x0, xzr
+		mov x1, xzr
+		adr x2, .Lfmt_char_c
+		mov x3, x19
+		bl _snprintf
+		add x0, x0, #1
+		str x0, [sp, #64]
+		bl _malloc
+		str x0, [sp, #72]
+		ldr x0, [sp, #72]
+		ldr x1, [sp, #64]
+		adr x2, .Lfmt_char_c
+		mov x3, x19
+		bl _snprintf
+		ldr x0, [sp, #72]
+		add sp, sp, #128
+		b .Lend_char_to_string
+		.Lfmt_char_c: .asciz "%c"
+		.p2align 2
+		.Lend_char_to_string:
+		```
+	}
+}

package/core/System/float.nm

@@ -0,0 +1,43 @@
+/**
+ * A double-precision (64-bit) floating-point number
+ **/
+pub struct float: Stringable {
+	pub func to_string = (self, out string) {
+		```
+		#arch: c
+		int length = snprintf(NULL, 0, "%f", self);
+		char* str = malloc(length + 1);
+		snprintf(str, length + 1, "%f", self);
+		return str;
+		```
+		```
+		#arch: aarch64
+		sub sp, sp, #128
+		str x0, [sp, #0]
+		str x1, [sp, #8]
+		str x2, [sp, #16]
+		str x3, [sp, #24]
+		str d0, [sp, #64]
+		mov x0, xzr
+		mov x1, xzr
+		adr x2, .Lfmt_float_f
+		fmov d0, x19
+		bl _snprintf
+		add x0, x0, #1
+		str x0, [sp, #64]
+		bl _malloc
+		str x0, [sp, #72]
+		ldr x0, [sp, #72]
+		ldr x1, [sp, #64]
+		adr x2, .Lfmt_float_f
+		fmov d0, x19
+		bl _snprintf
+		ldr x0, [sp, #72]
+		add sp, sp, #128
+		b .Lend_float_to_string
+		.Lfmt_float_f: .asciz "%f"
+		.p2align 2
+		.Lend_float_to_string:
+		```
+	}
+}

package/core/System/int.nm

@@ -0,0 +1,54 @@
+/**
+ * A signed integer — the default integer type
+ **/
+pub struct int: Stringable {
+	pub func to_string = (self, out string) {
+		```
+		#arch: c
+		int length = snprintf(NULL, 0, "%ld", self);
+		char* str = malloc(length + 1);
+		snprintf(str, length + 1, "%ld", self);
+		return str;
+		```
+		```
+		#arch: aarch64
+		sub sp, sp, #128
+		str x0, [sp, #0]
+		str x1, [sp, #8]
+		str x2, [sp, #16]
+		str x3, [sp, #24]
+		mov x0, xzr
+		mov x1, xzr
+		adr x2, .Lfmt_int_ld
+		mov x3, x19
+		bl _snprintf
+		add x0, x0, #1
+		str x0, [sp, #64]
+		bl _malloc
+		str x0, [sp, #72]
+		ldr x0, [sp, #72]
+		ldr x1, [sp, #64]
+		adr x2, .Lfmt_int_ld
+		mov x3, x19
+		bl _snprintf
+		ldr x0, [sp, #72]
+		add sp, sp, #128
+		b .Lend_int_to_string
+		.Lfmt_int_ld: .asciz "%ld"
+		.p2align 2
+		.Lend_int_to_string:
+		```
+	}
+
+	// Parse a base-10 integer from a string.
+	pub func parse = (string s, out int) {
+		```
+		#arch: c
+		return atoi(s);
+		```
+		```
+		#arch: aarch64
+		bl _atoi
+		```
+	}
+}

package/core/System/int64.nm

@@ -0,0 +1,42 @@
+/**
+ * A 64-bit signed integer
+ **/
+pub struct int64: Stringable {
+	pub func to_string = (self, out string) {
+		```
+		#arch: c
+		int length = snprintf(NULL, 0, "%lld", self);
+		char* str = malloc(length + 1);
+		snprintf(str, length + 1, "%lld", self);
+		return str;
+		```
+		```
+		#arch: aarch64
+		sub sp, sp, #128
+		str x0, [sp, #0]
+		str x1, [sp, #8]
+		str x2, [sp, #16]
+		str x3, [sp, #24]
+		mov x0, xzr
+		mov x1, xzr
+		adr x2, .Lfmt_int64_lld
+		mov x3, x19
+		bl _snprintf
+		add x0, x0, #1
+		str x0, [sp, #64]
+		bl _malloc
+		str x0, [sp, #72]
+		ldr x0, [sp, #72]
+		ldr x1, [sp, #64]
+		adr x2, .Lfmt_int64_lld
+		mov x3, x19
+		bl _snprintf
+		ldr x0, [sp, #72]
+		add sp, sp, #128
+		b .Lend_int64_to_string
+		.Lfmt_int64_lld: .asciz "%lld"
+		.p2align 2
+		.Lend_int64_to_string:
+		```
+	}
+}

package/core/System/int8.nm

@@ -0,0 +1,42 @@
+/**
+ * An 8-bit signed integer
+ **/
+pub struct int8: Stringable {
+	pub func to_string = (self, out string) {
+		```
+		#arch: c
+		int length = snprintf(NULL, 0, "%d", self);
+		char* str = malloc(length + 1);
+		snprintf(str, length + 1, "%d", self);
+		return str;
+		```
+		```
+		#arch: aarch64
+		sub sp, sp, #128
+		str x0, [sp, #0]
+		str x1, [sp, #8]
+		str x2, [sp, #16]
+		str x3, [sp, #24]
+		mov x0, xzr
+		mov x1, xzr
+		adr x2, .Lfmt_int8_d
+		mov x3, x19
+		bl _snprintf
+		add x0, x0, #1
+		str x0, [sp, #64]
+		bl _malloc
+		str x0, [sp, #72]
+		ldr x0, [sp, #72]
+		ldr x1, [sp, #64]
+		adr x2, .Lfmt_int8_d
+		mov x3, x19
+		bl _snprintf
+		ldr x0, [sp, #72]
+		add sp, sp, #128
+		b .Lend_int8_to_string
+		.Lfmt_int8_d: .asciz "%d"
+		.p2align 2
+		.Lend_int8_to_string:
+		```
+	}
+}

package/core/System/uint.nm

@@ -0,0 +1,42 @@
+/**
+ * An unsigned integer
+ **/
+pub struct uint: Stringable {
+	pub func to_string = (self, out string) {
+		```
+		#arch: c
+		int length = snprintf(NULL, 0, "%ld", self);
+		char* str = malloc(length + 1);
+		snprintf(str, length + 1, "%ld", self);
+		return str;
+		```
+		```
+		#arch: aarch64
+		sub sp, sp, #128
+		str x0, [sp, #0]
+		str x1, [sp, #8]
+		str x2, [sp, #16]
+		str x3, [sp, #24]
+		mov x0, xzr
+		mov x1, xzr
+		adr x2, .Lfmt_uint_ld
+		mov x3, x19
+		bl _snprintf
+		add x0, x0, #1
+		str x0, [sp, #64]
+		bl _malloc
+		str x0, [sp, #72]
+		ldr x0, [sp, #72]
+		ldr x1, [sp, #64]
+		adr x2, .Lfmt_uint_ld
+		mov x3, x19
+		bl _snprintf
+		ldr x0, [sp, #72]
+		add sp, sp, #128
+		b .Lend_uint_to_string
+		.Lfmt_uint_ld: .asciz "%ld"
+		.p2align 2
+		.Lend_uint_to_string:
+		```
+	}
+}

package/core/System/uint64.nm

@@ -0,0 +1,42 @@
+/**
+ * A 64-bit unsigned integer
+ **/
+pub struct uint64: Stringable {
+	pub func to_string = (self, out string) {
+		```
+		#arch: c
+		int length = snprintf(NULL, 0, "%llu", self);
+		char* str = malloc(length + 1);
+		snprintf(str, length + 1, "%llu", self);
+		return str;
+		```
+		```
+		#arch: aarch64
+		sub sp, sp, #128
+		str x0, [sp, #0]
+		str x1, [sp, #8]
+		str x2, [sp, #16]
+		str x3, [sp, #24]
+		mov x0, xzr
+		mov x1, xzr
+		adr x2, .Lfmt_uint64_llu
+		mov x3, x19
+		bl _snprintf
+		add x0, x0, #1
+		str x0, [sp, #64]
+		bl _malloc
+		str x0, [sp, #72]
+		ldr x0, [sp, #72]
+		ldr x1, [sp, #64]
+		adr x2, .Lfmt_uint64_llu
+		mov x3, x19
+		bl _snprintf
+		ldr x0, [sp, #72]
+		add sp, sp, #128
+		b .Lend_uint64_to_string
+		.Lfmt_uint64_llu: .asciz "%llu"
+		.p2align 2
+		.Lend_uint64_to_string:
+		```
+	}
+}

package/core/System/uint8.nm

@@ -0,0 +1,42 @@
+/**
+ * An 8-bit unsigned integer
+ **/
+pub struct uint8: Stringable {
+	pub func to_string = (self, out string) {
+		```
+		#arch: c
+		int length = snprintf(NULL, 0, "%d", self);
+		char* str = malloc(length + 1);
+		snprintf(str, length + 1, "%d", self);
+		return str;
+		```
+		```
+		#arch: aarch64
+		sub sp, sp, #128
+		str x0, [sp, #0]
+		str x1, [sp, #8]
+		str x2, [sp, #16]
+		str x3, [sp, #24]
+		mov x0, xzr
+		mov x1, xzr
+		adr x2, .Lfmt_uint8_d
+		mov x3, x19
+		bl _snprintf
+		add x0, x0, #1
+		str x0, [sp, #64]
+		bl _malloc
+		str x0, [sp, #72]
+		ldr x0, [sp, #72]
+		ldr x1, [sp, #64]
+		adr x2, .Lfmt_uint8_d
+		mov x3, x19
+		bl _snprintf
+		ldr x0, [sp, #72]
+		add sp, sp, #128
+		b .Lend_uint8_to_string
+		.Lfmt_uint8_d: .asciz "%d"
+		.p2align 2
+		.Lend_uint8_to_string:
+		```
+	}
+}

package/core/docs/System/Ansi.md

@@ -0,0 +1,40 @@
+# Ansi
+
+## `struct Ansi`
+
+Helpers for styling terminal output with ANSI escape codes
+
+**Members:**
+
+- `bold(string s) -> string`
+- `dim(string s) -> string`
+- `italic(string s) -> string`
+- `underline(string s) -> string`
+- `blink(string s) -> string`
+- `reverse(string s) -> string`
+- `hidden(string s) -> string`
+- `strikethrough(string s) -> string`
+- `black(string s) -> string`
+- `red(string s) -> string`
+- `green(string s) -> string`
+- `yellow(string s) -> string`
+- `blue(string s) -> string`
+- `magenta(string s) -> string`
+- `cyan(string s) -> string`
+- `white(string s) -> string`
+- `bright_black(string s) -> string`
+- `bright_red(string s) -> string`
+- `bright_green(string s) -> string`
+- `bright_yellow(string s) -> string`
+- `bright_blue(string s) -> string`
+- `bright_magenta(string s) -> string`
+- `bright_cyan(string s) -> string`
+- `bright_white(string s) -> string`
+- `bg_black(string s) -> string`
+- `bg_red(string s) -> string`
+- `bg_green(string s) -> string`
+- `bg_yellow(string s) -> string`
+- `bg_blue(string s) -> string`
+- `bg_magenta(string s) -> string`
+- `bg_cyan(string s) -> string`
+- `bg_white(string s) -> string`

package/core/docs/System/Array.md

@@ -0,0 +1,16 @@
+# Array
+
+## `struct Array<T>`
+
+A fixed-length array of values, created with a literal (`[1, 2, 3]`) and addressable by index
+
+**Members:**
+
+- `at(int index) -> T`
+- `first() -> T`
+- `set(int index, T value)`
+- `at_end() -> T`
+- `slice(int start, int end) -> view T`
+- `with(T value, int count) -> T[]`
+- `add(Array other) -> Array`
+- `mul(int other) -> Array`