mt-lang 0.4.23 → 0.4.25

data/std/color.mt

@@ -51,7 +51,7 @@ function fmod(x: float, m: float) -> float:
     # x - floor(x / m) * m
     let div = x / m
     let fl = float<-(int<-div)
-    if div < 0.0 and float<-(int<-div) != div:
+    if div < 0.0 and (int<-div) != div:
         return x - (fl - 1.0) * m
     return x - fl * m
 
@@ -143,9 +143,9 @@ extending Color:
 
 
     public function to_hsl() -> (float, float, float):
-        let rf = float<-this.r / 255.0
-        let gf = float<-this.g / 255.0
-        let bf = float<-this.b / 255.0
+        let rf = this.r / 255.0
+        let gf = this.g / 255.0
+        let bf = this.b / 255.0
 
         let mx = fmax(fmax(rf, gf), bf)
         let mn = fmin(fmin(rf, gf), bf)
@@ -171,9 +171,9 @@ extending Color:
 
 
     public function to_hsv() -> (float, float, float):
-        let rf = float<-this.r / 255.0
-        let gf = float<-this.g / 255.0
-        let bf = float<-this.b / 255.0
+        let rf = this.r / 255.0
+        let gf = this.g / 255.0
+        let bf = this.b / 255.0
 
         let mx = fmax(fmax(rf, gf), bf)
         let mn = fmin(fmin(rf, gf), bf)
@@ -198,10 +198,10 @@ extending Color:
 
 
     public function lerp(target: Color, t: float) -> Color:
-        let r = float<-this.r + (float<-target.r - float<-this.r) * t
-        let g = float<-this.g + (float<-target.g - float<-this.g) * t
-        let b = float<-this.b + (float<-target.b - float<-this.b) * t
-        let a = float<-this.a + (float<-target.a - float<-this.a) * t
+        let r = this.r + (float<-target.r - float<-this.r) * t
+        let g = this.g + (float<-target.g - float<-this.g) * t
+        let b = this.b + (float<-target.b - float<-this.b) * t
+        let a = this.a + (float<-target.a - float<-this.a) * t
         return Color(r = ubyte<-r, g = ubyte<-g, b = ubyte<-b, a = ubyte<-a)
 
 
@@ -211,12 +211,12 @@ extending Color:
         if this.a == 255:
             return this
 
-        let sa = float<-this.a / 255.0
-        let da = float<-background.a / 255.0
+        let sa = this.a / 255.0
+        let da = background.a / 255.0
 
-        let r_out = float<-this.r * sa + float<-background.r * da * (1.0 - sa)
-        let g_out = float<-this.g * sa + float<-background.g * da * (1.0 - sa)
-        let b_out = float<-this.b * sa + float<-background.b * da * (1.0 - sa)
+        let r_out = this.r * sa + background.r * da * (1.0 - sa)
+        let g_out = this.g * sa + background.g * da * (1.0 - sa)
+        let b_out = this.b * sa + background.b * da * (1.0 - sa)
         let a_out = sa + da * (1.0 - sa)
 
         return Color(
@@ -228,9 +228,9 @@ extending Color:
 
 
     public function scale(factor: float) -> Color:
-        let r = fmin(fmax(float<-this.r * factor, 0.0), 255.0)
-        let g = fmin(fmax(float<-this.g * factor, 0.0), 255.0)
-        let b = fmin(fmax(float<-this.b * factor, 0.0), 255.0)
+        let r = fmin(fmax(this.r * factor, 0.0), 255.0)
+        let g = fmin(fmax(this.g * factor, 0.0), 255.0)
+        let b = fmin(fmax(this.b * factor, 0.0), 255.0)
         return Color(r = ubyte<-r, g = ubyte<-g, b = ubyte<-b, a = this.a)
 
 
@@ -242,4 +242,4 @@ extending Color:
 
 
     public function with_alpha(a: ubyte) -> Color:
-        return Color(r = this.r, g = this.g, b = this.b, a = a)
+        return this.with(a = a)

data/std/cookie.mt

@@ -138,10 +138,7 @@ function ascii_lower(text_value: str) -> string.String:
     var index: ptr_uint = 0
     while index < text_value.len:
         let value = text_value.byte_at(index)
-        if value >= 65 and value <= 90:
-            result.push_byte(value + 32)
-        else:
-            result.push_byte(value)
+        if value >= 65 and value <= 90: result.push_byte(value + 32) else: result.push_byte(value)
         index += 1
 
     return result

data/std/deque.mt

@@ -114,10 +114,7 @@ extending Deque[T]:
             new_capacity = 4
 
         while new_capacity < min_capacity:
-            if new_capacity > heap.ptr_uint_max / 2:
-                new_capacity = min_capacity
-            else:
-                new_capacity *= 2
+            if new_capacity > heap.ptr_uint_max / 2: new_capacity = min_capacity else: new_capacity *= 2
 
         let new_data = heap.must_alloc[T](new_capacity)
         let old_data = this.data
@@ -191,10 +188,7 @@ extending Deque[T]:
         let data = this.data else:
             fatal(c"deque.push_front missing storage")
 
-        if this.len == 0:
-            this.head = 0
-        else:
-            this.head = Deque[T].previous_index(this.head, this.capacity)
+        if this.len == 0: this.head = 0 else: this.head = Deque[T].previous_index(this.head, this.capacity)
 
         unsafe:
             let data_ptr = ptr[T]<-data

data/std/encoding.mt

@@ -26,10 +26,7 @@ public function utf8_codepoint_count(text: str) -> ptr_uint:
     while index < text.len:
         let b = text.byte_at(index)
         let len = utf8_codepoint_length(b)
-        if len == 0:
-            index += 1
-        else:
-            index += len
+        if len == 0: index += 1 else: index += len
         count += 1
 
     if index != text.len:

data/std/fmt.mt

@@ -32,10 +32,7 @@ public function append_cstr(output: ref[string.String], c_text: cstr) -> void:
 
 
 public function append_bool(output: ref[string.String], bool_value: bool) -> void:
-    if bool_value:
-        output.append("true")
-    else:
-        output.append("false")
+    if bool_value: output.append("true") else: output.append("false")
 
 
 function append_formatted_float(output: ref[string.String], format: cstr, number: double) -> void:

data/std/graph.mt

@@ -612,7 +612,11 @@ extending DenseGraph[T]:
         return ShortestPaths(dist = dist, prev = prev)
 
 
-    public function astar(source: ptr_uint, target: ptr_uint, heuristic: fn(node: ptr_uint) -> float) -> vec.Vec[ptr_uint]:
+    public function astar(
+        source: ptr_uint,
+        target: ptr_uint,
+        heuristic: fn(node: ptr_uint) -> float
+    ) -> vec.Vec[ptr_uint]:
         var path = vec.Vec[ptr_uint].create()
         let n = this.node_count()
         if n == 0 or source >= n or target >= n:

data/std/htn.mt

@@ -110,7 +110,15 @@ function plan_task[World, Context](
 
                 for subtask_name_ptr in method.subtasks:
                     let subtask_name = unsafe: read(subtask_name_ptr)
-                    let sub_plan = plan_task(planner, context, current_world, subtask_name, depth + 1, iterations, reason)
+                    let sub_plan = plan_task(
+                        planner,
+                        context,
+                        current_world,
+                        subtask_name,
+                        depth + 1,
+                        iterations,
+                        reason
+                    )
                     match sub_plan:
                         Option.none:
                             success = false

data/std/http/server.mt

@@ -69,10 +69,7 @@ public function request_query_param(request: Request, key: str) -> Option[str]:
 
                     return Option[str].some(value = decoded.as_str())
 
-        if amp >= query_str.len:
-            start = query_str.len
-        else:
-            start = amp + 1
+        if amp >= query_str.len: start = query_str.len else: start = amp + 1
 
     return Option[str].none
 

data/std/http.mt

@@ -530,12 +530,10 @@ function discard_buffer_prefix(buffer: ref[vec.Vec[ubyte]], count: ptr_uint) ->
         fatal(c"http.discard_buffer_prefix missing storage")
 
     let remaining = buffer.len - count
-    unsafe:
-        let data_ptr = data
-        var index: ptr_uint = 0
-        while index < remaining:
-            read(data_ptr + index) = read(data_ptr + count + index)
-            index += 1
+    var index: ptr_uint = 0
+    while index < remaining:
+        read(data + index) = read(data + count + index)
+        index += 1
 
     buffer.len = remaining
 
@@ -572,14 +570,14 @@ function parse_response_head(header_text: str) -> Result[ResponseHead, Error]:
         Option.some as payload:
             status_code = int<-payload.value
 
+    if first_space + 4 < status_line.len and status_line.byte_at(first_space + 4) != 32:
+        return Result[
+            ResponseHead,
+            Error
+        ].failure(error = response_error("status line must separate code and reason with a space"))
+
     var reason = string.String.create()
     if first_space + 4 < status_line.len:
-        if status_line.byte_at(first_space + 4) != 32:
-            return Result[
-                ResponseHead,
-                Error
-            ].failure(error = response_error("status line must separate code and reason with a space"))
-
         let reason_start = first_space + 5
         reason = string.String.from_str(status_line.slice(reason_start, status_line.len - reason_start))
 
@@ -641,10 +639,7 @@ function parse_response_head(header_text: str) -> Result[ResponseHead, Error]:
                 head.release()
                 return Result[ResponseHead, Error].failure(error = response_error("unsupported Transfer-Encoding"))
 
-        if next_line_end == header_text.len:
-            index = header_text.len
-        else:
-            index = next_line_end + 2
+        if next_line_end == header_text.len: index = header_text.len else: index = next_line_end + 2
 
     if head.chunked:
         head.content_length = Option[ptr_uint].none
@@ -844,7 +839,9 @@ async function read_chunked_body(stream: net.TcpStream, prefix: span[ubyte]) ->
                                         return Result[
                                             bytes.Bytes,
                                             Error
-                                        ].failure(error = response_error("chunked response ended before trailers were complete"))
+                                        ].failure(error = response_error(
+                                            "chunked response ended before trailers were complete"
+                                        ))
 
                                     buffer.append_span(chunk.as_span())
                                     chunk.release()

data/std/jobs.mt

@@ -46,8 +46,8 @@ function error_from_mailbox(source: aio_mailbox.Error) -> Error:
     return Error(code = source.code, message = source.message)
 
 
-function noop_completion(arg: ptr[void]) -> void:
-    unsafe: arg
+function noop_completion(_arg: ptr[void]) -> void:
+    pass
 
 
 function stop_pool_state(state: ptr[PoolState]) -> void:
@@ -163,14 +163,13 @@ public function create_on(runtime: aio.Runtime, worker_count: ptr_uint) -> Resul
                             return Result[Pool, Error].failure(error = error_from_mailbox(payload.error))
                         Result.success as mailbox_payload:
                             let state = heap.must_alloc_zeroed[PoolState](1)
-                            unsafe:
-                                state.mutex = mutex_payload.value
-                                state.condition = condition_payload.value
-                                state.queue = deque.Deque[WorkItem].create()
-                                state.queued_jobs = 0
-                                state.running_jobs = 0
-                                state.stopping = false
-                                state.completions = mailbox_payload.value
+                            state.mutex = mutex_payload.value
+                            state.condition = condition_payload.value
+                            state.queue = deque.Deque[WorkItem].create()
+                            state.queued_jobs = 0
+                            state.running_jobs = 0
+                            state.stopping = false
+                            state.completions = mailbox_payload.value
 
                             var workers = vec.Vec[thread.Thread].with_capacity(worker_count)
                             var index: ptr_uint = 0

data/std/json.mt

@@ -112,15 +112,13 @@ public function object_value(value: ptr[Object]?) -> Value:
 
 public function create_array_value() -> Value:
     let array_ptr = heap.must_alloc[Array](1)
-    unsafe:
-        read(array_ptr) = Array.create()
+    read(array_ptr) = Array.create()
     return array_value(array_ptr)
 
 
 public function create_object_value() -> Value:
     let object_ptr = heap.must_alloc[Object](1)
-    unsafe:
-        read(object_ptr) = Object.create()
+    read(object_ptr) = Object.create()
     return object_value(object_ptr)
 
 
@@ -178,33 +176,28 @@ function value_as_object(value: Value) -> ptr[Object]?:
 
 function convert_raw_array(item: ptr[cjson.JSON]) -> Result[Value, Error]:
     let array_ptr = heap.must_alloc[Array](1)
-    unsafe:
-        read(array_ptr) = Array.create()
+    read(array_ptr) = Array.create()
 
     let count = cjson.get_array_size(item)
     if count < 0:
-        unsafe:
-            read(array_ptr).release()
+        read(array_ptr).release()
         heap.release(array_ptr)
         return Result[Value, Error].failure(error = error_message("json array size failed"))
 
     var index: int = 0
     while index < count:
         let child = cjson.get_array_item(item, index) else:
-            unsafe:
-                read(array_ptr).release()
+            read(array_ptr).release()
             heap.release(array_ptr)
             return Result[Value, Error].failure(error = error_message("json array item missing"))
 
         match convert_raw_value(child):
             Result.failure as payload:
-                unsafe:
-                    read(array_ptr).release()
+                read(array_ptr).release()
                 heap.release(array_ptr)
                 return Result[Value, Error].failure(error = payload.error)
             Result.success as payload:
-                unsafe:
-                    read(array_ptr).values.push(payload.value)
+                read(array_ptr).values.push(payload.value)
 
         index += 1
 
@@ -213,30 +206,26 @@ function convert_raw_array(item: ptr[cjson.JSON]) -> Result[Value, Error]:
 
 function convert_raw_object(item: ptr[cjson.JSON]) -> Result[Value, Error]:
     let object_ptr = heap.must_alloc[Object](1)
-    unsafe:
-        read(object_ptr) = Object.create()
+    read(object_ptr) = Object.create()
 
     var child = unsafe: ptr[cjson.JSON]?<-read(item).child
     while child != null:
-        let current = unsafe: child
+        let current = child
         let key_ptr = unsafe: ptr[char]?<-read(current).string else:
-            unsafe:
-                read(object_ptr).release()
+            read(object_ptr).release()
             heap.release(object_ptr)
             return Result[Value, Error].failure(error = error_message("json object key missing"))
 
         match convert_raw_value(current):
             Result.failure as payload:
-                unsafe:
-                    read(object_ptr).release()
+                read(object_ptr).release()
                 heap.release(object_ptr)
                 return Result[Value, Error].failure(error = payload.error)
             Result.success as payload:
-                unsafe:
-                    read(object_ptr).entries.push(Entry(
-                        key = string.String.from_str(text.chars_as_str(key_ptr)),
-                        value = payload.value
-                    ))
+                read(object_ptr).entries.push(Entry(
+                    key = string.String.from_str(text.chars_as_str(key_ptr)),
+                    value = payload.value
+                ))
 
         child = unsafe: ptr[cjson.JSON]?<-read(current).next
 
@@ -380,7 +369,7 @@ function render_with_mode(value: Value, pretty: bool) -> Result[string.String, E
     if pretty:
         let rendered_ptr = cjson.print(raw_value) else:
             return Result[string.String, Error].failure(error = error_message("json print failed"))
-        defer: raw.cJSON_free(unsafe: rendered_ptr)
+        defer: raw.cJSON_free(rendered_ptr)
         return Result[
             string.String,
             Error
@@ -388,7 +377,7 @@ function render_with_mode(value: Value, pretty: bool) -> Result[string.String, E
 
     let rendered_ptr = cjson.print_unformatted(raw_value) else:
         return Result[string.String, Error].failure(error = error_message("json print failed"))
-    defer: raw.cJSON_free(unsafe: rendered_ptr)
+    defer: raw.cJSON_free(rendered_ptr)
     return Result[string.String, Error].success(value = string.String.from_str(text.chars_as_str(rendered_ptr)))
 
 

data/std/linked_map.mt

@@ -188,10 +188,7 @@ extending LinkedMap[K, V]:
             new_capacity = 8
 
         while new_capacity < min_capacity:
-            if new_capacity > heap.ptr_uint_max / 2:
-                new_capacity = min_capacity
-            else:
-                new_capacity *= 2
+            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
@@ -243,10 +240,7 @@ extending LinkedMap[K, V]:
             )
             read(bucket_ptr + index) = node
 
-            if tail == null:
-                this.head = node
-            else:
-                read(ptr[Node[K, V]]<-tail).order_next = node
+            if tail == null: this.head = node else: read(ptr[Node[K, V]]<-tail).order_next = node
             this.tail = node
 
         this.len += 1
@@ -267,7 +261,7 @@ extending LinkedMap[K, V]:
                     fatal(c"linked_map.LinkedMap.get_or_insert missing inserted value")
                 unsafe:
                     return ptr_of(read(ptr[Node[K, V]]<-current).value)
-            Option.some as ignored_payload:
+            Option.some:
                 fatal(c"linked_map.LinkedMap.get_or_insert replaced unexpectedly")
 
 

data/std/map.mt

@@ -181,10 +181,7 @@ extending Map[K, V]:
             new_capacity = 8
 
         while new_capacity < min_capacity:
-            if new_capacity > heap.ptr_uint_max / 2:
-                new_capacity = min_capacity
-            else:
-                new_capacity *= 2
+            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

data/std/net/channel.mt

@@ -418,7 +418,7 @@ extending HostMessage:
 
 extending Channel:
     public editable function release() -> void:
-        let protocol = unsafe: ptr_of(this.protocol)
+        let protocol = ptr_of(this.protocol)
         release_protocol_state(protocol)
         this.socket.release()
 
@@ -442,7 +442,7 @@ extending Channel:
                 message = string.String.from_str("udp channel payload exceeds configured maximum")
             ))
 
-        let protocol = unsafe: ptr_of(this.protocol)
+        let protocol = ptr_of(this.protocol)
         let sequence = allocate_sequence(protocol)
         (await send_connected_packet(this.socket, protocol, sequence, 0, content))?
         return Result[uint, net.Error].success(value = sequence)
@@ -455,7 +455,7 @@ extending Channel:
                 message = string.String.from_str("udp channel payload exceeds configured maximum")
             ))
 
-        let protocol = unsafe: ptr_of(this.protocol)
+        let protocol = ptr_of(this.protocol)
         let pending_len = unsafe: read(protocol).pending_reliable.len()
         if pending_len >= pending_window_limit(this.config):
             return Result[uint, net.Error].failure(error = net.Error(
@@ -478,7 +478,7 @@ extending Channel:
         defer: packet.release()
 
         let header = decode_header(packet)?
-        let protocol = unsafe: ptr_of(this.protocol)
+        let protocol = ptr_of(this.protocol)
         remove_acked_pending(protocol, header.ack, header.ack_bits)
         let is_new = mark_received(protocol, header.sequence)
         let is_reliable = (header.packet_flags & reliable_flag) != 0
@@ -499,7 +499,7 @@ extending Channel:
 
 
     public async editable function tick(frame: uint) -> Result[ptr_uint, net.Error]:
-        let protocol = unsafe: ptr_of(this.protocol)
+        let protocol = ptr_of(this.protocol)
         var resent: ptr_uint = 0
         var index: ptr_uint = 0
         while true:
@@ -537,7 +537,7 @@ extending Host:
             if removed.is_none():
                 break
             var peer = removed.unwrap()
-            let peer_ptr = unsafe: ptr_of(peer)
+            let peer_ptr = ptr_of(peer)
             release_peer_state(peer_ptr)
 
         this.peers.release()

data/std/net/lobby.mt

@@ -263,8 +263,7 @@ public async function discover_lobbies_on(
                 Result.success:
                     pass
 
-            let empty = bytes.Bytes.empty()
-            let _ = await conn.mux_send(lobby_channel, type_discover_request, empty.as_span(), mux.flag_reliable)
+            let _ = await conn.mux_send(lobby_channel, type_discover_request, zero[span[ubyte]], mux.flag_reliable)
 
             var frame: uint = 0
             var result = vec.Vec[LobbyInfo].create()
@@ -714,7 +713,8 @@ public function build_beacon_probe() -> bytes.Bytes:
 public function is_beacon_probe(data: span[ubyte]) -> bool:
     if data.len < beacon_probe_len:
         return false
-    return data[0] == beacon_magic[0] and data[1] == beacon_magic[1] and data[2] == beacon_magic[2] and data[3] == beacon_magic[3]
+    return data[0] == beacon_magic[0] and data[1] == beacon_magic[1] and
+        data[2] == beacon_magic[2] and data[3] == beacon_magic[3]
 
 
 public function build_beacon_response(info: ref[LobbyInfo]) -> bytes.Bytes:

data/std/net/manager.mt

@@ -5,7 +5,6 @@ import std.net as net
 import std.net.clock as clock
 import std.net.mux as mux
 import std.net.session as sess
-import std.string as string
 import std.vec as vec
 
 const channel_system: ubyte = 0

data/std/net/mux.mt

@@ -728,7 +728,7 @@ function assemble_fragment(
             let buf_data = heap.must_alloc[ubyte](full_size)
             var fill: ptr_uint = 0
             while fill < full_size:
-                unsafe: read(buf_data + fill) = 0
+                read(buf_data + fill) = 0
                 fill += 1
             buf = bytes.Bytes(data = buf_data, len = full_size)
         buffers.push(FragBuffer(

data/std/net/packet.mt

@@ -44,7 +44,10 @@ function decode_packet_length(header: bytes.Bytes) -> ptr_uint:
         fatal(c"packet frame header length mismatch")
 
     let header_span = header.as_span()
-    let length = ((uint<-header_span[0]) << 24) | ((uint<-header_span[1]) << 16) | ((uint<-header_span[2]) << 8) | (uint<-header_span[3])
+    let length = ((uint<-header_span[0]) << 24) |
+        ((uint<-header_span[1]) << 16) |
+        ((uint<-header_span[2]) << 8) |
+        (uint<-header_span[3])
     return length
 
 

data/std/net/punch.mt

@@ -72,7 +72,8 @@ public function build_punch_probe() -> bytes.Bytes:
 public function is_punch_probe(data: span[ubyte]) -> bool:
     if data.len < 4z:
         return false
-    return data[0] == punch_magic[0] and data[1] == punch_magic[1] and data[2] == punch_magic[2] and data[3] == punch_magic[3]
+    return data[0] == punch_magic[0] and data[1] == punch_magic[1] and
+        data[2] == punch_magic[2] and data[3] == punch_magic[3]
 
 
 function result_from_datagram(
@@ -125,7 +126,7 @@ public async function punch(
                 break
             let send_result = await socket.send_to(probe.as_span(), unsafe: read(cand_ptr).address)
             match send_result:
-                Result.failure as sp:
+                Result.failure:
                     return Result[PunchResult, Error].failure(
                         error = punch_error(err_send_failed, "burst send failed")
                     )

data/std/net/rpc.mt

@@ -47,9 +47,7 @@ public function parse_request_id(data: span[ubyte]) -> Result[uint, Error]:
 
 public function payload_after_header(data: span[ubyte]) -> span[ubyte]:
     if data.len <= header_bytes:
-        let empty = bytes.Bytes.empty()
-        let result = empty.as_span()
-        return result
+        return zero[span[ubyte]]
     unsafe:
         return span[ubyte](data = data.data + header_bytes, len = data.len - header_bytes)