From e43a7008d85284d2ce0342d9ed9b3681598b1a0a Mon Sep 17 00:00:00 2001
From: Michael Bull <mikebull94@gmail.com>
Date: Tue, 18 Sep 2018 19:40:07 +0100
Subject: [PATCH] Add more mapping functions for Iterables

- mapAll
- mapResult
- mapResultTo
- mapResultNotNull
- mapResultNotNullTo
- mapResultIndexed
- mapResultIndexedTo
- mapResultIndexedNotNull
- mapResultIndexedNotNullTo
---
 .../com/github/michaelbull/result/Iterable.kt | 81 +++++++++++++++++++
 .../com/github/michaelbull/result/Map.kt      | 12 +++
 2 files changed, 93 insertions(+)

diff --git a/src/main/kotlin/com/github/michaelbull/result/Iterable.kt b/src/main/kotlin/com/github/michaelbull/result/Iterable.kt
index 1507bb1..ccaf71f 100644
--- a/src/main/kotlin/com/github/michaelbull/result/Iterable.kt
+++ b/src/main/kotlin/com/github/michaelbull/result/Iterable.kt
@@ -135,3 +135,84 @@ fun <V, E> Iterable<Result<V, E>>.partition(): Pair<List<V>, List<E>> {
 
     return Pair(values, errors)
 }
+
+/**
+ * Returns a [Result<List<U>, E>][Result] containing the results of applying the given [transform] function to each
+ * element in the original collection, returning early with the first [Err] if a transformation fails.
+ */
+fun <V, E, U> Iterable<V>.mapResult(transform: (V) -> Result<U, E>): Result<List<U>, E> {
+    return Ok(map { element ->
+        transform(element).getOrElse { return Err(it) }
+    })
+}
+
+/**
+ * Applies the given [transform] function to each element of the original collection and appends the results to the
+ * given [destination], returning early with the first [Err] if a transformation fails.
+ */
+fun <V, E, U, C : MutableCollection<in U>> Iterable<V>.mapResultTo(destination: C, transform: (V) -> Result<U, E>): Result<C, E> {
+    return Ok(mapTo(destination) { element ->
+        transform(element).getOrElse { return Err(it) }
+    })
+}
+
+/**
+ * Returns a [Result<List<U>, E>][Result] containing only the non-null results of applying the given [transform]
+ * function to each element in the original collection, returning early with the first [Err] if a transformation fails.
+ */
+fun <V, E, U : Any> Iterable<V>.mapResultNotNull(transform: (V) -> Result<U, E>?): Result<List<U>, E> {
+    return Ok(mapNotNull { element ->
+        transform(element)?.getOrElse { return Err(it) }
+    })
+}
+
+/**
+ * Applies the given [transform] function to each element in the original collection and appends only the non-null
+ * results to the given [destination], returning early with the first [Err] if a transformation fails.
+ */
+fun <V, E, U : Any, C : MutableCollection<in U>> Iterable<V>.mapResultNotNullTo(destination: C, transform: (V) -> Result<U, E>?): Result<C, E> {
+    return Ok(mapNotNullTo(destination) { element ->
+        transform(element)?.getOrElse { return Err(it) }
+    })
+}
+
+/**
+ * Returns a [Result<List<U>, E>][Result] containing the results of applying the given [transform] function to each
+ * element and its index in the original collection, returning early with the first [Err] if a transformation fails.
+ */
+fun <V, E, U> Iterable<V>.mapResultIndexed(transform: (index: Int, V) -> Result<U, E>): Result<List<U>, E> {
+    return Ok(mapIndexed { index, element ->
+        transform(index, element).getOrElse { return Err(it) }
+    })
+}
+
+/**
+ * Applies the given [transform] function to each element and its index in the original collection and appends the
+ * results to the given [destination], returning early with the first [Err] if a transformation fails.
+ */
+fun <V, E, U, C : MutableCollection<in U>> Iterable<V>.mapResultIndexedTo(destination: C, transform: (index: Int, V) -> Result<U, E>): Result<C, E> {
+    return Ok(mapIndexedTo(destination) { index, element ->
+        transform(index, element).getOrElse { return Err(it) }
+    })
+}
+
+/**
+ * Returns a [Result<List<U>, E>][Result] containing only the non-null results of applying the given [transform]
+ * function to each element and its index in the original collection, returning early with the first [Err] if a
+ * transformation fails.
+ */
+fun <V, E, U : Any> Iterable<V>.mapResultIndexedNotNull(transform: (index: Int, V) -> Result<U, E>?): Result<List<U>, E> {
+    return Ok(mapIndexedNotNull { index, element ->
+        transform(index, element)?.getOrElse { return Err(it) }
+    })
+}
+
+/**
+ * Applies the given [transform] function to each element and its index in the original collection and appends only the
+ * non-null results to the given [destination], returning early with the first [Err] if a transformation fails.
+ */
+fun <V, E, U : Any, C : MutableCollection<in U>> Iterable<V>.mapResultIndexedNotNullTo(destination: C, transform: (index: Int, V) -> Result<U, E>?): Result<C, E> {
+    return Ok(mapIndexedNotNullTo(destination) { index, element ->
+        transform(index, element)?.getOrElse { return Err(it) }
+    })
+}
diff --git a/src/main/kotlin/com/github/michaelbull/result/Map.kt b/src/main/kotlin/com/github/michaelbull/result/Map.kt
index 46e3fb1..015fba3 100644
--- a/src/main/kotlin/com/github/michaelbull/result/Map.kt
+++ b/src/main/kotlin/com/github/michaelbull/result/Map.kt
@@ -30,6 +30,18 @@ inline infix fun <V, E, F> Result<V, E>.mapError(transform: (E) -> F): Result<V,
     }
 }
 
+/**
+ * Returns a [Result<List<U>, E>][Result] containing the results of applying the given [transform] function to each
+ * element in the original collection, returning early with the first [Err] if a transformation fails.
+ */
+fun <V, E, U> Result<Iterable<V>, E>.mapAll(transform: (V) -> Result<U, E>): Result<List<U>, E> {
+    return map { iterable ->
+        iterable.map { element ->
+            transform(element).getOrElse { return Err(it) }
+        }
+    }
+}
+
 /**
  * Maps this [Result<V, E>][Result] to `U` by applying either the [success] function if this [Result]
  * is [Ok], or the [failure] function if this [Result] is an [Err]. Both of these functions must