mt-lang 0.2.17 → 0.2.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2b1f14318677bf9232d4163ad6aac3905650056716de05bf89762f08e1aa7d5
-  data.tar.gz: af90e63fd1c9fd21f6af721c1c039b61159d931d20eaa3eaca3b41369da053c1
+  metadata.gz: '076938689f867b9d3d7f60eab7f4654c03a45ea69b429f1af17c86a3afef51a5'
+  data.tar.gz: 6f01bf9d070e1307666949acf47d99170d6b28c0048c868a6310663f2d55c919
 SHA512:
-  metadata.gz: cef8b0d7f55c4d9496f41d02b0ace0df87f233ff8c24892768543ff3518e68271a2e4613a7654cef661506d42835d1ea8baa9b3d84225614aae420c0d105a0a4
-  data.tar.gz: b55024abb91b7fdf2694b4be82bf972f1410aa01b949952d30fb49be517fddd501467ebc55fcf3a6dc1a1eb01334709aa74c26a231348026e3197cc5b163b74c
+  metadata.gz: 8141047ac65832b64b8eab1d565b5c3eb3bf8841b5541624605179a1e4bc0479f4dab16a92b3b7055e2eb844e37781aac7acab2aa812b348e53d9a151a16fe97
+  data.tar.gz: e5ead28d45b33a6c7fdb5c46f84cdd9a887e6bca593b841687a1d1124ba904f02ee09bdb1ef8dab87f2b8dcfcd6480190e94cea57e8b3b4853148d06d199f6e6

data/README.md

@@ -855,7 +855,7 @@ Core modules in `std/`:
 - `std.option.Option[T]` — optional value with `is_some`, `is_none`, `unwrap`, `expect`, `unwrap_or`, `unwrap_or_else` (auto-imported via prelude)
 - `std.result.Result[T, E]` — fallible computation with `is_success`, `is_failure`, `unwrap`, `unwrap_error`, `unwrap_or`, `unwrap_or_else`, `ok`, `error`, `map_error` (auto-imported via prelude)
 
-**Collections**: `std.vec.Vec[T]`, `std.deque.Deque[T]`, `std.map.Map[K,V]`, `std.set.Set[T]`, `std.ordered_map.OrderedMap[K,V]`, `std.ordered_set.OrderedSet[T]`, `std.binary_heap.BinaryHeap[T]`, `std.priority_queue.PriorityQueue[T]`, `std.linked_map.LinkedMap[K,V]`, `std.linked_set.LinkedSet[T]`, `std.counter.Counter[T]`, `std.multiset.MultiSet[T]`, `std.queue.Queue[T]`, `std.stack.Stack[T]`
+**Collections**: `std.vec.Vec[T]`, `std.deque.Deque[T]`, `std.map.Map[K,V]`, `std.set.Set[T]`, `std.ordered_map.OrderedMap[K,V]`, `std.ordered_set.OrderedSet[T]`, `std.binary_heap.BinaryHeap[T]`, `std.priority_queue.PriorityQueue[T]`, `std.linked_map.LinkedMap[K,V]`, `std.linked_set.LinkedSet[T]`, `std.counter.Counter[T]`, `std.multiset.MultiSet[T]`, `std.queue.Queue[T]`, `std.stack.Stack[T]`, `std.bitset.Bitset`, `std.spatial.SpatialGrid[T]`, `std.ring_buffer.RingBuffer[T]`, `std.sparse_set.SparseSet[T]`, `std.lru_cache.LruCache[K,V]`
 
 **Serialization**: `std.json`, `std.toml`, `std.uri`, `std.serialize`
 
@@ -872,7 +872,7 @@ Core modules in `std/`:
 **Other**: `std.bytes`, `std.ctype`, `std.asset_pack`, `std.cell`
 
 See module source for full method surface. Iterator forms:
-- Pointer-returning (`next() -> nullable ptr[T]`): `Vec`, `Deque`, `BinaryHeap`/`PriorityQueue`/`OrderedSet` (read-only), `OrderedMap.keys`/`Map.keys`/`Set`/`LinkedMap.keys`/`LinkedSet`/`Counter.keys`/`MultiSet.values`, `Queue`/`Stack` (mutable)
+- Pointer-returning (`next() -> nullable ptr[T]`): `Vec`, `Deque`, `BinaryHeap`/`PriorityQueue`/`OrderedSet` (read-only), `OrderedMap.keys`/`Map.keys`/`Set`/`LinkedMap.keys`/`LinkedSet`/`Counter.keys`/`MultiSet.values`, `Queue`/`Stack` (mutable), `RingBuffer`, `SparseSet`
 - `next() -> bool` + `current()`: `OrderedMap.entries`/`iter`, `Map.entries`/`iter`, `LinkedMap.entries`/`iter`, `Counter.counts`/`entries`/`iter`, `MultiSet.entries`/`iter`, `SnapshotValues`/`SnapshotEntries`
 
 ## 12. Strings, Text, And Builders

data/docs/index.html

@@ -2164,6 +2164,11 @@ function attach(window: ref[Window]) -> Result[void, EventError]:
       <tr><td><code>std.multiset</code></td><td><code>MultiSet[T]</code></td><td>Values read-only; entries <code>current()</code></td><td>Bag with per-element counts</td></tr>
       <tr><td><code>std.queue</code></td><td><code>Queue[T]</code></td><td>Mutable <code>ptr[T]?</code></td><td>FIFO facade over Deque</td></tr>
       <tr><td><code>std.stack</code></td><td><code>Stack[T]</code></td><td>Mutable <code>ptr[T]?</code></td><td>LIFO facade over Deque</td></tr>
+      <tr><td><code>std.bitset</code></td><td><code>Bitset</code></td><td>&mdash;</td><td>Bit-level set with popcount</td></tr>
+      <tr><td><code>std.spatial</code></td><td><code>SpatialGrid[T]</code></td><td>&mdash;</td><td>Uniform spatial hash grid (returns Vec)</td></tr>
+      <tr><td><code>std.ring_buffer</code></td><td><code>RingBuffer[T]</code></td><td>Mutable <code>ptr[T]?</code></td><td>Fixed-capacity circular buffer</td></tr>
+      <tr><td><code>std.sparse_set</code></td><td><code>SparseSet[T]</code></td><td>Mutable <code>ptr[T]?</code></td><td>O(1) insert/remove; dense iteration</td></tr>
+      <tr><td><code>std.lru_cache</code></td><td><code>LruCache[K,V]</code></td><td><code>entries()</code></td><td>Capacity-bounded LRU eviction map</td></tr>
     </table>
   </div>
 

data/docs/language-manual.md

@@ -1129,6 +1129,11 @@ The current shipped collection modules in `std` are:
 - `std.multiset.MultiSet[T]`: insertion-ordered bag built on `Counter[T]`, with `create`, `with_capacity`, `len`, `total_count`, `distinct_len`, `capacity`, `is_empty`, `count`, `contains`, `values`, `entries`, `iter`, `is_subset`, `union_with`, `intersection`, `difference`, `symmetric_difference`, `clear`, `release`, `reserve`, `insert`, `add`, `remove_one`, and `remove_all`.
 - `std.queue.Queue[T]`: FIFO facade over `Deque[T]`, with `create`, `with_capacity`, `len`, `capacity`, `is_empty`, `iter`, `peek`, `clear`, `release`, `reserve`, `enqueue`, and `dequeue`.
 - `std.stack.Stack[T]`: LIFO facade over `Deque[T]`, with `create`, `with_capacity`, `len`, `capacity`, `is_empty`, `iter`, `peek`, `clear`, `release`, `reserve`, `push`, and `pop`.
+- `std.bitset.Bitset`: bit-level set backed by a heap-allocated word array, with `create`, `with_capacity`, `len`, `is_empty`, `set`, `clear`, `test`, `toggle`, `count`, `any`, `all`, `none`, `find_first_set`, `find_first_clear`, `clear_all`, `reserve`, and `release`.
+- `std.spatial.SpatialGrid[T]`: uniform spatial hash grid with `create`, `with_origin`, `insert`, `insert_many`, `query_radius`, `clear`, `release`, `cell_count`, `occupied_cells`, and `entity_count`.
+- `std.ring_buffer.RingBuffer[T]`: fixed-capacity circular buffer that overwrites oldest entries when full, with `with_capacity`, `len`, `capacity`, `is_empty`, `is_full`, `iter`, `get`, `at`, `peek`, `push`, `pop`, `clear`, and `release`.
+- `std.sparse_set.SparseSet[T]`: O(1) insert/remove/contains with cache-friendly dense iteration, keyed by `ptr_uint` handle, with `create`, `with_capacity`, `len`, `is_empty`, `iter`, `get`, `at`, `contains`, `key_at`, `insert`, `remove`, `clear`, `reserve`, and `release`.
+- `std.lru_cache.LruCache[K, V]`: capacity-bounded linked hash map with LRU eviction, keyed by the canonical `hash[K](...)` and `equal[K](...)` hooks, with `with_capacity`, `len`, `capacity`, `is_empty`, `iter`, `get`, `at`, `contains`, `set`, `remove`, `clear`, and `release`.
 - `std.linked_map_view.SnapshotValues[K, V]`: read-only snapshot view over `LinkedMap` values in insertion order, with `create(values: linked_map.Entries[K, V])` and `iter`.
 - `std.linked_map_view.SnapshotEntries[K, V]`: read-only snapshot view over `LinkedMap` entries in insertion order, with `create(values: linked_map.Entries[K, V])` and `iter`.
 
@@ -1151,7 +1156,10 @@ Iterator notes for those collection modules:
 - `MultiSet.values()` uses the pointer-returning iterator form with read-only value pointers in first-seen order.
 - `MultiSet.entries()` and `MultiSet.iter()` use the `next() -> bool` plus `current()` iterator form and yield immutable `{ value, count }` snapshots.
 - `Queue.iter()` and `Stack.iter()` use the same mutable pointer-returning iterator form as `Deque.iter()`, and `peek()` returns a mutable element pointer because changing an element value does not violate FIFO/LIFO ordering invariants.
+- `RingBuffer.iter()` uses the pointer-returning iterator form with mutable element pointers.
+- `SparseSet.iter()` uses the pointer-returning iterator form with mutable element pointers in dense order.
 - `SnapshotValues.iter()` and `SnapshotEntries.iter()` use the `next() -> bool` plus `current()` iterator form in insertion order.
+- `SpatialGrid` does not expose a direct iterator; query results are returned as a `Vec[T]`.
 
 ## 8. Strings, C Strings, And Format Strings
 

data/lib/milk_tea/base.rb

@@ -3,7 +3,7 @@
 require "pathname"
 
 module MilkTea
-  VERSION = "0.2.17"
+  VERSION = "0.2.19"
 
   def self.root
     @root ||= Pathname.new(File.expand_path("../..", __dir__))

data/lib/milk_tea/core/semantic_analyzer/flow_refinement.rb

@@ -122,11 +122,12 @@ module MilkTea
         start_line = [binding.ast.respond_to?(:line) ? binding.ast.line : nil, snapshots.first.line].compact.min
         end_line = snapshots.last.line
 
-        # Generic function bodies are not analysed during structural checking,
-        # so the frame only has the initial snapshot at the declaration line.
-        # Extend end_line to cover the actual body so that completion and hover
-        # lookups for parameters resolve correctly inside the body.
-        if snapshots.length == 1 && binding.ast.respond_to?(:body) && binding.ast.body
+        # Extend end_line to cover the actual function body so that completion
+        # and hover lookups resolve correctly even when snapshots don't reach
+        # the final body line (common for generic functions whose bodies are
+        # only partially analysed, and functions whose last statement does not
+        # record a snapshot).
+        if binding.ast.respond_to?(:body) && binding.ast.body
           body_end = last_ast_line(binding.ast.body)
           end_line = body_end if body_end && body_end > end_line
         end

data/lib/milk_tea/core/semantic_analyzer/function_binding.rb

@@ -334,6 +334,7 @@ module MilkTea
         when AST::LocalDecl
           check_expr_names(stmt.value, scopes, binding, names) if stmt.value
           names.add(stmt.name) if stmt.name
+          try_record_generic_local_snapshot(stmt, scopes, binding) if stmt.name && stmt.value
         when AST::Assignment
           check_expr_names(stmt.target, scopes, binding, names)
           check_expr_names(stmt.value, scopes, binding, names)
@@ -457,6 +458,138 @@ module MilkTea
         raise_sema_error("unknown name #{name}", node)
       end
 
+      # When a generic method body contains a let/var declaration, always record a
+      # completion snapshot so hover and completion can discover the local, even
+      # when full type inference is impossible.  The inferred type is used when
+      # available; otherwise the explicit type annotation on the declaration is
+      # consulted.  As a last resort a fallback primitive type is used so the
+      # binding is never silently dropped.
+      def try_record_generic_local_snapshot(stmt, scopes, binding)
+        type = infer_local_initializer_type(stmt, scopes) ||
+               explicit_declaration_type_for(stmt) ||
+               fallback_completion_type
+
+        decl_kind = stmt.kind == :var ? :var : :let
+        vb = value_binding(name: stmt.name, type: type, mutable: stmt.kind == :var, kind: decl_kind)
+        new_scopes = scopes.dup.unshift({ stmt.name => vb })
+        record_local_completion_snapshot(stmt.line, stmt.column, new_scopes)
+      end
+
+      def infer_local_initializer_type(stmt, scopes)
+        return nil unless stmt.value
+
+        infer_simple_local_type(stmt.value, scopes)
+      end
+
+      def explicit_declaration_type_for(stmt)
+        annotation = stmt.respond_to?(:type) ? stmt.type : nil
+        return nil unless annotation
+
+        name = annotation.respond_to?(:name) ? annotation.name : annotation.to_s
+        @ctx.types[name]
+      end
+
+      def fallback_completion_type
+        @ctx.types["int"] || @ctx.types.values.first
+      end
+
+      def infer_simple_local_type(value, scopes)
+        case value
+        when AST::Call
+          infer_call_return_type(value, scopes)
+        when AST::MemberAccess
+          infer_member_access_field_type(value, scopes)
+        when AST::Identifier
+          (binding = lookup_value(value.name, scopes)) ? binding.type : nil
+        when AST::IntegerLiteral
+          @ctx.types["int"]
+        when AST::FloatLiteral
+          @ctx.types["float"] || @ctx.types["double"]
+        when AST::CharLiteral
+          @ctx.types["ubyte"]
+        when AST::BooleanLiteral
+          @ctx.types["bool"]
+        when AST::StringLiteral
+          @ctx.types["str"]
+        when AST::PrefixCast
+          if value.target_type.respond_to?(:name)
+            @ctx.types[value.target_type.name] || @ctx.types["int"]
+          else
+            @ctx.types["int"]
+          end
+        end
+      end
+
+      def infer_member_access_field_type(value, scopes)
+        receiver_type = case value.receiver
+                        when AST::Identifier
+                          if value.receiver.name == "this"
+                            (binding = lookup_value("this", scopes)) ? binding.type : nil
+                          else
+                            (binding = lookup_value(value.receiver.name, scopes)) ? binding.type : nil
+                          end
+                        end
+        return nil unless receiver_type
+
+        field_receiver = receiver_type_for_fields(receiver_type)
+        field_receiver&.respond_to?(:fields) ? field_receiver.fields[value.member] : nil
+      end
+
+      def infer_call_return_type(call, scopes)
+        callee = call.callee
+        callee = callee.callee while callee.is_a?(AST::Specialization)
+
+        case callee
+        when AST::Identifier
+          func = @ctx.top_level_functions[callee.name]
+          return func.type.return_type if func
+
+          member = callee.name
+          this_binding = lookup_value("this", scopes)
+          if this_binding && (rt = receiver_type_for_fields(this_binding.type))
+            method = @ctx.methods.dig(rt, member)
+            return method.type.return_type if method
+          end
+        when AST::MemberAccess
+          name = resolve_receiver_name_for_call_inference(callee, scopes)
+          member = callee.member
+          return nil unless name
+
+          if (import = @ctx.imports[name])
+            func = import.functions[member]
+            return func.type.return_type if func
+          end
+
+          receiver_type = @ctx.types[name]
+          if receiver_type && @ctx.methods.key?(receiver_type)
+            method = @ctx.methods[receiver_type]["static:#{member}"] || @ctx.methods[receiver_type][member]
+            return method.type.return_type if method
+          end
+        end
+        nil
+      end
+
+      def resolve_receiver_name_for_call_inference(callee, scopes)
+        case callee.receiver
+        when AST::Identifier
+          if callee.receiver.name == "this"
+            binding = lookup_value("this", scopes)
+            return nil unless binding
+            this_type = receiver_type_for_fields(binding.type)
+            this_type&.name
+          else
+            callee.receiver.name
+          end
+        end
+      end
+
+      def receiver_type_for_fields(type)
+        type = type.base while type.is_a?(Types::Nullable)
+        type = type.arguments.first if type.respond_to?(:name) && type.name == 'ref' && type.respond_to?(:arguments) && type.arguments&.length == 1
+        type = type.definition if type.respond_to?(:definition)
+        type
+      end
+
       # Scans generic method bodies for assignments to this through a
       # non-editable receiver.  Full body checking is deferred to call-site
       # specialization, but immutable-this violations are type-independent.
@@ -491,8 +624,10 @@ module MilkTea
           with_scope(binding.body_params) do |scopes|
             start_local_completion_frame(binding, scopes)
             if binding.type_params.any?
-              check_generic_method_immutable_this(binding, scopes)
-              check_generic_method_names(binding, scopes)
+              if binding.ast.respond_to?(:body)
+                check_generic_method_immutable_this(binding, scopes)
+                check_generic_method_names(binding, scopes)
+              end
               return
             end
 

data/lib/milk_tea/core/semantic_analyzer/statements.rb

@@ -22,7 +22,19 @@ module MilkTea
                 if @nullability_flow_result && idx + 1 < statements.length
                   apply_nullability_continuation_refinements!(nested_scopes, statements[idx + 1])
                 end
-                record_local_completion_snapshot(statement_end_line(statement), 1_000_000, nested_scopes)
+                end_line = statement_end_line(statement)
+                # When the statement spans multiple lines (e.g. let … else:),
+                # record an extra snapshot at the declaration line so that
+                # hover and completion lookups on the declaration line itself
+                # can still find the new binding.
+                if end_line && statement.respond_to?(:line) && statement.line && end_line > statement.line
+                  record_local_completion_snapshot(
+                    statement.line,
+                    statement.respond_to?(:column) ? statement.column : 0,
+                    nested_scopes,
+                  )
+                end
+                record_local_completion_snapshot(end_line, 1_000_000, nested_scopes)
               rescue SemanticError => e
                 if @collecting_errors
                   @structural_errors << e

data/lib/milk_tea/lsp/server/hover.rb

@@ -1264,9 +1264,14 @@ module MilkTea
 
           header_line_tokens = non_trivia_tokens_on_line(tokens, current.line)
           header = header_line_tokens.first
+          type_index = 1
+          if header&.type == :public
+            header = header_line_tokens[1]
+            type_index = 2
+          end
           return nil unless [:struct, :union].include?(header&.type)
 
-          type_token = header_line_tokens[1]
+          type_token = header_line_tokens[type_index]
           return nil unless type_token&.type == :identifier
 
           return resolve_type_receiver_info(facts, type_token.lexeme, type_token.lexeme)

data/lib/milk_tea/lsp/server/rename.rb

@@ -462,7 +462,9 @@ module MilkTea
         struct_type = find_struct_containing_field(facts, field_name)
         return nil unless struct_type
 
-        changes = collect_struct_field_changes(uri, field_name, new_name)
+        changes = {}
+        edits = collect_struct_field_changes(uri, field_name, new_name)
+        changes[uri] = edits if edits
         related_uris = @workspace.related_open_document_uris(uri)
         related_uris.each do |related_uri|
           next if related_uri == uri

data/lib/milk_tea/tooling/linter/release_rules.rb

@@ -237,6 +237,8 @@ module MilkTea
             true
           elsif (expr = extract_expr(stmt)) && own_struct_field_transfer?(expr, name)
             true
+          elsif stmt.is_a?(AST::Assignment) && stmt.value.is_a?(AST::Identifier) && stmt.value.name == name
+            true
           else
             false
           end

data/lib/milk_tea/tooling/linter/visitors.rb

@@ -821,6 +821,7 @@ module MilkTea
             message: "every #{kind} branch returns a value; rewrite as `return #{kind} …` expression",
           )
         elsif stmts.all? { |s| s.is_a?(AST::Assignment) && s.operator == "=" } &&
+              stmts.all? { |s| s.target.respond_to?(:name) } &&
               stmts.map { |s| node_fingerprint(s.target) }.uniq.size == 1
           target_name = stmts.first.target.name
           emit_conciseness_hint(

data/std/async/libuv_runtime.mt

@@ -247,7 +247,7 @@ public function sleep_release(frame: ptr[void]) -> void:
 
         if not state.closing:
             state.closing = true
-            let handle = timer_as_handle(unsafe: ptr[NativeTimerHandle]<-state.timer)
+            let handle = timer_as_handle(ptr[NativeTimerHandle]<-state.timer)
             libuv.close(handle, sleep_timer_close)
 
 
@@ -323,7 +323,7 @@ public function work_release[T](frame: ptr[void]) -> void:
 
         state.released = true
         if state.queued and state.work != null:
-            libuv.cancel(work_as_req(unsafe: ptr[NativeWorkRequest]<-state.work))
+            libuv.cancel(work_as_req(ptr[NativeWorkRequest]<-state.work))
 
 
 public function work_take_result[T](frame: ptr[void]) -> T:

data/std/behavior_tree.mt

@@ -128,7 +128,7 @@ function tick_node[Context](tree: ref[Tree[Context]], node_id: ptr_uint, context
 
                 var saw_running = false
                 for child_ptr in read(node).children:
-                    let child_status = tick_node(tree, unsafe: read(child_ptr), context)
+                    let child_status = tick_node(tree, read(child_ptr), context)
                     match child_status:
                         Status.success:
                             pass
@@ -148,7 +148,7 @@ function tick_node[Context](tree: ref[Tree[Context]], node_id: ptr_uint, context
 
                 var saw_running = false
                 for child_ptr in read(node).children:
-                    let child_status = tick_node(tree, unsafe: read(child_ptr), context)
+                    let child_status = tick_node(tree, read(child_ptr), context)
                     match child_status:
                         Status.success:
                             return Status.success

data/std/deque.mt

@@ -140,6 +140,35 @@ extending Deque[T]:
         this.capacity = new_capacity
 
 
+    public editable function shrink_to_fit() -> void:
+        if this.len == 0:
+            heap.release(this.data)
+            this.data = null
+            this.head = 0
+            this.capacity = 0
+            return
+
+        if this.len == this.capacity:
+            return
+
+        let new_data = heap.must_alloc[T](this.len)
+        let old_data = this.data
+        if old_data != null:
+            unsafe:
+                let old_ptr = ptr[T]<-old_data
+                let new_ptr = ptr[T]<-new_data
+                var index: ptr_uint = 0
+                while index < this.len:
+                    let source_index = Deque[T].physical_index(this.head, this.capacity, index)
+                    read(new_ptr + index) = read(old_ptr + source_index)
+                    index += 1
+
+        heap.release(old_data)
+        this.data = new_data
+        this.head = 0
+        this.capacity = this.len
+
+
     public editable function push_back(value: T) -> void:
         if this.len == this.capacity:
             this.reserve(this.len + 1)

data/std/goap.mt

@@ -323,13 +323,12 @@ extending Planner[World, Goal, Context]:
                                         action_index += 1
                                         continue
 
-                                    if next_cost < unsafe: read(existing_ptr).cost_so_far:
-                                        unsafe:
-                                            read(existing_ptr).parent_index = current_index
-                                            read(existing_ptr).has_parent = true
-                                            read(existing_ptr).action_index = action_index
-                                            read(existing_ptr).cost_so_far = next_cost
-                                            read(existing_ptr).closed = false
+                                    if next_cost < read(existing_ptr).cost_so_far:
+                                        read(existing_ptr).parent_index = current_index
+                                        read(existing_ptr).has_parent = true
+                                        read(existing_ptr).action_index = action_index
+                                        read(existing_ptr).cost_so_far = next_cost
+                                        read(existing_ptr).closed = false
                                         if not open_list_contains(ref_of(open_list), existing_payload.value):
                                             open_list.push(existing_payload.value)
                         action_index += 1

data/std/lru_cache.mt

@@ -0,0 +1,75 @@
+import std.linked_map as linked_map
+
+public struct LruCache[K, V]:
+    values: linked_map.LinkedMap[K, V]
+    max_capacity: ptr_uint
+
+
+extending LruCache[K, V]:
+    public static function with_capacity(capacity: ptr_uint) -> LruCache[K, V]:
+        return LruCache[K, V](values = linked_map.LinkedMap[K, V].with_capacity(capacity), max_capacity = capacity)
+
+
+    public function len() -> ptr_uint:
+        return this.values.len()
+
+
+    public function capacity() -> ptr_uint:
+        return this.max_capacity
+
+
+    public function is_empty() -> bool:
+        return this.values.is_empty()
+
+
+    public function iter() -> linked_map.Entries[K, V]:
+        return this.values.entries()
+
+
+    public editable function get(key: K) -> ptr[V]?:
+        let removed = this.values.remove_entry(key)
+        match removed:
+            Option.some as entry:
+                this.values.set(key, entry.value.value)
+                return this.values.get(key)
+            Option.none:
+                return null
+
+
+    public editable 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 contains(key: K) -> bool:
+        return this.values.contains(key)
+
+
+    public editable function clear() -> void:
+        this.values.clear()
+
+
+    public editable function release() -> void:
+        this.values.release()
+
+
+    public editable function set(key: K, value: V) -> void:
+        this.values.remove(key)
+
+        if this.values.len() == this.max_capacity:
+            var key_iter = this.values.keys()
+            let first_key_ptr = key_iter.next() else:
+                return
+
+            unsafe:
+                let first_key = read(ptr[K]<-first_key_ptr)
+                this.values.remove(first_key)
+
+        this.values.set(key, value)
+
+
+    public editable function remove(key: K) -> bool:
+        return this.values.remove(key).is_some()

data/std/net/manager.mt

@@ -331,7 +331,7 @@ public function create_server(
                 is_server = true,
                 max_players = config.max_players,
                 mux_session = session_p.value,
-                mux_connection = unsafe: zero[mux.MuxedConnection],
+                mux_connection = zero[mux.MuxedConnection],
                 local_player_id = 0u,
                 players = vec.Vec[PlayerState].create(),
                 next_player_id = 1u,
@@ -357,7 +357,7 @@ public function create_client(
             let client_mgr = NetworkManager(
                 is_server = false,
                 max_players = config.max_players,
-                mux_session = unsafe: zero[mux.MuxedSession],
+                mux_session = zero[mux.MuxedSession],
                 mux_connection = mux_conn_p.value,
                 local_player_id = 0u,
                 players = vec.Vec[PlayerState].create(),

data/std/net/packet.mt

@@ -164,7 +164,7 @@ extending Stream:
             Result.failure as error_payload:
                 return Result[ptr_uint, Error].failure(error = error_from_net(error_payload.error))
             Result.success as write_payload:
-                unsafe: write_payload.value
+                write_payload.value
                 return Result[ptr_uint, Error].success(value = content.len)
 
 
@@ -183,7 +183,7 @@ extending Stream:
                         Result.failure as discard_payload:
                             return Result[bytes.Bytes, Error].failure(error = discard_payload.error)
                         Result.success as discard_payload:
-                            unsafe: discard_payload.value
+                            discard_payload.value
                             return Result[bytes.Bytes, Error].failure(error = packet_error(
                                 -2,
                                 "packet exceeds configured maximum"

data/std/net.mt

@@ -736,7 +736,7 @@ function connect_cleanup_and_release(state: ptr[ConnectState]) -> void:
             read(state).result_owned = false
 
         if read(state).handle != null[ptr[NativeTcpHandle]]:
-            close_tcp_handle(unsafe: ptr[NativeTcpHandle]<-read(state).handle)
+            close_tcp_handle(ptr[NativeTcpHandle]<-read(state).handle)
             read(state).handle = null
 
         heap.release(state)

data/std/process.mt

@@ -94,7 +94,7 @@ public function parent_environment() -> vec.Vec[EnvironmentEntry]:
             nname.reserve(eq_pos)
             var ni: ptr_uint = 0
             while ni < eq_pos:
-                nname.push_byte(ubyte<-(unsafe: read(entry_cstr + ni)))
+                nname.push_byte(ubyte<-(read(entry_cstr + ni)))
                 ni += 1
             var nvalue = string.String.create()
             let vlen = len - eq_pos - 1
@@ -102,7 +102,7 @@ public function parent_environment() -> vec.Vec[EnvironmentEntry]:
                 nvalue.reserve(vlen)
                 var vi: ptr_uint = 0
                 while vi < vlen:
-                    nvalue.push_byte(ubyte<-(unsafe: read(entry_cstr + eq_pos + 1 + vi)))
+                    nvalue.push_byte(ubyte<-(read(entry_cstr + eq_pos + 1 + vi)))
                     vi += 1
             result.push(EnvironmentEntry(
                 name = nname.as_str(),

data/std/queue.mt

@@ -47,6 +47,10 @@ extending Queue[T]:
         this.values.reserve(min_capacity)
 
 
+    public editable function shrink_to_fit() -> void:
+        this.values.shrink_to_fit()
+
+
     public editable function enqueue(value: T) -> void:
         this.values.push_back(value)
 

data/std/ring_buffer.mt

@@ -0,0 +1,131 @@
+import std.mem.heap as heap
+
+public struct RingBuffer[T]:
+    data: own[T]?
+    head: ptr_uint
+    len: ptr_uint
+    capacity: ptr_uint
+
+public struct Iter[T]:
+    data: ptr[T]?
+    head: ptr_uint
+    len: ptr_uint
+    capacity: ptr_uint
+    index: ptr_uint
+
+
+extending RingBuffer[T]:
+    public static function with_capacity(capacity: ptr_uint) -> RingBuffer[T]:
+        let data = heap.must_alloc[T](capacity)
+        return RingBuffer[T](data = data, head = 0, len = 0, capacity = capacity)
+
+
+    static function physical_index(head: ptr_uint, capacity: ptr_uint, index: ptr_uint) -> ptr_uint:
+        let raw = head + index
+        if raw >= capacity:
+            return raw - capacity
+
+        return raw
+
+
+    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 is_full() -> bool:
+        return this.len == this.capacity
+
+
+    public function iter() -> Iter[T]:
+        return Iter[T](data = this.data, head = this.head, len = this.len, capacity = this.capacity, index = 0)
+
+
+    public function get(index: ptr_uint) -> ptr[T]?:
+        if index >= this.len:
+            return null
+
+        let data = this.data else:
+            fatal(c"ring_buffer.RingBuffer.get missing storage")
+
+        return unsafe: ptr[T]<-data + RingBuffer[T].physical_index(this.head, this.capacity, index)
+
+
+    public function at(index: ptr_uint) -> Option[T]:
+        let p = this.get(index) else:
+            return Option[T].none
+
+        unsafe:
+            return Option[T].some(value = read(p))
+
+
+    public function peek() -> ptr[T]?:
+        return this.get(0)
+
+
+    public editable function push(value: T) -> void:
+        let data = this.data else:
+            fatal(c"ring_buffer.RingBuffer.push missing storage")
+
+        let tail = RingBuffer[T].physical_index(this.head, this.capacity, this.len)
+
+        unsafe:
+            let data_ptr = ptr[T]<-data
+            read(data_ptr + tail) = value
+
+        if this.len == this.capacity:
+            this.head = RingBuffer[T].physical_index(this.head, this.capacity, 1)
+        else:
+            this.len += 1
+
+
+    public editable function pop() -> Option[T]:
+        if this.len == 0:
+            return Option[T].none
+
+        let data = this.data else:
+            fatal(c"ring_buffer.RingBuffer.pop missing storage")
+
+        unsafe:
+            let data_ptr = ptr[T]<-data
+            let value = read(data_ptr + this.head)
+            this.head = RingBuffer[T].physical_index(this.head, this.capacity, 1)
+            this.len -= 1
+            return Option[T].some(value = value)
+
+
+    public editable function clear() -> void:
+        this.head = 0
+        this.len = 0
+
+
+    public editable function release() -> void:
+        heap.release(this.data)
+        this.data = null
+        this.head = 0
+        this.len = 0
+        this.capacity = 0
+
+
+extending Iter[T]:
+    public function iter() -> Iter[T]:
+        return this
+
+
+    public editable function next() -> ptr[T]?:
+        if this.index >= this.len:
+            return null
+
+        let data = this.data else:
+            fatal(c"ring_buffer.Iter.next missing storage")
+
+        let current_index = this.index
+        this.index += 1
+        return unsafe: ptr[T]<-data + RingBuffer[T].physical_index(this.head, this.capacity, current_index)

data/std/serialize.mt

@@ -25,7 +25,7 @@ public function unpack[T](source: span[ubyte]) -> Result[T, bin.Error]:
             error = raw_unpack_error("source too short for target type")
         )
 
-    var result = unsafe: zero[T]
+    var result = zero[T]
     var dest = unsafe: ptr[ubyte]<-ptr_of(result)
     var i: ptr_uint = 0
     while i < total:
@@ -59,7 +59,7 @@ extending bin.Reader:
                         error = raw_unpack_error("reader returned empty data")
                     )
 
-                var result = unsafe: zero[T]
+                var result = zero[T]
                 var dest = unsafe: ptr[ubyte]<-ptr_of(result)
                 var i: ptr_uint = 0
                 while i < total:

data/std/sparse_set.mt

@@ -0,0 +1,176 @@
+import std.vec as vec
+
+const SPARSE_EMPTY: ptr_uint = ~ptr_uint<-0
+
+public struct SparseSet[T]:
+    sparse: vec.Vec[ptr_uint]
+    dense: vec.Vec[T]
+    keys: vec.Vec[ptr_uint]
+
+public struct Iter[T]:
+    data: ptr[T]?
+    index: ptr_uint
+    len: ptr_uint
+
+
+extending SparseSet[T]:
+    public static function create() -> SparseSet[T]:
+        return SparseSet[T](
+            sparse = vec.Vec[ptr_uint].create(),
+            dense = vec.Vec[T].create(),
+            keys = vec.Vec[ptr_uint].create(),
+        )
+
+
+    public static function with_capacity(capacity: ptr_uint) -> SparseSet[T]:
+        var result = SparseSet[T].create()
+        result.reserve(capacity)
+        return result
+
+
+    public function len() -> ptr_uint:
+        return this.dense.len()
+
+
+    public function is_empty() -> bool:
+        return this.dense.is_empty()
+
+
+    public function iter() -> Iter[T]:
+        let view = this.dense.as_span()
+        return Iter[T](data = view.data, index = 0, len = view.len)
+
+
+    public function get(key: ptr_uint) -> ptr[T]?:
+        if key >= this.sparse.len():
+            return null
+
+        let position = this.sparse.get(key) else:
+            fatal(c"sparse_set.SparseSet.get missing sparse storage")
+
+        unsafe:
+            let index = read(ptr[ptr_uint]<-position)
+            if index == SPARSE_EMPTY:
+                return null
+
+            return this.dense.get(index)
+
+
+    public function at(key: ptr_uint) -> Option[T]:
+        let p = this.get(key) else:
+            return Option[T].none
+
+        unsafe:
+            return Option[T].some(value = read(p))
+
+
+    public function contains(key: ptr_uint) -> bool:
+        return this.get(key) != null
+
+
+    public function key_at(dense_index: ptr_uint) -> ptr_uint:
+        let key_ptr = this.keys.get(dense_index) else:
+            fatal(c"sparse_set.SparseSet.key_at missing keys storage")
+
+        unsafe:
+            return read(ptr[ptr_uint]<-key_ptr)
+
+
+    public editable function clear() -> void:
+        this.sparse.clear()
+        this.dense.clear()
+        this.keys.clear()
+
+
+    public editable function release() -> void:
+        this.sparse.release()
+        this.dense.release()
+        this.keys.release()
+
+
+    public editable function reserve(min_capacity: ptr_uint) -> void:
+        this.dense.reserve(min_capacity)
+        this.keys.reserve(min_capacity)
+
+
+    public editable function shrink_to_fit() -> void:
+        this.sparse.shrink_to_fit()
+        this.dense.shrink_to_fit()
+        this.keys.shrink_to_fit()
+
+
+    public editable function insert(key: ptr_uint, value: T) -> bool:
+        while key >= this.sparse.len():
+            this.sparse.push(SPARSE_EMPTY)
+
+        let position = this.sparse.get(key) else:
+            fatal(c"sparse_set.SparseSet.insert missing sparse storage")
+
+        unsafe:
+            if read(ptr[ptr_uint]<-position) != SPARSE_EMPTY:
+                return false
+
+        let dense_index = this.dense.len()
+        this.dense.push(value)
+        this.keys.push(key)
+
+        unsafe:
+            read(ptr[ptr_uint]<-position) = dense_index
+
+        return true
+
+
+    public editable function remove(key: ptr_uint) -> bool:
+        if key >= this.sparse.len():
+            return false
+
+        let dense_index_ptr = this.sparse.get(key) else:
+            fatal(c"sparse_set.SparseSet.remove missing sparse storage")
+
+        unsafe:
+            let dense_index = read(ptr[ptr_uint]<-dense_index_ptr)
+            if dense_index == SPARSE_EMPTY:
+                return false
+
+            let last_index = this.dense.len() - 1
+            if dense_index != last_index:
+                let last_value = this.dense.get(last_index) else:
+                    fatal(c"sparse_set.SparseSet.remove missing last dense value")
+                let dense_slot = this.dense.get(dense_index) else:
+                    fatal(c"sparse_set.SparseSet.remove missing dense slot")
+                read(dense_slot) = read(last_value)
+
+                let last_key = this.keys.get(last_index) else:
+                    fatal(c"sparse_set.SparseSet.remove missing last key")
+                let moved_key = read(ptr[ptr_uint]<-last_key)
+
+                let key_slot = this.keys.get(dense_index) else:
+                    fatal(c"sparse_set.SparseSet.remove missing key slot")
+                read(ptr[ptr_uint]<-key_slot) = moved_key
+
+                let moved_sparse_ptr = this.sparse.get(moved_key) else:
+                    fatal(c"sparse_set.SparseSet.remove missing sparse entry for moved key")
+                read(ptr[ptr_uint]<-moved_sparse_ptr) = dense_index
+
+            this.dense.pop()
+            this.keys.pop()
+            read(ptr[ptr_uint]<-dense_index_ptr) = SPARSE_EMPTY
+
+        return true
+
+
+extending Iter[T]:
+    public function iter() -> Iter[T]:
+        return this
+
+
+    public editable function next() -> ptr[T]?:
+        if this.index >= this.len:
+            return null
+
+        let data = this.data else:
+            fatal(c"sparse_set.Iter.next missing storage")
+
+        let current_index = this.index
+        this.index += 1
+        return unsafe: ptr[T]<-data + current_index

data/std/spatial.mt

@@ -9,7 +9,53 @@ public struct SpatialGrid[T]:
     origin_y: float
 
 
+function cell_index[T](grid: ref[SpatialGrid[T]], x: float, y: float) -> Option[ptr_uint]:
+    let cx = int<-(float<-((x - grid.origin_x) / grid.cell_size))
+    let cy = int<-(float<-((y - grid.origin_y) / grid.cell_size))
+    if cx < 0 or cy < 0 or uint<-cx >= grid.cols or uint<-cy >= grid.rows:
+        return Option[ptr_uint].none()
+    return Option[ptr_uint].some(value = ptr_uint<-cx + ptr_uint<-cy * ptr_uint<-grid.cols)
+
+
 extending SpatialGrid[T]:
+    public static function create(cell_size: float, width: float, height: float) -> SpatialGrid[T]:
+        var cols: uint = uint<-(float<-width / cell_size)
+        var rows: uint = uint<-(float<-height / cell_size)
+        if cols == 0:
+            cols = 1
+        if rows == 0:
+            rows = 1
+
+        var cells = vec.Vec[vec.Vec[T]].create()
+        var total: ptr_uint = ptr_uint<-cols * ptr_uint<-rows
+        var i: ptr_uint = 0
+        while i < total:
+            cells.push(vec.Vec[T].create())
+            i += 1
+
+        return SpatialGrid[T](
+            cells = cells,
+            cell_size = cell_size,
+            cols = cols,
+            rows = rows,
+            origin_x = 0.0,
+            origin_y = 0.0
+        )
+
+
+    public static function with_origin(
+        cell_size: float,
+        width: float,
+        height: float,
+        origin_x: float,
+        origin_y: float
+    ) -> SpatialGrid[T]:
+        var grid = SpatialGrid[T].create(cell_size, width, height)
+        grid.origin_x = origin_x
+        grid.origin_y = origin_y
+        return grid
+
+
     public editable function release() -> void:
         var i: ptr_uint = 0
         while i < this.cells.len():
@@ -20,53 +66,6 @@ extending SpatialGrid[T]:
         this.cells.release()
 
 
-function cell_index[T](grid: ref[SpatialGrid[T]], x: float, y: float) -> Option[ptr_uint]:
-    let cx = int<-(float<-((x - grid.origin_x) / grid.cell_size))
-    let cy = int<-(float<-((y - grid.origin_y) / grid.cell_size))
-    if cx < 0 or cy < 0 or uint<-cx >= grid.cols or uint<-cy >= grid.rows:
-        return Option[ptr_uint].none()
-    return Option[ptr_uint].some(value = ptr_uint<-cx + ptr_uint<-cy * ptr_uint<-grid.cols)
-
-
-public function new[T](cell_size: float, width: float, height: float) -> SpatialGrid[T]:
-    var cols: uint = uint<-(float<-width / cell_size)
-    var rows: uint = uint<-(float<-height / cell_size)
-    if cols == 0:
-        cols = 1
-    if rows == 0:
-        rows = 1
-
-    var cells = vec.Vec[vec.Vec[T]].create()
-    var total: ptr_uint = ptr_uint<-cols * ptr_uint<-rows
-    var i: ptr_uint = 0
-    while i < total:
-        cells.push(vec.Vec[T].create())
-        i += 1
-
-    return SpatialGrid[T](
-        cells = cells,
-        cell_size = cell_size,
-        cols = cols,
-        rows = rows,
-        origin_x = 0.0,
-        origin_y = 0.0
-    )
-
-
-public function new_with_origin[T](
-    cell_size: float,
-    width: float,
-    height: float,
-    origin_x: float,
-    origin_y: float
-) -> SpatialGrid[T]:
-    var grid = new[T](cell_size, width, height)
-    grid.origin_x = origin_x
-    grid.origin_y = origin_y
-    return grid
-
-
-extending SpatialGrid[T]:
     public editable function insert(entity: T, x: float, y: float) -> void:
         let idx_opt = cell_index(ref_of(this), x, y)
         match idx_opt:

data/std/stack.mt

@@ -47,6 +47,10 @@ extending Stack[T]:
         this.values.reserve(min_capacity)
 
 
+    public editable function shrink_to_fit() -> void:
+        this.values.shrink_to_fit()
+
+
     public editable function push(value: T) -> void:
         this.values.push_back(value)
 

data/std/string.mt

@@ -133,6 +133,26 @@ extending String:
         this.capacity = new_capacity
 
 
+    public editable function shrink_to_fit() -> void:
+        if not this.owns_storage:
+            return
+
+        if this.len == 0:
+            heap.release(this.data)
+            this.data = null
+            this.capacity = 0
+            return
+
+        if this.len == this.capacity:
+            return
+
+        let resized = heap.resize[ubyte](this.data, this.len) else:
+            fatal(c"string.shrink_to_fit out of memory")
+
+        this.data = resized
+        this.capacity = this.len
+
+
     public editable function push_byte(value: ubyte) -> void:
         if this.len == this.capacity:
             this.reserve(this.len + 1)

data/std/toml.mt

@@ -1214,7 +1214,7 @@ function append_value(output: ref[string.String], value: Value) -> void:
                     let item = values.values.get(index) else:
                         fatal(c"toml.append_value missing array item")
 
-                    append_value(output, unsafe: read(item))
+                    append_value(output, read(item))
                     index += 1
 
         output.push_byte(byte_right_bracket)
@@ -1233,7 +1233,7 @@ function append_value(output: ref[string.String], value: Value) -> void:
                 let entry = object_entries.entries.get(index) else:
                     fatal(c"toml.append_value missing object entry")
 
-                let current = unsafe: read(entry)
+                let current = read(entry)
                 append_entry_key(output, current.key.as_str())
                 output.append(" = ")
                 append_value(output, current.value)

data/std/vec.mt

@@ -117,6 +117,23 @@ extending Vec[T]:
         this.capacity = new_capacity
 
 
+    public editable function shrink_to_fit() -> void:
+        if this.len == 0:
+            heap.release(this.data)
+            this.data = null
+            this.capacity = 0
+            return
+
+        if this.len == this.capacity:
+            return
+
+        let resized = heap.resize[T](this.data, this.len) else:
+            fatal(c"vec.shrink_to_fit out of memory")
+
+        this.data = resized
+        this.capacity = this.len
+
+
     public editable function append_span(values: span[T]) -> void:
         if values.len == 0:
             return

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.2.17
+  version: 0.2.19
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -498,6 +498,7 @@ files:
 - std/linked_map_view.mt
 - std/linked_set.mt
 - std/log.mt
+- std/lru_cache.mt
 - std/map.mt
 - std/math.mt
 - std/mem/arena.mt
@@ -543,6 +544,7 @@ files:
 - std/raylib/tracy_gpu.mt
 - std/raymath.mt
 - std/result.mt
+- std/ring_buffer.mt
 - std/rlgl.mt
 - std/rpng.mt
 - std/rres.mt
@@ -550,6 +552,7 @@ files:
 - std/sdl3/runtime.mt
 - std/serialize.mt
 - std/set.mt
+- std/sparse_set.mt
 - std/spatial.mt
 - std/sqlite3.mt
 - std/stack.mt
@@ -583,7 +586,7 @@ metadata:
   homepage_uri: https://teefan.github.io/mt-lang/
   source_code_uri: https://github.com/teefan/mt-lang
 post_install_message: |
-  Milk Tea 0.2.17 installed!
+  Milk Tea 0.2.19 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH