Configuration with name 'implementation' not found.

Either<Error, List<A>>

either.map{ it.map { f } }

List<T> -> Option<NonEmptyList<T>>

NonEmptyList.fromList

list.toNonEmptyListOrNull()

Option<T>

list.toNonEmptyListOrNull().toOption()

list.toNonEmptyListOrNone()

list.toNelOrNone()

val bar = it.invoke(command) as E

val bar = it.invoke(command).bind()

when (either) {}

sealed interface LeftResult
sealed interface DatabaseLeftResult: LeftResult
sealed interface ApiLeftResult: LeftResult

fun queryDatabase() = effect<DatabaseLeftResult, Int> { 42 }
fun submitNumber(number: Int) = effect<ApiLeftResult, Unit> { println(number) }
fun queryAndSubmit() = effect<LeftResult, Unit> {
  val number = queryDatabase().bind()
  submitNumber(number).bind()
}

bind

queryAndSubmit

queryDatabase

submitNumber

LeftResult

bind

.toEither().bind()

bind()

either {}

Unresolved reference. None of the following candidates is applicable because of receiver type mismatch: 
public open suspend fun <B> Either<CallError, TypeVariable(B)>.bind(): TypeVariable(B) defined in arrow.core.continuations.EffectScope
public open suspend fun <B> Option<TypeVariable(B)>.bind(shift: () -> CallError): TypeVariable(B) defined in arrow.core.continuations.EffectScope
public open suspend fun <B> Validated<CallError, TypeVariable(B)>.bind(): TypeVariable(B) defined in arrow.core.continuations.EffectScope
public open suspend fun <B> EagerEffect<CallError, TypeVariable(B)>.bind(): TypeVariable(B) defined in arrow.core.continuations.EffectScope
public open suspend fun <B> Effect<CallError, TypeVariable(B)>.bind(): TypeVariable(B) defined in arrow.core.continuations.EffectScope
public open suspend fun <B> Result<TypeVariable(B)>.bind(transform: (Throwable) -> CallError): TypeVariable(B) defined in arrow.core.continuations.EffectScope

fun foo(): String? = if ((0..1).random() == 1) "Hello World" else null
    fun bar(s: String): String? = if ((0..1).random() == 1) s else null

    fun maybe(foo: () -> String?, bar: (input: String) -> String?): Either<Err, String> =
        foo()?.let { first ->
            bar(first)?.let { second ->
                Either.Right(second)
            } ?: Either.Left(Err("Could not find second"))
        } ?: Either.Left(Err("Could not find first"))


    maybe(::foo, ::bar)

product

add

product

add

import java.io.IOException
import arrow.core.computations.either
import arrow.core.Either
import arrow.core.Either.Left
import arrow.core.Either.Right
import arrow.core.getOrHandle

data class Error(val errorString: String, val exception: Exception?)

fun <A> remote(f: () -> A): A = if (Math.random() > 0.2) f() else throw IOException("boom!")

fun <A> trap(errorString: String, f: () -> A): Either<Error, A> =
    try { Right(f()) }
    catch (e: Exception) { Left(Error(errorString, e)) }

fun multiply(a: Int, b: Int): Either<Error, Int> = trap("multiplication failed") { remote { a * b } }

fun add(a: Int, b: Int): Either<Error, Int> = trap("addition failed") { remote { a + b } }

// If fetching `product` is failing `sum` should not be called at all.
suspend fun calculate(a: Int, b: Int): Either<Error, Int> =
    either<Error, Int> {
        val product = multiply(a, b).bind()
        val sum = add(a, b).bind()
        sum }

suspend fun main() {
    println(calculate(2, 10).getOrHandle { it.errorString })
    println(calculate(2, 10).getOrHandle { it.errorString })
}

removed-in-arrow-2

ValidatedNel

.zip

data class Ssn(val ssn: String) {
    companion object {

        suspend fun create(ssn: String): ValidatedNel<ValidationError, Ssn> = Validated.fromEither(
            either {
                val validLengthAndAllNumerical = validateLengthAndAllNumerical(ssn).bind()
                Ssn(validateControlNumbers(validLengthAndAllNumerical).bind())
            })


        private fun validateLengthAndAllNumerical(ssn: String): ValidatedNel<ValidationError, String> = with(ssn) {
                length().zip(allNumbers()) { _, _-> ssn }
            }

        context(String)
        private fun length(): ValidatedNel<ValidationError, Unit> =
            if (length == 11) Unit.valid()
            else ValidationError.IncorrectLength.invalidNel()

        context(String)
        private fun allNumbers(): ValidatedNel<ValidationError, Unit> =
            if (filter { it.isDigit() }.length == length) Unit.valid()
            else ValidationError.NotAllDigits.invalidNel()

        private fun validateControlNumbers(ssn: String): ValidatedNel<ValidationError, String> {
            val firstCtrl = listOf(3, 7, 6, 1, 8, 9, 4, 5, 2, 1)
            val secondCtrl = listOf(5, 4, 3, 2, 7, 6, 5, 4, 3, 2, 1)
            val ssnNumeric = ssn.map { it.digitToInt() }

            val firstValid = ssnNumeric.dropLast(1).reduceIndexed { index, acc, i ->
                acc + (i * firstCtrl[index]) } % 11 == 0

            val secondValid = ssnNumeric.reduceIndexed { index, acc, i ->
                acc + (i * secondCtrl[index]) } % 11 == 0

            return if (firstValid && secondValid) ssn.valid()
            else ValidationError.RuleViolation.invalidNel()
        }
    }
}

sealed class ValidationError {
    data object Error: ValidationError()
    data object IncorrectLength: ValidationError()
    data object NotAllDigits: ValidationError()
    data object RuleViolation: ValidationError()
}

Validated.zip(...)

Validated

Either

Either

Either<NetworkError, T>

fun <T : Any> MyFun(
    ...
    fetch: suspend () -> Either<NetworkError, T>,
    ...
): Flow<Either<DataError, T>>

NetworkError

T

Either<NetworkError, T>

Skipped

Either<Either<NetworkError, Skipped>, T>

Either

Either<NetworkResult, T>

sealed interface NetworkResult {
  object Skipped : NetworkResult
  data class Error(val networkError: NetworkError)
}

Either

sealed interface NetworkResult<T> {
  object Skipped : NetworkResult<Nothing>
  data class Error<Nothing>(val networkError: NetworkError)
  data class Data(val data: T)
}

Either

tap

fold

bind

Option<S>

bind

arrow-fx-stm

List<Either<A,B>>

Either<List<A>,List<B>>

ValidaterNel<A,List<B>>

.sequence

.traverse {}

either

withContext

withContext(<http://Dispatchers.IO|Dispatchers.IO>) {
  either {
    // Code that uses all of shift, bind,
    // and currentCoroutineContext().ensureActive()
  }
}

withContext

either

either {
  withContext(<http://Dispatchers.IO|Dispatchers.IO>) {
    // Code that uses all of shift, bind,
    // and currentCoroutineContext().ensureActive()
  }
}