@grain/stdlib 0.5.0 → 0.5.3

package/list.gr

@@ -548,6 +548,79 @@ export let unique = list => {
   iter(list, [])
 }
 
+/**
+ * Produces a new list filled with tuples of elements from both given lists.
+ * The first tuple will contain the first item of each list, the second tuple
+ * will contain the second item of each list, and so on.
+ * 
+ * Calling this function with lists of different sizes will cause the returned
+ * list to have the length of the smaller list.
+ *
+ * @param list1: The list to provide values for the first tuple element
+ * @param list2: The list to provide values for the second tuple element
+ * @returns The new list containing indexed pairs of `(a, b)`
+ *
+ * @example List.zip([1, 2, 3], [4, 5, 6]) // [(1, 4), (2, 5), (3, 6)]
+ * @example List.zip([1, 2, 3], [4, 5]) // [(1, 4), (2, 5)]
+ * 
+ * @since v0.5.3
+ */
+export let zip = (list1, list2) => {
+  let rec zipInner = (list1, list2, acc) => {
+    match ((list1, list2)) {
+      ([first1, ...rest1], [first2, ...rest2]) =>
+        zipInner(rest1, rest2, [(first1, first2), ...acc]),
+      _ => acc,
+    }
+  }
+  reverse(zipInner(list1, list2, []))
+}
+
+/**
+ * Produces a new list filled with elements defined by applying a function on
+ * pairs from both given lists. The first element will contain the result of
+ * applying the function to the first elements of each list, the second element
+ * will contain the result of applying the function to the second elements of
+ * each list, and so on.
+ * 
+ * Calling this function with lists of different sizes will cause the returned
+ * list to have the length of the smaller list.
+ *
+ * @param fn: The function to apply to pairs of elements
+ * @param list1: The list whose elements will each be passed to the function as the first argument
+ * @param list2: The list whose elements will each be passed to the function as the second argument
+ * @returns The new list containing elements derived from applying the function to pairs of input list elements
+ *
+ * @example List.zipWith((a, b) => a + b, [1, 2, 3], [4, 5, 6]) // [5, 7, 9]
+ * @example List.zipWith((a, b) => a * b, [1, 2, 3], [4, 5]) // [4, 10]
+ * 
+ * @since v0.5.3
+ */
+export let zipWith = (fn, list1, list2) => {
+  let rec zipWithInner = (list1, list2, acc) => {
+    match ((list1, list2)) {
+      ([first1, ...rest1], [first2, ...rest2]) =>
+        zipWithInner(rest1, rest2, [fn(first1, first2), ...acc]),
+      _ => acc,
+    }
+  }
+  reverse(zipWithInner(list1, list2, []))
+}
+
+/**
+ * Produces two lists by splitting apart a list of tuples.
+ *
+ * @param list: The list of tuples to split
+ * @returns An list containing all elements from the first tuple element, and a list containing all elements from the second tuple element
+ *
+ * @since v0.5.3
+ */
+export let unzip = list => {
+  reduceRight(((first, second), (firstUnzipped, secondUnzipped)) => {
+    ([first, ...firstUnzipped], [second, ...secondUnzipped])
+  }, ([], []), list)
+}
+
 /**
  * Produces a new list with the specified number of elements removed from
  * the beginning of the input list.

package/list.md

@@ -819,6 +819,116 @@ Returns:
 |----|-----------|
 |`List<a>`|The new list with only unique values|
 
+### List.**zip**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.3</code></summary>
+No other changes yet.
+</details>
+
+```grain
+zip : (List<a>, List<b>) -> List<(a, b)>
+```
+
+Produces a new list filled with tuples of elements from both given lists.
+The first tuple will contain the first item of each list, the second tuple
+will contain the second item of each list, and so on.
+
+Calling this function with lists of different sizes will cause the returned
+list to have the length of the smaller list.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`list1`|`List<a>`|The list to provide values for the first tuple element|
+|`list2`|`List<b>`|The list to provide values for the second tuple element|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`List<(a, b)>`|The new list containing indexed pairs of `(a, b)`|
+
+Examples:
+
+```grain
+List.zip([1, 2, 3], [4, 5, 6]) // [(1, 4), (2, 5), (3, 6)]
+```
+
+```grain
+List.zip([1, 2, 3], [4, 5]) // [(1, 4), (2, 5)]
+```
+
+### List.**zipWith**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.3</code></summary>
+No other changes yet.
+</details>
+
+```grain
+zipWith : (((a, b) -> c), List<a>, List<b>) -> List<c>
+```
+
+Produces a new list filled with elements defined by applying a function on
+pairs from both given lists. The first element will contain the result of
+applying the function to the first elements of each list, the second element
+will contain the result of applying the function to the second elements of
+each list, and so on.
+
+Calling this function with lists of different sizes will cause the returned
+list to have the length of the smaller list.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`fn`|`(a, b) -> c`|The function to apply to pairs of elements|
+|`list1`|`List<a>`|The list whose elements will each be passed to the function as the first argument|
+|`list2`|`List<b>`|The list whose elements will each be passed to the function as the second argument|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`List<c>`|The new list containing elements derived from applying the function to pairs of input list elements|
+
+Examples:
+
+```grain
+List.zipWith((a, b) => a + b, [1, 2, 3], [4, 5, 6]) // [5, 7, 9]
+```
+
+```grain
+List.zipWith((a, b) => a * b, [1, 2, 3], [4, 5]) // [4, 10]
+```
+
+### List.**unzip**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.3</code></summary>
+No other changes yet.
+</details>
+
+```grain
+unzip : List<(a, b)> -> (List<a>, List<b>)
+```
+
+Produces two lists by splitting apart a list of tuples.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`list`|`List<(a, b)>`|The list of tuples to split|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`(List<a>, List<b>)`|An list containing all elements from the first tuple element, and a list containing all elements from the second tuple element|
+
 ### List.**drop**
 
 <details disabled>

package/map.gr

@@ -504,8 +504,7 @@ export let reject = (predicate, map) => {
   filter((key, value) => !predicate(key, value), map)
 }
 
-// TODO: Should return a Record type instead of a Tuple
-// Waiting on https://github.com/grain-lang/grain/issues/190
+// TODO(#190): Should return a Record type instead of a Tuple
 /**
  * Provides data representing the internal state state of the map.
  *

package/map.md

@@ -263,7 +263,7 @@ Parameters:
 <tr><th>version</th><th>changes</th></tr>
 </thead>
 <tbody>
-<tr><td><code>next</code></td><td>Ensured the iterator function return type is always `Void`</td></tr>
+<tr><td><code>0.5.0</code></td><td>Ensured the iterator function return type is always `Void`</td></tr>
 </tbody>
 </table>
 </details>