fix(sorted_map): change the return type of keys and values to Iter

Author: FlyCloudC

sorted_map/README.mbt.md

@@ -155,8 +155,8 @@ Get all keys or values from the map.
 ```moonbit
 test {
   let map = @sorted_map.from_array([(3, "three"), (1, "one"), (2, "two")])
-  assert_eq!(map.keys(), [1, 2, 3])
-  assert_eq!(map.values(), ["one", "two", "three"])
+  assert_eq!(map.keys().collect(), [1, 2, 3])
+  assert_eq!(map.values().collect(), ["one", "two", "three"])
 }
 ```
 
@@ -301,4 +301,4 @@ Key properties of the AVL tree implementation:
 Choose SortedMap when you need:
 - Key-value pairs sorted by key
 - Efficient range queries
-- Ordered traversal guarantees
+- Ordered traversal guarantees

sorted_map/map.mbt

@@ -147,18 +147,42 @@ pub fn eachi[K, V](self : T[K, V], f : (Int, K, V) -> Unit) -> Unit {
 
 ///|
 /// Returns all keys in the map.
-pub fn keys[K, V](self : T[K, V]) -> Array[K] {
-  let keys = Array::new(capacity=self.size)
-  self.each(fn(k, _v) { keys.push(k) })
-  keys
+pub fn keys[K, V](self : T[K, V]) -> Iter[K] {
+  Iter::new(fn(yield_) {
+    fn go(node : Node[K, V]?) {
+      loop node {
+        None => IterContinue
+        Some(node) =>
+          if go(node.left) is IterContinue && yield_(node.key) is IterContinue {
+            continue node.right
+          } else {
+            IterEnd
+          }
+      }
+    }
+
+    go(self.root)
+  })
 }
 
 ///|
 /// Returns all values in the map.
-pub fn values[K, V](self : T[K, V]) -> Array[V] {
-  let values = Array::new(capacity=self.size)
-  self.each(fn(_k, v) { values.push(v) })
-  values
+pub fn values[K, V](self : T[K, V]) -> Iter[V] {
+  Iter::new(fn(yield_) {
+    fn go(node : Node[K, V]?) {
+      loop node {
+        None => IterContinue
+        Some(node) =>
+          if go(node.left) is IterContinue && yield_(node.value) is IterContinue {
+            continue node.right
+          } else {
+            IterEnd
+          }
+      }
+    }
+
+    go(self.root)
+  })
 }
 
 ///|

sorted_map/sorted_map.mbti

@@ -27,7 +27,7 @@ fn iter[K, V](T[K, V]) -> Iter[(K, V)]
 
 fn iter2[K, V](T[K, V]) -> Iter2[K, V]
 
-fn keys[K, V](T[K, V]) -> Array[K]
+fn keys[K, V](T[K, V]) -> Iter[K]
 
 fn new[K, V]() -> T[K, V]
 
@@ -47,7 +47,7 @@ fn size[K, V](T[K, V]) -> Int
 
 fn to_array[K, V](T[K, V]) -> Array[(K, V)]
 
-fn values[K, V](T[K, V]) -> Array[V]
+fn values[K, V](T[K, V]) -> Iter[V]
 
 // Types and methods
 type T[K, V]
@@ -61,15 +61,15 @@ impl T {
   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]
-  keys[K, V](Self[K, V]) -> Array[K]
+  keys[K, V](Self[K, V]) -> Iter[K]
   #deprecated
   op_get[K : Compare, V](Self[K, V], K) -> V?
   op_set[K : Compare, V](Self[K, V], K, V) -> Unit
   range[K : Compare, V](Self[K, V], K, K) -> Iter2[K, V]
   remove[K : Compare, V](Self[K, V], K) -> Unit
   size[K, V](Self[K, V]) -> Int
   to_array[K, V](Self[K, V]) -> Array[(K, V)]
-  values[K, V](Self[K, V]) -> Array[V]
+  values[K, V](Self[K, V]) -> Iter[V]
 }
 impl[K, V] Default for T[K, V]
 impl[K : Eq, V : Eq] Eq for T[K, V]