arrow-fx-rx2 / arrow.fx.rx2 / FlowableK

FlowableK

data class FlowableK<out A> : FlowableKOf<A>

Constructors

<init> FlowableK(flowable: Flowable<out A>)

Properties

flowable val flowable: Flowable<out A>

Functions

ap fun <B> ap(fa: FlowableKOf<(A) -> B>): FlowableK<B>
bracketCase fun <B> bracketCase(use: (A) -> FlowableKOf<B>, release: (A, ExitCase<Throwable>) -> FlowableKOf<Unit>, mode: BackpressureStrategy = BackpressureStrategy.BUFFER): FlowableK<B>
A way to safely acquire a resource and release in the face of errors and cancellation. It uses ExitCase to distinguish between different exit cases when releasing the acquired resource.
concatMap fun <B> concatMap(f: (A) -> FlowableKOf<B>): FlowableK<B>
continueOn fun continueOn(ctx: CoroutineContext): FlowableK<A>
equals fun equals(other: Any?): Boolean
filterMap fun <B> filterMap(f: (A) -> Option<B>): FlowableK<B>
flatMap fun <B> flatMap(f: (A) -> FlowableKOf<B>): FlowableK<B>
foldLeft fun <B> foldLeft(b: B, f: (B, A) -> B): B
foldRight fun <B> foldRight(lb: Eval<B>, f: (A, Eval<B>) -> Eval<B>): Eval<B>
hashCode fun hashCode(): Int
map fun <B> map(f: (A) -> B): FlowableK<B>
runAsync fun runAsync(cb: (Either<Throwable, A>) -> FlowableKOf<Unit>): FlowableK<Unit>
runAsyncCancellable fun runAsyncCancellable(cb: (Either<Throwable, A>) -> FlowableKOf<Unit>): FlowableK<Disposable>
switchMap fun <B> switchMap(f: (A) -> FlowableKOf<B>): FlowableK<B>
traverse fun <G, B> traverse(GA: Applicative<G>, f: (A) -> Kind<G, B>): Kind<G, FlowableK<B>>

Companion Object Functions

async fun <A> async(fa: FlowableKProc<A>, mode: BackpressureStrategy = BackpressureStrategy.BUFFER): FlowableK<A>
Creates a FlowableK that’ll run FlowableKProc.
asyncF fun <A> asyncF(fa: FlowableKProcF<A>, mode: BackpressureStrategy = BackpressureStrategy.BUFFER): FlowableK<A>
cancelable fun <A> cancelable(fa: ((Either<Throwable, A>) -> Unit) -> CancelToken<ForFlowableK>, mode: BackpressureStrategy = BackpressureStrategy.BUFFER): FlowableK<A>
cancelableF fun <A> cancelableF(fa: ((Either<Throwable, A>) -> Unit) -> FlowableKOf<CancelToken<ForFlowableK>>, mode: BackpressureStrategy = BackpressureStrategy.BUFFER): FlowableK<A>
defer fun <A> defer(fa: () -> FlowableKOf<A>): FlowableK<A>
invoke operator fun <A> invoke(fa: () -> A): FlowableK<A>
just fun <A> just(a: A): FlowableK<A>
raiseError fun <A> raiseError(t: Throwable): FlowableK<A>
tailRecM tailrec fun <A, B> tailRecM(a: A, f: (A) -> FlowableKOf<Either<A, B>>): FlowableK<B>

Extension Functions

ap fun <A, B> Kind<ForFlowableK, A>.ap(arg1: Kind<ForFlowableK, (A) -> B>): FlowableK<B>
as fun <A, B> Kind<ForFlowableK, A>.as(arg1: B): FlowableK<B>
Replaces A inside F with B resulting in a Kind<F, B>
attempt fun <A> Kind<ForFlowableK, A>.attempt(): FlowableK<Either<Throwable, A>>
bracket fun <A, B> Kind<ForFlowableK, A>.bracket(arg1: (A) -> Kind<ForFlowableK, Unit>, arg2: (A) -> Kind<ForFlowableK, B>): FlowableK<B>
Meant for specifying tasks with safe resource acquisition and release in the face of errors and interruption. It would be the the equivalent of try/catch/finally statements in mainstream imperative languages for resource acquisition and release.
bracketCase fun <A, B> Kind<ForFlowableK, A>.bracketCase(arg1: (A, ExitCase<Throwable>) -> Kind<ForFlowableK, Unit>, arg2: (A) -> Kind<ForFlowableK, B>): FlowableK<B>
A way to safely acquire a resource and release in the face of errors and cancellation. It uses ExitCase to distinguish between different exit cases when releasing the acquired resource.
combineAll fun <A> Kind<ForFlowableK, A>.combineAll(arg1: Monoid<A>): A
continueOn fun <A> Kind<ForFlowableK, A>.continueOn(arg1: CoroutineContext): FlowableK<A>
Continue the evaluation on provided CoroutineContext
effectM fun <A, B> Kind<ForFlowableK, A>.effectM(arg1: (A) -> Kind<ForFlowableK, B>): FlowableK<A>
effectMap fun <A, B> Kind<ForFlowableK, A>.effectMap(arg1: suspend (A) -> B): FlowableK<B>
Helper function that provides an easy way to construct a suspend effect
ensure fun <A> Kind<ForFlowableK, A>.ensure(arg1: () -> Throwable, arg2: (A) -> Boolean): FlowableK<A>
exists fun <A> Kind<ForFlowableK, A>.exists(arg1: (A) -> Boolean): Boolean
filter fun <A> Kind<ForFlowableK, A>.filter(arg1: (A) -> Boolean): FlowableK<A>
filterMap fun <A, B> Kind<ForFlowableK, A>.filterMap(arg1: (A) -> Option<B>): FlowableK<B>
filterMap fun <A, B> Kind<ForFlowableK, A>.filterMap(arg1: (A) -> Option<B>): FlowableK<B>
find fun <A> Kind<ForFlowableK, A>.find(arg1: (A) -> Boolean): Option<A>
firstOption fun <A> Kind<ForFlowableK, A>.firstOption(): Option<A>
fun <A> Kind<ForFlowableK, A>.firstOption(arg1: (A) -> Boolean): Option<A>
fix fun <A> FlowableKOf<A>.fix(): FlowableK<A>
flatMap fun <A, B> Kind<ForFlowableK, A>.flatMap(arg1: (A) -> Kind<ForFlowableK, B>): FlowableK<B>
flatTap fun <A, B> Kind<ForFlowableK, A>.flatTap(arg1: (A) -> Kind<ForFlowableK, B>): FlowableK<A>
flatten fun <A> Kind<ForFlowableK, Kind<ForFlowableK, A>>.flatten(): FlowableK<A>
flattenOption fun <A> Kind<ForFlowableK, Option<A>>.flattenOption(): FlowableK<A>
flatTraverse fun <G, A, B> Kind<ForFlowableK, A>.flatTraverse(arg1: Monad<ForFlowableK>, arg2: Applicative<G>, arg3: (A) -> Kind<G, Kind<ForFlowableK, B>>): Kind<G, Kind<ForFlowableK, B>>
fold fun <A> Kind<ForFlowableK, A>.fold(arg1: Monoid<A>): A
foldLeft fun <A, B> Kind<ForFlowableK, A>.foldLeft(arg1: B, arg2: (B, A) -> B): B
foldM fun <G, A, B> Kind<ForFlowableK, A>.foldM(arg1: Monad<G>, arg2: B, arg3: (B, A) -> Kind<G, B>): Kind<G, B>
foldMap fun <A, B> Kind<ForFlowableK, A>.foldMap(arg1: Monoid<B>, arg2: (A) -> B): B
foldMapM fun <G, A, B, MA : Monad<G>, MO : Monoid<B>> Kind<ForFlowableK, A>.foldMapM(arg1: MA, arg2: MO, arg3: (A) -> Kind<G, B>): Kind<G, B>
foldRight fun <A, B> Kind<ForFlowableK, A>.foldRight(arg1: Eval<B>, arg2: (A, Eval<B>) -> Eval<B>): Eval<B>
followedBy fun <A, B> Kind<ForFlowableK, A>.followedBy(arg1: Kind<ForFlowableK, B>): FlowableK<B>
followedByEval fun <A, B> Kind<ForFlowableK, A>.followedByEval(arg1: Eval<Kind<ForFlowableK, B>>): FlowableK<B>
forAll fun <A> Kind<ForFlowableK, A>.forAll(arg1: (A) -> Boolean): Boolean
forEffect fun <A, B> Kind<ForFlowableK, A>.forEffect(arg1: Kind<ForFlowableK, B>): FlowableK<A>
forEffectEval fun <A, B> Kind<ForFlowableK, A>.forEffectEval(arg1: Eval<Kind<ForFlowableK, B>>): FlowableK<A>
fproduct fun <A, B> Kind<ForFlowableK, A>.fproduct(arg1: (A) -> B): FlowableK<Tuple2<A, B>>
Applies f to an A inside F and returns the F structure with a tuple of the A value and the computed B value as result of applying f
get fun <A> Kind<ForFlowableK, A>.get(arg1: Long): Option<A>
guarantee fun <A> Kind<ForFlowableK, A>.guarantee(arg1: Kind<ForFlowableK, Unit>): FlowableK<A>
Executes the given finalizer when the source is finished, either in success or in error, or if canceled.
guaranteeCase fun <A> Kind<ForFlowableK, A>.guaranteeCase(arg1: (ExitCase<Throwable>) -> Kind<ForFlowableK, Unit>): FlowableK<A>
Executes the given finalizer when the source is finished, either in success or in error, or if canceled, allowing for differentiating between exit conditions. That’s thanks to the ExitCase argument of the finalizer.
handleError fun <A> Kind<ForFlowableK, A>.handleError(arg1: (Throwable) -> A): FlowableK<A>
handleErrorWith fun <A> FlowableK<A>.handleErrorWith(function: (Throwable) -> FlowableKOf<A>): FlowableK<A>
handleErrorWith fun <A> Kind<ForFlowableK, A>.handleErrorWith(arg1: (Throwable) -> Kind<ForFlowableK, A>): FlowableK<A>
ifM fun <B> Kind<ForFlowableK, Boolean>.ifM(arg1: () -> Kind<ForFlowableK, B>, arg2: () -> Kind<ForFlowableK, B>): FlowableK<B>
imap fun <A, B> Kind<ForFlowableK, A>.imap(arg1: (A) -> B, arg2: (B) -> A): FlowableK<B>
isEmpty fun <A> Kind<ForFlowableK, A>.isEmpty(): Boolean
map fun <A, B> Kind<ForFlowableK, A>.map(arg1: (A) -> B): FlowableK<B>
map fun <A, B> Kind<ForFlowableK, A>.map(arg1: (A) -> B): FlowableK<B>
Transform the F wrapped value A into B preserving the F structure Kind<F, A> -> Kind<F, B>
map fun <A, B> Kind<ForFlowableK, A>.map(arg1: (A) -> B): FlowableK<B>
map fun <A, B> Kind<ForFlowableK, A>.map(arg1: (A) -> B): FlowableK<B>
mproduct fun <A, B> Kind<ForFlowableK, A>.mproduct(arg1: (A) -> Kind<ForFlowableK, B>): FlowableK<Tuple2<A, B>>
nonEmpty fun <A> Kind<ForFlowableK, A>.nonEmpty(): Boolean
productL fun <A, B> Kind<ForFlowableK, A>.productL(arg1: Kind<ForFlowableK, B>): FlowableK<A>
productLEval fun <A, B> Kind<ForFlowableK, A>.productLEval(arg1: Eval<Kind<ForFlowableK, B>>): FlowableK<A>
redeem fun <A, B> Kind<ForFlowableK, A>.redeem(arg1: (Throwable) -> B, arg2: (A) -> B): FlowableK<B>
redeemWith fun <A, B> Kind<ForFlowableK, A>.redeemWith(arg1: (Throwable) -> Kind<ForFlowableK, B>, arg2: (A) -> Kind<ForFlowableK, B>): FlowableK<B>
reduceLeftOption fun <A> Kind<ForFlowableK, A>.reduceLeftOption(arg1: (A, A) -> A): Option<A>
reduceLeftToOption fun <A, B> Kind<ForFlowableK, A>.reduceLeftToOption(arg1: (A) -> B, arg2: (B, A) -> B): Option<B>
reduceRightOption fun <A> Kind<ForFlowableK, A>.reduceRightOption(arg1: (A, Eval<A>) -> Eval<A>): Eval<Option<A>>
reduceRightToOption fun <A, B> Kind<ForFlowableK, A>.reduceRightToOption(arg1: (A) -> B, arg2: (A, Eval<B>) -> Eval<B>): Eval<Option<B>>
rethrow fun <A> Kind<ForFlowableK, Either<Throwable, A>>.rethrow(): FlowableK<A>
runAsync fun <A> Kind<ForFlowableK, A>.runAsync(arg1: (Either<Throwable, A>) -> Kind<ForFlowableK, Unit>): FlowableK<Unit>
runAsyncCancellable fun <A> Kind<ForFlowableK, A>.runAsyncCancellable(arg1: (Either<Throwable, A>) -> Kind<ForFlowableK, Unit>): FlowableK<() -> Unit>
select fun <A, B> Kind<ForFlowableK, Either<A, B>>.select(arg1: Kind<ForFlowableK, (A) -> B>): FlowableK<B>
selectM fun <A, B> Kind<ForFlowableK, Either<A, B>>.selectM(arg1: Kind<ForFlowableK, (A) -> B>): FlowableK<B>
sequence fun <G, A> Kind<ForFlowableK, Kind<G, A>>.sequence(arg1: Applicative<G>): Kind<G, Kind<ForFlowableK, A>>
sequence fun <A, G> FlowableKOf<Kind<G, A>>.sequence(GA: Applicative<G>): Kind<G, FlowableK<A>>
sequence_ fun <G, A> Kind<ForFlowableK, Kind<G, A>>.sequence_(arg1: Applicative<G>): Kind<G, Unit>
size fun <A> Kind<ForFlowableK, A>.size(arg1: Monoid<Long>): Long
traverse fun <G, A, B> Kind<ForFlowableK, A>.traverse(arg1: Applicative<G>, arg2: (A) -> Kind<G, B>): Kind<G, Kind<ForFlowableK, B>>
traverse_ fun <G, A, B> Kind<ForFlowableK, A>.traverse_(arg1: Applicative<G>, arg2: (A) -> Kind<G, B>): Kind<G, Unit>
tupleLeft fun <A, B> Kind<ForFlowableK, A>.tupleLeft(arg1: B): FlowableK<Tuple2<B, A>>
Pairs B with A returning a Kind<F, Tuple2<B, A>>
tupleRight fun <A, B> Kind<ForFlowableK, A>.tupleRight(arg1: B): FlowableK<Tuple2<A, B>>
Pairs A with B returning a Kind<F, Tuple2<A, B>>
uncancelable fun <A> Kind<ForFlowableK, A>.uncancelable(): FlowableK<A>
Meant for ensuring a given task continues execution even when interrupted.
unit fun <A> Kind<ForFlowableK, A>.unit(): FlowableK<Unit>
Discards the A value inside F signaling this container may be pointing to a noop or an effect whose return value is deliberately ignored. The singleton value Unit serves as signal.
value fun <A> FlowableKOf<A>.value(): Flowable<A>
widen fun <B, A : B> Kind<ForFlowableK, A>.widen(): FlowableK<B>
Given A is a sub type of B, re-type this value from Kind<F, A> to Kind<F, B>

Companion Object Extension Functions

applicative fun FlowableK.Companion.applicative(): FlowableKApplicative
applicativeError fun FlowableK.Companion.applicativeError(): FlowableKApplicativeError
async fun FlowableK.Companion.async(): FlowableKAsync
asyncBuffer fun FlowableK.Companion.asyncBuffer(): FlowableKAsync
asyncDrop fun FlowableK.Companion.asyncDrop(): FlowableKAsync
asyncError fun FlowableK.Companion.asyncError(): FlowableKAsync
asyncLatest fun FlowableK.Companion.asyncLatest(): FlowableKAsync
asyncMissing fun FlowableK.Companion.asyncMissing(): FlowableKAsync
bracket fun FlowableK.Companion.bracket(): FlowableKBracket
concurrent fun FlowableK.Companion.concurrent(dispatchers: Dispatchers<ForFlowableK>): Concurrent<ForFlowableK>
concurrentEffect fun FlowableK.Companion.concurrentEffect(): FlowableKConcurrentEffect
effect fun FlowableK.Companion.effect(): FlowableKEffect
effectBuffer fun FlowableK.Companion.effectBuffer(): FlowableKEffect
effectDrop fun FlowableK.Companion.effectDrop(): FlowableKEffect
effectError fun FlowableK.Companion.effectError(): FlowableKEffect
effectLatest fun FlowableK.Companion.effectLatest(): FlowableKEffect
effectMissing fun FlowableK.Companion.effectMissing(): FlowableKEffect
foldable fun FlowableK.Companion.foldable(): FlowableKFoldable
functor fun FlowableK.Companion.functor(): FlowableKFunctor
functorFilter fun FlowableK.Companion.functorFilter(): FlowableKFunctorFilter
fx fun <A> FlowableK.Companion.fx(c: suspend AsyncSyntax<ForFlowableK>.() -> A): FlowableK<A>
monad fun FlowableK.Companion.monad(): FlowableKMonad
monadConcat fun FlowableK.Companion.monadConcat(): FlowableKMonad
monadDefer fun FlowableK.Companion.monadDefer(): FlowableKMonadDefer
monadError fun FlowableK.Companion.monadError(): FlowableKMonadError
monadErrorConcat fun FlowableK.Companion.monadErrorConcat(): FlowableKMonadError
monadErrorFlat fun FlowableK.Companion.monadErrorFlat(): FlowableKMonadError
monadErrorSwitch fun FlowableK.Companion.monadErrorSwitch(): FlowableKMonadError
monadFilter fun FlowableK.Companion.monadFilter(): FlowableKMonadFilter
monadFlat fun FlowableK.Companion.monadFlat(): FlowableKMonad
monadSuspendBuffer fun FlowableK.Companion.monadSuspendBuffer(): FlowableKMonadDefer
monadSuspendDrop fun FlowableK.Companion.monadSuspendDrop(): FlowableKMonadDefer
monadSuspendError fun FlowableK.Companion.monadSuspendError(): FlowableKMonadDefer
monadSuspendLatest fun FlowableK.Companion.monadSuspendLatest(): FlowableKMonadDefer
monadSuspendMissing fun FlowableK.Companion.monadSuspendMissing(): FlowableKMonadDefer
monadSwitch fun FlowableK.Companion.monadSwitch(): FlowableKMonad
monadThrow fun FlowableK.Companion.monadThrow(): FlowableKMonadThrow
timer fun FlowableK.Companion.timer(): FlowableKTimer
traverse fun FlowableK.Companion.traverse(): FlowableKTraverse

Type Class Hierarchy