mt-lang 0.3.1 → 0.3.4

data/std/iter.mt

@@ -0,0 +1,304 @@
+## std.iter — composable, lazy iteration adaptors.
+##
+## Each source/adaptor creates heap-allocated state linked through
+## function pointers. Release walks the chain to free all allocations.
+## Callbacks use fn types (function pointers, no captures).
+##
+## iter_map stores the mapped value inline in the adaptor state and
+## returns a pointer to it — no per-item allocation.
+##
+## Usage:
+##   import std.iter
+##   let it = iter.from_array(ref_of(arr))
+##   let it2 = iter.iter_filter(it, pred)
+##   let v = iter.collect_vec(it2)
+
+import std.mem.heap as heap
+import std.mem.ptr as ptr
+import std.vec as v
+
+## ── Core Iter type ───────────────────────────────────────────────────
+
+struct Iter[T]:
+    state: ptr[void]
+    next_fn: fn(state: ptr[void]) -> ptr[T]?
+    release_fn: fn(state: ptr[void]) -> void
+
+## ── Ownership helpers ────────────────────────────────────────────────
+
+public function own_to_ptr[T](owned: own[T]) -> ptr[void]:
+    return unsafe: ptr[void]<-owned
+
+## ── Source: Vec ─────────────────────────────────────────────────────
+
+public function from_vec[T](vec: ref[v.Vec[T]]) -> Iter[T]:
+    return from_span(vec.as_span())
+
+## ── Source: array ────────────────────────────────────────────────────
+
+public function from_array[T, N](arr: ref[array[T, N]]) -> Iter[T]:
+    return from_span(arr.as_span())
+
+## ── .as_iter() extending blocks ──────────────────────────────────────
+
+extending v.Vec[T]:
+    public editable function as_iter() -> Iter[T]:
+        return from_vec(ref_of(this))
+
+extending array[T, N]:
+    public editable function as_iter() -> Iter[T]:
+        return from_array[T, N](ref_of(this))
+
+extending span[T]:
+    public function as_iter() -> Iter[T]:
+        return from_span(this)
+
+## ── Source: span ─────────────────────────────────────────────────────
+
+struct SpanIterState[T]:
+    sp: span[T]
+    index: ptr_uint
+
+public function span_advance[T](state: ptr[void]) -> ptr[T]?:
+    let s = unsafe: ptr[SpanIterState[T]]<-state
+    let _this = unsafe: read(s)
+    if _this.index >= _this.sp.len:
+        return null
+    let item = unsafe: _this.sp.data + _this.index
+    unsafe: read(s).index += 1
+    return item
+
+public function span_release[T](state: ptr[void]) -> void:
+    let s = unsafe: ptr[SpanIterState[T]]<-state
+    heap.release[SpanIterState[T]](s)
+
+public function from_span[T](sp: span[T]) -> Iter[T]:
+    let state = heap.must_alloc[SpanIterState[T]](1)
+    state.index = 0
+    state.sp = sp
+    let p = own_to_ptr(state)
+    return Iter[T](state = p, next_fn = span_advance[T], release_fn = span_release[T])
+
+## ── Adaptor: Filter ──────────────────────────────────────────────────
+
+struct FilterState[T]:
+    inner: Iter[T]
+    pred: fn(value: T) -> bool
+
+public function filter_advance[T](state: ptr[void]) -> ptr[T]?:
+    let s = unsafe: ptr[FilterState[T]]<-state
+    let _this = unsafe: read(s)
+    var item = _this.inner.next_fn(_this.inner.state)
+    while item != null:
+        if _this.pred(item.load()):
+            return item
+        item = _this.inner.next_fn(_this.inner.state)
+    return null
+
+public function filter_release[T](state: ptr[void]) -> void:
+    let s = unsafe: ptr[FilterState[T]]<-state
+    let _this = unsafe: read(s)
+    _this.inner.release_fn(_this.inner.state)
+    heap.release[FilterState[T]](s)
+
+public function iter_filter[T](iter: Iter[T], pred: fn(value: T) -> bool) -> Iter[T]:
+    let state = heap.must_alloc[FilterState[T]](1)
+    state.inner = iter
+    state.pred = pred
+    let p = own_to_ptr(state)
+    return Iter[T](state = p, next_fn = filter_advance[T], release_fn = filter_release[T])
+
+## ── Adaptor: Map ─────────────────────────────────────────────────────
+
+struct MapState[T, U]:
+    inner: Iter[T]
+    map_fn: fn(value: T) -> U
+    current: U
+
+public function map_advance[T, U](state: ptr[void]) -> ptr[U]?:
+    let s = unsafe: ptr[MapState[T, U]]<-state
+    let current_offset = offset_of(MapState[T, U], current)
+    let p = unsafe: read(s)
+    let item = p.inner.next_fn(p.inner.state) else:
+        return null
+    let base: ptr[ubyte] = unsafe: ptr[ubyte]<-s
+    let field_ptr = unsafe: base + ptr_uint<-current_offset
+    let target: ptr[U] = unsafe: ptr[U]<-field_ptr
+    target.store(p.map_fn(item.load()))
+    return target
+
+public function map_release[T, U](state: ptr[void]) -> void:
+    let s = unsafe: ptr[MapState[T, U]]<-state
+    let _this = unsafe: read(s)
+    _this.inner.release_fn(_this.inner.state)
+    heap.release[MapState[T, U]](s)
+
+public function iter_map[T, U](iter: Iter[T], f: fn(value: T) -> U) -> Iter[U]:
+    let state = heap.must_alloc[MapState[T, U]](1)
+    state.inner = iter
+    state.map_fn = f
+    let p = own_to_ptr(state)
+    return Iter[U](state = p, next_fn = map_advance[T, U], release_fn = map_release[T, U])
+
+## ── Adaptor: Take ────────────────────────────────────────────────────
+
+struct TakeState[T]:
+    inner: Iter[T]
+    remaining: int
+
+public function take_advance[T](state: ptr[void]) -> ptr[T]?:
+    let s = unsafe: ptr[TakeState[T]]<-state
+    let _this = unsafe: read(s)
+    if _this.remaining <= 0:
+        return null
+    unsafe: read(s).remaining -= 1
+    return _this.inner.next_fn(_this.inner.state)
+
+public function take_release[T](state: ptr[void]) -> void:
+    let s = unsafe: ptr[TakeState[T]]<-state
+    let _this = unsafe: read(s)
+    _this.inner.release_fn(_this.inner.state)
+    heap.release[TakeState[T]](s)
+
+public function iter_take[T](iter: Iter[T], n: int) -> Iter[T]:
+    let state = heap.must_alloc[TakeState[T]](1)
+    state.inner = iter
+    state.remaining = n
+    let p = own_to_ptr(state)
+    return Iter[T](state = p, next_fn = take_advance[T], release_fn = take_release[T])
+
+## ── Adaptor: Skip ────────────────────────────────────────────────────
+
+struct SkipState[T]:
+    inner: Iter[T]
+    skip_count: int
+
+public function skip_advance[T](state: ptr[void]) -> ptr[T]?:
+    let s = unsafe: ptr[SkipState[T]]<-state
+    let _this = unsafe: read(s)
+    while _this.skip_count > 0:
+        let _ = _this.inner.next_fn(_this.inner.state) else:
+            return null
+        unsafe: read(s).skip_count -= 1
+    return _this.inner.next_fn(_this.inner.state)
+
+public function skip_release[T](state: ptr[void]) -> void:
+    let s = unsafe: ptr[SkipState[T]]<-state
+    let _this = unsafe: read(s)
+    _this.inner.release_fn(_this.inner.state)
+    heap.release[SkipState[T]](s)
+
+public function iter_skip[T](iter: Iter[T], n: int) -> Iter[T]:
+    let state = heap.must_alloc[SkipState[T]](1)
+    state.inner = iter
+    state.skip_count = n
+    let p = own_to_ptr(state)
+    return Iter[T](state = p, next_fn = skip_advance[T], release_fn = skip_release[T])
+
+## ── Adaptor: Enumerate ────────────────────────────────────────────────
+
+struct Enumerated[T]:
+    index: ptr_uint
+    value: T
+
+struct EnumerateState[T]:
+    inner: Iter[T]
+    index: ptr_uint
+    current: Enumerated[T]
+
+public function enum_advance[T](state: ptr[void]) -> ptr[Enumerated[T]]?:
+    let s = unsafe: ptr[EnumerateState[T]]<-state
+    let current_offset = offset_of(EnumerateState[T], current)
+    let p = unsafe: read(s)
+    let item = p.inner.next_fn(p.inner.state) else:
+        return null
+    let base: ptr[ubyte] = unsafe: ptr[ubyte]<-s
+    let field_ptr = unsafe: base + ptr_uint<-current_offset
+    let target: ptr[Enumerated[T]] = unsafe: ptr[Enumerated[T]]<-field_ptr
+    target.store(Enumerated[T](index = p.index, value = item.load()))
+    unsafe: read(s).index += 1
+    return target
+
+public function enum_release[T](state: ptr[void]) -> void:
+    let s = unsafe: ptr[EnumerateState[T]]<-state
+    let _this = unsafe: read(s)
+    _this.inner.release_fn(_this.inner.state)
+    heap.release[EnumerateState[T]](s)
+
+public function iter_enumerate[T](iter: Iter[T]) -> Iter[Enumerated[T]]:
+    let state = heap.must_alloc[EnumerateState[T]](1)
+    state.inner = iter
+    state.index = 0
+    let p = own_to_ptr(state)
+    let enum_it = Iter[Enumerated[T]](state = p, next_fn = enum_advance[T], release_fn = enum_release[T])
+    return enum_it
+
+## ── Consumer: Fold ───────────────────────────────────────────────────
+
+public function iter_fold[T, U](iter: Iter[T], init: U, f: fn(accum: U, value: T) -> U) -> U:
+    var accum = init
+    var item = iter.next_fn(iter.state)
+    while item != null:
+        accum = f(accum, item.load())
+        item = iter.next_fn(iter.state)
+    iter.release_fn(iter.state)
+    return accum
+
+## ── Consumer: Find ───────────────────────────────────────────────────
+
+public function iter_find[T](iter: Iter[T], pred: fn(value: T) -> bool) -> Option[T]:
+    var item = iter.next_fn(iter.state)
+    while item != null:
+        if pred(item.load()):
+            let val = item.load()
+            iter.release_fn(iter.state)
+            return Option[T].some(value = val)
+        item = iter.next_fn(iter.state)
+    iter.release_fn(iter.state)
+    return Option[T].none
+
+## ── Consumer: Any ────────────────────────────────────────────────────
+
+public function iter_any[T](iter: Iter[T], pred: fn(value: T) -> bool) -> bool:
+    var item = iter.next_fn(iter.state)
+    while item != null:
+        if pred(item.load()):
+            iter.release_fn(iter.state)
+            return true
+        item = iter.next_fn(iter.state)
+    iter.release_fn(iter.state)
+    return false
+
+## ── Consumer: All ────────────────────────────────────────────────────
+
+public function iter_all[T](iter: Iter[T], pred: fn(value: T) -> bool) -> bool:
+    var item = iter.next_fn(iter.state)
+    while item != null:
+        if not pred(item.load()):
+            iter.release_fn(iter.state)
+            return false
+        item = iter.next_fn(iter.state)
+    iter.release_fn(iter.state)
+    return true
+
+## ── Consumer: Count ──────────────────────────────────────────────────
+
+public function iter_count[T](iter: Iter[T]) -> ptr_uint:
+    var count: ptr_uint = 0
+    var item = iter.next_fn(iter.state)
+    while item != null:
+        count += 1
+        item = iter.next_fn(iter.state)
+    iter.release_fn(iter.state)
+    return count
+
+## ── Collect: Vec ─────────────────────────────────────────────────────
+
+public function collect_vec[T](iter: Iter[T]) -> v.Vec[T]:
+    var result = v.Vec[T].create()
+    var item = iter.next_fn(iter.state)
+    while item != null:
+        result.push(item.load())
+        item = iter.next_fn(iter.state)
+    iter.release_fn(iter.state)
+    return result

data/std/mem/ptr.mt

@@ -0,0 +1,12 @@
+## Pointer load/store — safe wrappers around unsafe: read(ptr).
+##
+##   import std.mem.ptr as ptr
+##   p.store(42)
+##   let v = p.load()
+
+extending ptr[T]:
+    public function load() -> T:
+        return unsafe: read(this)
+
+    public function store(value: T) -> void:
+        unsafe: read(this) = value

data/std/noise.mt

@@ -0,0 +1,201 @@
+## Coherent noise generation — Perlin noise and fractal variants.
+##
+## Seed-based deterministic noise for procedural generation:
+## terrain, textures, fog, animation, and more.
+##
+##   import std.noise as ns
+##   var noise = ns.Noise.create(42)
+##   let h = noise.fbm2d(x * 0.01, y * 0.01)
+
+
+public struct Noise:
+    perm: array[ubyte, 512]
+    octaves: int
+    lacunarity: float
+    gain: float
+    frequency: float
+
+
+# ── fade / interpolation ──
+
+function fade(t: float) -> float:
+    return t * t * t * (t * (t * 6.0 - 15.0) + 10.0)
+
+
+function lerp(a: float, b: float, t: float) -> float:
+    return a + t * (b - a)
+
+
+# ── gradient functions ──
+
+function grad2d(hash: int, x: float, y: float) -> float:
+    let h = hash & 3
+    let u = if h == 0 or h == 1: x else: y
+    let v = if h == 0 or h == 3: y else: x
+    return (if (h & 1) == 0: u else: -u) + (if (h & 2) == 0: v else: -v)
+
+
+function grad3d(hash: int, x: float, y: float, z: float) -> float:
+    let h = hash & 15
+    let u = if h < 8: x else: y
+    let v = if h < 4: y else: if h == 12 or h == 14: x else: z
+    let mu = if (h & 1) == 0: u else: -u
+    let mv = if (h & 2) == 0: v else: -v
+    return mu + mv
+
+
+# ── internal noise functions ──
+
+function perlin2d_impl(perm: array[ubyte, 512], x: float, y: float) -> float:
+    let ix = int<-(x)
+    let iy = int<-(y)
+    let X = ix & 255
+    let Y = iy & 255
+    let xf = x - float<-(ix - (ix & ~255))
+    let yf = y - float<-(iy - (iy & ~255))
+
+    let u = fade(if xf < 0.0: xf + 1.0 else: xf)
+    let v = fade(if yf < 0.0: yf + 1.0 else: yf)
+
+    let A = int<-(perm[X]) + Y
+    let B = int<-(perm[X + 1]) + Y
+    let aa = int<-(perm[A])
+    let ab = int<-(perm[A + 1])
+    let ba = int<-(perm[B])
+    let bb = int<-(perm[B + 1])
+
+    let x1 = lerp(grad2d(aa, xf, yf), grad2d(ba, xf - 1.0, yf), u)
+    let x2 = lerp(grad2d(ab, xf, yf - 1.0), grad2d(bb, xf - 1.0, yf - 1.0), u)
+
+    return lerp(x1, x2, v)
+
+
+function perlin3d_impl(perm: array[ubyte, 512], x: float, y: float, z: float) -> float:
+    let ix = int<-(x)
+    let iy = int<-(y)
+    let iz = int<-(z)
+    let X = ix & 255
+    let Y = iy & 255
+    let Z = iz & 255
+    let xf = x - float<-(ix - (ix & ~255))
+    let yf = y - float<-(iy - (iy & ~255))
+    let zf = z - float<-(iz - (iz & ~255))
+
+    let u = fade(if xf < 0.0: xf + 1.0 else: xf)
+    let v = fade(if yf < 0.0: yf + 1.0 else: yf)
+    let w = fade(if zf < 0.0: zf + 1.0 else: zf)
+
+    let A = int<-(perm[X]) + Y
+    let AA = int<-(perm[A]) + Z
+    let AB = int<-(perm[A + 1]) + Z
+    let B = int<-(perm[X + 1]) + Y
+    let BA = int<-(perm[B]) + Z
+    let BB = int<-(perm[B + 1]) + Z
+
+    let x1 = lerp(grad3d(int<-(perm[AA]), xf, yf, zf), grad3d(int<-(perm[BA]), xf - 1.0, yf, zf), u)
+    let x2 = lerp(grad3d(int<-(perm[AB]), xf, yf - 1.0, zf), grad3d(int<-(perm[BB]), xf - 1.0, yf - 1.0, zf), u)
+    let y1 = lerp(x1, x2, v)
+
+    let x3 = lerp(grad3d(int<-(perm[AA + 1]), xf, yf, zf - 1.0), grad3d(int<-(perm[BA + 1]), xf - 1.0, yf, zf - 1.0), u)
+    let x4 = lerp(grad3d(int<-(perm[AB + 1]), xf, yf - 1.0, zf - 1.0), grad3d(int<-(perm[BB + 1]), xf - 1.0, yf - 1.0, zf - 1.0), u)
+    let y2 = lerp(x3, x4, v)
+
+    return lerp(y1, y2, w)
+
+
+# ── float floor for negative numbers ──
+
+function floor_f(x: float) -> int:
+    let i = int<-(x)
+    if x < 0.0 and float<-(i) != x:
+        return i - 1
+    return i
+
+
+# ── public API ──
+
+extending Noise:
+    public static function create(seed: ulong) -> Noise:
+        var n = Noise(
+            perm = zero[array[ubyte, 512]],
+            octaves = 6,
+            lacunarity = 2.0,
+            gain = 0.5,
+            frequency = 1.0
+        )
+
+        var i: int = 0
+        while i < 256:
+            n.perm[i] = ubyte<-i
+            i += 1
+
+        var state: ulong = seed
+        var j: int = 255
+        while j > 0:
+            state = state * 6364136223846793005 + 1442695040888963407
+            let r = int<-(state % ulong<-(j + 1))
+            let tmp = n.perm[j]
+            n.perm[j] = n.perm[r]
+            n.perm[r] = tmp
+            j -= 1
+
+        i = 0
+        while i < 256:
+            n.perm[i + 256] = n.perm[i]
+            i += 1
+
+        return n
+
+
+    public function perlin2d(x: float, y: float) -> float:
+        return perlin2d_impl(this.perm, x, y)
+
+
+    public function perlin3d(x: float, y: float, z: float) -> float:
+        return perlin3d_impl(this.perm, x, y, z)
+
+
+    public function fbm2d(x: float, y: float) -> float:
+        var value: float = 0.0
+        var freq: float = this.frequency
+        var amp: float = 1.0
+        var max_val: float = 0.0
+        var i: int = 0
+        while i < this.octaves:
+            value = value + amp * perlin2d_impl(this.perm, x * freq, y * freq)
+            max_val = max_val + amp
+            amp = amp * this.gain
+            freq = freq * this.lacunarity
+            i += 1
+        return value / max_val
+
+
+    public function fbm3d(x: float, y: float, z: float) -> float:
+        var value: float = 0.0
+        var freq: float = this.frequency
+        var amp: float = 1.0
+        var max_val: float = 0.0
+        var i: int = 0
+        while i < this.octaves:
+            value = value + amp * perlin3d_impl(this.perm, x * freq, y * freq, z * freq)
+            max_val = max_val + amp
+            amp = amp * this.gain
+            freq = freq * this.lacunarity
+            i += 1
+        return value / max_val
+
+
+    public editable function set_octaves(n: int) -> void:
+        this.octaves = n
+
+
+    public editable function set_lacunarity(v: float) -> void:
+        this.lacunarity = v
+
+
+    public editable function set_gain(v: float) -> void:
+        this.gain = v
+
+
+    public editable function set_frequency(v: float) -> void:
+        this.frequency = v

data/std/pool.mt

@@ -0,0 +1,82 @@
+## Object pool — fixed-capacity reusable object storage.
+##
+## Pre-allocate objects once, then acquire/release without
+## allocation churn. O(1) acquire and release via free stack.
+##
+##   import std.pool as pool
+##   var p = pool.Pool[Bullet].create(64)
+##   let id = p.acquire() else: /* pool exhausted */
+##   let bullet = p.get(id)   # ptr to object
+##   p.release(id)
+
+import std.vec as vec
+import std.mem.heap as heap
+
+
+public struct Pool[T]:
+    objects: ptr[T]
+    free_stack: vec.Vec[ptr_uint]
+    capacity: ptr_uint
+
+
+# ── public API ──
+
+extending Pool[T]:
+    public static function create(capacity: ptr_uint) -> Pool[T]:
+        var p = Pool[T](
+            objects = heap.must_alloc[T](capacity),
+            free_stack = vec.Vec[ptr_uint].with_capacity(capacity),
+            capacity = capacity
+        )
+
+        # Push all indices onto the free stack in reverse order so
+        # acquire() returns them in ascending order (0 first).
+        var i = capacity
+        while i > 0:
+            i -= 1
+            p.free_stack.push(i)
+
+        return p
+
+
+    public editable function acquire() -> Option[ptr_uint]:
+        let idx = this.free_stack.pop() else:
+            return Option[ptr_uint].none
+        return Option[ptr_uint].some(value = idx)
+
+
+    public function get(index: ptr_uint) -> ptr[T]?:
+        if index >= this.capacity:
+            return null
+        unsafe:
+            return this.objects + index
+
+
+    public editable function release_object(index: ptr_uint) -> void:
+        if index >= this.capacity:
+            return
+
+        # Check for double-release by scanning free stack.
+        # Skip this check for simplicity — caller must not double-release.
+        this.free_stack.push(index)
+
+
+    public function available() -> ptr_uint:
+        return this.free_stack.len()
+
+
+    public function count() -> ptr_uint:
+        return this.capacity - this.free_stack.len()
+
+
+    public editable function clear() -> void:
+        this.free_stack.clear()
+        var i = this.capacity
+        while i > 0:
+            i -= 1
+            this.free_stack.push(i)
+
+
+    public editable function release() -> void:
+        this.free_stack.release()
+        heap.release(this.objects)

data/std/signal.mt

@@ -0,0 +1,66 @@
+## Signal — fixed-capacity observer / publish-subscribe.
+##
+## Connect callbacks to signals and fire typed payloads.
+## Up to 16 subscribers per signal, stack-allocated.
+##
+##   import std.signal as sig
+##   var on_damage = sig.Signal[int].create()
+##   on_damage.connect(handle_damage)
+##   on_damage.fire(25)
+
+public struct Signal[Payload]:
+    slots: array[fn(payload: Payload) -> void, 16]
+    count: ptr_uint
+
+
+# ── public API ──
+
+extending Signal[Payload]:
+    public static function create() -> Signal[Payload]:
+        var s = Signal[Payload](
+            slots = zero[array[fn(payload: Payload) -> void, 16]],
+            count = 0
+        )
+        return s
+
+
+    public editable function connect(callback: fn(payload: Payload) -> void) -> void:
+        if this.count >= 16:
+            return
+
+        var i: ptr_uint = 0
+        while i < this.count:
+            unsafe:
+                if this.slots[i] == callback:
+                    return
+            i += 1
+
+        unsafe:
+            this.slots[this.count] = callback
+        this.count = this.count + 1
+
+
+    public editable function disconnect(callback: fn(payload: Payload) -> void) -> void:
+        var i: ptr_uint = 0
+        while i < this.count:
+            unsafe:
+                if this.slots[i] == callback:
+                    # swap-remove with last
+                    this.count = this.count - 1
+                    if i < this.count:
+                        this.slots[i] = this.slots[this.count]
+                    return
+            i += 1
+
+
+    public function fire(payload: Payload) -> void:
+        var i: ptr_uint = 0
+        while i < this.count:
+            unsafe:
+                let cb = this.slots[i]
+                cb(payload)
+            i += 1
+
+
+    public function count() -> ptr_uint:
+        return this.count