mt-lang 0.2.0 → 0.2.1

data/std/linked_set.mt

@@ -0,0 +1,117 @@
+import std.linked_map as linked_map
+
+public struct LinkedSet[T]:
+    values: linked_map.LinkedMap[T, bool]
+
+
+extending LinkedSet[T]:
+    public static function create() -> LinkedSet[T]:
+        return LinkedSet[T](values = linked_map.LinkedMap[T, bool].create())
+
+
+    public static function with_capacity(capacity: ptr_uint) -> LinkedSet[T]:
+        var result = LinkedSet[T].create()
+        result.reserve(capacity)
+        return result
+
+
+    public function len() -> ptr_uint:
+        return this.values.len()
+
+
+    public function capacity() -> ptr_uint:
+        return this.values.capacity()
+
+
+    public function is_empty() -> bool:
+        return this.values.is_empty()
+
+
+    public function get(value: T) -> const_ptr[T]?:
+        return this.values.get_key(value)
+
+
+    public function at(value: T) -> Option[T]:
+        let p = this.get(value) else:
+            return Option[T].none
+
+        unsafe:
+            return Option[T].some(value = read(ptr[T]<-p))
+
+
+    public function contains(value: T) -> bool:
+        return this.values.contains(value)
+
+
+    public function iter() -> linked_map.Keys[T, bool]:
+        return this.values.keys()
+
+
+    public function is_subset(other: LinkedSet[T]) -> bool:
+        if this.len() > other.len():
+            return false
+
+        for value in this:
+            unsafe:
+                if not other.contains(read(ptr[T]<-value)):
+                    return false
+
+        return true
+
+
+    public function union_with(other: LinkedSet[T]) -> LinkedSet[T]:
+        var result = LinkedSet[T].with_capacity(this.len() + other.len())
+
+        for value in this:
+            unsafe:
+                result.insert(read(ptr[T]<-value))
+
+        for value in other:
+            unsafe:
+                result.insert(read(ptr[T]<-value))
+
+        return result
+
+
+    public function intersection(other: LinkedSet[T]) -> LinkedSet[T]:
+        var result = LinkedSet[T].with_capacity(this.len())
+
+        for value in this:
+            unsafe:
+                let current = read(ptr[T]<-value)
+                if other.contains(current):
+                    result.insert(current)
+
+        return result
+
+
+    public function difference(other: LinkedSet[T]) -> LinkedSet[T]:
+        var result = LinkedSet[T].with_capacity(this.len())
+
+        for value in this:
+            unsafe:
+                let current = read(ptr[T]<-value)
+                if not other.contains(current):
+                    result.insert(current)
+
+        return result
+
+
+    public editable function clear() -> void:
+        this.values.clear()
+
+
+    public editable function release() -> void:
+        this.values.release()
+
+
+    public editable function reserve(min_capacity: ptr_uint) -> void:
+        this.values.reserve(min_capacity)
+
+
+    public editable function insert(value: T) -> bool:
+        return this.values.set(value, true).is_none()
+
+
+    public editable function remove(value: T) -> bool:
+        return this.values.remove(value).is_some()

data/std/log.mt

@@ -0,0 +1,69 @@
+import std.string as string
+import std.terminal as terminal
+
+public enum Level: int
+    trace = 0
+    debug = 1
+    info = 2
+    warn = 3
+    error = 4
+    fatal = 5
+
+var global_level: Level = Level.trace
+
+
+public function set_level(level: Level) -> void:
+    global_level = level
+
+
+public function level() -> Level:
+    return global_level
+
+
+function level_label(level: Level) -> str:
+    return match level:
+        Level.trace: "TRACE"
+        Level.debug: "DEBUG"
+        Level.info: "INFO "
+        Level.warn: "WARN "
+        Level.error: "ERROR"
+        Level.fatal: "FATAL"
+
+
+public function log(level: Level, message: str) -> void:
+    if int<-level < int<-global_level:
+        return
+    var output = string.String.create()
+    defer output.release()
+    output.append("[")
+    output.append(level_label(level))
+    output.append("] ")
+    output.append(message)
+    output.push_byte(10)
+    let _ = terminal.write_stderr(output.as_str())
+    terminal.flush_stderr()
+
+
+public function trace(message: str) -> void:
+    log(Level.trace, message)
+
+
+public function debug(message: str) -> void:
+    log(Level.debug, message)
+
+
+public function info(message: str) -> void:
+    log(Level.info, message)
+
+
+public function warn(message: str) -> void:
+    log(Level.warn, message)
+
+
+public function error(message: str) -> void:
+    log(Level.error, message)
+
+
+public function fatal_message(message: str) -> void:
+    log(Level.fatal, message)
+    fatal(c"fatal log")

data/std/map.mt

@@ -0,0 +1,418 @@
+import std.hash
+import std.mem.heap as heap
+
+struct Node[K, V]:
+    hash: uint
+    key: K
+    value: V
+    next: ptr[Node[K, V]]?
+
+public struct Entry[K, V]:
+    key: const_ptr[K]
+    value: ptr[V]
+
+public struct RemovedEntry[K, V]:
+    key: K
+    value: V
+
+public struct Keys[K, V]:
+    buckets: ptr[ptr[Node[K, V]]?]?
+    bucket_index: ptr_uint
+    bucket_count: ptr_uint
+    node: ptr[Node[K, V]]?
+
+public struct Values[K, V]:
+    buckets: ptr[ptr[Node[K, V]]?]?
+    bucket_index: ptr_uint
+    bucket_count: ptr_uint
+    node: ptr[Node[K, V]]?
+
+public struct Entries[K, V]:
+    buckets: ptr[ptr[Node[K, V]]?]?
+    bucket_index: ptr_uint
+    bucket_count: ptr_uint
+    node: ptr[Node[K, V]]?
+
+public struct Map[K, V]:
+    buckets: own[ptr[Node[K, V]]?]?
+    len: ptr_uint
+    capacity: ptr_uint
+
+
+extending Map[K, V]:
+    public static function create() -> Map[K, V]:
+        return Map[K, V](buckets = null, len = 0, capacity = 0)
+
+
+    public static function with_capacity(capacity: ptr_uint) -> Map[K, V]:
+        var result = Map[K, V].create()
+        result.reserve(capacity)
+        return result
+
+
+    static function bucket_index(entry_hash: uint, capacity: ptr_uint) -> ptr_uint:
+        let bucket_count = uint<-capacity
+        return ptr_uint<-(entry_hash % bucket_count)
+
+
+    static function find_node(current: Map[K, V], key: K, key_hash: uint) -> ptr[Node[K, V]]?:
+        if current.len == 0:
+            return null
+
+        let buckets = current.buckets else:
+            fatal(c"map.Map.find_node missing buckets")
+
+        unsafe:
+            let bucket_ptr = ptr[ptr[Node[K, V]]?]<-buckets
+            let index = Map[K, V].bucket_index(key_hash, current.capacity)
+            var node = read(bucket_ptr + index)
+            while node != null:
+                let node_ptr = ptr[Node[K, V]]<-node
+                let stored_key = const_ptr_of(read(node_ptr).key)
+                if read(node_ptr).hash == key_hash and equal[K](key, stored_key):
+                    return node
+                node = read(node_ptr).next
+
+        return null
+
+
+    public function len() -> ptr_uint:
+        return this.len
+
+
+    public function capacity() -> ptr_uint:
+        return this.capacity
+
+
+    public function is_empty() -> bool:
+        return this.len == 0
+
+
+    public function get(key: K) -> ptr[V]?:
+        let key_hash = hash[K](key)
+        let node = Map[K, V].find_node(this, key, key_hash) else:
+            return null
+
+        unsafe:
+            return ptr_of(read(ptr[Node[K, V]]<-node).value)
+
+
+    public function at(key: K) -> Option[V]:
+        let p = this.get(key) else:
+            return Option[V].none
+
+        unsafe:
+            return Option[V].some(value = read(p))
+
+
+    public function get_key(key: K) -> const_ptr[K]?:
+        let key_hash = hash[K](key)
+        let node = Map[K, V].find_node(this, key, key_hash) else:
+            return null
+
+        unsafe:
+            return const_ptr_of(read(ptr[Node[K, V]]<-node).key)
+
+
+    public function get_or_else(key: K, default: V) -> V:
+        let value_ptr = this.get(key) else:
+            return default
+
+        unsafe:
+            return read(value_ptr)
+
+
+    public function iter() -> Entries[K, V]:
+        return this.entries()
+
+
+    public function keys() -> Keys[K, V]:
+        return Keys[K, V](buckets = this.buckets, bucket_index = 0, bucket_count = this.capacity, node = null)
+
+
+    public function values() -> Values[K, V]:
+        return Values[K, V](buckets = this.buckets, bucket_index = 0, bucket_count = this.capacity, node = null)
+
+
+    public function entries() -> Entries[K, V]:
+        return Entries[K, V](buckets = this.buckets, bucket_index = 0, bucket_count = this.capacity, node = null)
+
+
+    public function contains(key: K) -> bool:
+        return this.get(key) != null
+
+
+    public editable function clear() -> void:
+        if this.len == 0:
+            return
+
+        let buckets = this.buckets else:
+            fatal(c"map.Map.clear missing buckets")
+
+        unsafe:
+            let bucket_ptr = ptr[ptr[Node[K, V]]?]<-buckets
+            var index: ptr_uint = 0
+            while index < this.capacity:
+                var node = read(bucket_ptr + index)
+                while node != null:
+                    let node_ptr = ptr[Node[K, V]]<-node
+                    let next = read(node_ptr).next
+                    heap.release(node)
+                    node = next
+                read(bucket_ptr + index) = null
+                index += 1
+
+        this.len = 0
+
+
+    public editable function release() -> void:
+        this.clear()
+        heap.release(this.buckets)
+        this.buckets = null
+        this.capacity = 0
+
+
+    public editable function reserve(min_capacity: ptr_uint) -> void:
+        if min_capacity <= this.capacity:
+            return
+
+        var new_capacity = this.capacity
+        if new_capacity == 0:
+            new_capacity = 8
+
+        while new_capacity < min_capacity:
+            if new_capacity > heap.ptr_uint_max / 2:
+                new_capacity = min_capacity
+            else:
+                new_capacity *= 2
+
+        let new_buckets = heap.must_alloc_zeroed[ptr[Node[K, V]]?](new_capacity)
+        let old_buckets = this.buckets
+        let old_capacity = this.capacity
+
+        if old_buckets != null:
+            unsafe:
+                let old_ptr = ptr[ptr[Node[K, V]]?]<-old_buckets
+                let new_ptr = ptr[ptr[Node[K, V]]?]<-new_buckets
+                var index: ptr_uint = 0
+                while index < old_capacity:
+                    var node = read(old_ptr + index)
+                    while node != null:
+                        let node_ptr = ptr[Node[K, V]]<-node
+                        let next = read(node_ptr).next
+                        let target = Map[K, V].bucket_index(read(node_ptr).hash, new_capacity)
+                        read(node_ptr).next = read(new_ptr + target)
+                        read(new_ptr + target) = node
+                        node = next
+                    index += 1
+            heap.release(old_buckets)
+
+        this.buckets = new_buckets
+        this.capacity = new_capacity
+
+
+    public editable function set(key: K, value: V) -> Option[V]:
+        let key_hash = hash[K](key)
+        let existing = Map[K, V].find_node(this, key, key_hash)
+        if existing != null:
+            unsafe:
+                let node_ptr = ptr[Node[K, V]]<-existing
+                let previous = read(node_ptr).value
+                read(node_ptr).value = value
+                return Option[V].some(value = previous)
+
+        if this.len == this.capacity:
+            this.reserve(this.len + 1)
+
+        let current_buckets = this.buckets else:
+            fatal(c"map.Map.set missing buckets")
+
+        unsafe:
+            let bucket_ptr = ptr[ptr[Node[K, V]]?]<-current_buckets
+            let index = Map[K, V].bucket_index(key_hash, this.capacity)
+            let node = heap.must_alloc[Node[K, V]](1)
+            let node_ptr = ptr[Node[K, V]]<-node
+            read(node_ptr) = Node[K, V](
+                hash = key_hash,
+                key = key,
+                value = value,
+                next = read(bucket_ptr + index)
+            )
+            read(bucket_ptr + index) = node
+
+        this.len += 1
+        return Option[V].none
+
+
+    public editable function get_or_insert(key: K, value: V) -> ptr[V]:
+        let key_hash = hash[K](key)
+        let existing = Map[K, V].find_node(this, key, key_hash)
+        if existing != null:
+            unsafe:
+                return ptr_of(read(ptr[Node[K, V]]<-existing).value)
+
+        let inserted = this.set(key, value)
+        match inserted:
+            Option.none:
+                let current = Map[K, V].find_node(this, key, key_hash) else:
+                    fatal(c"map.Map.get_or_insert missing inserted value")
+                unsafe:
+                    return ptr_of(read(ptr[Node[K, V]]<-current).value)
+            Option.some:
+                fatal(c"map.Map.get_or_insert replaced unexpectedly")
+
+
+    public editable function remove_entry(key: K) -> Option[RemovedEntry[K, V]]:
+        if this.len == 0:
+            return Option[RemovedEntry[K, V]].none
+
+        let buckets = this.buckets else:
+            fatal(c"map.Map.remove_entry missing buckets")
+
+        let key_hash = hash[K](key)
+
+        unsafe:
+            let bucket_ptr = ptr[ptr[Node[K, V]]?]<-buckets
+            let index = Map[K, V].bucket_index(key_hash, this.capacity)
+            var previous: ptr[Node[K, V]]? = null
+            var node = read(bucket_ptr + index)
+            while node != null:
+                let node_ptr = ptr[Node[K, V]]<-node
+                let stored_key = const_ptr_of(read(node_ptr).key)
+                if read(node_ptr).hash == key_hash and equal[K](key, stored_key):
+                    let next = read(node_ptr).next
+                    if previous == null:
+                        read(bucket_ptr + index) = next
+                    else:
+                        read(ptr[Node[K, V]]<-previous).next = next
+
+                    let removed = RemovedEntry[K, V](key = read(node_ptr).key, value = read(node_ptr).value)
+                    heap.release(node)
+                    this.len -= 1
+                    return Option[RemovedEntry[K, V]].some(value = removed)
+
+                previous = node
+                node = read(node_ptr).next
+
+        return Option[RemovedEntry[K, V]].none
+
+
+    public editable function remove(key: K) -> Option[V]:
+        let removed = this.remove_entry(key)
+        if removed.is_none():
+            return Option[V].none
+        return Option[V].some(value = removed.unwrap().value)
+
+
+extending Keys[K, V]:
+    public function iter() -> Keys[K, V]:
+        return this
+
+
+    public editable function next() -> const_ptr[K]?:
+        let current_node = this.node
+        if current_node != null:
+            unsafe:
+                let next_node = read(ptr[Node[K, V]]<-current_node).next
+                if next_node != null:
+                    this.node = next_node
+                    return const_ptr_of(read(ptr[Node[K, V]]<-next_node).key)
+
+        let buckets = this.buckets else:
+            this.bucket_index = this.bucket_count
+            this.node = null
+            return null
+
+        unsafe:
+            let bucket_ptr = ptr[ptr[Node[K, V]]?]<-buckets
+            var index = this.bucket_index
+            while index < this.bucket_count:
+                let candidate = read(bucket_ptr + index)
+                index += 1
+                if candidate != null:
+                    this.bucket_index = index
+                    this.node = candidate
+                    return const_ptr_of(read(ptr[Node[K, V]]<-candidate).key)
+
+        this.bucket_index = this.bucket_count
+        this.node = null
+        return null
+
+
+extending Values[K, V]:
+    public function iter() -> Values[K, V]:
+        return this
+
+
+    public editable function next() -> ptr[V]?:
+        let current_node = this.node
+        if current_node != null:
+            unsafe:
+                let next_node = read(ptr[Node[K, V]]<-current_node).next
+                if next_node != null:
+                    this.node = next_node
+                    return ptr_of(read(ptr[Node[K, V]]<-next_node).value)
+
+        let buckets = this.buckets else:
+            this.bucket_index = this.bucket_count
+            this.node = null
+            return null
+
+        unsafe:
+            let bucket_ptr = ptr[ptr[Node[K, V]]?]<-buckets
+            var index = this.bucket_index
+            while index < this.bucket_count:
+                let candidate = read(bucket_ptr + index)
+                index += 1
+                if candidate != null:
+                    this.bucket_index = index
+                    this.node = candidate
+                    return ptr_of(read(ptr[Node[K, V]]<-candidate).value)
+
+        this.bucket_index = this.bucket_count
+        this.node = null
+        return null
+
+
+extending Entries[K, V]:
+    public function iter() -> Entries[K, V]:
+        return this
+
+
+    public editable function next() -> bool:
+        let current_node = this.node
+        if current_node != null:
+            unsafe:
+                let next_node = read(ptr[Node[K, V]]<-current_node).next
+                if next_node != null:
+                    this.node = next_node
+                    return true
+
+        let buckets = this.buckets else:
+            this.bucket_index = this.bucket_count
+            this.node = null
+            return false
+
+        unsafe:
+            let bucket_ptr = ptr[ptr[Node[K, V]]?]<-buckets
+            var index = this.bucket_index
+            while index < this.bucket_count:
+                let candidate = read(bucket_ptr + index)
+                index += 1
+                if candidate != null:
+                    this.bucket_index = index
+                    this.node = candidate
+                    return true
+
+        this.bucket_index = this.bucket_count
+        this.node = null
+        return false
+
+
+    public function current() -> Entry[K, V]:
+        let current_node = this.node else:
+            fatal(c"map.Entries.current missing current node")
+
+        unsafe:
+            let node_ptr = ptr[Node[K, V]]<-current_node
+            return Entry[K, V](key = const_ptr_of(read(node_ptr).key), value = ptr_of(read(node_ptr).value))

data/std/math.mt

@@ -0,0 +1,24 @@
+import std.c.math as c
+
+public const PI: double = 3.141592653589793
+public const HALF_PI: double = 1.5707963267948966
+public const QUARTER_PI: double = 0.7853981633974483
+public const TAU: double = 6.283185307179586
+public const E: double = 2.718281828459045
+
+public foreign function abs(value: double) -> double = c.mt_math_abs
+public foreign function sqrt(value: double) -> double = c.mt_math_sqrt
+public foreign function pow(base: double, exponent: double) -> double = c.mt_math_pow
+public foreign function exp(value: double) -> double = c.mt_math_exp
+public foreign function log(value: double) -> double = c.mt_math_log
+public foreign function log10(value: double) -> double = c.mt_math_log10
+public foreign function sin(radians: double) -> double = c.mt_math_sin
+public foreign function cos(radians: double) -> double = c.mt_math_cos
+public foreign function tan(radians: double) -> double = c.mt_math_tan
+public foreign function asin(value: double) -> double = c.mt_math_asin
+public foreign function acos(value: double) -> double = c.mt_math_acos
+public foreign function atan(value: double) -> double = c.mt_math_atan
+public foreign function atan2(y: double, x: double) -> double = c.mt_math_atan2
+public foreign function floor(value: double) -> double = c.mt_math_floor
+public foreign function ceil(value: double) -> double = c.mt_math_ceil
+public foreign function mod(value: double, divisor: double) -> double = c.mt_math_mod