Simple Async<T> state handling for MvRx

MvRxAsyncStateHandling.kt

//Any.takeAs() found in KotlinExt.kt gist

inline fun <T> Async<T>.doOnUninitialized(block: () -> Unit): Async<T> =
    takeAs<Uninitialized>()?.also { block() } ?: this

inline fun <T> Async<T>.doOnLoading(block: () -> Unit): Async<T> =
    takeAs<Loading<T>>()?.also { block() } ?: this

inline fun <T> Async<T>.doOnSuccess(block: (T) -> Unit): Async<T> =
    takeAs<Success<T>>()?.also { block(it()) } ?: this

inline fun <T> Async<T>.doOnFailure(block: (Throwable) -> Unit): Async<T> =
    takeAs<Fail<T>>()?.also { block(it.error) } ?: this

inline fun <reified T> Async<T>.doOn(block: AsyncHandlers<T>.() -> Unit): Async<T> =
    AsyncHandlers<T>().also(block).let { handlers ->
        when (this) {
            is Uninitialized -> handlers.uninitialized?.invoke()
            is Loading -> handlers.loading?.invoke()
            is Success -> handlers.success?.invoke(this())
            is Fail -> handlers.failure?.invoke(this.error)
        }
        this
    }

inline fun <S, reified T> S.reduceAndDoOn(async: Async<T>, block: AsyncStateUpdates<S, T>.() -> Unit): S =
    AsyncStateUpdates<S, T>().also(block).let { handlers ->
        return when (async) {
            is Uninitialized -> handlers.uninitialized?.invoke(this)
            is Loading -> handlers.loading?.invoke(this)
            is Success -> handlers.success?.invoke(this, async())
            is Fail -> handlers.failure?.invoke(this, async.error)
        } ?: this
    }

class AsyncHandlers<T> {
    var uninitialized: (() -> Unit)? = null
    var loading: (() -> Unit)? = null
    var success: ((T) -> Unit)? = null
    var failure: ((Throwable) -> Unit)? = null
}

class AsyncStateUpdates<S, T> {
    var uninitialized: (S.() -> S)? = null
    var loading: (S.() -> S)? = null
    var success: (S.(T) -> S)? = null
    var failure: (S.(Throwable) -> S)? = null
}