Haskell

Mappings from Haskell's Either and Bifunctor types to kotlin-result.

---

Either.either

<V, E, U> Result<V, E>.mapBoth(success: (V) -> U, failure: (E) -> U): U

If the value is Ok(V), apply the first function to V; if it is Err(E), apply the second function to E.

val value: String = Ok("he").mapBoth(
    success = { "$it succeeded" },
    failure = { "$it failed" }
)
// value = "he succeeded"

---

Either.lefts

<V, E> Iterable<Result<V, E>>.getAll(): List<V>

Extracts from an Iterable of Result all the Ok elements. All the Ok elements are extracted in order.

val values: List<String> = getAll(
    Ok("hello"),
    Ok("world")
)
// values = [ "hello", "world" ]

---

Either.rights

<V, E> Iterable<Result<V, E>>.getAllErrors(): List<E>

Extracts from an Iterable of Result all the Error elements. All the Error elements are extracted in order.

val errors: List<String> = getAllErrors(
    Err("error 1"),
    Err("error 2")
)
// errors = [ "error 1", "error 2" ]

---

Either.isLeft

Return true if the result is a Ok, false otherwise.

val result = Ok(500)
if (result is Ok) {
    println("Result is ok")
}

---

Either.isRight

Return true if the result is a Error, false otherwise.

val result = Err(600)
if (result is Err) {
    println("Result is not ok")
}

---

Either.fromLeft

<V, E> Result<V, E>.getOr(default: V): V

Return the value of an Ok-result or a default value otherwise.

val value: String = Err("error").getOr("default")
// value = "default"

---

Either.fromRight

<V, E> Result<V, E>.getErrorOr(default: E): E

Return the error of an Error-result or a default value otherwise.

val error: String = Ok("hello").getErrorOr("world")
// error = "world"

---

Either.partitionEithers

<V, E> Iterable<Result<V, E>>.partition(): Pair<List<V>, List<E>>

Partitions an Iterable of Result into a Pair of two Lists. All the Ok elements are extracted, in order, to the first value of the Pair. Similarly the Error elements are extracted to the second value of the Pair.

val pairs: Pair<List<String>, List<String>> = partition(
    Err("c#"),
    Ok("haskell"),
    Err("java"),
    Ok("f#"),
    Err("c"),
    Ok("elm"),
    Err("lua"),
    Ok("clojure"),
    Err("javascript")
)
// pairs.first = [ "haskell", "f#", "elm", "clojure" ]
// pairs.second = [ "c#", "java", "c", "lua", "javascript"]

---

Bifunctor.bimap

<V, E, U, F> Result<V, E>.mapEither(success: (V) -> U, failure: (E) -> F): Result<U, F>

Map over both arguments at the same time.

val result: Result<String, String> = Err("the reckless").mapEither(
    success = { "the wild youth" },
    failure = { "the truth" }
)

// result = Err("the truth")