mt-lang 0.2.17 → 0.2.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2b1f14318677bf9232d4163ad6aac3905650056716de05bf89762f08e1aa7d5
-  data.tar.gz: af90e63fd1c9fd21f6af721c1c039b61159d931d20eaa3eaca3b41369da053c1
+  metadata.gz: 35157666294e3aadb1c8106b1ccbacdf0d548f06a009b99c2a7799e76436e320
+  data.tar.gz: acc6091f6f22e2bbe340ebba54f49dc0b195849294f6086959027751a6cbfee1
 SHA512:
-  metadata.gz: cef8b0d7f55c4d9496f41d02b0ace0df87f233ff8c24892768543ff3518e68271a2e4613a7654cef661506d42835d1ea8baa9b3d84225614aae420c0d105a0a4
-  data.tar.gz: b55024abb91b7fdf2694b4be82bf972f1410aa01b949952d30fb49be517fddd501467ebc55fcf3a6dc1a1eb01334709aa74c26a231348026e3197cc5b163b74c
+  metadata.gz: 831ed7f14aaef5be511434b7697f0f0d23896d78fd2cfd5ef6037fee9c9909dbce3cc6c51bd6d9b1c95dae2dbeb7990b1cece93f455990f3f7c4e911dc64e24a
+  data.tar.gz: 6621e043744173fe77a457a3823a6b38032b4f12a71f96f707539154578bf9b7c95d8e688d36ba7d44404148ed4f85a47b55a3a00d81fb13e466fa86e9bc1be7

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.18"
 
   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/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/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/sparse_set.mt

@@ -0,0 +1,170 @@
+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 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:

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.2.17
+  version: 0.2.18
 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.18 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH