Merge branch 'main' into buffer-test

hashmap/hashmap.mbti

@@ -18,6 +18,7 @@ impl T {
   get_or_default[K : Hash + Eq, V](Self[K, V], K, V) -> V
   is_empty[K, V](Self[K, V]) -> Bool
   iter[K, V](Self[K, V]) -> Iter[(K, V)]
+  iter2[K, V](Self[K, V]) -> Iter2[K, V]
   new[K, V](capacity~ : Int = ..) -> Self[K, V]
   of[K : Eq + Hash, V](FixedArray[(K, V)]) -> Self[K, V]
   op_get[K : Hash + Eq, V](Self[K, V], K) -> V?

hashmap/hashmap_test.mbt

@@ -142,6 +142,15 @@ test "iter" {
   inspect!(buf, content="[2-two][1-one]")
 }
 
+test "iter2" {
+  let buf = StringBuilder::new(size_hint=20)
+  let map = @hashmap.of([(1, "one"), (2, "two"), (3, "three")])
+  for k, v in map {
+    buf.write_string("[\{k}-\{v}]")
+  }
+  inspect!(buf, content="[2-two][1-one][3-three]")
+}
+
 test "to_array" {
   let map = @hashmap.of([(1, "one"), (2, "two"), (3, "three")])
   inspect!(

hashmap/utils.mbt

@@ -38,9 +38,8 @@ pub fn clear[K, V](self : T[K, V]) -> Unit {
 pub fn iter[K, V](self : T[K, V]) -> Iter[(K, V)] {
   Iter::new(
     fn(yield_) {
-      let len = self.entries.length()
-      for i = 0; i < len; i = i + 1 {
-        match self.entries[i] {
+      for entry in self.entries {
+        match entry {
           Some({ key, value, .. }) =>
             if yield_((key, value)) == IterEnd {
               break IterEnd
@@ -54,6 +53,25 @@ pub fn iter[K, V](self : T[K, V]) -> Iter[(K, V)] {
   )
 }
 
+///|
+pub fn T::iter2[K, V](self : T[K, V]) -> Iter2[K, V] {
+  Iter2::new(
+    fn(yield_) {
+      for entry in self.entries {
+        match entry {
+          Some({ key, value, .. }) =>
+            if yield_(key, value) == IterEnd {
+              break IterEnd
+            }
+          None => continue
+        }
+      } else {
+        IterContinue
+      }
+    },
+  )
+}
+
 ///|
 pub fn T::from_iter[K : Hash + Eq, V](iter : Iter[(K, V)]) -> T[K, V] {
   let m = T::new()

hashset/hashset.mbt

@@ -220,8 +220,8 @@ pub fn symmetric_difference[K : Hash + Eq](self : T[K], other : T[K]) -> T[K] {
 pub fn iter[K](self : T[K]) -> Iter[K] {
   Iter::new(
     fn(yield_) {
-      for i = 0, len = self.entries.length(); i < len; i = i + 1 {
-        match self.entries[i] {
+      for entry in self.entries {
+        match entry {
           Some({ key, .. }) => if yield_(key) == IterEnd { break IterEnd }
           None => continue
         }