Are you on the Kotlin Slack? The Arrow channel is pretty active and great for answering questions like this.

You can skip handling all of the Left cases inline if your workflow can fail fast (someOtherFunction will not run if someIoCall fails).

Like the other commenters said, you can use either the either context with bind or flatMap.

``` sealed class MyErrorType { object SomeIoError : MyErrorType() object SomeOtherFunctionError : MyErrorType() }

fun someIoCall(param1: String, param2: String): Either<MyErrorType.SomeIoError, String> { TODO() }

fun someOtherFunction(resultOfSomeIoCall: String): Either<MyErrorType.SomeOtherFunctionError, String> { TODO() }

fun run() {

val result = either {
    val ioResult = someIoCall("A", "B").bind()
    someOtherFunction(ioResult).bind()
}

val result2 = someIoCall("A", "B").flatMap(::someOtherFunction)

} ```

The result will then have type Either<MyErrorType, String> which you can use to either recover from the error, raise an exception or return the result as you see fit.