mt-lang 0.4.24 → 0.4.25

data/lib/milk_tea/tooling/std_catalog.rb

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+module MilkTea
+  # Discovers the hand-written standard library modules shipped in std/, and
+  # resolves module names to source paths for tooling commands.
+  #
+  # Generated modules (bindgen output under std/c/ and imported-binding
+  # wrappers such as raylib or zstd) are excluded from discovery but stay
+  # resolvable, so `std show` can still print them.
+  class StdCatalog
+    Entry = Struct.new(:name, :description, :category, :path, keyword_init: true)
+
+    GENERATED_HEADER_PREFIX = "# generated by mtc"
+    PLATFORM_SUFFIXES = %w[linux windows wasm].freeze
+    EXCLUDED_DIRECTORIES = %w[c].freeze
+
+    CATEGORY_ORDER = [
+      "Core & Patterns",
+      "Collections",
+      "Memory",
+      "Text & Formatting",
+      "Math & Simulation",
+      "Data & Serialization",
+      "Concurrency & Time",
+      "Files & System",
+      "Network",
+      "Security",
+      "AI & Behavior",
+      "Game & Graphics",
+    ].freeze
+
+    # name => [category, description]. Must cover every hand-written module
+    # discovered under std/; a test enforces that coverage.
+    REGISTRY = {
+      "asset_pack" => ["Game & Graphics", "MTAP asset pack reader and writer for bundled runtime assets."],
+      "async" => ["Concurrency & Time", "Async/await runtime facade over a pluggable event-loop backend."],
+      "async.libuv_runtime" => ["Concurrency & Time", "libuv-backed async runtime implementation."],
+      "async.mailbox" => ["Concurrency & Time", "Typed mailboxes for message passing between async tasks."],
+      "async.runtime" => ["Concurrency & Time", "Async backend selection and event-loop plumbing shared by async code."],
+      "base64" => ["Text & Formatting", "Base64 encode and decode."],
+      "behavior_tree" => ["AI & Behavior", "Behavior trees with sequence, selector, decorator, and leaf nodes."],
+      "binary" => ["Data & Serialization", "Binary reader/writer with explicit endianness and error reporting."],
+      "binary_heap" => ["Collections", "Binary heap over a flat array with sift-up/sift-down operations."],
+      "bitset" => ["Collections", "Fixed-capacity bit array with set, clear, test, and population count."],
+      "blackboard" => ["AI & Behavior", "Typed key-value shared state for AI agents."],
+      "box" => ["Core & Patterns", "Explicit single-value heap storage for owned boxed values."],
+      "bytes" => ["Data & Serialization", "Byte buffer type with slicing, comparison, and stream I/O."],
+      "cli" => ["Files & System", "Command-line parsing helpers for flags, options, and positionals."],
+      "cmd" => ["Core & Patterns", "Command pattern with paired do/undo callbacks for undo/redo stacks."],
+      "color" => ["Game & Graphics", "RGBA color conversion, blending, and named presets."],
+      "cookie" => ["Data & Serialization", "HTTP cookie parsing and serialization."],
+      "counter" => ["Collections", "Occurrence counter keyed by value, a counting multiset."],
+      "crypto" => ["Security", "Digests, HMAC, and secure random via the platform crypto bindings."],
+      "cstring" => ["Text & Formatting", "Null-terminated C string helpers backed by libc memory routines."],
+      "ctype" => ["Text & Formatting", "Character classification: alnum, digit, space, and case tests."],
+      "curl.runtime" => ["Network", "libcurl runtime glue for handle setup and error reporting."],
+      "deque" => ["Collections", "Double-ended queue with amortized O(1) operations at both ends."],
+      "encoding" => ["Text & Formatting", "UTF-8 validation, codepoint iteration, and encoding helpers."],
+      "env" => ["Files & System", "Environment variable access returning Option values."],
+      "errno" => ["Files & System", "errno code constants and error message lookup."],
+      "fmt" => ["Text & Formatting", "Value formatting helpers for integers, floats, and fixed buffers."],
+      "fs" => ["Files & System", "File and directory operations with platform-specific variants."],
+      "fsm" => ["AI & Behavior", "Finite state machines with table-driven transitions and dispatch."],
+      "goap" => ["AI & Behavior", "Goal-oriented action planning (GOAP) with forward search."],
+      "graph" => ["Game & Graphics", "Weighted graph algorithms such as shortest paths and reachability."],
+      "gzip" => ["Data & Serialization", "Gzip and zlib compression and decompression."],
+      "hash" => ["Core & Patterns", "Canonical hash, equality, and ordering for common primitive types."],
+      "htn" => ["AI & Behavior", "Hierarchical Task Network (HTN) planner."],
+      "http" => ["Network", "HTTP client for requests, responses, and chunked bodies."],
+      "http.server" => ["Network", "Small HTTP server with routing, static files, and JSON responses."],
+      "input" => ["Game & Graphics", "Input action mapping that decouples logical actions from physical devices."],
+      "intern" => ["Text & Formatting", "String interning table producing unique identifier handles."],
+      "iter" => ["Core & Patterns", "Composable lazy iteration adaptors over sequences."],
+      "jobs" => ["Concurrency & Time", "Job scheduler for fan-out parallel work with completion tracking."],
+      "json" => ["Data & Serialization", "JSON parsing and serialization over cjson with arena-backed values."],
+      "libc" => ["Files & System", "Curated libc facade for memory, string, process, and math functions."],
+      "linear_algebra" => ["Math & Simulation", "Vectors and matrices for 2D/3D graphics and physics."],
+      "linked_map" => ["Collections", "Hash map with a doubly-linked order list for O(1) reordering."],
+      "linked_map_view" => ["Collections", "Read-only snapshot views over linked_map instances."],
+      "linked_set" => ["Collections", "Insertion-ordered hash set backed by a linked list."],
+      "log" => ["Files & System", "Leveled logging with configurable output sinks."],
+      "lru_cache" => ["Collections", "Least-recently-used cache with bounded capacity."],
+      "map" => ["Collections", "Chained hash map with pluggable hashing for generic keys and values."],
+      "math" => ["Math & Simulation", "Mathematical constants and functions beyond the language builtins."],
+      "mem.arena" => ["Memory", "Region allocator: bump allocation with O(1) mark/reset."],
+      "mem.endian" => ["Memory", "Byte-swap and endian conversion helpers."],
+      "mem.heap" => ["Memory", "General-purpose heap allocator wrapper with alignment control."],
+      "mem.pool" => ["Memory", "Fixed-slot pool allocator for uniform-size objects."],
+      "mem.ptr" => ["Memory", "Safe pointer load/store wrappers around raw memory access."],
+      "mem.stack" => ["Memory", "Stack allocator with mark/release layered on the arena."],
+      "mem.tracking" => ["Memory", "Allocation tracker for leak detection and usage diagnostics."],
+      "multiset" => ["Collections", "Hash multiset that counts duplicate values."],
+      "net" => ["Network", "UDP and TCP sockets, address resolution, and packet I/O."],
+      "net.channel" => ["Network", "Multiplexed message channels over a single connection."],
+      "net.clock" => ["Network", "Synchronized network clock with ping and offset estimation."],
+      "net.discovery" => ["Network", "LAN service discovery via UDP broadcast."],
+      "net.lobby" => ["Network", "Lobby listing and joining built on discovery."],
+      "net.manager" => ["Network", "Connection and session manager for multiplayer topologies."],
+      "net.mux" => ["Network", "Stream multiplexer with reliable and unordered delivery flags."],
+      "net.nat" => ["Network", "NAT type detection and address binding via STUN."],
+      "net.packet" => ["Network", "Framed packet reading and writing over byte streams."],
+      "net.punch" => ["Network", "UDP hole punching for peer-to-peer connections."],
+      "net.rpc" => ["Network", "Request/response RPC framing over net channels."],
+      "net.session" => ["Network", "Client session state machine with heartbeats and timeouts."],
+      "net.stun" => ["Network", "STUN client for public address and port discovery."],
+      "net.sync" => ["Network", "State synchronization primitives for replicated values."],
+      "net.turn" => ["Network", "TURN relay client for NAT-restricted peers."],
+      "noise" => ["Math & Simulation", "Coherent Perlin noise and fractal variants."],
+      "oauth2" => ["Data & Serialization", "OAuth2 token requests and refresh flows."],
+      "option" => ["Core & Patterns", "Option[T] optional values, some(value) or none, with combinators."],
+      "ordered_map" => ["Collections", "Hash map that preserves insertion order."],
+      "ordered_set" => ["Collections", "Hash set that preserves insertion order."],
+      "parse" => ["Text & Formatting", "Numeric string parsing for integers and floats."],
+      "path" => ["Files & System", "Path join, split, and normalization utilities."],
+      "pcre2.runtime" => ["Text & Formatting", "Compiled regex matching runtime over the pcre2 bindings."],
+      "pool" => ["Collections", "Fixed-capacity reusable object storage."],
+      "priority_queue" => ["Collections", "Priority queue backed by a binary heap."],
+      "process" => ["Files & System", "Child process spawning with pipes and exit status."],
+      "queue" => ["Collections", "First-in first-out queue."],
+      "random" => ["Math & Simulation", "PCG pseudo-random number generation with seeding and ranges."],
+      "raylib.debug_console" => ["Game & Graphics", "In-game debug console overlay with command history."],
+      "raylib.easing" => ["Game & Graphics", "Easing curves for animation interpolation."],
+      "raylib.packed_assets" => ["Game & Graphics", "Load images, textures, and audio from assets.mtpack packs."],
+      "raylib.runtime" => ["Game & Graphics", "raylib app lifecycle helpers: window loop, asset directory, fatal errors."],
+      "raylib.tracy_gpu" => ["Game & Graphics", "Tracy profiler GPU zone calibration for raylib."],
+      "result" => ["Core & Patterns", "Result[T, E] success/failure type for recoverable errors."],
+      "ring_buffer" => ["Collections", "Fixed-capacity circular buffer with overwrite behavior."],
+      "sdl3.runtime" => ["Game & Graphics", "SDL3 app lifecycle helpers and main-loop wrappers."],
+      "serialize" => ["Data & Serialization", "Struct field serialization helpers layered on std.binary."],
+      "set" => ["Collections", "Hash set of unique values."],
+      "signal" => ["Concurrency & Time", "Fixed-capacity observer and publish-subscribe signals."],
+      "simd" => ["Math & Simulation", "SIMD load, store, and reduction helpers."],
+      "sparse_set" => ["Collections", "Sparse set with dense iteration for integer-keyed data."],
+      "spatial" => ["Math & Simulation", "Uniform spatial hash grid for broad-phase queries."],
+      "stack" => ["Collections", "Last-in first-out stack."],
+      "steering" => ["AI & Behavior", "Craig Reynolds steering behaviors for autonomous motion."],
+      "stdio" => ["Files & System", "Stdin, stdout, and stderr FILE wrappers and console I/O."],
+      "str" => ["Text & Formatting", "Borrowed string slice helpers: length, compare, search, split."],
+      "string" => ["Text & Formatting", "Heap-owned growable string type with builder operations."],
+      "sync" => ["Concurrency & Time", "Mutex, condition variable, and once primitives over libuv."],
+      "tar" => ["Data & Serialization", "TAR archive reading and writing with 512-byte blocks."],
+      "terminal" => ["Files & System", "Terminal size, color, and raw-mode helpers."],
+      "thread" => ["Concurrency & Time", "Threads via libuv with join and handle management."],
+      "time" => ["Concurrency & Time", "Wall-clock timestamps and monotonic time helpers."],
+      "timer" => ["Concurrency & Time", "Countdown and repeating timers."],
+      "tls" => ["Security", "TLS client and server streams over libuv handles."],
+      "toml" => ["Data & Serialization", "TOML parser for configuration files."],
+      "tween" => ["Game & Graphics", "Tweening and easing for smooth value interpolation."],
+      "uri" => ["Data & Serialization", "URI parsing and construction, including file and web schemes."],
+      "url" => ["Data & Serialization", "URL parsing: scheme, host, path, query, and percent-encoding."],
+      "utility" => ["AI & Behavior", "Utility AI with score-based action selection."],
+      "vec" => ["Collections", "Growable contiguous array Vec[T], the default dynamic sequence."],
+    }.freeze
+
+    class << self
+      def std_root
+        File.join(MilkTea.root.to_s, "std")
+      end
+
+      def entries
+        discover
+      end
+
+      # Resolves a module name ("mem.arena", "mem/arena", "c.cjson", "fs") to a
+      # source path. Prefers the active platform variant, matching the
+      # compiler's import resolution rule. Returns nil when unresolvable.
+      def resolve(name)
+        clean = name.to_s.strip
+        return nil if clean.empty? || clean.include?("..")
+
+        relative = clean.tr(".", "/").delete_suffix(".mt")
+        root = std_root
+
+        variant = File.join(root, "#{relative}.#{MilkTea.host_platform}.mt")
+        return variant if File.file?(variant)
+
+        shared = File.join(root, "#{relative}.mt")
+        return shared if File.file?(shared)
+
+        nil
+      end
+
+      def discover
+        root = std_root
+        by_name = {}
+
+        module_files(root).each do |path|
+          add_module(by_name, logical_name(path), path)
+        end
+
+        namespace_directories(root).each do |directory|
+          namespace = File.basename(directory)
+          module_files(directory).each do |path|
+            add_module(by_name, "#{namespace}.#{logical_name(path)}", path)
+          end
+        end
+
+        by_name.values.sort_by(&:name)
+      end
+
+      def add_module(by_name, name, path)
+        return if generated?(path)
+
+        category, description = REGISTRY.fetch(name, [nil, nil])
+        description ||= doc_comment_summary(path)
+        entry = by_name[name]
+        unless entry
+          by_name[name] = Entry.new(name:, description:, category:, path:)
+          return
+        end
+
+        entry.path = path if prefer_path?(path, entry.path)
+      end
+
+      # A shared file beats any variant; among variants the host platform
+      # wins, then the first alphabetically.
+      def prefer_path?(candidate, current)
+        candidate_rank = path_rank(candidate)
+        current_rank = path_rank(current)
+        order = candidate_rank <=> current_rank
+        order.negative? || (order.zero? && candidate < current)
+      end
+
+      def path_rank(path)
+        host = MilkTea.host_platform.to_s
+        [platform_variant?(path) ? 1 : 0, platform_of(path) == host ? 0 : 1]
+      end
+
+      def module_files(directory)
+        Dir.glob(File.join(directory, "*.mt")).sort
+      end
+
+      def namespace_directories(root)
+        Dir.children(root).map { |child| File.join(root, child) }
+           .select { |path| File.directory?(path) }
+           .reject { |path| EXCLUDED_DIRECTORIES.include?(File.basename(path)) }
+           .sort
+      end
+
+      def logical_name(path)
+        stem = File.basename(path, ".mt")
+        platform = platform_of(path)
+        platform ? stem.delete_suffix(".#{platform}") : stem
+      end
+
+      def platform_variant?(path)
+        PLATFORM_SUFFIXES.include?(platform_of(path))
+      end
+
+      def platform_of(path)
+        stem = File.basename(path, ".mt")
+        suffix = stem[/\.([^.]+)\z/, 1]
+        suffix && PLATFORM_SUFFIXES.include?(suffix) ? suffix : nil
+      end
+
+      def generated?(path)
+        File.open(path, "r") { |file| file.readline.start_with?(GENERATED_HEADER_PREFIX) }
+      rescue EOFError, Errno::ENOENT
+        false
+      end
+
+      def doc_comment_summary(path)
+        File.foreach(path) do |line|
+          stripped = line.strip
+          next if stripped.empty?
+
+          return stripped.sub(/\A##\s?/, "").rstrip if stripped.start_with?("##")
+
+          break
+        end
+        nil
+      rescue Errno::ENOENT
+        nil
+      end
+    end
+  end
+end

data/lib/milk_tea/tooling.rb

@@ -15,6 +15,7 @@ require_relative "tooling/error_formatter"
 require_relative "tooling/formatter"
 require_relative "tooling/linter"
 require_relative "tooling/docs_app"
+require_relative "tooling/std_catalog"
 require_relative "tooling/project_scaffold"
 require_relative "tooling/toolchain_cli"
 require_relative "tooling/bindgen_cli"

data/std/async/libuv_runtime.mt

@@ -79,23 +79,22 @@ function work_as_req(work: ptr[NativeWorkRequest]) -> ptr[NativeRequest]:
     return unsafe: ptr[NativeRequest]<-work
 
 
-function close_all_handles_cb(handle: ptr[NativeHandle], arg: ptr[void]) -> void:
+function close_all_handles_cb(handle: ptr[NativeHandle], _arg: ptr[void]) -> void:
     if libuv.is_closing(handle) == 0:
         libuv.close(handle, close_all_handles_close_cb)
-    unsafe: arg
 
 
-function close_all_handles_close_cb(handle: ptr[NativeHandle]) -> void:
-    unsafe: ptr[void]<-handle
+function close_all_handles_close_cb(_handle: ptr[NativeHandle]) -> void:
+    pass
 
 
-function noop_waiter(frame: ptr[void]) -> void:
-    unsafe: frame
+function noop_waiter(_frame: ptr[void]) -> void:
+    pass
 
 
 function require_current_runtime() -> Runtime:
     if not current_runtime_active:
-        fatal(c"async runtime requires an active runtime; use async.wait or async.run, or call the explicit *_on helpers")
+        fatal(c"async runtime requires an active runtime; use async.wait or async.run, or call the *_on helpers")
     return current_runtime
 
 
@@ -337,20 +336,19 @@ public function sleep_on(runtime: Runtime, timeout: ptr_uint) -> Task[int]:
     let loop = live_loop(runtime)
 
     let state = heap.must_alloc_zeroed[SleepState](1)
-    unsafe:
-        state.ready = false
-        state.status = 0
-        state.waiter_frame = null
-        state.waiter = noop_waiter
-        state.waiter_registered = false
-        state.timer = null
-        state.closing = false
-        state.closed = false
-        state.released = false
+    state.ready = false
+    state.status = 0
+    state.waiter_frame = null
+    state.waiter = noop_waiter
+    state.waiter_registered = false
+    state.timer = null
+    state.closing = false
+    state.closed = false
+    state.released = false
 
     let timer_size = libuv.handle_size(libuv.uv_handle_type.UV_TIMER)
     let timer = unsafe: ptr[NativeTimerHandle]<-heap.must_alloc_zeroed_bytes(1, timer_size)
-    unsafe: state.timer = timer
+    state.timer = timer
 
     let init_status = libuv.timer_init(loop, timer)
     if init_status != 0:
@@ -367,11 +365,10 @@ public function sleep_on(runtime: Runtime, timeout: ptr_uint) -> Task[int]:
 
     let start_status = libuv.timer_start(timer, sleep_timer_fire, timeout, 0)
     if start_status != 0:
-        unsafe:
-            state.status = start_status
-            state.ready = true
-            state.closing = true
-            libuv.close(timer_as_handle(timer), sleep_timer_close)
+        state.status = start_status
+        state.ready = true
+        state.closing = true
+        libuv.close(timer_as_handle(timer), sleep_timer_close)
 
     return sleep_task(state)
 

data/std/async/mailbox.mt

@@ -45,8 +45,8 @@ function handle_as_async(handle: ptr[NativeHandle]) -> ptr[NativeAsyncHandle]:
     return unsafe: ptr[NativeAsyncHandle]<-handle
 
 
-function mailbox_async_callback(handle: ptr[NativeAsyncHandle]) -> void:
-    unsafe: handle
+function mailbox_async_callback(_handle: ptr[NativeAsyncHandle]) -> void:
+    pass
 
 
 function mailbox_destroy_state[T](state_frame: ptr[void]) -> void:

data/std/base64.mt

@@ -163,18 +163,15 @@ public function decode(text_value: str) -> Result[bytes.Bytes, Error]:
 
         let combined = (ulong<-raw0 << 18) | (ulong<-raw1 << 12) | (ulong<-raw2 << 6) | ulong<-raw3
 
-        unsafe:
-            read(output + out_index) = ubyte<-( (combined >> 16) & 0xFF)
+        read(output + out_index) = ubyte<-( (combined >> 16) & 0xFF)
         out_index += 1
 
         if out_index < output_len:
-            unsafe:
-                read(output + out_index) = ubyte<-( (combined >> 8) & 0xFF)
+            read(output + out_index) = ubyte<-( (combined >> 8) & 0xFF)
             out_index += 1
 
         if out_index < output_len:
-            unsafe:
-                read(output + out_index) = ubyte<-(combined & 0xFF)
+            read(output + out_index) = ubyte<-(combined & 0xFF)
             out_index += 1
 
     return Result[bytes.Bytes, Error].success(value = bytes.Bytes(data = output, len = output_len))

data/std/behavior_tree.mt

@@ -233,11 +233,8 @@ function tick_node[Context](tree: ref[Tree[Context]], node_id: ptr_uint, context
                 match child_status:
                     Status.success:
                         return Status.success
-                    Status.failure:
-                        return Status.running
-                    Status.running:
+                    Status.failure | Status.running:
                         return Status.running
-
             NodeKind.until_failure:
                 let child_ptr = read(node).children.first() else:
                     return Status.failure
@@ -251,8 +248,6 @@ function tick_node[Context](tree: ref[Tree[Context]], node_id: ptr_uint, context
                     Status.running:
                         return Status.running
 
-    return Status.failure
-
 
 extending Node[Context]:
     static function create(kind: NodeKind) -> Node[Context]:

data/std/binary.mt

@@ -95,10 +95,7 @@ extending Writer:
 
 
     public editable function write_bool(value: bool) -> void:
-        if value:
-            writer_append_byte(ref_of(this), 1)
-        else:
-            writer_append_byte(ref_of(this), 0)
+        if value: writer_append_byte(ref_of(this), 1) else: writer_append_byte(ref_of(this), 0)
 
 
     public editable function write_bytes(data: span[ubyte]) -> void:
@@ -268,7 +265,7 @@ extending Reader:
 
     public editable function read_span(count: ptr_uint) -> Result[span[ubyte], Error]:
         if count == 0:
-            let empty = unsafe: span[ubyte](data = this.data.data, len = 0)
+            let empty = span[ubyte](data = this.data.data, len = 0)
             return Result[span[ubyte], Error].success(value = empty)
 
         reader_check_remaining(ref_of(this), count)?

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