@shd101wyy/yo 0.1.26 → 0.1.27

package/std/collections/hash_map.yo

@@ -1,8 +1,6 @@
 //! Hash map using SwissTable algorithm with SIMD-accelerated lookup.
-
-{ GlobalAllocator, AllocError } :: import "../allocator.yo";
+{ GlobalAllocator, AllocError } :: import("../allocator.yo");
 { malloc, calloc, realloc, free } :: GlobalAllocator;
-
 /// Error variants for HashMap operations.
 HashMapError :: enum(
   /// Memory allocation failed.
@@ -12,487 +10,437 @@ HashMapError :: enum(
   /// Capacity calculation overflowed.
   CapacityOverflow
 );
-
 /// Control byte for an empty bucket (never used).
 CTRL_EMPTY :: u8(255);
 /// Control byte for a deleted bucket (tombstone).
 CTRL_DELETED :: u8(254);
-
 /// Default initial capacity (must be power of 2).
 DEFAULT_CAPACITY :: usize(16);
-
 /// Maximum load factor numerator (7/8 = 0.875). Resize when `size > capacity * 7 / 8`.
 MAX_LOAD_FACTOR_NUMERATOR :: usize(7);
 MAX_LOAD_FACTOR_DENOMINATOR :: usize(8);
-
 /// Key-value pair stored in a hash map bucket.
-Bucket :: (fn(comptime(K): Type, comptime(V): Type) -> comptime(Type))
+Bucket :: (fn(comptime(K) : Type, comptime(V) : Type) -> comptime(Type))(
   struct(
     key : K,
     value : V
   )
-;
-
+);
 /// Extract H2 hash (lower 7 bits) from full hash for control byte comparison.
-h2_hash :: (fn(hash: u64) -> u8)
-  u8(hash & u64(127))
-;
-
+h2_hash :: (fn(hash : u64) -> u8)(u8(hash & u64(127)));
 /// Extract H1 hash (upper bits) for bucket index calculation.
-h1_hash :: (fn(hash: u64, capacity: usize) -> usize)
-  (usize((hash >> u64(7))) % capacity)
-;
-
+h1_hash :: (fn(hash : u64, capacity : usize) -> usize)(usize(hash >> u64(7)) % capacity);
 /// High-performance hash map using SwissTable algorithm.
 /// Keys must implement `Eq` and `Hash`. Provides O(1) average lookup, insert, and delete.
-HashMap :: (fn(
-  comptime(K): Type,
-  comptime(V): Type,
-  where(K <: (Eq(K), Hash))
-) -> comptime(Type))
+HashMap :: (
+  fn(
+    comptime(K) : Type,
+    comptime(V) : Type,
+    where(K <: (Eq(K), Hash))
+  ) -> comptime(Type)
+)(
   object(
     ctrl : ?*(u8),
     data : ?*(Bucket(K, V)),
     capacity : usize,
     size : usize
   )
-;
-
-impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), HashMap(K, V),
+);
+impl(
+  forall(K : Type, V : Type),
+  where(K <: (Eq(K), Hash)),
+  HashMap(K, V),
   /**
-    * Allocate memory for HashMap with given capacity
-    * Initializes all control bytes to EMPTY
-    */
-  _alloc_with_capacity : (fn(capacity: usize) -> Result(Self, HashMapError))(
-    {
-      bucket_size :: sizeof(Bucket(K, V));
-      ctrl_size := capacity;
-      data_size := (capacity * bucket_size);
-      
-      ctrl_result := malloc(ctrl_size);
-      match(ctrl_result,
-        .None => .Err(.AllocError(error: .OutOfMemory)),
-        .Some(ctrl_void_ptr) => {
-          ctrl_ptr := *(u8)(ctrl_void_ptr);
-          
-          data_result := malloc(data_size);
-          match(data_result,
-            .None => {
-              free(.Some(*(void)(ctrl_ptr)));
-              .Err(.AllocError(error: .OutOfMemory))
-            },
-            .Some(data_void_ptr) => {
-              data_ptr := *(Bucket(K, V))(data_void_ptr);
-              
-              i := usize(0);
-              while(i < capacity, i = (i + usize(1)), {
-                (ctrl_ptr &+ i).* = CTRL_EMPTY;
-              });
-              
-              .Ok(Self(
-                ctrl: .Some(ctrl_ptr),
-                data: .Some(data_ptr),
-                capacity: capacity,
-                size: usize(0)
-              ))
-            }
-          )
-        }
-      )
-    }
-  ),
-
+  * Allocate memory for HashMap with given capacity
+  * Initializes all control bytes to EMPTY
+  */
+  _alloc_with_capacity : (fn(capacity : usize) -> Result(Self, HashMapError))({
+    bucket_size :: sizeof(Bucket(K, V));
+    ctrl_size := capacity;
+    data_size := (capacity * bucket_size);
+    ctrl_result := malloc(ctrl_size);
+    match(
+      ctrl_result,
+      .None =>.Err(.AllocError(error :.OutOfMemory)),
+      .Some(ctrl_void_ptr) => {
+        ctrl_ptr := *(u8)(ctrl_void_ptr);
+        data_result := malloc(data_size);
+        match(
+          data_result,
+          .None => {
+            free(.Some(*(void)(ctrl_ptr)));
+            .Err(.AllocError(error :.OutOfMemory))
+          },
+          .Some(data_void_ptr) => {
+            data_ptr := *(Bucket(K, V))(data_void_ptr);
+            i := usize(0);
+            while(i < capacity, i = (i + usize(1)), {
+              (ctrl_ptr &+ i).* = CTRL_EMPTY;
+            });
+            .Ok(
+              Self(
+                ctrl :.Some(ctrl_ptr),
+                data :.Some(data_ptr),
+                capacity : capacity,
+                size : usize(0)
+              )
+            )
+          }
+        )
+      }
+    )
+  }),
   /**
-    * Create a new empty HashMap with default capacity
-    */
+  * Create a new empty HashMap with default capacity
+  */
   new : (fn() -> Self)({
     result := Self._alloc_with_capacity(DEFAULT_CAPACITY);
-    match(result,
+    match(
+      result,
       .Ok(map) => map,
       .Err(_) => panic("Failed to allocate HashMap")
     )
   }),
-
   /**
-    * Create a HashMap with a specific initial capacity
-    * Capacity will be rounded up to next power of 2
-    */
-  with_capacity : (fn(requested_capacity: usize) -> Self)(
-    {
-      capacity := cond(
-        (requested_capacity < DEFAULT_CAPACITY) => DEFAULT_CAPACITY,
-        true => {
-          c := requested_capacity;
-          c = (c - usize(1));
-          c = (c | (c >> usize(1)));
-          c = (c | (c >> usize(2)));
-          c = (c | (c >> usize(4)));
-          c = (c | (c >> usize(8)));
-          c = (c | (c >> usize(16)));
-          (c + usize(1))
-        }
-      );
-      
-      result := Self._alloc_with_capacity(capacity);
-      match(result,
-        .Ok(map) => map,
-        .Err(_) => panic("Failed to allocate HashMap")
-      )
-    }
-  ),
-
+  * Create a HashMap with a specific initial capacity
+  * Capacity will be rounded up to next power of 2
+  */
+  with_capacity : (fn(requested_capacity : usize) -> Self)({
+    capacity := cond(
+      (requested_capacity < DEFAULT_CAPACITY) => DEFAULT_CAPACITY,
+      true => {
+        c := requested_capacity;
+        c = (c - usize(1));
+        c = (c | (c >> usize(1)));
+        c = (c | (c >> usize(2)));
+        c = (c | (c >> usize(4)));
+        c = (c | (c >> usize(8)));
+        c = (c | (c >> usize(16)));
+        c + usize(1)
+      }
+    );
+    result := Self._alloc_with_capacity(capacity);
+    match(
+      result,
+      .Ok(map) => map,
+      .Err(_) => panic("Failed to allocate HashMap")
+    )
+  }),
   /**
-    * Get ctrl pointer (unwrapped for internal use)
-    */
-  _ctrl_ptr : (fn(self: Self) -> *(u8))(
-    match(self.ctrl,
+  * Get ctrl pointer (unwrapped for internal use)
+  */
+  _ctrl_ptr : (fn(self : Self) -> *(u8))(
+    match(
+      self.ctrl,
       .Some(ptr) => ptr,
       .None => panic("HashMap ctrl pointer is null")
     )
   ),
-
   /**
-    * Get data pointer (unwrapped for internal use)
-    */
-  _data_ptr : (fn(self: Self) -> *(Bucket(K, V)))(
-    match(self.data,
+  * Get data pointer (unwrapped for internal use)
+  */
+  _data_ptr : (fn(self : Self) -> *(Bucket(K, V)))(
+    match(
+      self.data,
       .Some(ptr) => ptr,
       .None => panic("HashMap data pointer is null")
     )
   ),
-
   /**
-    * Find bucket index for a given key using quadratic probing
-    * Returns Some(index) if key is found, None otherwise
-    */
-  _find_bucket : (fn(self: Self, key: K, hash: u64) -> Option(usize))(
-    {
-      h2 := h2_hash(hash);
-      index := h1_hash(hash, self.capacity);
-      probe := usize(0);
-      ctrl_ptr := Self._ctrl_ptr(self);
-      data_ptr := Self._data_ptr(self);
-      
-      while(probe < self.capacity, probe = (probe + usize(1)), {
-        probe_index := ((index + probe) % self.capacity);
-        ctrl_byte := (ctrl_ptr &+ probe_index).*;
-        
-        cond(
-          (ctrl_byte == CTRL_EMPTY) => {
-            return .None;
-          },
-          (ctrl_byte == h2) => {
-            bucket := (data_ptr &+ probe_index).*;
-            cond(
-              (bucket.key == key) => {
-                return .Some(probe_index);
-              },
-              true => ()
-            );
-          },
-          true => ()
-        );
-      });
-      
-      .None
-    }
-  ),
-
-  /**
-    * Find first available bucket (EMPTY or DELETED) for insertion
-    * Returns bucket index using quadratic probing
-    */
-  _find_insert_bucket : (fn(self: Self, hash: u64) -> usize)(
-    {
-      index := h1_hash(hash, self.capacity);
-      probe := usize(0);
-      ctrl_ptr := Self._ctrl_ptr(self);
-      
-      while(probe < self.capacity, probe = (probe + usize(1)), {
-        probe_index := ((index + probe) % self.capacity);
-        ctrl_byte := (ctrl_ptr &+ probe_index).*;
-        
-        cond(
-          ((ctrl_byte == CTRL_EMPTY) || (ctrl_byte == CTRL_DELETED)) => {
-            return probe_index;
-          },
-          true => ()
-        );
-      });
-      
-      panic("HashMap is full - should have resized")
-    }
-  ),
-
-  /**
-    * Check if HashMap needs resizing based on load factor
-    */
-  _needs_resize : (fn(self: Self) -> bool)(
-    {
-      threshold := ((self.capacity * MAX_LOAD_FACTOR_NUMERATOR) / MAX_LOAD_FACTOR_DENOMINATOR);
-      (self.size >= threshold)
-    }
-  ),
-
-  /**
-    * Resize and rehash the HashMap to a new capacity
-    */
-  _resize : (fn(self: Self, new_capacity: usize) -> Result(unit, HashMapError))(
-    {
-      result := Self._alloc_with_capacity(new_capacity);
-      match(result,
-        .Err(err) => .Err(err),
-        .Ok(new_map) => {
-          i := usize(0);
-          ctrl_ptr := Self._ctrl_ptr(self);
-          data_ptr := Self._data_ptr(self);
-          while(i < self.capacity, i = (i + usize(1)), {
-            ctrl_byte := (ctrl_ptr &+ i).*;
-            cond(
-              ((ctrl_byte != CTRL_EMPTY) && (ctrl_byte != CTRL_DELETED)) => {
-                bucket := (data_ptr &+ i).*;
-                hash := (bucket.key).hash();
-                h2 := h2_hash(hash);
-                new_index := Self._find_insert_bucket(new_map, hash);
-                
-                new_ctrl_ptr := Self._ctrl_ptr(new_map);
-                new_data_ptr := Self._data_ptr(new_map);
-                (new_ctrl_ptr &+ new_index).* = h2;
-                consume((new_data_ptr &+ new_index).* = bucket);
-                new_map.size = (new_map.size + usize(1));
-              },
-              true => ()
-            );
-          });
-
-          // Drop old buckets before freeing old data array
-          // (bucket := ... above duped them, so we need to drop the old refs)
+  * Find bucket index for a given key using quadratic probing
+  * Returns Some(index) if key is found, None otherwise
+  */
+  _find_bucket : (fn(self : Self, key : K, hash : u64) -> Option(usize))({
+    h2 := h2_hash(hash);
+    index := h1_hash(hash, self.capacity);
+    probe := usize(0);
+    ctrl_ptr := Self._ctrl_ptr(self);
+    data_ptr := Self._data_ptr(self);
+    while(probe < self.capacity, probe = (probe + usize(1)), {
+      probe_index := ((index + probe) % self.capacity);
+      ctrl_byte := (ctrl_ptr &+ probe_index).*;
+      cond(
+        (ctrl_byte == CTRL_EMPTY) => {
+          return(.None);
+        },
+        (ctrl_byte == h2) => {
+          bucket := (data_ptr &+ probe_index).*;
           cond(
-            (Type.contains_rc_type(K) || Type.contains_rc_type(V)) => {
-              j := usize(0);
-              while(j < self.capacity, j = (j + usize(1)), {
-                ctrl_byte := (ctrl_ptr &+ j).*;
-                cond(
-                  ((ctrl_byte != CTRL_EMPTY) && (ctrl_byte != CTRL_DELETED)) => {
-                    bucket_ptr := (data_ptr &+ j);
-                    cond(
-                      Type.contains_rc_type(K) => unsafe.drop((bucket_ptr.*).key),
-                      true => ()
-                    );
-                    cond(
-                      Type.contains_rc_type(V) => unsafe.drop((bucket_ptr.*).value),
-                      true => ()
-                    );
-                  },
-                  true => ()
-                );
-              });
+            (bucket.key == key) => {
+              return(.Some(probe_index));
             },
             true => ()
           );
-          
-          match(self.ctrl,
-            .Some(ptr) => free(.Some(*(void)(ptr))),
-            .None => ()
-          );
-          match(self.data,
-            .Some(ptr) => free(.Some(*(void)(ptr))),
-            .None => ()
-          );
-          
-          self.ctrl = new_map.ctrl;
-          self.data = new_map.data;
-          self.capacity = new_map.capacity;
-          
-          new_map.ctrl = .None;
-          new_map.data = .None;
-          
-          .Ok(())
-        }
-      )
-    }
-  ),
-
+        },
+        true => ()
+      );
+    });
+    .None
+  }),
   /**
-    * Insert or update a key-value pair
-    * Returns Ok(Some(old_value)) if key existed, Ok(None) if new key
-    */
-  set : (fn(self: Self, key: K, value: V) -> Result(Option(V), HashMapError))(
-    {
-      hash := key.hash();
-      bucket_opt := Self._find_bucket(self, key, hash);
-      
-      match(bucket_opt,
-        .Some(index) => {
-          data_ptr := Self._data_ptr(self);
-          old_bucket := (data_ptr &+ index).*;
-          old_value := old_bucket.value;
-          new_bucket := Bucket(K, V)(key: key, value: value);
-          // Don't use consume here - we want to drop the old bucket at memory
-          // Note: old_bucket already duped it, so dropping here decrements to RC=1
-          // Then old_bucket goes out of scope and drops again to RC=0
-          // But wait - we return old_value which was duped from old_bucket...
-          // Actually the Bucket struct contains RC types, so assignment drops old + dups new
-          (data_ptr &+ index).* = new_bucket;
-          .Ok(.Some(old_value))
+  * Find first available bucket (EMPTY or DELETED) for insertion
+  * Returns bucket index using quadratic probing
+  */
+  _find_insert_bucket : (fn(self : Self, hash : u64) -> usize)({
+    index := h1_hash(hash, self.capacity);
+    probe := usize(0);
+    ctrl_ptr := Self._ctrl_ptr(self);
+    while(probe < self.capacity, probe = (probe + usize(1)), {
+      probe_index := ((index + probe) % self.capacity);
+      ctrl_byte := (ctrl_ptr &+ probe_index).*;
+      cond(
+        ((ctrl_byte == CTRL_EMPTY) || (ctrl_byte == CTRL_DELETED)) => {
+          return(probe_index);
         },
-        .None => {
-          resize_check := cond(
-            (Self._needs_resize(self)) => {
-              new_capacity := (self.capacity * usize(2));
-              Self._resize(self, new_capacity)
+        true => ()
+      );
+    });
+    panic("HashMap is full - should have resized")
+  }),
+  /**
+  * Check if HashMap needs resizing based on load factor
+  */
+  _needs_resize : (fn(self : Self) -> bool)({
+    threshold := ((self.capacity * MAX_LOAD_FACTOR_NUMERATOR) / MAX_LOAD_FACTOR_DENOMINATOR);
+    self.size >= threshold
+  }),
+  /**
+  * Resize and rehash the HashMap to a new capacity
+  */
+  _resize : (fn(self : Self, new_capacity : usize) -> Result(unit, HashMapError))({
+    result := Self._alloc_with_capacity(new_capacity);
+    match(
+      result,
+      .Err(err) =>.Err(err),
+      .Ok(new_map) => {
+        i := usize(0);
+        ctrl_ptr := Self._ctrl_ptr(self);
+        data_ptr := Self._data_ptr(self);
+        while(i < self.capacity, i = (i + usize(1)), {
+          ctrl_byte := (ctrl_ptr &+ i).*;
+          cond(
+            ((ctrl_byte != CTRL_EMPTY) && (ctrl_byte != CTRL_DELETED)) => {
+              bucket := (data_ptr &+ i).*;
+              hash := (bucket.key).hash();
+              h2 := h2_hash(hash);
+              new_index := Self._find_insert_bucket(new_map, hash);
+              new_ctrl_ptr := Self._ctrl_ptr(new_map);
+              new_data_ptr := Self._data_ptr(new_map);
+              (new_ctrl_ptr &+ new_index).* = h2;
+              consume((new_data_ptr &+ new_index).* = bucket);
+              new_map.size = (new_map.size + usize(1));
             },
-            true => (Result(unit, HashMapError).Ok(()))
+            true => ()
           );
-          
-          match(resize_check,
-            .Err(err) => .Err(err),
-            .Ok(_) => {
-              h2 := h2_hash(hash);
-              index := Self._find_insert_bucket(self, hash);
-              
-              ctrl_ptr := Self._ctrl_ptr(self);
-              data_ptr := Self._data_ptr(self);
-              (ctrl_ptr &+ index).* = h2;
-              new_bucket := Bucket(K, V)(key: key, value: value);
-              consume((data_ptr &+ index).* = new_bucket);
-              self.size = (self.size + usize(1));
-              
-              .Ok(.None)
-            }
-          )
-        }
-      )
-    }
-  ),
-
+        });
+        // Drop old buckets before freeing old data array
+        // (bucket := ... above duped them, so we need to drop the old refs)
+        cond(
+          (Type.contains_rc_type(K) || Type.contains_rc_type(V)) => {
+            j := usize(0);
+            while(j < self.capacity, j = (j + usize(1)), {
+              ctrl_byte := (ctrl_ptr &+ j).*;
+              cond(
+                ((ctrl_byte != CTRL_EMPTY) && (ctrl_byte != CTRL_DELETED)) => {
+                  bucket_ptr := (data_ptr &+ j);
+                  cond(
+                    Type.contains_rc_type(K) => unsafe.drop((bucket_ptr.*).key),
+                    true => ()
+                  );
+                  cond(
+                    Type.contains_rc_type(V) => unsafe.drop((bucket_ptr.*).value),
+                    true => ()
+                  );
+                },
+                true => ()
+              );
+            });
+          },
+          true => ()
+        );
+        match(
+          self.ctrl,
+          .Some(ptr) => free(.Some(*(void)(ptr))),
+          .None => ()
+        );
+        match(
+          self.data,
+          .Some(ptr) => free(.Some(*(void)(ptr))),
+          .None => ()
+        );
+        self.ctrl = new_map.ctrl;
+        self.data = new_map.data;
+        self.capacity = new_map.capacity;
+        new_map.ctrl =.None;
+        new_map.data =.None;
+        .Ok(())
+      }
+    )
+  }),
   /**
-    * Get a value by key
-    * Returns Some(value) if found, None otherwise
-    */
-  get : (fn(self: Self, key: K) -> Option(V))(
-    {
-      hash := key.hash();
-      bucket_opt := Self._find_bucket(self, key, hash);
-      match(bucket_opt,
-        .Some(index) => {
-          data_ptr := Self._data_ptr(self);
-          bucket := (data_ptr &+ index).*;
-          .Some(bucket.value)
-        },
-        .None => .None
-      )
-    }
-  ),
-
+  * Insert or update a key-value pair
+  * Returns Ok(Some(old_value)) if key existed, Ok(None) if new key
+  */
+  set : (fn(self : Self, key : K, value : V) -> Result(Option(V), HashMapError))({
+    hash := key.hash();
+    bucket_opt := Self._find_bucket(self, key, hash);
+    match(
+      bucket_opt,
+      .Some(index) => {
+        data_ptr := Self._data_ptr(self);
+        old_bucket := (data_ptr &+ index).*;
+        old_value := old_bucket.value;
+        new_bucket := Bucket(K, V)(key : key, value : value);
+        // Don't use consume here - we want to drop the old bucket at memory
+        // Note: old_bucket already duped it, so dropping here decrements to RC=1
+        // Then old_bucket goes out of scope and drops again to RC=0
+        // But wait - we return old_value which was duped from old_bucket...
+        // Actually the Bucket struct contains RC types, so assignment drops old + dups new
+        (data_ptr &+ index).* = new_bucket;
+        .Ok(.Some(old_value))
+      },
+      .None => {
+        resize_check := cond(
+          (Self._needs_resize(self)) => {
+            new_capacity := (self.capacity * usize(2));
+            Self._resize(self, new_capacity)
+          },
+          true => Result(unit, HashMapError).Ok(())
+        );
+        match(
+          resize_check,
+          .Err(err) =>.Err(err),
+          .Ok(_) => {
+            h2 := h2_hash(hash);
+            index := Self._find_insert_bucket(self, hash);
+            ctrl_ptr := Self._ctrl_ptr(self);
+            data_ptr := Self._data_ptr(self);
+            (ctrl_ptr &+ index).* = h2;
+            new_bucket := Bucket(K, V)(key : key, value : value);
+            consume((data_ptr &+ index).* = new_bucket);
+            self.size = (self.size + usize(1));
+            .Ok(.None)
+          }
+        )
+      }
+    )
+  }),
   /**
-    * Check if a key exists in the map
-    */
-  contains_key : (fn(self: Self, key: K) -> bool)(
-    {
-      hash := key.hash();
-      bucket_opt := Self._find_bucket(self, key, hash);
-      match(bucket_opt,
-        .Some(_) => true,
-        .None => false
-      )
-    }
-  ),
-
+  * Get a value by key
+  * Returns Some(value) if found, None otherwise
+  */
+  get : (fn(self : Self, key : K) -> Option(V))({
+    hash := key.hash();
+    bucket_opt := Self._find_bucket(self, key, hash);
+    match(
+      bucket_opt,
+      .Some(index) => {
+        data_ptr := Self._data_ptr(self);
+        bucket := (data_ptr &+ index).*;
+        .Some(bucket.value)
+      },
+      .None =>.None
+    )
+  }),
   /**
-    * Remove a key-value pair by key
-    * Returns Some(value) if the key was found and removed, None otherwise
-    */
-  remove : (fn(self: Self, key: K) -> Option(V))(
-    {
-      hash := key.hash();
-      bucket_opt := Self._find_bucket(self, key, hash);
-      match(bucket_opt,
-        .Some(index) => {
-          data_ptr := Self._data_ptr(self);
-          ctrl_ptr := Self._ctrl_ptr(self);
-          bucket_ptr := (data_ptr &+ index);
-          
-          // Read and dup value for return
-          value := bucket_ptr.*.value;
-          
-          // Drop the bucket's key (we're removing it)
-          unsafe.drop(bucket_ptr.*.key);
-          
-          // Drop the bucket's value extra ref (we duped it above)
-          unsafe.drop(bucket_ptr.*.value);
-          
-          (ctrl_ptr &+ index).* = CTRL_DELETED;
-          self.size = (self.size - usize(1));
-          
-          .Some(value)
-        },
-        .None => .None
-      )
-    }
-  ),
-
+  * Check if a key exists in the map
+  */
+  contains_key : (fn(self : Self, key : K) -> bool)({
+    hash := key.hash();
+    bucket_opt := Self._find_bucket(self, key, hash);
+    match(
+      bucket_opt,
+      .Some(_) => true,
+      .None => false
+    )
+  }),
   /**
-    * Get the number of key-value pairs in the map
-    */
-  len : (fn(self: Self) -> usize)(
+  * Remove a key-value pair by key
+  * Returns Some(value) if the key was found and removed, None otherwise
+  */
+  remove : (fn(self : Self, key : K) -> Option(V))({
+    hash := key.hash();
+    bucket_opt := Self._find_bucket(self, key, hash);
+    match(
+      bucket_opt,
+      .Some(index) => {
+        data_ptr := Self._data_ptr(self);
+        ctrl_ptr := Self._ctrl_ptr(self);
+        bucket_ptr := (data_ptr &+ index);
+        // Read and dup value for return
+        value := bucket_ptr.*.value;
+        // Drop the bucket's key (we're removing it)
+        unsafe.drop(bucket_ptr.*.key);
+        // Drop the bucket's value extra ref (we duped it above)
+        unsafe.drop(bucket_ptr.*.value);
+        (ctrl_ptr &+ index).* = CTRL_DELETED;
+        self.size = (self.size - usize(1));
+        .Some(value)
+      },
+      .None =>.None
+    )
+  }),
+  /**
+  * Get the number of key-value pairs in the map
+  */
+  len : (fn(self : Self) -> usize)(
     self.size
   ),
-
   /**
-    * Check if the map is empty
-    */
-  is_empty : (fn(self: Self) -> bool)(
-    (self.size == usize(0))
+  * Check if the map is empty
+  */
+  is_empty : (fn(self : Self) -> bool)(
+    self.size == usize(0)
   ),
-
   /**
-    * Clear all key-value pairs
-    * Resets all control bytes to EMPTY
-    */
-  clear : (fn(self: Self) -> unit)(
-    {
-      // Drop all occupied buckets before clearing
-      cond(
-        (Type.contains_rc_type(K) || Type.contains_rc_type(V)) => {
-          ctrl_ptr := Self._ctrl_ptr(self);
-          data_ptr := Self._data_ptr(self);
-          i := usize(0);
-          while(i < self.capacity, i = (i + usize(1)), {
-            ctrl_byte := (ctrl_ptr &+ i).*;
-            cond(
-              ((ctrl_byte != CTRL_EMPTY) && (ctrl_byte != CTRL_DELETED)) => {
-                bucket_ptr := (data_ptr &+ i);
-                unsafe.drop(bucket_ptr.*);
-              },
-              true => ()
-            );
-          });
-        },
-        true => ()
-      );
-      
-      ctrl_ptr := Self._ctrl_ptr(self);
-      i := usize(0);
-      while(i < self.capacity, i = (i + usize(1)), {
-        (ctrl_ptr &+ i).* = CTRL_EMPTY;
-      });
-      self.size = usize(0);
-    }
-  )
+  * Clear all key-value pairs
+  * Resets all control bytes to EMPTY
+  */
+  clear : (fn(self : Self) -> unit)({
+    // Drop all occupied buckets before clearing
+    cond(
+      (Type.contains_rc_type(K) || Type.contains_rc_type(V)) => {
+        ctrl_ptr := Self._ctrl_ptr(self);
+        data_ptr := Self._data_ptr(self);
+        i := usize(0);
+        while(i < self.capacity, i = (i + usize(1)), {
+          ctrl_byte := (ctrl_ptr &+ i).*;
+          cond(
+            ((ctrl_byte != CTRL_EMPTY) && (ctrl_byte != CTRL_DELETED)) => {
+              bucket_ptr := (data_ptr &+ i);
+              unsafe.drop(bucket_ptr.*);
+            },
+            true => ()
+          );
+        });
+      },
+      true => ()
+    );
+    ctrl_ptr := Self._ctrl_ptr(self);
+    i := usize(0);
+    while(i < self.capacity, i = (i + usize(1)), {
+      (ctrl_ptr &+ i).* = CTRL_EMPTY;
+    });
+    self.size = usize(0);
+  })
 );
-impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), HashMap(K, V),
+impl(
+  forall(K : Type, V : Type),
+  where(K <: (Eq(K), Hash)),
+  HashMap(K, V),
   Dispose(
     /**
-      * RAII destructor - automatically called when HashMap goes out of scope
-      */
-    dispose : (fn(self: Self) -> unit)({
+    * RAII destructor - automatically called when HashMap goes out of scope
+    */
+    dispose : (fn(self : Self) -> unit)({
       // Drop all occupied buckets before freeing memory
       cond(
         (Type.contains_rc_type(K) || Type.contains_rc_type(V)) => {
-          match(self.ctrl,
+          match(
+            self.ctrl,
             .Some(ctrl_ptr) => {
-              match(self.data,
+              match(
+                self.data,
                 .Some(data_ptr) => {
                   i := usize(0);
                   while(i < self.capacity, i = (i + usize(1)), {
@@ -514,192 +462,221 @@ impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), HashMap(K, V),
         },
         true => ()
       );
-      
-      match(self.ctrl,
+      match(
+        self.ctrl,
         .Some(ptr) => free(.Some(*(void)(ptr))),
         .None => ()
       );
-      match(self.data,
+      match(
+        self.data,
         .Some(ptr) => free(.Some(*(void)(ptr))),
         .None => ()
       );
     })
-  ));
-
+  )
+);
 /**
- * Value iterator for HashMap - yields Bucket(K, V) by value
- * Scans ctrl bytes to find occupied slots.
- */
+* Value iterator for HashMap - yields Bucket(K, V) by value
+* Scans ctrl bytes to find occupied slots.
+*/
 HashMapIter :: (fn(comptime(K) : Type, comptime(V) : Type) -> comptime(Type))(
   struct(
-    _map   : HashMap(K, V),
+    _map : HashMap(K, V),
     _index : usize
   )
 );
-
-impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), HashMapIter(K, V), Iterator(
-  Item : Bucket(K, V),
-  next : (fn(self : *(Self)) -> Option(Bucket(K, V)))(
-    cond(
-      (self._map.capacity == usize(0)) => .None,
-      true => {
-        ctrl_ptr := self._map.ctrl.unwrap();
-        data_ptr := self._map.data.unwrap();
-        result := Option(Bucket(K, V)).None;
-        while ((self._index < self._map.capacity) && result.is_none()), (self._index = (self._index + usize(1))), {
-          ctrl_byte := (ctrl_ptr &+ self._index).*;
-          cond(
-            ((ctrl_byte != CTRL_EMPTY) && (ctrl_byte != CTRL_DELETED)) => {
-              result = .Some((data_ptr &+ self._index).*);
-            },
-            true => ()
-          );
-        };
-        result
-      }
+impl(
+  forall(K : Type, V : Type),
+  where(K <: (Eq(K), Hash)),
+  HashMapIter(K, V),
+  Iterator(
+    Item : Bucket(K, V),
+    next : (fn(self : *(Self)) -> Option(Bucket(K, V)))(
+      cond(
+        (self._map.capacity == usize(0)) =>.None,
+        true => {
+          ctrl_ptr := self._map.ctrl.unwrap();
+          data_ptr := self._map.data.unwrap();
+          result := Option(Bucket(K, V)).None;
+          while((self._index < self._map.capacity) && result.is_none(), self._index = (self._index + usize(1)), {
+            ctrl_byte := (ctrl_ptr &+ self._index).*;
+            cond(
+              ((ctrl_byte != CTRL_EMPTY) && (ctrl_byte != CTRL_DELETED)) => {
+                result =.Some((data_ptr &+ self._index).*);
+              },
+              true => ()
+            );
+          });
+          result
+        }
+      )
     )
   )
-));
-
-impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), HashMap(K, V),
+);
+impl(
+  forall(K : Type, V : Type),
+  where(K <: (Eq(K), Hash)),
+  HashMap(K, V),
   into_iter : (fn(self : Self) -> HashMapIter(K, V))(
-    HashMapIter(K, V)(_map: self, _index: usize(0))
+    HashMapIter(K, V)(_map : self, _index : usize(0))
   )
 );
-
 /**
- * Pointer iterator for HashMap - yields pointers to Bucket(K, V)
- * Pointers are valid as long as the map is not modified during iteration.
- */
+* Pointer iterator for HashMap - yields pointers to Bucket(K, V)
+* Pointers are valid as long as the map is not modified during iteration.
+*/
 HashMapIterPtr :: (fn(comptime(K) : Type, comptime(V) : Type) -> comptime(Type))(
   struct(
-    _map   : HashMap(K, V),
+    _map : HashMap(K, V),
     _index : usize
   )
 );
-
-impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), HashMapIterPtr(K, V), Iterator(
-  Item : *(Bucket(K, V)),
-  next : (fn(self : *(Self)) -> Option(*(Bucket(K, V))))(
-    cond(
-      (self._map.capacity == usize(0)) => .None,
-      true => {
-        ctrl_ptr := self._map.ctrl.unwrap();
-        data_ptr := self._map.data.unwrap();
-        result := Option(*(Bucket(K, V))).None;
-        while ((self._index < self._map.capacity) && result.is_none()), (self._index = (self._index + usize(1))), {
-          ctrl_byte := (ctrl_ptr &+ self._index).*;
-          cond(
-            ((ctrl_byte != CTRL_EMPTY) && (ctrl_byte != CTRL_DELETED)) => {
-              result = .Some((data_ptr &+ self._index));
-            },
-            true => ()
-          );
-        };
-        result
-      }
+impl(
+  forall(K : Type, V : Type),
+  where(K <: (Eq(K), Hash)),
+  HashMapIterPtr(K, V),
+  Iterator(
+    Item : *(Bucket(K, V)),
+    next : (fn(self : *(Self)) -> Option(*(Bucket(K, V))))(
+      cond(
+        (self._map.capacity == usize(0)) =>.None,
+        true => {
+          ctrl_ptr := self._map.ctrl.unwrap();
+          data_ptr := self._map.data.unwrap();
+          result := Option(*(Bucket(K, V))).None;
+          while((self._index < self._map.capacity) && result.is_none(), self._index = (self._index + usize(1)), {
+            ctrl_byte := (ctrl_ptr &+ self._index).*;
+            cond(
+              ((ctrl_byte != CTRL_EMPTY) && (ctrl_byte != CTRL_DELETED)) => {
+                result =.Some(data_ptr &+ self._index);
+              },
+              true => ()
+            );
+          });
+          result
+        }
+      )
     )
   )
-));
-
-impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), HashMap(K, V),
+);
+impl(
+  forall(K : Type, V : Type),
+  where(K <: (Eq(K), Hash)),
+  HashMap(K, V),
   iter : (fn(self : *(Self)) -> HashMapIterPtr(K, V))(
-    HashMapIterPtr(K, V)(_map: self.*, _index: usize(0))
+    HashMapIterPtr(K, V)(_map : self.*, _index : usize(0))
   )
 );
-
 /**
- * Keys iterator - wraps HashMapIter and yields only the keys
- */
+* Keys iterator - wraps HashMapIter and yields only the keys
+*/
 HashMapKeys :: (fn(comptime(K) : Type, comptime(V) : Type) -> comptime(Type))(
   struct(
     _inner : HashMapIter(K, V)
   )
 );
-
-impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), HashMapKeys(K, V), Iterator(
-  Item : K,
-  next : (fn(self : *(Self)) -> Option(K))(
-    match(self._inner.next(),
-      .None => .None,
-      .Some(bucket) => .Some(bucket.key)
+impl(
+  forall(K : Type, V : Type),
+  where(K <: (Eq(K), Hash)),
+  HashMapKeys(K, V),
+  Iterator(
+    Item : K,
+    next : (fn(self : *(Self)) -> Option(K))(
+      match(
+        self._inner.next(),
+        .None =>.None,
+        .Some(bucket) =>.Some(bucket.key)
+      )
     )
   )
-));
-
-impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), HashMap(K, V),
+);
+impl(
+  forall(K : Type, V : Type),
+  where(K <: (Eq(K), Hash)),
+  HashMap(K, V),
   keys : (fn(self : Self) -> HashMapKeys(K, V))(
-    HashMapKeys(K, V)(_inner: HashMapIter(K, V)(_map: self, _index: usize(0)))
+    HashMapKeys(K, V)(_inner : HashMapIter(K, V)(_map : self, _index : usize(0)))
   )
 );
-
 /**
- * Values iterator - wraps HashMapIter and yields only the values
- */
+* Values iterator - wraps HashMapIter and yields only the values
+*/
 HashMapValues :: (fn(comptime(K) : Type, comptime(V) : Type) -> comptime(Type))(
   struct(
     _inner : HashMapIter(K, V)
   )
 );
-
-impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), HashMapValues(K, V), Iterator(
-  Item : V,
-  next : (fn(self : *(Self)) -> Option(V))(
-    match(self._inner.next(),
-      .None => .None,
-      .Some(bucket) => .Some(bucket.value)
+impl(
+  forall(K : Type, V : Type),
+  where(K <: (Eq(K), Hash)),
+  HashMapValues(K, V),
+  Iterator(
+    Item : V,
+    next : (fn(self : *(Self)) -> Option(V))(
+      match(
+        self._inner.next(),
+        .None =>.None,
+        .Some(bucket) =>.Some(bucket.value)
+      )
     )
   )
-));
-
-impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), HashMap(K, V),
+);
+impl(
+  forall(K : Type, V : Type),
+  where(K <: (Eq(K), Hash)),
+  HashMap(K, V),
   values : (fn(self : Self) -> HashMapValues(K, V))(
-    HashMapValues(K, V)(_inner: HashMapIter(K, V)(_map: self, _index: usize(0)))
+    HashMapValues(K, V)(_inner : HashMapIter(K, V)(_map : self, _index : usize(0)))
+  )
+);
+impl(
+  forall(K : Type, V : Type),
+  HashMap(K, V),
+  Index(K)(
+    Output : V,
+    index : (fn(self : *(Self), idx : K, where(K <: (Eq(K), Hash))) -> *(Self.Output))({
+      hash := idx.hash();
+      bucket_opt := Self._find_bucket(self.*, idx, hash);
+      match(
+        bucket_opt,
+        .Some(i) => {
+          data_ptr := Self._data_ptr(self.*);
+          &((data_ptr &+ i).*.value)
+        },
+        .None => panic("HashMap: key not found")
+      )
+    })
   )
 );
-
-impl(forall(K : Type, V : Type), HashMap(K, V), Index(K)(
-  Output : V,
-  index : (fn(self: *(Self), idx: K, where(K <: (Eq(K), Hash))) -> *(Self.Output))({
-    hash := idx.hash();
-    bucket_opt := Self._find_bucket(self.*, idx, hash);
-    match(bucket_opt,
-      .Some(i) => {
-        data_ptr := Self._data_ptr(self.*);
-        &((data_ptr &+ i).*.value)
-      },
-      .None => panic("HashMap: key not found")
-    )
-  })
-));
-
 /// Clone implementation for HashMap — deep-clones all key-value entries.
-impl(forall(K : Type, V : Type),
-     where(K <: (Clone, Eq(K), Hash), V <: Clone),
-     HashMap(K, V),
-     Clone(
-       clone : (fn(self: *(Self)) -> Self)(
-         {
-           result := Self.new();
-           it := self.iter();
-           running := true;
-           while running, {
-             nxt := it.next();
-             match(nxt,
-               .None => { running = false; },
-               .Some(bucket_ptr) => {
-                 k := (&(bucket_ptr.*.key)).clone();
-                 v := (&(bucket_ptr.*.value)).clone();
-                 result.set(k, v);
-               }
-             );
-           };
-           result
-         }
-       )
-     ));
-
-export
+impl(
+  forall(K : Type, V : Type),
+  where(K <: (Clone, Eq(K), Hash), V <: Clone),
+  HashMap(K, V),
+  Clone(
+    clone : (fn(self : *(Self)) -> Self)({
+      result := Self.new();
+      it := self.iter();
+      running := true;
+      while(running, {
+        nxt := it.next();
+        match(
+          nxt,
+          .None => {
+            running = false;
+          },
+          .Some(bucket_ptr) => {
+            k := (&(bucket_ptr.*.key)).clone();
+            v := (&(bucket_ptr.*.value)).clone();
+            result.set(k, v);
+          }
+        );
+      });
+      result
+    })
+  )
+);
+export(
   HashMap,
   HashMapError,
   Bucket,
@@ -707,12 +684,10 @@ export
   HashMapIterPtr,
   HashMapKeys,
   HashMapValues
-;
-
+);
 // =============================================================================
 // hash_map! literal macro
 // =============================================================================
-
 /// Internal helper: build a list of `tmp.set(k, v).unwrap()` statements from
 /// a sequence of `k => v` arrow expressions.
 __hash_map_build_sets :: (fn(comptime(tmp) : Expr, comptime(entries) : ExprList) -> comptime(ExprList))(
@@ -723,17 +698,16 @@ __hash_map_build_sets :: (fn(comptime(tmp) : Expr, comptime(entries) : ExprList)
       rest :: entries.cdr();
       __ :: comptime_assert(first.is_fn_call(), "hash_map entries must use 'k => v'");
       callee :: first.get_callee();
-      __1 :: comptime_assert((callee.is_atom() && (callee == quote(=>))), "hash_map entries must use 'k => v'");
+      __1 :: comptime_assert(callee.is_atom() && (callee == quote(=>)), "hash_map entries must use 'k => v'");
       pair :: first.get_args();
-      __2 :: comptime_assert((pair.len() == usize(2)), "hash_map entries must use 'k => v'");
+      __2 :: comptime_assert(pair.len() == usize(2), "hash_map entries must use 'k => v'");
       key :: pair.car();
       val :: pair.cdr().car();
-      stmt :: quote((unquote(tmp).set(unquote(key), unquote(val)).unwrap()));
+      stmt :: quote(unquote(tmp).set(unquote(key), unquote(val)).unwrap());
       stmt.cons(recur(tmp, rest))
     }
   )
 );
-
 /// `hash_map` macro — construct a `HashMap(K, V)` literal.
 ///
 /// `K` and `V` are inferred from the first entry's key and value via `typeof`,
@@ -743,15 +717,17 @@ __hash_map_build_sets :: (fn(comptime(tmp) : Expr, comptime(entries) : ExprList)
 /// ```rust
 /// m := hash_map(`a` => i32(1), `b` => i32(2));
 /// ```
-hash_map :: (fn(...(quote(entries))) -> unquote(Expr)) {
-  __ :: comptime_assert((entries.len() > usize(0)),
-    "hash_map requires at least one 'k => v' entry to infer K and V");
+hash_map :: (fn(...(quote(entries))) -> unquote(Expr))({
+  __ :: comptime_assert(
+    entries.len() > usize(0),
+    "hash_map requires at least one 'k => v' entry to infer K and V"
+  );
   first :: entries.car();
   __1 :: comptime_assert(first.is_fn_call(), "hash_map entries must use 'k => v'");
   callee :: first.get_callee();
-  __2 :: comptime_assert((callee.is_atom() && (callee == quote(=>))), "hash_map entries must use 'k => v'");
+  __2 :: comptime_assert(callee.is_atom() && (callee == quote(=>)), "hash_map entries must use 'k => v'");
   pair :: first.get_args();
-  __3 :: comptime_assert((pair.len() == usize(2)), "hash_map entries must use 'k => v'");
+  __3 :: comptime_assert(pair.len() == usize(2), "hash_map entries must use 'k => v'");
   first_key :: pair.car();
   first_val :: pair.cdr().car();
   rest :: entries.cdr();
@@ -759,13 +735,13 @@ hash_map :: (fn(...(quote(entries))) -> unquote(Expr)) {
   k_tmp :: gensym("hash_map_k0");
   v_tmp :: gensym("hash_map_v0");
   rest_sets :: __hash_map_build_sets(tmp, rest);
-  quote {
+  quote({
     unquote(k_tmp) := unquote(first_key);
     unquote(v_tmp) := unquote(first_val);
     unquote(tmp) := HashMap(typeof(unquote(k_tmp)), typeof(unquote(v_tmp))).new();
     unquote(tmp).set(unquote(k_tmp), unquote(v_tmp)).unwrap();
     unquote_splicing(rest_sets);
     unquote(tmp)
-  }
-};
-export hash_map;
+  })
+});
+export(hash_map);