override suspend fun invoke(command: Command): Either<BusinessError, Unit> = 
        either {
            val responseOne = serviceOne.call(command.data.first).bind()
            val responseTwo = serviceTwo.call(command.data.second).bind()
    
            if (responseOne.amount > responseTwo.amount) {
                serviceThree.call()
            }
        }

@Singleton
class AuthUseCase @Inject constructor(
    private val networkDataSource: NetworkDataSource,
    private val storage: AuthStorage,
) {

    suspend fun refreshTokenIfNeeded(): Either<DomainError, Unit> = either {
        val token = storage.getToken().bind()
        ensure(token.expirationDate.isInTheFuture()) {
            TokenExpired
        }
    }.handleErrorWith { error ->
        when (error) {
            is TokenNotFound,
            TokenExpired,
            -> fetchNewTokenAndSaveIt()
            else -> error.left()
        }
    }

    private suspend fun fetchNewTokenAndSaveIt(): Either<DomainError, Unit> = either {
        networkDataSource.getAccessToken().bind()
    }.flatMap { (accessToken, expiresIn) ->
        catch {
            AuthToken(
                accessToken,
                expirationDate = nowPlusMillis(expiresIn)
            )
        }.mapLeft { InvalidExpirationDate }
    }.map { storage.putToken(it) }
}

arrow

interface HasAge { val age: Int }

@optics
data class Form(
  override val age: Int
): HasAge {
  companion object
}
// is exported out of the current "module"
val lens: Lens<HasAge, Int> = Form.age // compilation error

// in another module
fun transformAge(form: HasAge, lens: Lens<HasAge, Int>)

val lens

data class Form

Any

HasAge

tuplize

fun foo(x: Int, y: Int) = 3 * x + 2 * y + 1

fun <T, U, R> tuplize(f: (T, U) -> R): ((Pair<T, U>) -> R) = { (a, b): Pair<T, U> -> f(a, b) }

val xs = listOf(Pair(1, 2), Pair(42, 23))

val ys = xs.map(tuplize(::foo))

Throwable

suspend fun scheduleCall(service: Service, handleError: (Throwable) -> Unit) =
    (Schedule.doWhile<Either<Throwable, Data>> { it.isEmpty() }
            .logOutput { it.mapLeft { throwable -> handleError(throwable) } })
        .repeat { service.call() }
suspend fun callServices(
    a: Service,
    b: Service
): Either<List<Throwable>, String> {
  val errors = mutableListOf<Throwable>()
  val winner =
      raceN(
          <http://Dispatchers.IO|Dispatchers.IO>,
          { scheduleCall(a) { errors += it } },
          { scheduleCall(b) { errors += it } },
          { delay(60.seconds) })
  return when (winner) {
    is First -> "A".right()
    is Second -> "B".right()
    is Third -> errors.left()
  }
}

arrow-meta

Either.resolve

List<Either<A,B>>

partitionEithers

ControlThrowable

CancellationException

ShiftCancellationException

CancellationException

ControlThrowable

CancellationException

ControlThrowable

ShiftCancellationException

ShiftCancellationException

callbackFlow

Either

val flow = callbackFlow<Unit> {
    delay(2000)
    cancel(CancellationException("Boom"))
}

Either.catch {
    flow
        .catch { throw RuntimeException(it.message) }
        .collect()
}.mapLeft { it.message?.let { msg -> FlowError.Canceled(msg) } }

traverse

Either

MutableStateFlow<Either<DataMissing, T>>

val automations: MutableStateFlow<Either<DataMissing, AutomationList>>

    private fun handleEvent(event: EntityModel) {
        if (event is AutomationUpdatePendingStateEvent) {
            automations.update { automationsEither ->
                automationsEither.map { automations ->
                    automations.updateAutomationState(
                        automationId = event.automationId,
                        pendingState = event.deviceState,
                        provisioningComplete = event.provisioningComplete
                    )
                }
            }
        }
    }

Either

right

return either<Error, Unit> {
  parZip(
    { someComputation().toEither() },
    { someComputation().toEither() },
  ) { one, two ->
    one.bind()
    two.bind()
  }
}

bind()

async();async();awaitAll()

mapLeft

EffectScope

context(EffectScope<Throwable>)
fun count(): Int = TODO()

sealed interface DomainError

context(EffectScope<DomainError>)
fun logic(): Int {
  // I want to map Throwable to DomainError here
  return count()
}

java.lang.AssertionError: java.net.SocketException: Software caused connection abort: recv failed is of type java.net.SocketException but expected java.net.ConnectException

fun foo(): Either<Err, Ok>
val res = foo().map { bar(it) }.mapLeft { return it }

Inline classes with generic underlying type (experimental)

data class Foo<T>(val value: T)

.refaster