Add zip function to standard library (#127)

Author: mikosik

CHANGELOG.md

@@ -8,6 +8,7 @@ Version ?????? (??????????)
  * added tuple to smooth language
  * extended smooth syntax: Allow omitting parentheses in function type when it has one parameter
  * added standard library function `fold`
+ * added standard library function `zip`
 
 Version 0.23.0 (2025.03.20)
 ---------------------------

doc/api.md

@@ -28,6 +28,7 @@
 | [toBlob](api/toBlob.md)               | Converts String to Blob using UTF-8 encoding.                       |
 | [toString](api/toString.md)           | Converts Blob to String using UTF-8 encoding.                       |
 | [unjar](api/unjar.md)                 | Unjars (uncompresses) files from given jar file.                    |
+| [zip](api/zip.md)                     | Combines two arrays into a single array of tuples.                  |
 
 | value | definition                 |
 |-------|----------------------------|

doc/api/zip.md

@@ -0,0 +1,24 @@
+## [{A,B}] zip<A,B>([A] first, [B] second)
+
+Combines two arrays into a single array of tuples, where each tuple contains elements from both arrays at the same position.
+
+| Name   | Type | Default | Description                                |
+|--------|------|---------|--------------------------------------------|
+| first  | [A]  |         | First array to be zipped.                  |
+| second | [B]  |         | Second array to be zipped.                 |
+
+Returns __[{A,B}]__ array of tuples where each tuple contains elements from both arrays at the same position. The length of the result array is equal to the minimum length of the input arrays.
+
+### examples
+
+Zipping two arrays of different types:
+```
+[{String,Int}] zipped = zip(["a", "b", "c"], [1, 2, 3]);
+// Result: [{"a", 1}, {"b", 2}, {"c", 3}]
+```
+
+Zipping arrays of different lengths (the shorter array determines the result length):
+```
+[{String,Int}] zipped = zip(["a", "b"], [1, 2, 3, 4]);
+// Result: [{"a", 1}, {"b", 2}]
+```

src/standard-library/src/main/java/org/smoothbuild/stdlib/array/ZipFunc.java

@@ -0,0 +1,48 @@
+package org.smoothbuild.stdlib.array;
+
+import static org.smoothbuild.common.collect.List.list;
+
+import org.smoothbuild.virtualmachine.bytecode.BytecodeException;
+import org.smoothbuild.virtualmachine.bytecode.expr.base.BArray;
+import org.smoothbuild.virtualmachine.bytecode.expr.base.BTuple;
+import org.smoothbuild.virtualmachine.bytecode.expr.base.BValue;
+import org.smoothbuild.virtualmachine.evaluate.plugin.NativeApi;
+
+public class ZipFunc {
+  public static BValue func(NativeApi nativeApi, BTuple args) throws BytecodeException {
+    BArray firstArray = (BArray) args.get(0);
+    BArray secondArray = (BArray) args.get(1);
+
+    var factory = nativeApi.factory();
+    var firstElementType = firstArray.evaluationType().element();
+    var secondElementType = secondArray.evaluationType().element();
+
+    // Create a tuple type for the result elements
+    var tupleType = factory.tupleType(firstElementType, secondElementType);
+
+    // Create an array builder for the result
+    var arrayType = factory.arrayType(tupleType);
+    var resultBuilder = factory.arrayBuilder(arrayType);
+
+    // Get the elements from both arrays
+    var firstElements = firstArray.elements(BValue.class);
+    var secondElements = secondArray.elements(BValue.class);
+
+    // Determine the minimum size of the two arrays
+    long minSize = Math.min(firstArray.size(), secondArray.size());
+
+    // Zip the elements together
+    for (int i = 0; i < minSize; i++) {
+      BValue firstElement = firstElements.get(i);
+      BValue secondElement = secondElements.get(i);
+
+      // Create a tuple for each pair of elements
+      BTuple tuple = factory.tuple(list(firstElement, secondElement));
+
+      // Add the tuple to the result array
+      resultBuilder.add(tuple);
+    }
+
+    return resultBuilder.build();
+  }
+}

src/standard-library/src/main/smooth/std_lib.smooth

@@ -93,6 +93,9 @@ A if<A>(Bool condition, A then, A else);
 @Bytecode("org.smoothbuild.stdlib.core.MapFunc")
 [R] map<S,R>([S] array, (S)->R mapper);
 
+@Native("org.smoothbuild.stdlib.array.ZipFunc")
+[{A,B}] zip<A,B>([A] first, [B] second);
+
 @Bytecode("org.smoothbuild.stdlib.core.FoldFunc")
 A fold<A,E>([E] array, A initial, (A,E)->A folder);
 

src/standard-library/src/test/java/org/smoothbuild/stdlib/array/ZipTest.java

@@ -0,0 +1,54 @@
+package org.smoothbuild.stdlib.array;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import org.junit.jupiter.api.Test;
+import org.smoothbuild.stdlib.StandardLibraryTestContext;
+
+public class ZipTest extends StandardLibraryTestContext {
+  @Test
+  void zip_empty_arrays() throws Exception {
+    var userModule = """
+        [{Int,String}] result = zip([], []);
+        """;
+    createUserModule(userModule);
+    evaluate("result");
+    assertThat(artifact()).isEqualTo(bArray(bTupleType(bIntType(), bStringType())));
+  }
+
+  @Test
+  void zip_arrays_of_same_length() throws Exception {
+    var userModule = """
+        result = zip([1, 2, 3], ["a", "b", "c"]);
+        """;
+    createUserModule(userModule);
+    evaluate("result");
+    assertThat(artifact())
+        .isEqualTo(bArray(
+            bTuple(bInt(1), bString("a")),
+            bTuple(bInt(2), bString("b")),
+            bTuple(bInt(3), bString("c"))));
+  }
+
+  @Test
+  void zip_first_array_shorter() throws Exception {
+    var userModule = """
+        result = zip([1, 2], ["a", "b", "c"]);
+        """;
+    createUserModule(userModule);
+    evaluate("result");
+    assertThat(artifact())
+        .isEqualTo(bArray(bTuple(bInt(1), bString("a")), bTuple(bInt(2), bString("b"))));
+  }
+
+  @Test
+  void zip_second_array_shorter() throws Exception {
+    var userModule = """
+        result = zip([1, 2, 3], ["a", "b"]);
+        """;
+    createUserModule(userModule);
+    evaluate("result");
+    assertThat(artifact())
+        .isEqualTo(bArray(bTuple(bInt(1), bString("a")), bTuple(bInt(2), bString("b"))));
+  }
+}