Either.catch

Try { }

try/catch

lose

Try

Either

@optics
@recursion
typealias Result<A> = Union<Error, A> // Union<A, B, ...> synthetic and of arbitrary arity up to 22

val a: Result<Int> = error //ok, no need to error.left()
val b: Result<Int> = 1 // ok, no need to 1.right()
val c: Int? = a // ok because it's an error becomes `null`
val d: Int? = b // ok because it's an Int and stays Int
val e: Result<Int> = "other type" // not ok because not an error or an Int. String is not part of the union

val exhaustiveChecks = 
  when (a) {
    is Error -> TODO()
    is Int -> TODO()
  }

a.fold({ e: Error -> TODO() }, { n: Int -> TODO() }) //@recursion folds cata and recursion schemes

Result.error.msg.modify(a, String::trim) // @optics DSLs for all union and products

2

arrow.fx.internal.Platform$_trampoline$1

Platform

class ForResult private constructor() { companion object }
typealias ResultOf<A> = arrow.Kind<ForResult, A>

@Suppress("UNCHECKED_CAST", "NOTHING_TO_INLINE")
inline fun <A> ResultOf<A>.fix(): Result<A> = this as Result<A>

race

IO.sleep

fun ListK<Tuple2<String, Int>>.modifyListItem(key: String, amount: Int) = Option.fx {
        //Find the item
        val index = indexOfFirst { it.a == key }.let { if(it == -1) None else Some(it) }.bind()
        //Get the item
        val item = get(index)
        //Modify
        val modified = itemLens.set(item, item.b + amount)
        //Create an index
        val listIndex = ListK.index<Item>().index(index)
        //Replace the item
        listIndex.set(this@modifyListItem, modified)
}

list.map {
  if (it.a == key) {
    ...
  } else {
    it
  }
}

Either.catch

suspend fun <A> Either.Companion.catch(f: suspend () -> A): Either<Throwable, A> =
try { f().right() } catch (t: Throwable) { t.left() }

catch

suspend

inline fun <A> Either.Companion.catch(f: () -> A): Either<Throwable, A> =
try { f().right() } catch (t: Throwable) { t.left() }

fun blocking(): Int = 42
suspend fun suspended(): Int = 42

fun main() {
    Either.catch { "first: ${blocking()}" }
    
    runBlocking {
        Either.catch { "second: ${suspended()}" }
    }
}

fun authenticate(
    request: AuthenticateRequest,
    secretKey: SecretKey,
    con: Connection
): Either<ErrorMessage, Token>> = Either.fx {
    val (optUser) = getUserByUsername(con, request.username)
    val (user) = checkUserExists(optUser)
    val (_) = checkPassword(request.password, user)
    val (token) = generateToken(user, secretKey)
    token
}

fun authenticate(request: AuthenticateRequest): Reader<Context, Either<ErrorMessage, Token>> {
    return ReaderApi.ask<Context>().map { ctx ->
        Either.fx {
            val (optUser) = getUserByUsername(ctx.sql2o, request.username)
            val (user) = checkUserExists(optUser)
            val (_) = checkPassword(request.password, user)
            val (token) = generateToken(user, ctx.secretKey)
            token
        }
    }
}