Some note from learning Arrow-kt

arrow-ext.kt

fun <T> T?.catchErrWhenNull(tw: Throwable): Either<Throwable, T> = Either.Companion.catch { this ?: throw tw }

fun <T> Either<Throwable, T?>.flattenCatchErrWhenNull(tw: Throwable): Either<Throwable, T> =
    when (this) {
        is Either.Left -> this
        is Either.Right -> Either.Companion.catch {
            this.value ?: throw tw
        }
    }

suspend fun <T> T.catchErrWhenTrue(tw: Throwable, block: suspend (t: T) -> Boolean): Either<Throwable, T> =
    Either.Companion.catch {
        if (block.invoke(this)) throw tw
        else this
    }

suspend fun <T> Either<Throwable, T>.flattenCatchErrWhenTrue(tw: Throwable, block: suspend (t: T) -> Boolean): Either<Throwable, T> =
    when (this) {
        is Either.Left -> this
        is Either.Right -> Either.Companion.catch {
            if (block.invoke(this.value)) throw tw
            else this.value
        }
    }

suspend fun <T, R> T.catchErrWhenMap(tw: Throwable, block: suspend (t: T) -> R): Either<Throwable, R> =
    Either.Companion.catch {
        try {
            block.invoke(this)
        } catch (_: Throwable) {
            throw tw
        }
    }

suspend fun <T, R> Either<Throwable, T>.flattenCatchErrWhenMap(tw: Throwable, block: suspend (t: T) -> R): Either<Throwable, R> =
    when (this) {
        is Either.Left -> this
        is Either.Right -> Either.Companion.catch {
            try {
                block.invoke(this.value)
            } catch (_: Throwable) {
                throw tw
            }
        }
    }
    
fun eitherValidateLogic1(): Either<Throwable, Boolean> = catch { false }
fun eitherValidateLogic2(): Either<Throwable, Boolean> = catch { false }
fun eitherCalculateLogic1(): Either<Throwable, String?> = catch { "null ?" }
fun eitherCalculateLogic2(): Either<Throwable, Map<String, String>> = catch { mapOf("" to "") }
    
fun demoArrow(input: Map<String, Any>): Either<Throwable, Map<String, Any>> =
    catch {
        input
    }.flatMap {
        eitherValidateLogic1()
    }.flatMap {
        eitherValidateLogic2()
    }.flatMap {
        eitherCalculateLogic1()
    }.flatMap {
        catch { it ?: throw RuntimeException("") }
    }.flatMap {
        eitherCalculateLogic2()
    }

fun validateLogic1(): Boolean = false
fun validateLogic2(): Boolean = false
fun calculateLogic1(): String? = "null ?"
fun calculateLogic2(): Map<String, String> = mapOf("" to "")
    
fun demoMyArrow(input: Map<String, Any>): Either<Throwable, Map<String, Any>> = runBlocking {
    input.catchErrWhenTrue(RuntimeException("")) { validateLogic1() }
        .flattenCatchErrWhenTrue(RuntimeException("")) { validateLogic2() }
        .flattenCatchErrWhenMap(RuntimeException("")) { calculateLogic1() }
        .flattenCatchErrWhenNull(RuntimeException(""))
        .flattenCatchErrWhenMap(RuntimeException("")) { calculateLogic2() }
}