Option.fold[F, T, S](ifNone: => F[S], block: T => F[S])

suspend () -> T

IO<T>

suspend () -> T

F

Kind<ForF, T>

YET▾

import arrow.core.Either

// fictitious domain
sealed class BusinessLogic1Error { 
  // all errors
}

sealed class BusinessLogic2Error {
  // all errors
}

sealed class BusinessLogic3Error {
  // all errors
}

fun businessLogic1(): Either<BusinessLogic1Error, String> = TODO()
fun businessLogic2(): Either<BusinessLogic2Error, String> = TODO()
fun businessLogic3(): Either<BusinessLogic3Error, String> = TODO()


// use cases that use different business logic

// approach 1
// Union Type through wrapper class

sealed class UseCaseError {
  class BusinessLogic1(val businessLogic1Error: BusinessLogic1Error): UseCaseError()
  class BusinessLogic2(val businessLogic2Error: BusinessLogic2Error): UseCaseError()
  // any other error that can be generated by a function used by this use case
  
}
fun useCase(): Either<UseCaseError, String> = TODO()

// Pros:
// Explicit and doesn't lose type information
// Cons:
// Doing this across multiple use cases gets unwieldy


// approach 2
fun useCase(): Either<Throwable, String> = TODO()

// Loses all type info and its only serving as a placeholder to say that the function can fail

any

Option

IO

fun areRemindersEnabled(): IO<Unit, Boolean> =
        storage.load<Boolean>(key)
            .handleError { false }
            .mapError { Unit }

IO<Boolean>

validatorAE.validateEmailWithRules(user.email).bind()
cityShouldBeValid(user).bind()
loginShouldNotExit(user).bind()

suspend fun one(): Either<Error, Int>
suspend fun two(i: Int): Either<Error, Value>

launch{
   one().fold(::Left, { right ->
       two(right) /// <- Kotlin is complaining that this needs to be in a coroutine scope
   }
}

List<IO<Either<E,A>>>

fx

suspend

suspend fun loadInt(key: String): Int?

null

Either

Option

IO

fun loadInt(key: String): IO<Int>

fix()

IO.unit.continueOn(Dispatchers.Main)
            .followedBy(IO.effect { render(ViewState.Error(it.message ?: "Ooops!")) })

IO(Dispatchers.Main) { render(ViewState.Error(it.message ?: "Ooops!") }