arrow-fx-rx2 / arrow.fx.rx2

Package arrow.fx.rx2

Types

CoroutineContextRx2Scheduler object CoroutineContextRx2Scheduler
FlowableK data class FlowableK<out A> : FlowableKOf<A>
ForFlowableK class ForFlowableK
ForMaybeK class ForMaybeK
ForObservableK class ForObservableK
ForSingleK class ForSingleK
MaybeK data class MaybeK<out A> : MaybeKOf<A>
ObservableK data class ObservableK<out A> : ObservableKOf<A>
SingleK data class SingleK<out A> : SingleKOf<A>

Type Aliases

FlowableKConnection typealias FlowableKConnection = KindConnection<ForFlowableK>
FlowableKOf typealias FlowableKOf<A> = Kind<ForFlowableK, A>
FlowableKProc typealias FlowableKProc<A> = ((Either<Throwable, A>) -> Unit) -> Unit
FlowableKProcF typealias FlowableKProcF<A> = ((Either<Throwable, A>) -> Unit) -> FlowableKOf<Unit>
MaybeKOf typealias MaybeKOf<A> = Kind<ForMaybeK, A>
MaybeKProc typealias MaybeKProc<A> = ((Either<Throwable, A>) -> Unit) -> Unit
MaybeKProcF typealias MaybeKProcF<A> = ((Either<Throwable, A>) -> Unit) -> Kind<ForMaybeK, Unit>
ObservableKOf typealias ObservableKOf<A> = Kind<ForObservableK, A>
ObservableKProc typealias ObservableKProc<A> = ((Either<Throwable, A>) -> Unit) -> Unit
ObservableKProcF typealias ObservableKProcF<A> = ((Either<Throwable, A>) -> Unit) -> ObservableKOf<Unit>
SingleKOf typealias SingleKOf<A> = Kind<ForSingleK, A>
SingleKProc typealias SingleKProc<A> = ((Either<Throwable, A>) -> Unit) -> Unit
SingleKProcF typealias SingleKProcF<A> = ((Either<Throwable, A>) -> Unit) -> SingleKOf<Unit>

Extensions for External Classes

arrow.Kind  
io.reactivex.Flowable  
io.reactivex.Maybe  
io.reactivex.Observable  
io.reactivex.Single  

Functions

FlowableKConnection fun FlowableKConnection(dummy: Unit = Unit): KindConnection<ForFlowableK>
Connection for FlowableK.
handleErrorWith fun <A> FlowableK<A>.handleErrorWith(function: (Throwable) -> FlowableKOf<A>): FlowableK<A>
fun <A> MaybeK<A>.handleErrorWith(function: (Throwable) -> MaybeKOf<A>): MaybeK<A>
fun <A> SingleK<A>.handleErrorWith(function: (Throwable) -> SingleKOf<A>): SingleK<A>
MaybeKConnection fun MaybeKConnection(dummy: Unit = Unit): KindConnection<ForMaybeK>
Connection for MaybeK.
ObservableKConnection fun ObservableKConnection(dummy: Unit = Unit): KindConnection<ForObservableK>
Connection for ObservableK.
SingleKConnection fun SingleKConnection(dummy: Unit = Unit): KindConnection<ForSingleK>
Connection for SingleK.