align @immut/list.zip with @array.zip

Author: myfreess

immut/list/list.mbt

@@ -460,25 +460,20 @@ pub fn fold_righti[A, B](self : T[A], f : (Int, A, B) -> B, init~ : B) -> B {
 
 ///|
 /// Zip two lists.
-/// If the lists have different lengths, it will return None.
+/// If the lists have different lengths, it will return a list with shorter length.
 ///
 /// # Example
 ///
 /// ```
 /// let r = @list.zip(@list.of([1, 2, 3, 4, 5]), @list.of([6, 7, 8, 9, 10]))
-/// assert_eq!(r, Some(@list.from_array([(1, 6), (2, 7), (3, 8), (4, 9), (5, 10)])))
-/// ```
-pub fn zip[A, B](self : T[A], other : T[B]) -> T[(A, B)]? {
-  let mut acc = Nil
-  let res = loop self, other {
-    Nil, Nil => break Some(acc)
-    Cons(x, xs), Cons(y, ys) => {
-      acc = Cons((x, y), acc)
-      continue xs, ys
-    }
-    _, _ => break None
+/// assert_eq!(r, @list.from_array([(1, 6), (2, 7), (3, 8), (4, 9), (5, 10)]))
+/// ```
+pub fn zip[A, B](self : T[A], other : T[B]) -> T[(A, B)] {
+  match (self, other) {
+    (Nil, _) => Nil
+    (_, Nil) => Nil
+    (Cons(x, xs), Cons(y, ys)) => Cons((x, y), zip(xs, ys))
   }
-  res.map(T::rev)
 }
 
 ///|

immut/list/list.mbti

@@ -159,7 +159,7 @@ fn unsafe_nth[A](T[A], Int) -> A
 
 fn unzip[A, B](T[(A, B)]) -> (T[A], T[B])
 
-fn zip[A, B](T[A], T[B]) -> T[(A, B)]?
+fn zip[A, B](T[A], T[B]) -> T[(A, B)]
 
 // Types and methods
 pub(all) enum T[A] {
@@ -249,7 +249,7 @@ impl T {
   unsafe_minimum[A : Compare](Self[A]) -> A
   unsafe_nth[A](Self[A], Int) -> A
   unzip[A, B](Self[(A, B)]) -> (Self[A], Self[B])
-  zip[A, B](Self[A], Self[B]) -> Self[(A, B)]?
+  zip[A, B](Self[A], Self[B]) -> Self[(A, B)]
 }
 impl[A] Add for T[A]
 impl[X] Default for T[X]

immut/list/list_test.mbt

@@ -215,7 +215,7 @@ test "zip" {
   let rs = @list.of([6, 7, 8, 9, 10])
   inspect!(
     ls.zip(rs),
-    content="Some(@list.of([(1, 6), (2, 7), (3, 8), (4, 9), (5, 10)]))",
+    content="@list.of([(1, 6), (2, 7), (3, 8), (4, 9), (5, 10)])",
   )
 }
 
@@ -607,13 +607,16 @@ test "List::zip with lists of equal length" {
   let list1 = @list.of([1, 2, 3])
   let list2 = @list.of(["a", "b", "c"])
   let zipped = list1.zip(list2)
-  let expected = Some(@list.of([(1, "a"), (2, "b"), (3, "c")]))
+  let expected = @list.of([(1, "a"), (2, "b"), (3, "c")])
   assert_eq!(zipped, expected)
 }
 
 ///|
 test "@list.zip with empty list" {
-  inspect!(@list.of([1]).zip((@list.Nil : @list.T[Int])), content="None")
+  inspect!(
+    @list.of([1]).zip((@list.Nil : @list.T[Int])),
+    content="@list.of([])",
+  )
 }
 
 ///|

immut/list/moon.pkg.json

@@ -3,8 +3,7 @@
     "moonbitlang/core/builtin",
     "moonbitlang/core/array",
     "moonbitlang/core/quickcheck",
-    "moonbitlang/core/json",
-    "moonbitlang/core/option"
+    "moonbitlang/core/json"
   ],
   "targets": {
     "panic_test.mbt": ["not", "native"]