Async Arrow sample

fun t(msg: String = "alisson") {
    println(f(msg, Either.monadError()))
    println("11111111111111111111111111111111111")
    println(f(msg, Try.monadError()))
    println("22222222222222222222222222222222222")
    println(g(msg, Either.monadError()))
    println("33333333333333333333333333333333333")
    println(g(msg, Try.monadError()))
    println("44444444444444444444444444444444444")
    IO.async()
            .i(msg)
            .fix()
            .attempt()
            .unsafeRunAsync { callback -> callback.fold({ println(it) }, { println(it) }) }
    println("55555555555555555555555555555555555")
    IO.async()
            .j(msg)
            .fix()
            .attempt()
            .unsafeRunAsync { callback -> callback.fold({ println(it) }, { println(it) }) }
}

fun <F> f(msg: String, monad: MonadError<F, Throwable>): Kind<F, String> = when {
    msg.isEmpty() -> monad.just("f: $msg")
    else -> monad.raiseError(Throwable(HasGenesisError))
}

fun <F> g(msg: String, monad: MonadError<F, Throwable>): Kind<F, String> = monad
        .binding {
            when {
                msg.isEmpty() -> "g: $msg"
                else -> monad.raiseError<String>(Throwable(HasGenesisError)).bind()
            }
        }

fun <F> Async<F>.i(msg: String): Kind<F, String> = async { callback: (Either<Throwable, String>) -> Unit ->
    when {
        msg.isEmpty() -> callback("i: $msg".right())
        else -> callback(Throwable(HasGenesisError).left())
    }
}

fun <F> Async<F>.j(msg: String): Kind<F, String> = defer {
    binding {
        when {
            msg.isEmpty() -> "j: $msg"
            else -> raiseError<String>(Throwable(HasGenesisError)).bind()
        }
    }
}

t()