refactor(linked_hash_map): change type of prev and tail to Int

Author: FlyCloudC

builtin/linked_hash_map.mbt

@@ -15,7 +15,7 @@
 ///|
 // Types
 priv struct Entry[K, V] {
-  mut prev : Int?
+  mut prev : Int
   mut next : Entry[K, V]?
   mut psl : Int
   hash : Int
@@ -47,7 +47,7 @@ struct Map[K, V] {
   mut capacity_mask : Int // capacity_mask = capacity - 1, used to find idx
   mut growAt : Int // threshold that triggers grow
   mut head : Entry[K, V]? // head of linked list
-  mut tail : Int? // tail of linked list
+  mut tail : Int // tail of linked list
 }
 
 // Implementations
@@ -90,7 +90,7 @@ pub fn Map::new[K, V](capacity~ : Int = 8) -> Map[K, V] {
     growAt: calc_grow_threshold(capacity),
     entries: FixedArray::make(capacity, None),
     head: None,
-    tail: None,
+    tail: -1,
   }
 }
 
@@ -165,8 +165,8 @@ fn Map::set_entry[K, V](
 ) -> Unit {
   self.entries[new_idx] = Some(entry)
   match entry.next {
-    None => self.tail = Some(new_idx)
-    Some(next) => next.prev = Some(new_idx)
+    None => self.tail = new_idx
+    Some(next) => next.prev = new_idx
   }
 }
 
@@ -347,24 +347,19 @@ fn Map::add_entry_to_tail[K, V](
   entry : Entry[K, V]
 ) -> Unit {
   match self.tail {
-    None => {
-      self.head = Some(entry)
-      self.tail = Some(idx)
-    }
-    Some(tail) => {
-      self.entries[tail].unwrap().next = Some(entry)
-      self.tail = Some(idx)
-    }
+    -1 => self.head = Some(entry)
+    tail => self.entries[tail].unwrap().next = Some(entry)
   }
+  self.tail = idx
   self.entries[idx] = Some(entry)
   self.size += 1
 }
 
 ///|
 fn Map::remove_entry[K, V](self : Map[K, V], entry : Entry[K, V]) -> Unit {
   match entry.prev {
-    None => self.head = entry.next
-    Some(idx) => self.entries[idx].unwrap().next = entry.next
+    -1 => self.head = entry.next
+    idx => self.entries[idx].unwrap().next = entry.next
   }
   match entry.next {
     None => self.tail = entry.prev
@@ -395,7 +390,7 @@ fn Map::grow[K : Hash + Eq, V](self : Map[K, V]) -> Unit {
   self.growAt = calc_grow_threshold(self.capacity)
   self.size = 0
   self.head = None
-  self.tail = None
+  self.tail = -1
   loop old_head {
     Some({ next, key, value, .. }) => {
       self.set(key, value)
@@ -491,7 +486,7 @@ pub fn Map::clear[K, V](self : Map[K, V]) -> Unit {
   self.entries.fill(None)
   self.size = 0
   self.head = None
-  self.tail = None
+  self.tail = -1
 }
 
 ///|

builtin/linked_hash_map_wbtest.mbt

@@ -191,7 +191,7 @@ test "clear" {
   assert_eq!(m.size, 0)
   assert_eq!(m.capacity, 8)
   assert_eq!(m.head, None)
-  assert_eq!(m.tail, None)
+  assert_eq!(m.tail, -1)
   for i in 0..<m.capacity {
     assert_eq!(m.entries[i], None)
   }
@@ -406,7 +406,7 @@ test "clear" {
   assert_eq!(m.size, 0)
   assert_eq!(m.capacity, 8)
   assert_eq!(m.head, None)
-  assert_eq!(m.tail, None)
+  assert_eq!(m.tail, -1)
   for i in 0..<m.capacity {
     assert_eq!(m.entries[i], None)
   }
@@ -454,7 +454,7 @@ test "new" {
   assert_eq!(m.size, 0)
   assert_eq!(m.capacity, 8)
   assert_eq!(m.head, None)
-  assert_eq!(m.tail, None)
+  assert_eq!(m.tail, -1)
   for i in 0..<m.capacity {
     assert_eq!(m.entries[i], None)
   }
@@ -547,7 +547,7 @@ test "clear" {
   assert_eq!(m.size, 0)
   assert_eq!(m.capacity, 8)
   assert_eq!(m.head, None)
-  assert_eq!(m.tail, None)
+  assert_eq!(m.tail, -1)
   for i in 0..<m.capacity {
     assert_eq!(m.entries[i], None)
   }
@@ -640,7 +640,7 @@ test "clear" {
   assert_eq!(m.size, 0)
   assert_eq!(m.capacity, 8)
   assert_eq!(m.head, None)
-  assert_eq!(m.tail, None)
+  assert_eq!(m.tail, -1)
   for i in 0..<m.capacity {
     assert_eq!(m.entries[i], None)
   }
@@ -793,7 +793,7 @@ test "remove_entry_head" {
   // This should ensure the head is updated correctly
   assert_false!(map.head is None)
   guard map.head is Some(head)
-  assert_eq!(head.prev, None)
+  assert_eq!(head.prev, -1)
   assert_true!(head.next is None)
   assert_eq!(head.psl, 0)
   assert_eq!(head.hash, (2).hash())
@@ -808,11 +808,10 @@ test "remove_entry_tail" {
   map.set(2, 2)
   map.remove(2)
   // This should ensure the tail is updated correctly
-  assert_false!(map.tail is None)
-  guard map.tail is Some(tail_idx)
-  assert_false!(map.entries[tail_idx] is None)
-  guard map.entries[tail_idx] is Some(tail)
-  assert_eq!(tail.prev, None)
+  assert_false!(map.tail is -1)
+  assert_false!(map.entries[map.tail] is None)
+  guard map.entries[map.tail] is Some(tail)
+  assert_eq!(tail.prev, -1)
   assert_true!(tail.next is None)
   assert_eq!(tail.psl, 0)
   assert_eq!(tail.hash, (1).hash())