mt-lang 0.2.0 → 0.2.1

data/std/testing.mt

@@ -0,0 +1,266 @@
+# Standard library: testing core (T0 prototype)
+#
+# Minimal, in-language unit-testing surface — see docs/testing.md (§5, T0).
+# A test function returns `Check` and propagates the first failure with `?`:
+#
+#     import std.testing as t
+#
+#     function test_math() -> t.Check:
+#         t.expect_equal_int(2 + 2, 4)?
+#         return t.ok()
+#
+# A hand-written runner (see docs/testing.md §6 for future compiler-driven
+# discovery) calls `record` per test and `summarize` at the end:
+#
+#     function main() -> int:
+#         var stats = t.Stats.create()
+#         stats = t.record(stats, "math", test_math())
+#         return t.summarize(stats)
+
+import std.string as string
+import std.fmt as fmt
+import std.stdio as stdio
+import std.str
+import std.hash
+
+# A test outcome: success carries no meaningful value; failure carries a
+# `Failure`. `Result` is used (not a bespoke variant) so `?` propagation works.
+
+# A failed (or skipped) expectation. `message` is owned and must be released by
+# whoever consumes it (the runner does this in `record`). `is_skip` distinguishes
+# a skip from a real assertion failure.
+public struct Failure:
+    message: string.String
+    is_skip: bool
+
+public type Check = Result[bool, Failure]
+
+
+# Tally of outcomes for a run. Value type; `record` returns an updated copy.
+public struct Stats:
+    passed: int
+    failed: int
+    skipped: int
+
+
+extending Stats:
+    public static function create() -> Stats:
+        return Stats(passed = 0, failed = 0, skipped = 0)
+
+
+# ── Outcome constructors ──────────────────────────────────────────────────
+
+public function ok() -> Check:
+    return Result[bool, Failure].success(value = true)
+
+
+public function fail(message: str) -> Check:
+    return Result[bool, Failure].failure(error = Failure(message = string.String.from_str(message), is_skip = false))
+
+
+public function skip(reason: str) -> Check:
+    return Result[bool, Failure].failure(error = Failure(message = string.String.from_str(reason), is_skip = true))
+
+
+# ── Expectations ──────────────────────────────────────────────────────────
+
+public function expect(condition: bool, message: str) -> Check:
+    if condition:
+        return ok()
+
+    return fail(message)
+
+
+public function expect_true(condition: bool) -> Check:
+    return expect(condition, "expected true")
+
+
+public function expect_false(condition: bool) -> Check:
+    return expect(not condition, "expected false")
+
+
+public function expect_equal_int(actual: int, expected: int) -> Check:
+    if actual == expected:
+        return ok()
+
+    var message = string.String.create()
+    message.append("expected ")
+    fmt.append_int(ref_of(message), expected)
+    message.append(", got ")
+    fmt.append_int(ref_of(message), actual)
+    return Result[bool, Failure].failure(error = Failure(message = message, is_skip = false))
+
+
+public function expect_equal_str(actual: str, expected: str) -> Check:
+    var actual_string = string.String.from_str(actual)
+    var expected_string = string.String.from_str(expected)
+    let same = actual_string.equal(expected_string)
+    actual_string.release()
+    expected_string.release()
+    if same:
+        return ok()
+
+    var message = string.String.create()
+    message.append("expected [")
+    message.append(expected)
+    message.append("], got [")
+    message.append(actual)
+    message.append("]")
+    return Result[bool, Failure].failure(error = Failure(message = message, is_skip = false))
+
+
+public function expect_equal_bool(actual: bool, expected: bool) -> Check:
+    if actual == expected:
+        return ok()
+
+    var message = string.String.create()
+    message.append("expected ")
+    fmt.append_bool(ref_of(message), expected)
+    message.append(", got ")
+    fmt.append_bool(ref_of(message), actual)
+    return Result[bool, Failure].failure(error = Failure(message = message, is_skip = false))
+
+
+public function expect_not_equal_int(actual: int, expected: int) -> Check:
+    if actual != expected:
+        return ok()
+
+    var message = string.String.create()
+    message.append("expected not ")
+    fmt.append_int(ref_of(message), expected)
+    message.append(", got ")
+    fmt.append_int(ref_of(message), actual)
+    return Result[bool, Failure].failure(error = Failure(message = message, is_skip = false))
+
+
+public function expect_not_equal_str(actual: str, expected: str) -> Check:
+    var actual_string = string.String.from_str(actual)
+    var expected_string = string.String.from_str(expected)
+    let same = actual_string.equal(expected_string)
+    actual_string.release()
+    expected_string.release()
+    if not same:
+        return ok()
+
+    var message = string.String.create()
+    message.append("expected not [")
+    message.append(expected)
+    message.append("], got [")
+    message.append(actual)
+    message.append("]")
+    return Result[bool, Failure].failure(error = Failure(message = message, is_skip = false))
+
+
+public function expect_not_equal_bool(actual: bool, expected: bool) -> Check:
+    if actual != expected:
+        return ok()
+
+    var message = string.String.create()
+    message.append("expected not ")
+    fmt.append_bool(ref_of(message), expected)
+    message.append(", got ")
+    fmt.append_bool(ref_of(message), actual)
+    return Result[bool, Failure].failure(error = Failure(message = message, is_skip = false))
+
+
+# Generic equality over any type with a canonical `T.equal` hook: primitives
+# (import std.hash), `str` (import std.str), and user structs that define `equal`
+# (or delegate to std.hash.equal_struct). On failure the actual/expected values
+# are rendered via `std.fmt.format_value`, so `T` must be a primitive or a struct
+# whose fields are themselves `format_value`-renderable.
+public function expect_equal[T](actual: T, expected: T) -> Check:
+    if equal[T](actual, expected):
+        return ok()
+
+    var message = string.String.create()
+    message.append("expected ")
+    fmt.format_value[T](ref_of(message), const_ptr_of(expected))
+    message.append(", got ")
+    fmt.format_value[T](ref_of(message), const_ptr_of(actual))
+    return Result[bool, Failure].failure(error = Failure(message = message, is_skip = false))
+
+
+public function expect_some[T](option: Option[T]) -> Check:
+    if option.is_some():
+        return ok()
+
+    return fail("expected Option.some, got Option.none")
+
+
+public function expect_none[T](option: Option[T]) -> Check:
+    if option.is_none():
+        return ok()
+
+    return fail("expected Option.none, got Option.some")
+
+
+public function expect_null[T](pointer: const_ptr[T]?) -> Check:
+    if pointer == null:
+        return ok()
+
+    return fail("expected null pointer, got non-null")
+
+
+public function expect_not_null[T](pointer: const_ptr[T]?) -> Check:
+    if pointer != null:
+        return ok()
+
+    return fail("expected non-null pointer, got null")
+
+
+public function expect_error[T, E](result: Result[T, E]) -> Check:
+    if result.is_failure():
+        return ok()
+
+    return fail("expected Result.failure, got Result.success")
+
+
+# ── Runner (hand-written; compiler discovery is a later phase) ─────────────
+
+public function record(stats: Stats, name: str, outcome: Check) -> Stats:
+    match outcome:
+        Result.success:
+            var line = string.String.create()
+            line.append("ok   - ")
+            line.append(name)
+            stdio.print_line(line.as_str())
+            line.release()
+            return Stats(passed = stats.passed + 1, failed = stats.failed, skipped = stats.skipped)
+        Result.failure as payload:
+            let failure = payload.error
+            var line = string.String.create()
+            if failure.is_skip:
+                line.append("skip - ")
+            else:
+                line.append("FAIL - ")
+
+            line.append(name)
+            line.append(": ")
+            line.append(failure.message.as_str())
+            stdio.print_line(line.as_str())
+            line.release()
+
+            var owned_message = failure.message
+            owned_message.release()
+
+            if failure.is_skip:
+                return Stats(passed = stats.passed, failed = stats.failed, skipped = stats.skipped + 1)
+
+            return Stats(passed = stats.passed, failed = stats.failed + 1, skipped = stats.skipped)
+
+
+public function summarize(stats: Stats) -> int:
+    var line = string.String.create()
+    line.append("passed=")
+    fmt.append_int(ref_of(line), stats.passed)
+    line.append(" failed=")
+    fmt.append_int(ref_of(line), stats.failed)
+    line.append(" skipped=")
+    fmt.append_int(ref_of(line), stats.skipped)
+    stdio.print_line(line.as_str())
+    line.release()
+
+    if stats.failed > 0:
+        return 1
+
+    return 0

data/std/thread.mt

@@ -0,0 +1,120 @@
+import std.libuv as libuv
+import std.mem.heap as heap
+import std.str as text
+import std.string as string
+
+public type NativeThreadHandle = libuv.uv_thread_t
+
+public struct Error:
+    code: int
+    message: string.String
+
+public struct Thread:
+    handle: ptr[NativeThreadHandle]?
+
+struct RawStartState:
+    entry: fn(arg: ptr[void]) -> void
+    arg: ptr[void]
+
+struct VoidStartState:
+    run: fn() -> void
+
+
+function libuv_error(code: int) -> Error:
+    return Error(code = code, message = string.String.from_str(text.cstr_as_str(libuv.strerror(code))))
+
+
+function thread_handle(handle: ptr[NativeThreadHandle]?) -> ptr[NativeThreadHandle]:
+    let live_handle = handle else:
+        fatal(c"thread handle is released")
+
+    return live_handle
+
+
+function thread_entry_raw(frame: ptr[void]) -> void:
+    let state = unsafe: ptr[RawStartState]<-frame
+    let entry = unsafe: read(state).entry
+    let arg = unsafe: read(state).arg
+    heap.release(state)
+    entry(arg)
+
+
+function thread_entry_void(frame: ptr[void]) -> void:
+    let state = unsafe: ptr[VoidStartState]<-frame
+    let run = unsafe: read(state).run
+    heap.release(state)
+    run()
+
+
+public function spawn_raw(entry: fn(arg: ptr[void]) -> void, arg: ptr[void]) -> Result[Thread, Error]:
+    let handle = heap.must_alloc_zeroed[NativeThreadHandle](1)
+    let state = heap.must_alloc_zeroed[RawStartState](1)
+    unsafe:
+        state.entry = entry
+        state.arg = arg
+
+    let status_code = libuv.thread_create(handle, thread_entry_raw, unsafe: ptr[void]<-state)
+    if status_code != 0:
+        heap.release(state)
+        heap.release(handle)
+        return Result[Thread, Error].failure(error = libuv_error(status_code))
+
+    return Result[Thread, Error].success(value = Thread(handle = handle))
+
+
+public function spawn(run: fn() -> void) -> Result[Thread, Error]:
+    let handle = heap.must_alloc_zeroed[NativeThreadHandle](1)
+    let state = heap.must_alloc_zeroed[VoidStartState](1)
+    unsafe: state.run = run
+
+    let status_code = libuv.thread_create(handle, thread_entry_void, unsafe: ptr[void]<-state)
+    if status_code != 0:
+        heap.release(state)
+        heap.release(handle)
+        return Result[Thread, Error].failure(error = libuv_error(status_code))
+
+    return Result[Thread, Error].success(value = Thread(handle = handle))
+
+
+extending Error:
+    public editable function release() -> void:
+        this.message.release()
+
+
+extending Thread:
+    public editable function release() -> void:
+        let handle = this.handle else:
+            return
+
+        let status_code = libuv.thread_detach(handle)
+        if status_code != 0:
+            fatal(c"thread release detach failed")
+
+        heap.release(handle)
+        this.handle = null
+
+
+    public function joinable() -> bool:
+        return this.handle != null[ptr[NativeThreadHandle]]
+
+
+    public editable function join() -> Result[bool, Error]:
+        let handle = this.handle else:
+            return Result[bool, Error].failure(error = Error(
+                code = -1,
+                message = string.String.from_str("thread handle is released")
+            ))
+
+        let status_code = libuv.thread_join(handle)
+        if status_code != 0:
+            return Result[bool, Error].failure(error = libuv_error(status_code))
+
+        heap.release(handle)
+        this.handle = null
+        return Result[bool, Error].success(value = true)
+
+
+public function sleep_ms(milliseconds: uint) -> void:
+    usleep(milliseconds * 1000u)
+
+external function usleep(__useconds: uint) -> int

data/std/time.mt

@@ -0,0 +1,105 @@
+import std.c.time as c
+
+public type Timestamp = c.time_t
+public type ClockId = c.clockid_t
+public type DateTime = c.tm
+public type TimeSpec = c.timespec
+
+public const REALTIME_CLOCK: ClockId = c.CLOCK_REALTIME
+public const MONOTONIC_CLOCK: ClockId = c.CLOCK_MONOTONIC
+public const NANOSECONDS_PER_SECOND: ptr_uint = 1000000000
+public const NANOSECONDS_PER_MILLISECOND: ptr_uint = 1000000
+
+public foreign function current_timestamp(out value: Timestamp) -> Timestamp = c.time
+public foreign function timestamp_from_local_time(value: ptr[DateTime]) -> Timestamp = c.mktime
+public foreign function seconds_between(left: Timestamp, right: Timestamp) -> double = c.difftime
+public foreign function format_date_time(buffer: ptr[char], max_size: ptr_uint, format: str as cstr, value: ptr[DateTime]) -> ptr_uint = c.strftime
+public foreign function clock_resolution_into(clock_id: ClockId, out resolution: TimeSpec) -> int = c.clock_getres
+public foreign function clock_time_into(clock_id: ClockId, out value: TimeSpec) -> int = c.clock_gettime
+public foreign function sleep_for(duration: const_ptr[TimeSpec], remaining: ptr[TimeSpec]?) -> int = c.nanosleep
+
+
+public function now() -> Timestamp:
+    return c.time(null)
+
+
+public function local_time_ptr(value: Timestamp) -> ptr[DateTime]?:
+    var copy = value
+    return c.localtime(ptr_of(copy))
+
+
+public function utc_time_ptr(value: Timestamp) -> ptr[DateTime]?:
+    var copy = value
+    return c.gmtime(ptr_of(copy))
+
+
+public function format_into(buffer: ptr[char], max_size: ptr_uint, format: str, value: ptr[DateTime]?) -> ptr_uint:
+    if value == null:
+        return 0
+
+    return format_date_time(buffer, max_size, format, value)
+
+
+public function format_local_time_into(
+    buffer: ptr[char],
+    max_size: ptr_uint,
+    format: str,
+    value: Timestamp
+) -> ptr_uint:
+    return format_into(buffer, max_size, format, local_time_ptr(value))
+
+
+public function format_utc_time_into(buffer: ptr[char], max_size: ptr_uint, format: str, value: Timestamp) -> ptr_uint:
+    return format_into(buffer, max_size, format, utc_time_ptr(value))
+
+
+public function clock_resolution(clock_id: ClockId, resolution: ref[TimeSpec]) -> int:
+    return c.clock_getres(clock_id, ptr_of(resolution))
+
+
+public function clock_time(clock_id: ClockId, value: ref[TimeSpec]) -> int:
+    return c.clock_gettime(clock_id, ptr_of(value))
+
+
+public function realtime(value: ref[TimeSpec]) -> int:
+    return clock_time(REALTIME_CLOCK, value)
+
+
+public function monotonic(value: ref[TimeSpec]) -> int:
+    return clock_time(MONOTONIC_CLOCK, value)
+
+
+public function seconds(value: ptr_int) -> TimeSpec:
+    return c.timespec(tv_sec = value, tv_nsec = 0)
+
+
+public function milliseconds(value: ptr_uint) -> TimeSpec:
+    let seconds_part = ptr_int<-(value / 1000z)
+    let nanoseconds_part = ptr_int<-((value % 1000z) * NANOSECONDS_PER_MILLISECOND)
+    return c.timespec(tv_sec = seconds_part, tv_nsec = nanoseconds_part)
+
+
+public function nanoseconds(value: ptr_uint) -> TimeSpec:
+    let seconds_part = ptr_int<-(value / NANOSECONDS_PER_SECOND)
+    let nanoseconds_part = ptr_int<-(value % NANOSECONDS_PER_SECOND)
+    return c.timespec(tv_sec = seconds_part, tv_nsec = nanoseconds_part)
+
+
+public function sleep(duration: TimeSpec) -> int:
+    var requested = duration
+    return sleep_for(ptr_of(requested), null)
+
+
+public function sleep_seconds(value: ptr_uint) -> int:
+    var requested = seconds(ptr_int<-value)
+    return sleep_for(ptr_of(requested), null)
+
+
+public function sleep_milliseconds(value: ptr_uint) -> int:
+    var requested = milliseconds(value)
+    return sleep_for(ptr_of(requested), null)
+
+
+public function sleep_nanoseconds(value: ptr_uint) -> int:
+    var requested = nanoseconds(value)
+    return sleep_for(ptr_of(requested), null)