Uses of Interface
io.reactivex.rxjava3.functions.Function

Packages that use Function

Package	Description
io.reactivex.rxjava3.core	Base reactive classes: Flowable, Observable, Single, Maybe and Completable; base reactive consumers; other common base interfaces.
io.reactivex.rxjava3.internal.functions
io.reactivex.rxjava3.internal.jdk8
io.reactivex.rxjava3.internal.operators.completable
io.reactivex.rxjava3.internal.operators.flowable
io.reactivex.rxjava3.internal.operators.maybe
io.reactivex.rxjava3.internal.operators.mixed
io.reactivex.rxjava3.internal.operators.observable
io.reactivex.rxjava3.internal.operators.parallel
io.reactivex.rxjava3.internal.operators.single
io.reactivex.rxjava3.internal.schedulers
io.reactivex.rxjava3.internal.util
io.reactivex.rxjava3.parallel	Contains the base type ParallelFlowable, a sub-DSL for working with Flowable sequences in parallel.
io.reactivex.rxjava3.plugins	Contains the central plugin handler RxJavaPlugins class to hook into the lifecycle of the base reactive types and schedulers.

Uses of Function in io.reactivex.rxjava3.core

Methods in io.reactivex.rxjava3.core with parameters of type Function

Modifier and Type	Method	Description
final <@NonNull TOpening, @NonNull TClosing> @NonNull Flowable<List<T>>	Flowable.buffer(@NonNull org.reactivestreams.Publisher<? extends @NonNull TOpening> openingIndicator, @NonNull Function<? super @NonNull TOpening, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull TClosing>> closingIndicator)	Returns a Flowable that emits buffers of items it collects from the current Flowable.
final <@NonNull TOpening, @NonNull TClosing, @NonNull U extends Collection<? super @NonNull T>> @NonNull Flowable<U>	Flowable.buffer(@NonNull org.reactivestreams.Publisher<? extends @NonNull TOpening> openingIndicator, @NonNull Function<? super @NonNull TOpening, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull TClosing>> closingIndicator, @NonNull Supplier<@NonNull U> bufferSupplier)	Returns a Flowable that emits buffers of items it collects from the current Flowable.
final <@NonNull TOpening, @NonNull TClosing> @NonNull Observable<@NonNull List<T>>	Observable.buffer(@NonNull ObservableSource<? extends @NonNull TOpening> openingIndicator, @NonNull Function<? super @NonNull TOpening, ? extends ObservableSource<? extends @NonNull TClosing>> closingIndicator)	Returns an Observable that emits buffers of items it collects from the current Observable.
final <@NonNull TOpening, @NonNull TClosing, @NonNull U extends Collection<? super @NonNull T>> @NonNull Observable<U>	Observable.buffer(@NonNull ObservableSource<? extends @NonNull TOpening> openingIndicator, @NonNull Function<? super @NonNull TOpening, ? extends ObservableSource<? extends @NonNull TClosing>> closingIndicator, @NonNull Supplier<@NonNull U> bufferSupplier)	Returns an Observable that emits buffers of items it collects from the current Observable.
static <@NonNull T, @NonNull R> @NonNull Flowable<R>	Flowable.combineLatest(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner)	Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <@NonNull T, @NonNull R> @NonNull Flowable<R>	Flowable.combineLatest(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize)	Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <@NonNull T, @NonNull R> @NonNull Observable<R>	Observable.combineLatest(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner)	Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the returned ObservableSources each time an item is received from any of the returned ObservableSources, where this aggregation is defined by a specified function.
static <@NonNull T, @NonNull R> @NonNull Observable<R>	Observable.combineLatest(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize)	Combines an Iterable of source ObservableSources by emitting an item that aggregates the latest values of each of the returned ObservableSources each time an item is received from any of the returned ObservableSources, where this aggregation is defined by a specified function.
static <@NonNull T, @NonNull R> @NonNull Flowable<R>	Flowable.combineLatestArray(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner)	Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <@NonNull T, @NonNull R> @NonNull Flowable<R>	Flowable.combineLatestArray(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize)	Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <@NonNull T, @NonNull R> @NonNull Observable<R>	Observable.combineLatestArray(@NonNull ObservableSource<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner)	Combines an array of source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the returned ObservableSources, where this aggregation is defined by a specified function.
static <@NonNull T, @NonNull R> @NonNull Observable<R>	Observable.combineLatestArray(@NonNull ObservableSource<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize)	Combines an array of source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.
static <@NonNull T, @NonNull R> @NonNull Flowable<R>	Flowable.combineLatestArrayDelayError(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner)	Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <@NonNull T, @NonNull R> @NonNull Flowable<R>	Flowable.combineLatestArrayDelayError(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize)	Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.
static <@NonNull T, @NonNull R> @NonNull Observable<R>	Observable.combineLatestArrayDelayError(@NonNull ObservableSource<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner)	Combines an array of ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.
static <@NonNull T, @NonNull R> @NonNull Observable<R>	Observable.combineLatestArrayDelayError(@NonNull ObservableSource<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize)	Combines an array of ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function and delays any error from the sources until all source ObservableSources terminate.
static <@NonNull T, @NonNull R> @NonNull Flowable<R>	Flowable.combineLatestDelayError(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner)	Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.
static <@NonNull T, @NonNull R> @NonNull Flowable<R>	Flowable.combineLatestDelayError(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize)	Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.
static <@NonNull T, @NonNull R> @NonNull Observable<R>	Observable.combineLatestDelayError(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner)	Combines an Iterable of ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function and delays any error from the sources until all source ObservableSources terminate.
static <@NonNull T, @NonNull R> @NonNull Observable<R>	Observable.combineLatestDelayError(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize)	Combines an Iterable of ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function and delays any error from the sources until all source ObservableSources terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMap(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper)	Returns a new Flowable that emits items resulting from applying a function that you supply to each item emitted by the current Flowable, where that function returns a Publisher, and then emitting the items that result from concatenating those returned Publishers.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMap(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int prefetch)	Returns a new Flowable that emits items resulting from applying a function that you supply to each item emitted by the current Flowable, where that function returns a Publisher, and then emitting the items that result from concatenating those returned Publishers.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMap(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int prefetch, @NonNull Scheduler scheduler)	Returns a new Flowable that emits items resulting from applying a function (on a designated scheduler) that you supply to each item emitted by the current Flowable, where that function returns a Publisher, and then emitting the items that result from concatenating those returned Publishers.
final <@NonNull R> @NonNull Maybe<R>	Maybe.concatMap(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper)	Returns a Maybe that is based on applying a specified function to the item emitted by the current Maybe, where that function returns a MaybeSource.
final <@NonNull R> @NonNull Observable<R>	Observable.concatMap(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper)	Returns a new Observable that emits items resulting from applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then emitting the items that result from concatenating those returned ObservableSources.
final <@NonNull R> @NonNull Observable<R>	Observable.concatMap(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, int bufferSize)	Returns a new Observable that emits items resulting from applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then emitting the items that result from concatenating those returned ObservableSources.
final <@NonNull R> @NonNull Observable<R>	Observable.concatMap(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, int bufferSize, @NonNull Scheduler scheduler)	Returns a new Observable that emits items resulting from applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then emitting the items that result from concatenating those returned ObservableSources.
final <@NonNull R> @NonNull Single<R>	Single.concatMap(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper)	Returns a Single that is based on applying a specified function to the item emitted by the current Single, where that function returns a SingleSource.
final @NonNull Completable	Flowable.concatMapCompletable(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper)	Maps the upstream items into CompletableSources and subscribes to them one after the other completes.
final @NonNull Completable	Flowable.concatMapCompletable(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, int prefetch)	Maps the upstream items into CompletableSources and subscribes to them one after the other completes.
final @NonNull Completable	Maybe.concatMapCompletable(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper)	Returns a Completable that completes based on applying a specified function to the item emitted by the current Maybe, where that function returns a Completable.
final @NonNull Completable	Observable.concatMapCompletable(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper)	Maps each element of the current Observable into CompletableSources, subscribes to them one at a time in order and waits until the upstream and all CompletableSources complete.
final @NonNull Completable	Observable.concatMapCompletable(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, int capacityHint)	Maps each element of the current Observable into CompletableSources, subscribes to them one at a time in order and waits until the upstream and all CompletableSources complete.
final @NonNull Completable	Single.concatMapCompletable(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper)	Returns a Completable that completes based on applying a specified function to the item emitted by the current Single, where that function returns a CompletableSource.
final @NonNull Completable	Flowable.concatMapCompletableDelayError(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper)	Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, delaying all errors till both this Flowable and all inner CompletableSources terminate.
final @NonNull Completable	Flowable.concatMapCompletableDelayError(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean tillTheEnd)	Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both this Flowable and all inner CompletableSources terminate.
final @NonNull Completable	Flowable.concatMapCompletableDelayError(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean tillTheEnd, int prefetch)	Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both this Flowable and all inner CompletableSources terminate.
final @NonNull Completable	Observable.concatMapCompletableDelayError(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper)	Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, delaying all errors till both the current Observable and all inner CompletableSources terminate.
final @NonNull Completable	Observable.concatMapCompletableDelayError(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean tillTheEnd)	Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both the current Observable and all inner CompletableSources terminate.
final @NonNull Completable	Observable.concatMapCompletableDelayError(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean tillTheEnd, int bufferSize)	Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both the current Observable and all inner CompletableSources terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapDelayError(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper)	Maps each of the items into a Publisher, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner Publishers till all of them terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapDelayError(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean tillTheEnd, int prefetch)	Maps each of the items into a Publisher, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner Publishers till all of them terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapDelayError(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean tillTheEnd, int prefetch, @NonNull Scheduler scheduler)	Maps each of the upstream items into a Publisher, subscribes to them one after the other, one at a time and emits their values in order while executing the mapper function on the designated scheduler, delaying any error from either this or any of the inner Publishers till all of them terminate.
final <@NonNull R> @NonNull Observable<R>	Observable.concatMapDelayError(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper)	Maps each of the items into an ObservableSource, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner ObservableSources till all of them terminate.
final <@NonNull R> @NonNull Observable<R>	Observable.concatMapDelayError(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int bufferSize)	Maps each of the items into an ObservableSource, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner ObservableSources till all of them terminate.
final <@NonNull R> @NonNull Observable<R>	Observable.concatMapDelayError(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int bufferSize, @NonNull Scheduler scheduler)	Maps each of the items into an ObservableSource, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner ObservableSources till all of them terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapEager(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper)	Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapEager(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int maxConcurrency, int prefetch)	Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.
final <@NonNull R> @NonNull Observable<R>	Observable.concatMapEager(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper)	Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single Observable sequence.
final <@NonNull R> @NonNull Observable<R>	Observable.concatMapEager(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, int maxConcurrency, int bufferSize)	Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single Observable sequence.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapEagerDelayError(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean tillTheEnd)	Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapEagerDelayError(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean tillTheEnd, int maxConcurrency, int prefetch)	Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Flowable sequence.
final <@NonNull R> @NonNull Observable<R>	Observable.concatMapEagerDelayError(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, boolean tillTheEnd)	Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single Observable sequence.
final <@NonNull R> @NonNull Observable<R>	Observable.concatMapEagerDelayError(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int maxConcurrency, int bufferSize)	Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single Observable sequence.
final <@NonNull U> @NonNull Flowable<U>	Flowable.concatMapIterable(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper)	Returns a Flowable that concatenate each item emitted by the current Flowable with the values in an Iterable corresponding to that item that is generated by a selector.
final <@NonNull U> @NonNull Flowable<U>	Flowable.concatMapIterable(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper, int prefetch)	Returns a Flowable that concatenate each item emitted by the current Flowable with the values in an Iterable corresponding to that item that is generated by a selector.
final <@NonNull U> @NonNull Observable<U>	Observable.concatMapIterable(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper)	Returns an Observable that concatenate each item emitted by the current Observable with the values in an Iterable corresponding to that item that is generated by a selector.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapMaybe(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper)	Maps the upstream items into MaybeSources and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either this Flowable or the current inner MaybeSource fail.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapMaybe(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, int prefetch)	Maps the upstream items into MaybeSources and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either this Flowable or the current inner MaybeSource fail.
final <@NonNull R> @NonNull Observable<R>	Observable.concatMapMaybe(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper)	Maps the upstream items into MaybeSources and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either the current Observable or the current inner MaybeSource fail.
final <@NonNull R> @NonNull Observable<R>	Observable.concatMapMaybe(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, int bufferSize)	Maps the upstream items into MaybeSources and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either the current Observable or the current inner MaybeSource fail.
final <@NonNull R> @NonNull Maybe<R>	Single.concatMapMaybe(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper)	Returns a Maybe that is based on applying a specified function to the item emitted by the current Single, where that function returns a MaybeSource.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapMaybeDelayError(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper)	Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and delaying all errors till both this Flowable and all inner MaybeSources terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapMaybeDelayError(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, boolean tillTheEnd)	Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both this Flowable and all inner MaybeSources terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapMaybeDelayError(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int prefetch)	Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both this Flowable and all inner MaybeSources terminate.
final <@NonNull R> @NonNull Observable<R>	Observable.concatMapMaybeDelayError(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper)	Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and delaying all errors till both the current Observable and all inner MaybeSources terminate.
final <@NonNull R> @NonNull Observable<R>	Observable.concatMapMaybeDelayError(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, boolean tillTheEnd)	Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both the current Observable and all inner MaybeSources terminate.
final <@NonNull R> @NonNull Observable<R>	Observable.concatMapMaybeDelayError(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int bufferSize)	Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both the current Observable and all inner MaybeSources terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapSingle(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper)	Maps the upstream items into SingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either this Flowable or the current inner SingleSource fail.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapSingle(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, int prefetch)	Maps the upstream items into SingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either this Flowable or the current inner SingleSource fail.
final <@NonNull R> @NonNull Maybe<R>	Maybe.concatMapSingle(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper)	Returns a Maybe based on applying a specified function to the item emitted by the current Maybe, where that function returns a Single.
final <@NonNull R> @NonNull Observable<R>	Observable.concatMapSingle(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper)	Maps the upstream items into SingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either the current Observable or the current inner SingleSource fail.
final <@NonNull R> @NonNull Observable<R>	Observable.concatMapSingle(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, int bufferSize)	Maps the upstream items into SingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either the current Observable or the current inner SingleSource fail.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapSingleDelayError(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper)	Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and delays all errors till both this Flowable and all inner SingleSources terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapSingleDelayError(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, boolean tillTheEnd)	Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays all errors till both this Flowable and all inner SingleSources terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapSingleDelayError(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int prefetch)	Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays errors till both this Flowable and all inner SingleSources terminate.
final <@NonNull R> @NonNull Observable<R>	Observable.concatMapSingleDelayError(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper)	Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and delays all errors till both the current Observable and all inner SingleSources terminate.
final <@NonNull R> @NonNull Observable<R>	Observable.concatMapSingleDelayError(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, boolean tillTheEnd)	Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays all errors till both the current Observable and all inner SingleSources terminate.
final <@NonNull R> @NonNull Observable<R>	Observable.concatMapSingleDelayError(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int bufferSize)	Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays errors till both the current Observable and all inner SingleSources terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapStream(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper)	Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapStream(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper, int prefetch)	Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion.
final <@NonNull R> @NonNull Observable<R>	Observable.concatMapStream(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper)	Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion.
final <@NonNull U> @NonNull Flowable<T>	Flowable.debounce(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull U>> debounceIndicator)	Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the current Flowable that are followed by another item within a computed debounce duration.
final <@NonNull U> @NonNull Observable<T>	Observable.debounce(@NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull U>> debounceIndicator)	Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by another item within a computed debounce duration denoted by an item emission or completion from a generated inner ObservableSource for that original item.
final <@NonNull U> @NonNull Flowable<T>	Flowable.delay(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull U>> itemDelayIndicator)	Returns a Flowable that delays the emissions of the current Flowable via another Publisher on a per-item basis.
final <@NonNull U, @NonNull V> @NonNull Flowable<T>	Flowable.delay(@NonNull org.reactivestreams.Publisher<@NonNull U> subscriptionIndicator, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemDelayIndicator)	Returns a Flowable that delays the subscription to and emissions from the current Flowable via another Publisher on a per-item basis.
final <@NonNull U, @NonNull V> @NonNull Observable<T>	Observable.delay(@NonNull ObservableSource<@NonNull U> subscriptionIndicator, @NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull V>> itemDelayIndicator)	Returns an Observable that delays the subscription to and emissions from the current Observable via ObservableSources for the subscription itself and on a per-item basis.
final <@NonNull U> @NonNull Observable<T>	Observable.delay(@NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull U>> itemDelayIndicator)	Returns an Observable that delays the emissions of the current Observable via a per-item derived ObservableSource's item emission or termination, on a per source item basis.
final <@NonNull R> @NonNull Flowable<R>	Flowable.dematerialize(@NonNull Function<@NonNull ? super @NonNull T, @NonNull Notification<@NonNull R>> selector)	Returns a Flowable that reverses the effect of materialize by transforming the Notification objects extracted from the source items via a selector function into their respective Subscriber signal types.
final <@NonNull R> @NonNull Maybe<R>	Maybe.dematerialize(@NonNull Function<? super @NonNull T, @NonNull Notification<@NonNull R>> selector)	Maps the Notification success value of the current Maybe back into normal onSuccess, onError or onComplete signals.
final <@NonNull R> @NonNull Observable<R>	Observable.dematerialize(@NonNull Function<? super @NonNull T, Notification<@NonNull R>> selector)	Returns an Observable that reverses the effect of materialize by transforming the Notification objects extracted from the source items via a selector function into their respective Observer signal types.
final <@NonNull R> @NonNull Maybe<R>	Single.dematerialize(@NonNull Function<? super @NonNull T, @NonNull Notification<@NonNull R>> selector)	Maps the Notification success value of the current Single back into normal onSuccess, onError or onComplete signals as a Maybe source.
final <@NonNull K> @NonNull Flowable<T>	Flowable.distinct(@NonNull Function<? super @NonNull T, @NonNull K> keySelector)	Returns a Flowable that emits all items emitted by the current Flowable that are distinct according to a key selector function and based on Object.equals(Object) comparison of the objects returned by the key selector function.
final <@NonNull K> @NonNull Flowable<T>	Flowable.distinct(@NonNull Function<? super @NonNull T, @NonNull K> keySelector, @NonNull Supplier<? extends Collection<? super @NonNull K>> collectionSupplier)	Returns a Flowable that emits all items emitted by the current Flowable that are distinct according to a key selector function and based on Object.equals(Object) comparison of the objects returned by the key selector function.
final <@NonNull K> @NonNull Observable<T>	Observable.distinct(@NonNull Function<? super @NonNull T, @NonNull K> keySelector)	Returns an Observable that emits all items emitted by the current Observable that are distinct according to a key selector function and based on Object.equals(Object) comparison of the objects returned by the key selector function.
final <@NonNull K> @NonNull Observable<T>	Observable.distinct(@NonNull Function<? super @NonNull T, @NonNull K> keySelector, @NonNull Supplier<? extends Collection<? super @NonNull K>> collectionSupplier)	Returns an Observable that emits all items emitted by the current Observable that are distinct according to a key selector function and based on Object.equals(Object) comparison of the objects returned by the key selector function.
final <@NonNull K> @NonNull Flowable<T>	Flowable.distinctUntilChanged(@NonNull Function<? super @NonNull T, @NonNull K> keySelector)	Returns a Flowable that emits all items emitted by the current Flowable that are distinct from their immediate predecessors, according to a key selector function and based on Object.equals(Object) comparison of those objects returned by the key selector function.
final <@NonNull K> @NonNull Observable<T>	Observable.distinctUntilChanged(@NonNull Function<? super @NonNull T, @NonNull K> keySelector)	Returns an Observable that emits all items emitted by the current Observable that are distinct from their immediate predecessors, according to a key selector function and based on Object.equals(Object) comparison of those objects returned by the key selector function.
final <@NonNull R> @NonNull Flowable<R>	Flowable.flatMap(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper)	Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the current Flowable, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger.
final <@NonNull R> @NonNull Flowable<R>	Flowable.flatMap(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayErrors)	Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the current Flowable, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger.
final <@NonNull R> @NonNull Flowable<R>	Flowable.flatMap(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency)	Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the current Flowable, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these Publishers.
final <@NonNull R> @NonNull Flowable<R>	Flowable.flatMap(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize)	Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the current Flowable, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these Publishers.
final <@NonNull R> @NonNull Flowable<R>	Flowable.flatMap(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int maxConcurrency)	Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the current Flowable, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these Publishers.
final <@NonNull R> @NonNull Flowable<R>	Flowable.flatMap(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> onNextMapper, @NonNull Function<? super Throwable, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends org.reactivestreams.Publisher<? extends @NonNull R>> onCompleteSupplier)	Returns a Flowable that applies a function to each item emitted or notification raised by the current Flowable and then flattens the Publishers returned from these functions and emits the resulting items.
final <@NonNull R> @NonNull Flowable<R>	Flowable.flatMap(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> onNextMapper, @NonNull Function<Throwable, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends org.reactivestreams.Publisher<? extends @NonNull R>> onCompleteSupplier, int maxConcurrency)	Returns a Flowable that applies a function to each item emitted or notification raised by the current Flowable and then flattens the Publishers returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to these Publishers.
final <@NonNull U, @NonNull R> @NonNull Flowable<R>	Flowable.flatMap(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner)	Returns a Flowable that emits the results of a specified function to the pair of values emitted by the current Flowable and a specified collection Publisher.
final <@NonNull U, @NonNull R> @NonNull Flowable<R>	Flowable.flatMap(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, boolean delayErrors)	Returns a Flowable that emits the results of a specified function to the pair of values emitted by the current Flowable and a specified inner Publisher.
final <@NonNull U, @NonNull R> @NonNull Flowable<R>	Flowable.flatMap(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, boolean delayErrors, int maxConcurrency)	Returns a Flowable that emits the results of a specified function to the pair of values emitted by the current Flowable and a specified collection Publisher, while limiting the maximum number of concurrent subscriptions to these Publishers.
final <@NonNull U, @NonNull R> @NonNull Flowable<R>	Flowable.flatMap(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, boolean delayErrors, int maxConcurrency, int bufferSize)	Returns a Flowable that emits the results of a specified function to the pair of values emitted by the current Flowable and a specified collection Publisher, while limiting the maximum number of concurrent subscriptions to these Publishers.
final <@NonNull U, @NonNull R> @NonNull Flowable<R>	Flowable.flatMap(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, int maxConcurrency)	Returns a Flowable that emits the results of a specified function to the pair of values emitted by the current Flowable and a specified collection Publisher, while limiting the maximum number of concurrent subscriptions to these Publishers.
final <@NonNull R> @NonNull Maybe<R>	Maybe.flatMap(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper)	Returns a Maybe that is based on applying a specified function to the item emitted by the current Maybe, where that function returns a MaybeSource.
final <@NonNull R> @NonNull Maybe<R>	Maybe.flatMap(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> onSuccessMapper, @NonNull Function<? super Throwable, ? extends MaybeSource<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends MaybeSource<? extends @NonNull R>> onCompleteSupplier)	Maps the onSuccess, onError or onComplete signals of the current Maybe into a MaybeSource and emits that MaybeSource's signals.
final <@NonNull U, @NonNull R> @NonNull Maybe<R>	Maybe.flatMap(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner)	Returns a Maybe that emits the results of a specified function to the pair of values emitted by the current Maybe and a specified mapped MaybeSource.
final <@NonNull R> @NonNull Observable<R>	Observable.flatMap(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper)	Returns an Observable that emits items based on applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then merging those returned ObservableSources and emitting the results of this merger.
final <@NonNull R> @NonNull Observable<R>	Observable.flatMap(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, boolean delayErrors)	Returns an Observable that emits items based on applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then merging those returned ObservableSources and emitting the results of this merger.
final <@NonNull R> @NonNull Observable<R>	Observable.flatMap(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency)	Returns an Observable that emits items based on applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then merging those returned ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
final <@NonNull R> @NonNull Observable<R>	Observable.flatMap(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize)	Returns an Observable that emits items based on applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then merging those returned ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
final <@NonNull R> @NonNull Observable<R>	Observable.flatMap(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, int maxConcurrency)	Returns an Observable that emits items based on applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then merging those returned ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
final <@NonNull R> @NonNull Observable<R>	Observable.flatMap(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> onNextMapper, @NonNull Function<? super Throwable, ? extends ObservableSource<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends ObservableSource<? extends @NonNull R>> onCompleteSupplier)	Returns an Observable that applies a function to each item emitted or notification raised by the current Observable and then flattens the ObservableSources returned from these functions and emits the resulting items.
final <@NonNull R> @NonNull Observable<R>	Observable.flatMap(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> onNextMapper, @NonNull Function<Throwable, ? extends ObservableSource<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends ObservableSource<? extends @NonNull R>> onCompleteSupplier, int maxConcurrency)	Returns an Observable that applies a function to each item emitted or notification raised by the current Observable and then flattens the ObservableSources returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
final <@NonNull U, @NonNull R> @NonNull Observable<R>	Observable.flatMap(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner)	Returns an Observable that emits the results of a specified function to the pair of values emitted by the current Observable and the mapped inner ObservableSource.
final <@NonNull U, @NonNull R> @NonNull Observable<R>	Observable.flatMap(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, boolean delayErrors)	Returns an Observable that emits the results of a specified function to the pair of values emitted by the current Observable and the mapped inner ObservableSource.
final <@NonNull U, @NonNull R> @NonNull Observable<R>	Observable.flatMap(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, boolean delayErrors, int maxConcurrency)	Returns an Observable that emits the results of a specified function to the pair of values emitted by the current Observable and the mapped inner ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
final <@NonNull U, @NonNull R> @NonNull Observable<R>	Observable.flatMap(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, boolean delayErrors, int maxConcurrency, int bufferSize)	Returns an Observable that emits the results of a specified function to the pair of values emitted by the current Observable and the mapped inner ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
final <@NonNull U, @NonNull R> @NonNull Observable<R>	Observable.flatMap(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, int maxConcurrency)	Returns an Observable that emits the results of a specified function to the pair of values emitted by the current Observable and the mapped inner ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
final <@NonNull R> @NonNull Single<R>	Single.flatMap(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper)	Returns a Single that is based on applying a specified function to the item emitted by the current Single, where that function returns a SingleSource.
final <@NonNull R> @NonNull Single<R>	Single.flatMap(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> onSuccessMapper, @NonNull Function<? super Throwable, ? extends SingleSource<? extends @NonNull R>> onErrorMapper)	Maps the onSuccess or onError signals of the current Single into a SingleSource and emits that SingleSource's signals.
final <@NonNull U, @NonNull R> @NonNull Single<R>	Single.flatMap(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner)	Returns a Single that emits the results of a specified function to the pair of values emitted by the current Single and a specified mapped SingleSource.
final @NonNull Completable	Flowable.flatMapCompletable(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper)	Maps each element of the upstream Flowable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete.
final @NonNull Completable	Flowable.flatMapCompletable(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean delayErrors, int maxConcurrency)	Maps each element of the upstream Flowable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete, optionally delaying all errors.
final @NonNull Completable	Maybe.flatMapCompletable(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper)	Returns a Completable that completes based on applying a specified function to the item emitted by the current Maybe, where that function returns a Completable.
final @NonNull Completable	Observable.flatMapCompletable(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper)	Maps each element of the current Observable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete.
final @NonNull Completable	Observable.flatMapCompletable(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean delayErrors)	Maps each element of the current Observable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete, optionally delaying all errors.
final @NonNull Completable	Single.flatMapCompletable(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper)	Returns a Completable that completes based on applying a specified function to the item emitted by the current Single, where that function returns a CompletableSource.
final <@NonNull U> @NonNull Flowable<U>	Flowable.flatMapIterable(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper)	Merges Iterables generated by a mapper Function for each individual item emitted by the current Flowable into a single Flowable sequence.
final <@NonNull U> @NonNull Flowable<U>	Flowable.flatMapIterable(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper, int bufferSize)	Merges Iterables generated by a mapper Function for each individual item emitted by the current Flowable into a single Flowable sequence.
final <@NonNull U, @NonNull V> @NonNull Flowable<V>	Flowable.flatMapIterable(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull V> combiner)	Merges Iterables generated by a mapper Function for each individual item emitted by the current Flowable into a single Flowable sequence where the resulting items will be the combination of the original item and each inner item of the respective Iterable as returned by the resultSelector BiFunction.
final <@NonNull U, @NonNull V> @NonNull Flowable<V>	Flowable.flatMapIterable(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull V> combiner, int prefetch)	Merges Iterables generated by a mapper Function for each individual item emitted by the current Flowable into a single Flowable sequence where the resulting items will be the combination of the original item and each inner item of the respective Iterable as returned by the resultSelector BiFunction.
final <@NonNull U> @NonNull Observable<U>	Observable.flatMapIterable(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper)	Merges Iterables generated by a mapper Function for each individual item emitted by the current Observable into a single Observable sequence.
final <@NonNull U, @NonNull V> @NonNull Observable<V>	Observable.flatMapIterable(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull V> combiner)	Merges Iterables generated by a mapper Function for each individual item emitted by the current Observable into a single Observable sequence where the resulting items will be the combination of the original item and each inner item of the respective Iterable as returned by the resultSelector BiFunction.
final <@NonNull R> @NonNull Flowable<R>	Flowable.flatMapMaybe(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper)	Maps each element of the upstream Flowable into MaybeSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Flowable sequence.
final <@NonNull R> @NonNull Flowable<R>	Flowable.flatMapMaybe(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency)	Maps each element of the upstream Flowable into MaybeSources, subscribes to at most maxConcurrency MaybeSources at a time and merges their onSuccess values, in no particular order, into a single Flowable sequence, optionally delaying all errors.
final <@NonNull R> @NonNull Observable<R>	Observable.flatMapMaybe(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper)	Maps each element of the current Observable into MaybeSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Observable sequence.
final <@NonNull R> @NonNull Observable<R>	Observable.flatMapMaybe(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, boolean delayErrors)	Maps each element of the current Observable into MaybeSources, subscribes to them and merges their onSuccess values, in no particular order, into a single Observable sequence, optionally delaying all errors.
final <@NonNull R> @NonNull Maybe<R>	Single.flatMapMaybe(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper)	Returns a Maybe that is based on applying a specified function to the item emitted by the current Single, where that function returns a MaybeSource.
final <@NonNull R> @NonNull Observable<R>	Maybe.flatMapObservable(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper)	Returns an Observable that is based on applying a specified function to the item emitted by the current Maybe, where that function returns an ObservableSource.
final <@NonNull R> @NonNull Observable<R>	Single.flatMapObservable(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper)	Returns an Observable that is based on applying a specified function to the item emitted by the current Single, where that function returns an ObservableSource.
final <@NonNull R> @NonNull Flowable<R>	Maybe.flatMapPublisher(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper)	Returns a Flowable that emits items based on applying a specified function to the item emitted by the current Maybe, where that function returns a Publisher.
final <@NonNull R> @NonNull Flowable<R>	Single.flatMapPublisher(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper)	Returns a Flowable that emits items based on applying a specified function to the item emitted by the current Single, where that function returns a Publisher.
final <@NonNull R> @NonNull Flowable<R>	Flowable.flatMapSingle(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper)	Maps each element of the upstream Flowable into SingleSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Flowable sequence.
final <@NonNull R> @NonNull Flowable<R>	Flowable.flatMapSingle(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency)	Maps each element of the upstream Flowable into SingleSources, subscribes to at most maxConcurrency SingleSources at a time and merges their onSuccess values, in no particular order, into a single Flowable sequence, optionally delaying all errors.
final <@NonNull R> @NonNull Maybe<R>	Maybe.flatMapSingle(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper)	Returns a Maybe based on applying a specified function to the item emitted by the current Maybe, where that function returns a Single.
final <@NonNull R> @NonNull Observable<R>	Observable.flatMapSingle(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper)	Maps each element of the current Observable into SingleSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Observable sequence.
final <@NonNull R> @NonNull Observable<R>	Observable.flatMapSingle(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, boolean delayErrors)	Maps each element of the current Observable into SingleSources, subscribes to them and merges their onSuccess values, in no particular order, into a single Observable sequence, optionally delaying all errors.
final <@NonNull R> @NonNull Flowable<R>	Flowable.flatMapStream(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper)	Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion.
final <@NonNull R> @NonNull Flowable<R>	Flowable.flatMapStream(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper, int prefetch)	Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion.
final <@NonNull R> @NonNull Observable<R>	Observable.flatMapStream(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper)	Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion.
final <@NonNull U> @NonNull Flowable<U>	Maybe.flattenAsFlowable(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper)	Maps the success value of the current Maybe into an Iterable and emits its items as a Flowable sequence.
final <@NonNull U> @NonNull Flowable<U>	Single.flattenAsFlowable(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper)	Maps the success value of the current Single into an Iterable and emits its items as a Flowable sequence.
final <@NonNull U> @NonNull Observable<U>	Maybe.flattenAsObservable(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper)	Maps the success value of the current Maybe into an Iterable and emits its items as an Observable sequence.
final <@NonNull U> @NonNull Observable<U>	Single.flattenAsObservable(@NonNull Function<@NonNull ? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper)	Maps the success value of the current Single into an Iterable and emits its items as an Observable sequence.
final <@NonNull R> @NonNull Flowable<R>	Maybe.flattenStreamAsFlowable(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper)	Maps the upstream succecss value into a Java Stream and emits its items to the downstream consumer as a Flowable.
final <@NonNull R> @NonNull Flowable<R>	Single.flattenStreamAsFlowable(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper)	Maps the upstream succecss value into a Java Stream and emits its items to the downstream consumer as a Flowable.
final <@NonNull R> @NonNull Observable<R>	Maybe.flattenStreamAsObservable(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper)	Maps the upstream succecss value into a Java Stream and emits its items to the downstream consumer as an Observable.
final <@NonNull R> @NonNull Observable<R>	Single.flattenStreamAsObservable(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper)	Maps the upstream succecss value into a Java Stream and emits its items to the downstream consumer as an Observable.
final <@NonNull K> @NonNull Flowable<GroupedFlowable<K,T>>	Flowable.groupBy(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector)	Groups the items emitted by the current Flowable according to a specified criterion, and emits these grouped items as GroupedFlowables.
final <@NonNull K> @NonNull Flowable<GroupedFlowable<K,T>>	Flowable.groupBy(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, boolean delayError)	Groups the items emitted by the current Flowable according to a specified criterion, and emits these grouped items as GroupedFlowables.
final <@NonNull K, @NonNull V> @NonNull Flowable<GroupedFlowable<K,V>>	Flowable.groupBy(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector)	Groups the items emitted by the current Flowable according to a specified criterion, and emits these grouped items as GroupedFlowables.
final <@NonNull K, @NonNull V> @NonNull Flowable<GroupedFlowable<K,V>>	Flowable.groupBy(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, boolean delayError)	Groups the items emitted by the current Flowable according to a specified criterion, and emits these grouped items as GroupedFlowables.
final <@NonNull K, @NonNull V> @NonNull Flowable<GroupedFlowable<K,V>>	Flowable.groupBy(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, boolean delayError, int bufferSize)	Groups the items emitted by the current Flowable according to a specified criterion, and emits these grouped items as GroupedFlowables.
final <@NonNull K, @NonNull V> @NonNull Flowable<GroupedFlowable<K,V>>	Flowable.groupBy(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, boolean delayError, int bufferSize, @NonNull Function<? super Consumer<Object>, ? extends Map<@NonNull K, Object>> evictingMapFactory)	Groups the items emitted by the current Flowable according to a specified criterion, and emits these grouped items as GroupedFlowables.
final <@NonNull K> @NonNull Observable<GroupedObservable<K,T>>	Observable.groupBy(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector)	Groups the items emitted by the current Observable according to a specified criterion, and emits these grouped items as GroupedObservables.
final <@NonNull K> @NonNull Observable<GroupedObservable<K,T>>	Observable.groupBy(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, boolean delayError)	Groups the items emitted by the current Observable according to a specified criterion, and emits these grouped items as GroupedObservables.
final <@NonNull K, @NonNull V> @NonNull Observable<GroupedObservable<K,V>>	Observable.groupBy(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, boolean delayError)	Groups the items emitted by the current Observable according to a specified criterion, and emits these grouped items as GroupedObservables.
final <@NonNull K, @NonNull V> @NonNull Observable<GroupedObservable<K,V>>	Observable.groupBy(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, boolean delayError, int bufferSize)	Groups the items emitted by the current Observable according to a specified criterion, and emits these grouped items as GroupedObservables.
final <@NonNull K, @NonNull V> @NonNull Observable<GroupedObservable<K,V>>	Observable.groupBy(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, Function<? super @NonNull T, ? extends @NonNull V> valueSelector)	Groups the items emitted by the current Observable according to a specified criterion, and emits these grouped items as GroupedObservables.
final <@NonNull TRight, @NonNull TLeftEnd, @NonNull TRightEnd, @NonNull R> @NonNull Flowable<R>	Flowable.groupJoin(@NonNull org.reactivestreams.Publisher<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight, @NonNull ? extends org.reactivestreams.Publisher<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T, ? super Flowable<@NonNull TRight>, ? extends @NonNull R> resultSelector)	Returns a Flowable that correlates two Publishers when they overlap in time and groups the results.
final <@NonNull TRight, @NonNull TLeftEnd, @NonNull TRightEnd, @NonNull R> @NonNull Observable<R>	Observable.groupJoin(@NonNull ObservableSource<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight, ? extends ObservableSource<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T, ? super Observable<@NonNull TRight>, ? extends @NonNull R> resultSelector)	Returns an Observable that correlates two ObservableSources when they overlap in time and groups the results.
final <@NonNull TRight, @NonNull TLeftEnd, @NonNull TRightEnd, @NonNull R> @NonNull Flowable<R>	Flowable.join(@NonNull org.reactivestreams.Publisher<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight, @NonNull ? extends org.reactivestreams.Publisher<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T, ? super @NonNull TRight, ? extends @NonNull R> resultSelector)	Correlates the items emitted by two Publishers based on overlapping durations.
final <@NonNull TRight, @NonNull TLeftEnd, @NonNull TRightEnd, @NonNull R> @NonNull Observable<R>	Observable.join(@NonNull ObservableSource<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight, ? extends ObservableSource<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T, ? super @NonNull TRight, ? extends @NonNull R> resultSelector)	Correlates the items emitted by two ObservableSources based on overlapping durations.
final <@NonNull R> @NonNull Flowable<R>	Flowable.map(@NonNull Function<? super @NonNull T, ? extends @NonNull R> mapper)	Returns a Flowable that applies a specified function to each item emitted by the current Flowable and emits the results of these function applications.
final <@NonNull R> @NonNull Maybe<R>	Maybe.map(@NonNull Function<? super @NonNull T, ? extends @NonNull R> mapper)	Returns a Maybe that applies a specified function to the item emitted by the current Maybe and emits the result of this function application.
final <@NonNull R> @NonNull Observable<R>	Observable.map(@NonNull Function<? super @NonNull T, ? extends @NonNull R> mapper)	Returns an Observable that applies a specified function to each item emitted by the current Observable and emits the results of these function applications.
final <@NonNull R> @NonNull Single<R>	Single.map(@NonNull Function<? super @NonNull T, ? extends @NonNull R> mapper)	Returns a Single that applies a specified function to the item emitted by the current Single and emits the result of this function application.
final <@NonNull R> @NonNull Flowable<R>	Flowable.mapOptional(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper)	Maps each upstream value into an Optional and emits the contained item if not empty.
final <@NonNull R> @NonNull Maybe<R>	Maybe.mapOptional(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper)	Maps the upstream success value into an Optional and emits the contained item if not empty.
final <@NonNull R> @NonNull Observable<R>	Observable.mapOptional(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper)	Maps each upstream value into an Optional and emits the contained item if not empty.
final <@NonNull R> @NonNull Maybe<R>	Single.mapOptional(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper)	Maps the upstream success value into an Optional and emits the contained item if not empty as a Maybe.
final @NonNull Completable	Completable.onErrorResumeNext(@NonNull Function<? super Throwable, ? extends CompletableSource> fallbackSupplier)	Returns a Completable instance that when encounters an error from this Completable, calls the specified mapper Function that returns a CompletableSource instance for it and resumes the execution with it.
final @NonNull Flowable<T>	Flowable.onErrorResumeNext(@NonNull Function<? super Throwable, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> fallbackSupplier)	Resumes the flow with a Publisher returned for the failure Throwable of the current Flowable by a function instead of signaling the error via onError.
final @NonNull Maybe<T>	Maybe.onErrorResumeNext(@NonNull Function<? super Throwable, ? extends MaybeSource<? extends @NonNull T>> fallbackSupplier)	Resumes the flow with a MaybeSource returned for the failure Throwable of the current Maybe by a function instead of signaling the error via onError.
final @NonNull Observable<T>	Observable.onErrorResumeNext(@NonNull Function<? super Throwable, ? extends ObservableSource<? extends @NonNull T>> fallbackSupplier)	Resumes the flow with an ObservableSource returned for the failure Throwable of the current Observable by a function instead of signaling the error via onError.
final @NonNull Single<T>	Single.onErrorResumeNext(@NonNull Function<? super Throwable, ? extends SingleSource<? extends @NonNull T>> fallbackSupplier)	Resumes the flow with a SingleSource returned for the failure Throwable of the current Single by a function instead of signaling the error via onError.
final <@NonNull T> @NonNull Maybe<T>	Completable.onErrorReturn(@NonNull Function<? super Throwable, ? extends @NonNull T> itemSupplier)	Ends the flow with a success item returned by a function for the Throwable error signaled by the current Completable instead of signaling the error via onError.
final @NonNull Flowable<T>	Flowable.onErrorReturn(@NonNull Function<? super Throwable, ? extends @NonNull T> itemSupplier)	Ends the flow with a last item returned by a function for the Throwable error signaled by the current Flowable instead of signaling the error via onError.
final @NonNull Maybe<T>	Maybe.onErrorReturn(@NonNull Function<? super Throwable, ? extends @NonNull T> itemSupplier)	Ends the flow with a success item returned by a function for the Throwable error signaled by the current Maybe instead of signaling the error via onError.
final @NonNull Observable<T>	Observable.onErrorReturn(@NonNull Function<? super Throwable, ? extends @NonNull T> itemSupplier)	Ends the flow with a last item returned by a function for the Throwable error signaled by the current Observable instead of signaling the error via onError.
final @NonNull Single<T>	Single.onErrorReturn(@NonNull Function<Throwable, ? extends @NonNull T> itemSupplier)	Ends the flow with a success item returned by a function for the Throwable error signaled by the current Single instead of signaling the error via onError.
final <@NonNull R> @NonNull Flowable<R>	Flowable.publish(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> selector, int prefetch)	Returns a Flowable that emits the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the underlying sequence.
final <@NonNull R> @NonNull Flowable<R>	Flowable.publish(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector)	Returns a Flowable that emits the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the underlying sequence.
final <@NonNull R> @NonNull Observable<R>	Observable.publish(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector)	Returns an Observable that emits the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable sequence.
final @NonNull Completable	Completable.repeatWhen(@NonNull Function<? super Flowable<Object>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler)	Returns a Completable instance that repeats when the Publisher returned by the handler Function emits an item or completes when this Publisher emits an onComplete event.
final @NonNull Flowable<T>	Flowable.repeatWhen(@NonNull Function<? super Flowable<Object>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler)	Returns a Flowable that emits the same values as the current Flowable with the exception of an onComplete.
final @NonNull Flowable<T>	Maybe.repeatWhen(@NonNull Function<? super Flowable<Object>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler)	Returns a Flowable that emits the same values as the current Maybe with the exception of an onComplete.
final @NonNull Observable<T>	Observable.repeatWhen(@NonNull Function<? super Observable<Object>, ? extends ObservableSource<?>> handler)	Returns an Observable that emits the same values as the current Observable with the exception of an onComplete.
final @NonNull Flowable<T>	Single.repeatWhen(@NonNull Function<? super Flowable<Object>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler)	Re-subscribes to the current Single if the Publisher returned by the handler function signals a value in response to a value signaled through the Flowable the handler receives.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector)	Returns a Flowable that emits items that are the results of invoking a specified selector on the items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying bufferSize notifications.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, boolean eagerTruncate)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying bufferSize notifications.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying no more than bufferSize items that were emitted within a specified time window.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying no more than bufferSize items that were emitted within a specified time window.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying no more than bufferSize items that were emitted within a specified time window.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, long time, @NonNull TimeUnit unit)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying all items that were emitted within a specified time window.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying all items that were emitted within a specified time window.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying all items that were emitted within a specified time window.
final <@NonNull R> @NonNull Observable<R>	Observable.replay(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector)	Returns an Observable that emits items that are the results of invoking a specified selector on the items emitted by a ConnectableObservable that shares a single subscription to the current Observable.
final <@NonNull R> @NonNull Observable<R>	Observable.replay(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, int bufferSize)	Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying bufferSize notifications.
final <@NonNull R> @NonNull Observable<R>	Observable.replay(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, int bufferSize, boolean eagerTruncate)	Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying bufferSize notifications.
final <@NonNull R> @NonNull Observable<R>	Observable.replay(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit)	Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying no more than bufferSize items that were emitted within a specified time window.
final <@NonNull R> @NonNull Observable<R>	Observable.replay(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying no more than bufferSize items that were emitted within a specified time window.
final <@NonNull R> @NonNull Observable<R>	Observable.replay(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate)	Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying no more than bufferSize items that were emitted within a specified time window.
final <@NonNull R> @NonNull Observable<R>	Observable.replay(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, long time, @NonNull TimeUnit unit)	Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying all items that were emitted within a specified time window.
final <@NonNull R> @NonNull Observable<R>	Observable.replay(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying all items that were emitted within a specified time window.
final <@NonNull R> @NonNull Observable<R>	Observable.replay(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate)	Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying all items that were emitted within a specified time window.
final @NonNull Completable	Completable.retryWhen(@NonNull Function<? super Flowable<Throwable>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler)	Returns a Completable which given a Publisher and when this Completable emits an error, delivers that error through a Flowable and the Publisher should signal a value indicating a retry in response or a terminal event indicating a termination.
final @NonNull Flowable<T>	Flowable.retryWhen(@NonNull Function<? super Flowable<Throwable>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler)	Returns a Flowable that emits the same values as the current Flowable with the exception of an onError.
final @NonNull Maybe<T>	Maybe.retryWhen(@NonNull Function<? super Flowable<Throwable>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler)	Returns a Maybe that emits the same values as the current Maybe with the exception of an onError.
final @NonNull Observable<T>	Observable.retryWhen(@NonNull Function<? super Observable<Throwable>, ? extends ObservableSource<?>> handler)	Returns an Observable that emits the same values as the current Observable with the exception of an onError.
final @NonNull Single<T>	Single.retryWhen(@NonNull Function<? super Flowable<Throwable>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler)	Re-subscribes to the current Single if and when the Publisher returned by the handler function signals a value.
final <@NonNull R> @NonNull Flowable<R>	Flowable.switchMap(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper)	Returns a new Flowable by applying a function that you supply to each item emitted by the current Flowable that returns a Publisher, and then emitting the items emitted by the most recently emitted of these Publishers.
final <@NonNull R> @NonNull Flowable<R>	Flowable.switchMap(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int bufferSize)	Returns a new Flowable by applying a function that you supply to each item emitted by the current Flowable that returns a Publisher, and then emitting the items emitted by the most recently emitted of these Publishers.
final <@NonNull R> @NonNull Observable<R>	Observable.switchMap(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper)	Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources.
final <@NonNull R> @NonNull Observable<R>	Observable.switchMap(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, int bufferSize)	Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources.
(package private) <R> Flowable<R>	Flowable.switchMap0(Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends R>> mapper, int bufferSize, boolean delayError)
final @NonNull Completable	Flowable.switchMapCompletable(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper)	Maps the upstream values into CompletableSources, subscribes to the newer one while disposing the subscription to the previous CompletableSource, thus keeping at most one active CompletableSource running.
final @NonNull Completable	Observable.switchMapCompletable(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper)	Maps the items of the current Observable into CompletableSources, subscribes to the newer one while disposing the subscription to the previous CompletableSource, thus keeping at most one active CompletableSource running.
final @NonNull Completable	Flowable.switchMapCompletableDelayError(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper)	Maps the upstream values into CompletableSources, subscribes to the newer one while disposing the subscription to the previous CompletableSource, thus keeping at most one active CompletableSource running and delaying any main or inner errors until all of them terminate.
final @NonNull Completable	Observable.switchMapCompletableDelayError(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper)	Maps the upstream values into CompletableSources, subscribes to the newer one while disposing the subscription to the previous CompletableSource, thus keeping at most one active CompletableSource running and delaying any main or inner errors until all of them terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.switchMapDelayError(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper)	Returns a new Flowable by applying a function that you supply to each item emitted by the current Flowable that returns a Publisher, and then emitting the items emitted by the most recently emitted of these Publishers and delays any error until all Publishers terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.switchMapDelayError(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int bufferSize)	Returns a new Flowable by applying a function that you supply to each item emitted by the current Flowable that returns a Publisher, and then emitting the items emitted by the most recently emitted of these Publishers and delays any error until all Publishers terminate.
final <@NonNull R> @NonNull Observable<R>	Observable.switchMapDelayError(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper)	Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources and delays any error until all ObservableSources terminate.
final <@NonNull R> @NonNull Observable<R>	Observable.switchMapDelayError(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, int bufferSize)	Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources and delays any error until all ObservableSources terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.switchMapMaybe(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper)	Maps the upstream items into MaybeSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available while failing immediately if this Flowable or any of the active inner MaybeSources fail.
final <@NonNull R> @NonNull Observable<R>	Observable.switchMapMaybe(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper)	Maps the items of the current Observable into MaybeSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available while failing immediately if the current Observable or any of the active inner MaybeSources fail.
final <@NonNull R> @NonNull Flowable<R>	Flowable.switchMapMaybeDelayError(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper)	Maps the upstream items into MaybeSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available, delaying errors from this Flowable or the inner MaybeSources until all terminate.
final <@NonNull R> @NonNull Observable<R>	Observable.switchMapMaybeDelayError(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper)	Maps the upstream items into MaybeSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available, delaying errors from the current Observable or the inner MaybeSources until all terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.switchMapSingle(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper)	Maps the upstream items into SingleSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one while failing immediately if this Flowable or any of the active inner SingleSources fail.
final <@NonNull R> @NonNull Observable<R>	Observable.switchMapSingle(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper)	Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns a SingleSource, and then emitting the item emitted by the most recently emitted of these SingleSources.
final <@NonNull R> @NonNull Flowable<R>	Flowable.switchMapSingleDelayError(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper)	Maps the upstream items into SingleSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one, delaying errors from this Flowable or the inner SingleSources until all terminate.
final <@NonNull R> @NonNull Observable<R>	Observable.switchMapSingleDelayError(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper)	Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns a SingleSource, and then emitting the item emitted by the most recently emitted of these SingleSources and delays any error until all SingleSources terminate.
final <@NonNull V> @NonNull Flowable<T>	Flowable.timeout(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemTimeoutIndicator)	Returns a Flowable that mirrors the current Flowable, but notifies Subscribers of a TimeoutException if an item emitted by the current Flowable doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by a Publisher that is a function of the previous item.
final <@NonNull V> @NonNull Flowable<T>	Flowable.timeout(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemTimeoutIndicator, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback)	Returns a Flowable that mirrors the current Flowable, but that switches to a fallback Publisher if an item emitted by the current Flowable doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by a Publisher that is a function of the previous item.
final <@NonNull U, @NonNull V> @NonNull Flowable<T>	Flowable.timeout(@NonNull org.reactivestreams.Publisher<@NonNull U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemTimeoutIndicator)	Returns a Flowable that mirrors the current Flowable, but notifies Subscribers of a TimeoutException if either the first item emitted by the current Flowable or any subsequent item doesn't arrive within time windows defined by other Publishers.
final <@NonNull U, @NonNull V> @NonNull Flowable<T>	Flowable.timeout(@NonNull org.reactivestreams.Publisher<@NonNull U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemTimeoutIndicator, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback)	Returns a Flowable that mirrors the current Flowable, but switches to a fallback Publisher if either the first item emitted by the current Flowable or any subsequent item doesn't arrive within time windows defined by other Publishers.
final <@NonNull U, @NonNull V> @NonNull Observable<T>	Observable.timeout(@NonNull ObservableSource<@NonNull U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull V>> itemTimeoutIndicator)	Returns an Observable that mirrors the current Observable, but notifies observers of a TimeoutException if either the first item emitted by the current Observable or any subsequent item doesn't arrive within time windows defined by indicator ObservableSources.
final <@NonNull U, @NonNull V> @NonNull Observable<T>	Observable.timeout(@NonNull ObservableSource<@NonNull U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull V>> itemTimeoutIndicator, @NonNull ObservableSource<? extends @NonNull T> fallback)	Returns an Observable that mirrors the current Observable, but switches to a fallback ObservableSource if either the first item emitted by the current Observable or any subsequent item doesn't arrive within time windows defined by indicator ObservableSources.
final <@NonNull V> @NonNull Observable<T>	Observable.timeout(@NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull V>> itemTimeoutIndicator)	Returns an Observable that mirrors the current Observable, but notifies observers of a TimeoutException if an item emitted by the current Observable doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by an ObservableSource that is a function of the previous item.
final <@NonNull V> @NonNull Observable<T>	Observable.timeout(@NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull V>> itemTimeoutIndicator, @NonNull ObservableSource<? extends @NonNull T> fallback)	Returns an Observable that mirrors the current Observable, but that switches to a fallback ObservableSource if an item emitted by the current Observable doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by an ObservableSource that is a function of the previous item.
private <@NonNull U, @NonNull V> Flowable<T>	Flowable.timeout0(org.reactivestreams.Publisher<@NonNull U> firstTimeoutIndicator, Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemTimeoutIndicator, org.reactivestreams.Publisher<? extends @NonNull T> fallback)
private <U,V> @NonNull Observable<T>	Observable.timeout0(@NonNull ObservableSource<U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T, ? extends ObservableSource<V>> itemTimeoutIndicator, @Nullable ObservableSource<? extends @NonNull T> fallback)
final <@NonNull K> @NonNull Single<Map<K,T>>	Flowable.toMap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector)	Returns a Single that emits a single HashMap containing all items emitted by the finite source Publisher, mapped by the keys returned by a specified keySelector function.
final <@NonNull K, @NonNull V> @NonNull Single<Map<K,V>>	Flowable.toMap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector)	Returns a Single that emits a single HashMap containing values corresponding to items emitted by the finite source Publisher, mapped by the keys returned by a specified keySelector function.
final <@NonNull K, @NonNull V> @NonNull Single<Map<K,V>>	Flowable.toMap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, @NonNull V>> mapSupplier)	Returns a Single that emits a single Map, returned by a specified mapFactory function, that contains keys and values extracted from the items emitted by the finite source Publisher.
final <@NonNull K> @NonNull Single<@NonNull Map<K,T>>	Observable.toMap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector)	Returns a Single that emits a single HashMap containing all items emitted by the current and finite Observable, mapped by the keys returned by a specified keySelector function.
final <@NonNull K, @NonNull V> @NonNull Single<Map<K,V>>	Observable.toMap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector)	Returns a Single that emits a single HashMap containing values corresponding to items emitted by the current and finite Observable, mapped by the keys and values returned by the given selector functions.
final <@NonNull K, @NonNull V> @NonNull Single<Map<K,V>>	Observable.toMap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, @NonNull V>> mapSupplier)	Returns a Single that emits a single Map (subclass), returned by a specified mapFactory function, that contains keys and values extracted from the items, via selector functions, emitted by the current and finite Observable.
final <@NonNull K> @NonNull Single<Map<K, Collection<T>>>	Flowable.toMultimap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector)	Returns a Single that emits a single HashMap that contains an ArrayList of items emitted by the finite source Publisher keyed by a specified keySelector function.
final <@NonNull K, @NonNull V> @NonNull Single<Map<K, Collection<V>>>	Flowable.toMultimap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector)	Returns a Single that emits a single HashMap that contains an ArrayList of values extracted by a specified valueSelector function from items emitted by the finite source Publisher, keyed by a specified keySelector function.
final <@NonNull K, @NonNull V> @NonNull Single<Map<K, Collection<V>>>	Flowable.toMultimap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, Collection<@NonNull V>>> mapSupplier, @NonNull Function<? super @NonNull K, ? extends Collection<? super @NonNull V>> collectionFactory)	Returns a Single that emits a single Map, returned by a specified mapFactory function, that contains a custom collection of values, extracted by a specified valueSelector function from items emitted by the finite source Publisher, and keyed by the keySelector function.
final <@NonNull K, @NonNull V> @NonNull Single<Map<K, Collection<V>>>	Flowable.toMultimap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<Map<@NonNull K, Collection<@NonNull V>>> mapSupplier)	Returns a Single that emits a single Map, returned by a specified mapFactory function, that contains an ArrayList of values, extracted by a specified valueSelector function from items emitted by the finite source Publisher and keyed by the keySelector function.
final <@NonNull K> @NonNull Single<@NonNull Map<K, Collection<T>>>	Observable.toMultimap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector)	Returns a Single that emits a single HashMap that contains an ArrayList of items emitted by the current and finite Observable keyed by a specified keySelector function.
final <@NonNull K, @NonNull V> @NonNull Single<@NonNull Map<K, Collection<V>>>	Observable.toMultimap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, Collection<@NonNull V>>> mapSupplier, @NonNull Function<? super @NonNull K, ? extends Collection<? super @NonNull V>> collectionFactory)	Returns a Single that emits a single Map (subclass), returned by a specified mapFactory function, that contains a custom Collection of values, extracted by a specified valueSelector function from items emitted by the current and finite Observable, and keyed by the keySelector function.
final <@NonNull K, @NonNull V> @NonNull Single<@NonNull Map<K, Collection<V>>>	Observable.toMultimap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<Map<@NonNull K, Collection<@NonNull V>>> mapSupplier)	Returns a Single that emits a single Map (subclass), returned by a specified mapFactory function, that contains an ArrayList of values, extracted by a specified valueSelector function from items emitted by the current and finite Observable and keyed by the keySelector function.
final <@NonNull K, @NonNull V> @NonNull Single<@NonNull Map<K, Collection<V>>>	Observable.toMultimap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, Function<? super @NonNull T, ? extends @NonNull V> valueSelector)	Returns a Single that emits a single HashMap that contains an ArrayList of values extracted by a specified valueSelector function from items emitted by the current and finite Observable, keyed by a specified keySelector function.
static <@NonNull R> @NonNull Completable	Completable.using(@NonNull Supplier<@NonNull R> resourceSupplier, @NonNull Function<? super @NonNull R, ? extends CompletableSource> sourceSupplier, @NonNull Consumer<? super @NonNull R> resourceCleanup)	Returns a Completable instance which manages a resource along with a custom CompletableSource instance while the subscription is active.
static <@NonNull R> @NonNull Completable	Completable.using(@NonNull Supplier<@NonNull R> resourceSupplier, @NonNull Function<? super @NonNull R, ? extends CompletableSource> sourceSupplier, @NonNull Consumer<? super @NonNull R> resourceCleanup, boolean eager)	Returns a Completable instance which manages a resource along with a custom CompletableSource instance while the subscription is active and performs eager or lazy resource disposition.
static <@NonNull T, @NonNull D> @NonNull Flowable<T>	Flowable.using(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup)	Constructs a Flowable that creates a dependent resource object, a Publisher with that resource and calls the provided resourceDisposer function if this inner source terminates or the downstream cancels the flow.
static <@NonNull T, @NonNull D> @NonNull Flowable<T>	Flowable.using(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup, boolean eager)	Constructs a Flowable that creates a dependent resource object, a Publisher with that resource and calls the provided resourceDisposer function if this inner source terminates or the downstream disposes the flow; doing it before these end-states have been reached if eager == true, after otherwise.
static <@NonNull T, @NonNull D> @NonNull Maybe<T>	Maybe.using(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, ? extends MaybeSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup)	Constructs a Maybe that creates a dependent resource object which is disposed of when the generated MaybeSource terminates or the downstream calls dispose().
static <@NonNull T, @NonNull D> @NonNull Maybe<T>	Maybe.using(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, ? extends MaybeSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup, boolean eager)	Constructs a Maybe that creates a dependent resource object which is disposed first ({code eager == true}) when the generated MaybeSource terminates or the downstream disposes; or after ({code eager == false}).
static <@NonNull T, @NonNull D> @NonNull Observable<T>	Observable.using(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, ? extends ObservableSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup)	Constructs an Observable that creates a dependent resource object, an ObservableSource with that resource and calls the provided resourceDisposer function if this inner source terminates or the downstream disposes the flow.
static <@NonNull T, @NonNull D> @NonNull Observable<T>	Observable.using(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, ? extends ObservableSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup, boolean eager)	Constructs an Observable that creates a dependent resource object, an ObservableSource with that resource and calls the provided disposer function if this inner source terminates or the downstream disposes the flow; doing it before these end-states have been reached if eager == true, after otherwise.
static <@NonNull T, @NonNull U> @NonNull Single<T>	Single.using(@NonNull Supplier<@NonNull U> resourceSupplier, @NonNull Function<? super @NonNull U, ? extends SingleSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull U> resourceCleanup)	Allows using and disposing a resource while running a SingleSource instance generated from that resource (similar to a try-with-resources).
static <@NonNull T, @NonNull U> @NonNull Single<T>	Single.using(@NonNull Supplier<@NonNull U> resourceSupplier, @NonNull Function<? super @NonNull U, ? extends SingleSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull U> resourceCleanup, boolean eager)	Allows using and disposing a resource while running a SingleSource instance generated from that resource (similar to a try-with-resources).
<S extends Scheduler & Disposable> S	Scheduler.when(@NonNull Function<Flowable<Flowable<Completable>>, Completable> combine)	Allows the use of operators for controlling the timing around when actions scheduled on workers are actually done.
final <@NonNull U, @NonNull V> @NonNull Flowable<Flowable<T>>	Flowable.window(@NonNull org.reactivestreams.Publisher<@NonNull U> openingIndicator, @NonNull Function<? super @NonNull U, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> closingIndicator)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final <@NonNull U, @NonNull V> @NonNull Flowable<Flowable<T>>	Flowable.window(@NonNull org.reactivestreams.Publisher<@NonNull U> openingIndicator, @NonNull Function<? super @NonNull U, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> closingIndicator, int bufferSize)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final <@NonNull U, @NonNull V> @NonNull Observable<Observable<T>>	Observable.window(@NonNull ObservableSource<@NonNull U> openingIndicator, @NonNull Function<? super @NonNull U, ? extends ObservableSource<@NonNull V>> closingIndicator)	Returns an Observable that emits windows of items it collects from the current Observable.
final <@NonNull U, @NonNull V> @NonNull Observable<Observable<T>>	Observable.window(@NonNull ObservableSource<@NonNull U> openingIndicator, @NonNull Function<? super @NonNull U, ? extends ObservableSource<@NonNull V>> closingIndicator, int bufferSize)	Returns an Observable that emits windows of items it collects from the current Observable.
final <@NonNull R> @NonNull Flowable<R>	Flowable.withLatestFrom(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> others, @NonNull Function<? super Object[], @NonNull R> combiner)	Combines the value emission from the current Flowable with the latest emissions from the other Publishers via a function to produce the output item.
final <@NonNull R> @NonNull Flowable<R>	Flowable.withLatestFrom(@NonNull org.reactivestreams.Publisher<@NonNull ?>[] others, @NonNull Function<? super Object[], @NonNull R> combiner)	Combines the value emission from the current Flowable with the latest emissions from the other Publishers via a function to produce the output item.
final <@NonNull R> @NonNull Observable<R>	Observable.withLatestFrom(@NonNull ObservableSource<?>[] others, @NonNull Function<? super Object[], @NonNull R> combiner)	Combines the value emission from the current Observable with the latest emissions from the other ObservableSources via a function to produce the output item.
final <@NonNull R> @NonNull Observable<R>	Observable.withLatestFrom(@NonNull Iterable<@NonNull ? extends ObservableSource<?>> others, @NonNull Function<? super Object[], @NonNull R> combiner)	Combines the value emission from the current Observable with the latest emissions from the other ObservableSources via a function to produce the output item.
static <@NonNull T, @NonNull R> @NonNull Flowable<R>	Flowable.zip(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper)	Returns a Flowable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other Publishers.
static <@NonNull T, @NonNull R> @NonNull Flowable<R>	Flowable.zip(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper, boolean delayError, int bufferSize)	Returns a Flowable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other Publishers.
static <@NonNull T, @NonNull R> @NonNull Maybe<R>	Maybe.zip(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper)	Returns a Maybe that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other MaybeSources.
static <@NonNull T, @NonNull R> @NonNull Observable<R>	Observable.zip(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper)	Returns an Observable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other ObservableSources.
static <@NonNull T, @NonNull R> @NonNull Observable<R>	Observable.zip(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper, boolean delayError, int bufferSize)	Returns an Observable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other ObservableSources.
static <@NonNull T, @NonNull R> @NonNull Single<R>	Single.zip(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper)	Waits until all SingleSource sources provided by the Iterable sequence signal a success value and calls a zipper function with an array of these values to return a result to be emitted to the downstream.
static <@NonNull T, @NonNull R> @NonNull Flowable<R>	Flowable.zipArray(@NonNull Function<? super Object[], ? extends @NonNull R> zipper, boolean delayError, int bufferSize, @NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources)	Returns a Flowable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of other Publishers.
static <@NonNull T, @NonNull R> @NonNull Maybe<R>	Maybe.zipArray(@NonNull Function<? super Object[], ? extends @NonNull R> zipper, @NonNull MaybeSource<? extends @NonNull T>... sources)	Returns a Maybe that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of other MaybeSources.
static <@NonNull T, @NonNull R> @NonNull Observable<R>	Observable.zipArray(@NonNull Function<? super Object[], ? extends @NonNull R> zipper, boolean delayError, int bufferSize, @NonNull ObservableSource<? extends @NonNull T>... sources)	Returns an Observable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of other ObservableSources.
static <@NonNull T, @NonNull R> @NonNull Single<R>	Single.zipArray(@NonNull Function<? super Object[], ? extends @NonNull R> zipper, @NonNull SingleSource<? extends @NonNull T>... sources)	Waits until all SingleSource sources provided via an array signal a success value and calls a zipper function with an array of these values to return a result to be emitted to downstream.

Uses of Function in io.reactivex.rxjava3.internal.functions

Classes in io.reactivex.rxjava3.internal.functions that implement Function

Modifier and Type	Class	Description
(package private) static final class	Functions.Array2Func<T1,T2,R>
(package private) static final class	Functions.Array3Func<T1,T2,T3,R>
(package private) static final class	Functions.Array4Func<T1,T2,T3,T4,R>
(package private) static final class	Functions.Array5Func<T1,T2,T3,T4,T5,R>
(package private) static final class	Functions.Array6Func<T1,T2,T3,T4,T5,T6,R>
(package private) static final class	Functions.Array7Func<T1,T2,T3,T4,T5,T6,T7,R>
(package private) static final class	Functions.Array8Func<T1,T2,T3,T4,T5,T6,T7,T8,R>
(package private) static final class	Functions.Array9Func<T1,T2,T3,T4,T5,T6,T7,T8,T9,R>
(package private) static final class	Functions.CastToClass<T,U>
(package private) static final class	Functions.Identity
(package private) static final class	Functions.JustValue<T,U>
(package private) static final class	Functions.ListSorter<T>
(package private) static final class	Functions.TimestampFunction<T>

Fields in io.reactivex.rxjava3.internal.functions declared as Function

Modifier and Type	Field	Description
private final Function<? super K, ? extends Collection<? super V>>	Functions.ToMultimapKeyValueSelector.collectionFactory
(package private) static final Function<Object,Object>	Functions.IDENTITY	A singleton identity function.
private final Function<? super T, ? extends K>	Functions.ToMapKeySelector.keySelector
private final Function<? super T, ? extends K>	Functions.ToMapKeyValueSelector.keySelector
private final Function<? super T, ? extends K>	Functions.ToMultimapKeyValueSelector.keySelector
private final Function<? super T, ? extends V>	Functions.ToMapKeyValueSelector.valueSelector
private final Function<? super T, ? extends V>	Functions.ToMultimapKeyValueSelector.valueSelector

Methods in io.reactivex.rxjava3.internal.functions that return Function

Modifier and Type	Method	Description
static <T,U> @NonNull Function<T,U>	Functions.castFunction(@NonNull Class<U> target)	Returns a function that cast the incoming values via a Class object.
static <T> @NonNull Function<T,T>	Functions.identity()	Returns an identity function that simply returns its argument.
static <T,U> @NonNull Function<T,U>	Functions.justFunction(U value)	Returns a Function that ignores its parameter and returns the given value.
static <T> Function<List<T>,List<T>>	Functions.listSorter(Comparator<? super T> comparator)
static <T> Function<T,Timed<T>>	Functions.timestampWith(TimeUnit unit, Scheduler scheduler)
static <T1,T2,R> @NonNull Function<Object[],R>	Functions.toFunction(@NonNull BiFunction<? super T1, ? super T2, ? extends R> f)
static <T1,T2,T3,R> @NonNull Function<Object[],R>	Functions.toFunction(@NonNull Function3<T1,T2,T3,R> f)
static <T1,T2,T3,T4,R> @NonNull Function<Object[],R>	Functions.toFunction(@NonNull Function4<T1,T2,T3,T4,R> f)
static <T1,T2,T3,T4,T5,R> @NonNull Function<Object[],R>	Functions.toFunction(@NonNull Function5<T1,T2,T3,T4,T5,R> f)
static <T1,T2,T3,T4,T5,T6,R> @NonNull Function<Object[],R>	Functions.toFunction(@NonNull Function6<T1,T2,T3,T4,T5,T6,R> f)
static <T1,T2,T3,T4,T5,T6,T7,R> @NonNull Function<Object[],R>	Functions.toFunction(@NonNull Function7<T1,T2,T3,T4,T5,T6,T7,R> f)
static <T1,T2,T3,T4,T5,T6,T7,T8,R> @NonNull Function<Object[],R>	Functions.toFunction(@NonNull Function8<T1,T2,T3,T4,T5,T6,T7,T8,R> f)
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> @NonNull Function<Object[],R>	Functions.toFunction(@NonNull Function9<T1,T2,T3,T4,T5,T6,T7,T8,T9,R> f)

Methods in io.reactivex.rxjava3.internal.functions with parameters of type Function

Modifier and Type	Method	Description
static <T,K> BiConsumer<Map<K,T>,T>	Functions.toMapKeySelector(Function<? super T, ? extends K> keySelector)
static <T,K,V> BiConsumer<Map<K,V>,T>	Functions.toMapKeyValueSelector(Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector)
static <T,K,V> BiConsumer<Map<K, Collection<V>>, T>	Functions.toMultimapKeyValueSelector(Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector, Function<? super K, ? extends Collection<? super V>> collectionFactory)

Constructors in io.reactivex.rxjava3.internal.functions with parameters of type Function

Modifier	Constructor	Description
(package private)	ToMapKeySelector(Function<? super T, ? extends K> keySelector)
(package private)	ToMapKeyValueSelector(Function<? super T, ? extends V> valueSelector, Function<? super T, ? extends K> keySelector)
(package private)	ToMultimapKeyValueSelector(Function<? super K, ? extends Collection<? super V>> collectionFactory, Function<? super T, ? extends V> valueSelector, Function<? super T, ? extends K> keySelector)

Uses of Function in io.reactivex.rxjava3.internal.jdk8

Fields in io.reactivex.rxjava3.internal.jdk8 declared as Function

Modifier and Type	Field	Description
(package private) final Function<? super T, ? extends Stream<? extends R>>	FlowableFlatMapStream.FlatMapStreamSubscriber.mapper
(package private) final Function<? super T, ? extends Stream<? extends R>>	FlowableFlatMapStream.mapper
(package private) final Function<? super T, Optional<? extends R>>	FlowableMapOptional.MapOptionalConditionalSubscriber.mapper
(package private) final Function<? super T, Optional<? extends R>>	FlowableMapOptional.MapOptionalSubscriber.mapper
(package private) final Function<? super T, Optional<? extends R>>	FlowableMapOptional.mapper
(package private) final Function<? super T, ? extends Stream<? extends R>>	MaybeFlattenStreamAsFlowable.FlattenStreamMultiObserver.mapper
(package private) final Function<? super T, ? extends Stream<? extends R>>	MaybeFlattenStreamAsFlowable.mapper
(package private) final Function<? super T, ? extends Stream<? extends R>>	MaybeFlattenStreamAsObservable.FlattenStreamMultiObserver.mapper
(package private) final Function<? super T, ? extends Stream<? extends R>>	MaybeFlattenStreamAsObservable.mapper
(package private) final Function<? super T, Optional<? extends R>>	MaybeMapOptional.MapOptionalMaybeObserver.mapper
(package private) final Function<? super T, Optional<? extends R>>	MaybeMapOptional.mapper
(package private) final Function<? super T, ? extends Stream<? extends R>>	ObservableFlatMapStream.FlatMapStreamObserver.mapper
(package private) final Function<? super T, ? extends Stream<? extends R>>	ObservableFlatMapStream.mapper
(package private) final Function<? super T, Optional<? extends R>>	ObservableMapOptional.MapOptionalObserver.mapper
(package private) final Function<? super T, Optional<? extends R>>	ObservableMapOptional.mapper
(package private) final Function<? super T, ? extends Stream<? extends R>>	ParallelFlatMapStream.mapper
(package private) final Function<? super T, Optional<? extends R>>	ParallelMapOptional.mapper
(package private) final Function<? super T, Optional<? extends R>>	ParallelMapOptional.ParallelMapConditionalSubscriber.mapper
(package private) final Function<? super T, Optional<? extends R>>	ParallelMapOptional.ParallelMapSubscriber.mapper
(package private) final Function<? super T, Optional<? extends R>>	ParallelMapTryOptional.mapper
(package private) final Function<? super T, Optional<? extends R>>	ParallelMapTryOptional.ParallelMapTryConditionalSubscriber.mapper
(package private) final Function<? super T, Optional<? extends R>>	ParallelMapTryOptional.ParallelMapTrySubscriber.mapper
(package private) final Function<? super T, ? extends Stream<? extends R>>	SingleFlattenStreamAsFlowable.mapper
(package private) final Function<? super T, ? extends Stream<? extends R>>	SingleFlattenStreamAsObservable.mapper
(package private) final Function<? super T, Optional<? extends R>>	SingleMapOptional.MapOptionalSingleObserver.mapper
(package private) final Function<? super T, Optional<? extends R>>	SingleMapOptional.mapper

Methods in io.reactivex.rxjava3.internal.jdk8 with parameters of type Function

Modifier and Type	Method	Description
static <T,R> org.reactivestreams.Subscriber<T>	FlowableFlatMapStream.subscribe(org.reactivestreams.Subscriber<? super R> downstream, Function<? super T, ? extends Stream<? extends R>> mapper, int prefetch)	Create a Subscriber with the given parameters.

Constructors in io.reactivex.rxjava3.internal.jdk8 with parameters of type Function

Modifier	Constructor	Description
(package private)	FlatMapStreamObserver(Observer<? super R> downstream, Function<? super T, ? extends Stream<? extends R>> mapper)
(package private)	FlatMapStreamSubscriber(org.reactivestreams.Subscriber<? super R> downstream, Function<? super T, ? extends Stream<? extends R>> mapper, int prefetch)
(package private)	FlattenStreamMultiObserver(org.reactivestreams.Subscriber<? super R> downstream, Function<? super T, ? extends Stream<? extends R>> mapper)
(package private)	FlattenStreamMultiObserver(Observer<? super R> downstream, Function<? super T, ? extends Stream<? extends R>> mapper)
	FlowableFlatMapStream(Flowable<T> source, Function<? super T, ? extends Stream<? extends R>> mapper, int prefetch)
	FlowableMapOptional(Flowable<T> source, Function<? super T, Optional<? extends R>> mapper)
(package private)	MapOptionalConditionalSubscriber(ConditionalSubscriber<? super R> downstream, Function<? super T, Optional<? extends R>> mapper)
(package private)	MapOptionalMaybeObserver(MaybeObserver<? super R> downstream, Function<? super T, Optional<? extends R>> mapper)
(package private)	MapOptionalObserver(Observer<? super R> downstream, Function<? super T, Optional<? extends R>> mapper)
(package private)	MapOptionalSingleObserver(MaybeObserver<? super R> downstream, Function<? super T, Optional<? extends R>> mapper)
(package private)	MapOptionalSubscriber(org.reactivestreams.Subscriber<? super R> downstream, Function<? super T, Optional<? extends R>> mapper)
	MaybeFlattenStreamAsFlowable(Maybe<T> source, Function<? super T, ? extends Stream<? extends R>> mapper)
	MaybeFlattenStreamAsObservable(Maybe<T> source, Function<? super T, ? extends Stream<? extends R>> mapper)
	MaybeMapOptional(Maybe<T> source, Function<? super T, Optional<? extends R>> mapper)
	ObservableFlatMapStream(Observable<T> source, Function<? super T, ? extends Stream<? extends R>> mapper)
	ObservableMapOptional(Observable<T> source, Function<? super T, Optional<? extends R>> mapper)
	ParallelFlatMapStream(ParallelFlowable<T> source, Function<? super T, ? extends Stream<? extends R>> mapper, int prefetch)
(package private)	ParallelMapConditionalSubscriber(ConditionalSubscriber<? super R> actual, Function<? super T, Optional<? extends R>> mapper)
	ParallelMapOptional(ParallelFlowable<T> source, Function<? super T, Optional<? extends R>> mapper)
(package private)	ParallelMapSubscriber(org.reactivestreams.Subscriber<? super R> actual, Function<? super T, Optional<? extends R>> mapper)
(package private)	ParallelMapTryConditionalSubscriber(ConditionalSubscriber<? super R> actual, Function<? super T, Optional<? extends R>> mapper, BiFunction<? super Long, ? super Throwable, ParallelFailureHandling> errorHandler)
	ParallelMapTryOptional(ParallelFlowable<T> source, Function<? super T, Optional<? extends R>> mapper, BiFunction<? super Long, ? super Throwable, ParallelFailureHandling> errorHandler)
(package private)	ParallelMapTrySubscriber(org.reactivestreams.Subscriber<? super R> actual, Function<? super T, Optional<? extends R>> mapper, BiFunction<? super Long, ? super Throwable, ParallelFailureHandling> errorHandler)
	SingleFlattenStreamAsFlowable(Single<T> source, Function<? super T, ? extends Stream<? extends R>> mapper)
	SingleFlattenStreamAsObservable(Single<T> source, Function<? super T, ? extends Stream<? extends R>> mapper)
	SingleMapOptional(Single<T> source, Function<? super T, Optional<? extends R>> mapper)

Uses of Function in io.reactivex.rxjava3.internal.operators.completable

Fields in io.reactivex.rxjava3.internal.operators.completable declared as Function

Modifier and Type	Field	Description
(package private) final Function<? super R, ? extends CompletableSource>	CompletableUsing.completableFunction
(package private) final Function<? super Throwable, ? extends CompletableSource>	CompletableResumeNext.errorMapper
(package private) final Function<? super Throwable, ? extends CompletableSource>	CompletableResumeNext.ResumeNextObserver.errorMapper
(package private) final Function<? super Throwable, ? extends T>	CompletableOnErrorReturn.OnErrorReturnMaybeObserver.itemSupplier
(package private) final Function<? super Throwable, ? extends T>	CompletableOnErrorReturn.valueSupplier

Constructors in io.reactivex.rxjava3.internal.operators.completable with parameters of type Function

Modifier	Constructor	Description
	CompletableOnErrorReturn(CompletableSource source, Function<? super Throwable, ? extends T> valueSupplier)
	CompletableResumeNext(CompletableSource source, Function<? super Throwable, ? extends CompletableSource> errorMapper)
	CompletableUsing(Supplier<R> resourceSupplier, Function<? super R, ? extends CompletableSource> completableFunction, Consumer<? super R> disposer, boolean eager)
(package private)	OnErrorReturnMaybeObserver(MaybeObserver<? super T> actual, Function<? super Throwable, ? extends T> itemSupplier)
(package private)	ResumeNextObserver(CompletableObserver observer, Function<? super Throwable, ? extends CompletableSource> errorMapper)

Uses of Function in io.reactivex.rxjava3.internal.operators.flowable

Classes in io.reactivex.rxjava3.internal.operators.flowable that implement Function

Modifier and Type	Class	Description
(package private) final class	FlowableCombineLatest.SingletonArrayFunc
(package private) static final class	FlowableInternalHelper.FlatMapIntoIterable<T,U>
(package private) static final class	FlowableInternalHelper.FlatMapWithCombinerInner<U,R,T>
(package private) static final class	FlowableInternalHelper.FlatMapWithCombinerOuter<T,R,U>
(package private) static final class	FlowableInternalHelper.ItemDelayFunction<T,U>
(package private) final class	FlowableWithLatestFromMany.SingletonArrayFunc

Fields in io.reactivex.rxjava3.internal.operators.flowable declared as Function

Modifier and Type	Field	Description
(package private) final Function<? super Open, ? extends org.reactivestreams.Publisher<? extends Close>>	FlowableBufferBoundary.BufferBoundarySubscriber.bufferClose
(package private) final Function<? super Open, ? extends org.reactivestreams.Publisher<? extends Close>>	FlowableBufferBoundary.bufferClose
(package private) final Function<? super B, ? extends org.reactivestreams.Publisher<V>>	FlowableWindowBoundarySelector.closingIndicator
(package private) final Function<? super B, ? extends org.reactivestreams.Publisher<V>>	FlowableWindowBoundarySelector.WindowBoundaryMainSubscriber.closingIndicator
(package private) final Function<? super Object[], ? extends R>	FlowableCombineLatest.CombineLatestCoordinator.combiner
(package private) final Function<? super Object[], ? extends R>	FlowableCombineLatest.combiner
(package private) final Function<? super Object[], R>	FlowableWithLatestFromMany.combiner
(package private) final Function<? super Object[], R>	FlowableWithLatestFromMany.WithLatestFromSubscriber.combiner
(package private) final Function<? super T, ? extends org.reactivestreams.Publisher<U>>	FlowableDebounce.debounceSelector
(package private) final Function<? super T, ? extends org.reactivestreams.Publisher<U>>	FlowableDebounce.DebounceSubscriber.debounceSelector
(package private) final Function<? super Flowable<Object>, ? extends org.reactivestreams.Publisher<?>>	FlowableRepeatWhen.handler
(package private) final Function<? super Flowable<Throwable>, ? extends org.reactivestreams.Publisher<?>>	FlowableRetryWhen.handler
(package private) final Function<? super T, ? extends org.reactivestreams.Publisher<U>>	FlowableInternalHelper.ItemDelayFunction.itemDelay
(package private) final Function<? super T, ? extends org.reactivestreams.Publisher<V>>	FlowableTimeout.itemTimeoutIndicator
(package private) final Function<? super T, ? extends org.reactivestreams.Publisher<?>>	FlowableTimeout.TimeoutFallbackSubscriber.itemTimeoutIndicator
(package private) final Function<? super T, ? extends org.reactivestreams.Publisher<?>>	FlowableTimeout.TimeoutSubscriber.itemTimeoutIndicator
(package private) final Function<? super T, K>	FlowableDistinct.DistinctSubscriber.keySelector
(package private) final Function<? super T, K>	FlowableDistinct.keySelector
(package private) final Function<? super T, K>	FlowableDistinctUntilChanged.DistinctUntilChangedConditionalSubscriber.keySelector
(package private) final Function<? super T, K>	FlowableDistinctUntilChanged.DistinctUntilChangedSubscriber.keySelector
(package private) final Function<? super T, K>	FlowableDistinctUntilChanged.keySelector
(package private) final Function<? super T, ? extends K>	FlowableGroupBy.GroupBySubscriber.keySelector
(package private) final Function<? super T, ? extends K>	FlowableGroupBy.keySelector
(package private) final Function<? super TLeft, ? extends org.reactivestreams.Publisher<TLeftEnd>>	FlowableGroupJoin.GroupJoinSubscription.leftEnd
(package private) final Function<? super TLeft, ? extends org.reactivestreams.Publisher<TLeftEnd>>	FlowableGroupJoin.leftEnd
(package private) final Function<? super TLeft, ? extends org.reactivestreams.Publisher<TLeftEnd>>	FlowableJoin.JoinSubscription.leftEnd
(package private) final Function<? super TLeft, ? extends org.reactivestreams.Publisher<TLeftEnd>>	FlowableJoin.leftEnd
(package private) final Function<? super Consumer<Object>, ? extends Map<K,Object>>	FlowableGroupBy.mapFactory
(package private) final Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>>	FlowableConcatMap.BaseConcatMapSubscriber.mapper
(package private) final Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>>	FlowableConcatMap.mapper
(package private) final Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>>	FlowableConcatMapEager.ConcatMapEagerDelayErrorSubscriber.mapper
(package private) final Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>>	FlowableConcatMapEager.mapper
(package private) final Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>>	FlowableConcatMapEagerPublisher.mapper
(package private) final Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>>	FlowableConcatMapScheduler.BaseConcatMapSubscriber.mapper
(package private) final Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>>	FlowableConcatMapScheduler.mapper
(package private) final Function<? super T, ? extends org.reactivestreams.Publisher<? extends U>>	FlowableFlatMap.mapper
(package private) final Function<? super T, ? extends org.reactivestreams.Publisher<? extends U>>	FlowableFlatMap.MergeSubscriber.mapper
(package private) final Function<? super T, ? extends CompletableSource>	FlowableFlatMapCompletable.FlatMapCompletableMainSubscriber.mapper
(package private) final Function<? super T, ? extends CompletableSource>	FlowableFlatMapCompletable.mapper
(package private) final Function<? super T, ? extends CompletableSource>	FlowableFlatMapCompletableCompletable.FlatMapCompletableMainSubscriber.mapper
(package private) final Function<? super T, ? extends CompletableSource>	FlowableFlatMapCompletableCompletable.mapper
(package private) final Function<? super T, ? extends MaybeSource<? extends R>>	FlowableFlatMapMaybe.FlatMapMaybeSubscriber.mapper
(package private) final Function<? super T, ? extends MaybeSource<? extends R>>	FlowableFlatMapMaybe.mapper
(package private) final Function<? super T, ? extends MaybeSource<? extends R>>	FlowableFlatMapMaybePublisher.mapper
(package private) final Function<? super T, ? extends SingleSource<? extends R>>	FlowableFlatMapSingle.FlatMapSingleSubscriber.mapper
(package private) final Function<? super T, ? extends SingleSource<? extends R>>	FlowableFlatMapSingle.mapper
(package private) final Function<? super T, ? extends SingleSource<? extends R>>	FlowableFlatMapSinglePublisher.mapper
(package private) final Function<? super T, ? extends Iterable<? extends R>>	FlowableFlattenIterable.FlattenIterableSubscriber.mapper
(package private) final Function<? super T, ? extends Iterable<? extends R>>	FlowableFlattenIterable.mapper
private final Function<? super T, ? extends Iterable<? extends U>>	FlowableInternalHelper.FlatMapIntoIterable.mapper
private final Function<? super T, ? extends org.reactivestreams.Publisher<? extends U>>	FlowableInternalHelper.FlatMapWithCombinerOuter.mapper
(package private) final Function<? super T, ? extends U>	FlowableMap.MapConditionalSubscriber.mapper
(package private) final Function<? super T, ? extends U>	FlowableMap.mapper
(package private) final Function<? super T, ? extends U>	FlowableMap.MapSubscriber.mapper
(package private) final Function<? super T, ? extends U>	FlowableMapPublisher.mapper
(package private) final Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>>	FlowableScalarXMap.ScalarXMapFlowable.mapper
(package private) final Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>>	FlowableSwitchMap.mapper
(package private) final Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>>	FlowableSwitchMap.SwitchMapSubscriber.mapper
(package private) final Function<? super Throwable, ? extends org.reactivestreams.Publisher<? extends T>>	FlowableOnErrorNext.nextSupplier
(package private) final Function<? super Throwable, ? extends org.reactivestreams.Publisher<? extends T>>	FlowableOnErrorNext.OnErrorNextSubscriber.nextSupplier
(package private) final Function<? super Throwable, ? extends R>	FlowableMapNotification.MapNotificationSubscriber.onErrorMapper
(package private) final Function<? super Throwable, ? extends R>	FlowableMapNotification.onErrorMapper
(package private) final Function<? super T, ? extends R>	FlowableMapNotification.MapNotificationSubscriber.onNextMapper
(package private) final Function<? super T, ? extends R>	FlowableMapNotification.onNextMapper
(package private) final Function<? super TRight, ? extends org.reactivestreams.Publisher<TRightEnd>>	FlowableGroupJoin.GroupJoinSubscription.rightEnd
(package private) final Function<? super TRight, ? extends org.reactivestreams.Publisher<TRightEnd>>	FlowableGroupJoin.rightEnd
(package private) final Function<? super TRight, ? extends org.reactivestreams.Publisher<TRightEnd>>	FlowableJoin.JoinSubscription.rightEnd
(package private) final Function<? super TRight, ? extends org.reactivestreams.Publisher<TRightEnd>>	FlowableJoin.rightEnd
(package private) final Function<? super T, ? extends Notification<R>>	FlowableDematerialize.DematerializeSubscriber.selector
(package private) final Function<? super T, ? extends Notification<R>>	FlowableDematerialize.selector
(package private) final Function<? super Flowable<T>, ? extends org.reactivestreams.Publisher<? extends R>>	FlowablePublishMulticast.selector
private final Function<? super Flowable<U>, ? extends org.reactivestreams.Publisher<R>>	FlowableReplay.MulticastFlowable.selector
(package private) final Function<? super D, ? extends org.reactivestreams.Publisher<? extends T>>	FlowableUsing.sourceSupplier
(package private) final Function<? super T, ? extends V>	FlowableGroupBy.GroupBySubscriber.valueSelector
(package private) final Function<? super T, ? extends V>	FlowableGroupBy.valueSelector
(package private) final Function<? super Throwable, ? extends T>	FlowableOnErrorReturn.OnErrorReturnSubscriber.valueSupplier
(package private) final Function<? super Throwable, ? extends T>	FlowableOnErrorReturn.valueSupplier
(package private) final Function<? super Object[], ? extends R>	FlowableZip.ZipCoordinator.zipper
(package private) final Function<? super Object[], ? extends R>	FlowableZip.zipper

Methods in io.reactivex.rxjava3.internal.operators.flowable that return Function

Modifier and Type	Method	Description
static <T,U> Function<T, org.reactivestreams.Publisher<U>>	FlowableInternalHelper.flatMapIntoIterable(Function<? super T, ? extends Iterable<? extends U>> mapper)
static <T,U,R> Function<T, org.reactivestreams.Publisher<R>>	FlowableInternalHelper.flatMapWithCombiner(Function<? super T, ? extends org.reactivestreams.Publisher<? extends U>> mapper, BiFunction<? super T, ? super U, ? extends R> combiner)
static <T,U> Function<T, org.reactivestreams.Publisher<T>>	FlowableInternalHelper.itemDelay(Function<? super T, ? extends org.reactivestreams.Publisher<U>> itemDelay)

Methods in io.reactivex.rxjava3.internal.operators.flowable with parameters of type Function

Modifier and Type	Method	Description
static <T,U> Function<T, org.reactivestreams.Publisher<U>>	FlowableInternalHelper.flatMapIntoIterable(Function<? super T, ? extends Iterable<? extends U>> mapper)
static <T,U,R> Function<T, org.reactivestreams.Publisher<R>>	FlowableInternalHelper.flatMapWithCombiner(Function<? super T, ? extends org.reactivestreams.Publisher<? extends U>> mapper, BiFunction<? super T, ? super U, ? extends R> combiner)
static <T,U> Function<T, org.reactivestreams.Publisher<T>>	FlowableInternalHelper.itemDelay(Function<? super T, ? extends org.reactivestreams.Publisher<U>> itemDelay)
static <U,R> Flowable<R>	FlowableReplay.multicastSelector(Supplier<? extends ConnectableFlowable<U>> connectableFactory, Function<? super Flowable<U>, ? extends org.reactivestreams.Publisher<R>> selector)	Given a connectable observable factory, it multicasts over the generated ConnectableObservable via a selector function.
static <T,U> Flowable<U>	FlowableScalarXMap.scalarXMap(T value, Function<? super T, ? extends org.reactivestreams.Publisher<? extends U>> mapper)	Maps a scalar value into a Publisher and emits its values.
static <T,R> org.reactivestreams.Subscriber<T>	FlowableConcatMap.subscribe(org.reactivestreams.Subscriber<? super R> s, Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>> mapper, int prefetch, ErrorMode errorMode)
static <T,U> FlowableSubscriber<T>	FlowableFlatMap.subscribe(org.reactivestreams.Subscriber<? super U> s, Function<? super T, ? extends org.reactivestreams.Publisher<? extends U>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize)
static <T,R> org.reactivestreams.Subscriber<T>	FlowableFlattenIterable.subscribe(org.reactivestreams.Subscriber<? super R> downstream, Function<? super T, ? extends Iterable<? extends R>> mapper, int prefetch)	Create a Subscriber with the given parameters.
static <T,R> boolean	FlowableScalarXMap.tryScalarXMapSubscribe(org.reactivestreams.Publisher<T> source, org.reactivestreams.Subscriber<? super R> subscriber, Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>> mapper)	Tries to subscribe to a possibly Supplier source's mapped Publisher.

Constructors in io.reactivex.rxjava3.internal.operators.flowable with parameters of type Function

Modifier	Constructor	Description
(package private)	BaseConcatMapSubscriber(Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>> mapper, int prefetch)
(package private)	BaseConcatMapSubscriber(Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>> mapper, int prefetch, Scheduler.Worker worker)
(package private)	BufferBoundarySubscriber(org.reactivestreams.Subscriber<? super C> actual, org.reactivestreams.Publisher<? extends Open> bufferOpen, Function<? super Open, ? extends org.reactivestreams.Publisher<? extends Close>> bufferClose, Supplier<C> bufferSupplier)
(package private)	CombineLatestCoordinator(org.reactivestreams.Subscriber<? super R> actual, Function<? super Object[], ? extends R> combiner, int n, int bufferSize, boolean delayErrors)
(package private)	ConcatMapDelayed(org.reactivestreams.Subscriber<? super R> actual, Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>> mapper, int prefetch, boolean veryEnd)
(package private)	ConcatMapDelayed(org.reactivestreams.Subscriber<? super R> actual, Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>> mapper, int prefetch, boolean veryEnd, Scheduler.Worker worker)
(package private)	ConcatMapEagerDelayErrorSubscriber(org.reactivestreams.Subscriber<? super R> actual, Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>> mapper, int maxConcurrency, int prefetch, ErrorMode errorMode)
(package private)	ConcatMapImmediate(org.reactivestreams.Subscriber<? super R> actual, Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>> mapper, int prefetch)
(package private)	ConcatMapImmediate(org.reactivestreams.Subscriber<? super R> actual, Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>> mapper, int prefetch, Scheduler.Worker worker)
(package private)	DebounceSubscriber(org.reactivestreams.Subscriber<? super T> actual, Function<? super T, ? extends org.reactivestreams.Publisher<U>> debounceSelector)
(package private)	DematerializeSubscriber(org.reactivestreams.Subscriber<? super R> downstream, Function<? super T, ? extends Notification<R>> selector)
(package private)	DistinctSubscriber(org.reactivestreams.Subscriber<? super T> actual, Function<? super T, K> keySelector, Collection<? super K> collection)
(package private)	DistinctUntilChangedConditionalSubscriber(ConditionalSubscriber<? super T> actual, Function<? super T, K> keySelector, BiPredicate<? super K, ? super K> comparer)
(package private)	DistinctUntilChangedSubscriber(org.reactivestreams.Subscriber<? super T> actual, Function<? super T, K> keySelector, BiPredicate<? super K, ? super K> comparer)
(package private)	FlatMapCompletableMainSubscriber(org.reactivestreams.Subscriber<? super T> subscriber, Function<? super T, ? extends CompletableSource> mapper, boolean delayErrors, int maxConcurrency)
(package private)	FlatMapCompletableMainSubscriber(CompletableObserver observer, Function<? super T, ? extends CompletableSource> mapper, boolean delayErrors, int maxConcurrency)
(package private)	FlatMapIntoIterable(Function<? super T, ? extends Iterable<? extends U>> mapper)
(package private)	FlatMapMaybeSubscriber(org.reactivestreams.Subscriber<? super R> actual, Function<? super T, ? extends MaybeSource<? extends R>> mapper, boolean delayErrors, int maxConcurrency)
(package private)	FlatMapSingleSubscriber(org.reactivestreams.Subscriber<? super R> actual, Function<? super T, ? extends SingleSource<? extends R>> mapper, boolean delayErrors, int maxConcurrency)
(package private)	FlatMapWithCombinerOuter(BiFunction<? super T, ? super U, ? extends R> combiner, Function<? super T, ? extends org.reactivestreams.Publisher<? extends U>> mapper)
(package private)	FlattenIterableSubscriber(org.reactivestreams.Subscriber<? super R> actual, Function<? super T, ? extends Iterable<? extends R>> mapper, int prefetch)
	FlowableBufferBoundary(Flowable<T> source, org.reactivestreams.Publisher<? extends Open> bufferOpen, Function<? super Open, ? extends org.reactivestreams.Publisher<? extends Close>> bufferClose, Supplier<U> bufferSupplier)
	FlowableCombineLatest(@NonNull Iterable<? extends org.reactivestreams.Publisher<? extends T>> iterable, @NonNull Function<? super Object[], ? extends R> combiner, int bufferSize, boolean delayErrors)
	FlowableCombineLatest(@NonNull org.reactivestreams.Publisher<? extends T>[] array, @NonNull Function<? super Object[], ? extends R> combiner, int bufferSize, boolean delayErrors)
	FlowableConcatMap(Flowable<T> source, Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>> mapper, int prefetch, ErrorMode errorMode)
	FlowableConcatMapEager(Flowable<T> source, Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>> mapper, int maxConcurrency, int prefetch, ErrorMode errorMode)
	FlowableConcatMapEagerPublisher(org.reactivestreams.Publisher<T> source, Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>> mapper, int maxConcurrency, int prefetch, ErrorMode errorMode)
	FlowableConcatMapScheduler(Flowable<T> source, Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>> mapper, int prefetch, ErrorMode errorMode, Scheduler scheduler)
	FlowableDebounce(Flowable<T> source, Function<? super T, ? extends org.reactivestreams.Publisher<U>> debounceSelector)
	FlowableDematerialize(Flowable<T> source, Function<? super T, ? extends Notification<R>> selector)
	FlowableDistinct(Flowable<T> source, Function<? super T, K> keySelector, Supplier<? extends Collection<? super K>> collectionSupplier)
	FlowableDistinctUntilChanged(Flowable<T> source, Function<? super T, K> keySelector, BiPredicate<? super K, ? super K> comparer)
	FlowableFlatMap(Flowable<T> source, Function<? super T, ? extends org.reactivestreams.Publisher<? extends U>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize)
	FlowableFlatMapCompletable(Flowable<T> source, Function<? super T, ? extends CompletableSource> mapper, boolean delayErrors, int maxConcurrency)
	FlowableFlatMapCompletableCompletable(Flowable<T> source, Function<? super T, ? extends CompletableSource> mapper, boolean delayErrors, int maxConcurrency)
	FlowableFlatMapMaybe(Flowable<T> source, Function<? super T, ? extends MaybeSource<? extends R>> mapper, boolean delayError, int maxConcurrency)
	FlowableFlatMapMaybePublisher(org.reactivestreams.Publisher<T> source, Function<? super T, ? extends MaybeSource<? extends R>> mapper, boolean delayError, int maxConcurrency)
	FlowableFlatMapSingle(Flowable<T> source, Function<? super T, ? extends SingleSource<? extends R>> mapper, boolean delayError, int maxConcurrency)
	FlowableFlatMapSinglePublisher(org.reactivestreams.Publisher<T> source, Function<? super T, ? extends SingleSource<? extends R>> mapper, boolean delayError, int maxConcurrency)
	FlowableFlattenIterable(Flowable<T> source, Function<? super T, ? extends Iterable<? extends R>> mapper, int prefetch)
	FlowableGroupBy(Flowable<T> source, Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector, int bufferSize, boolean delayError, Function<? super Consumer<Object>, ? extends Map<K,Object>> mapFactory)
	FlowableGroupJoin(Flowable<TLeft> source, org.reactivestreams.Publisher<? extends TRight> other, Function<? super TLeft, ? extends org.reactivestreams.Publisher<TLeftEnd>> leftEnd, Function<? super TRight, ? extends org.reactivestreams.Publisher<TRightEnd>> rightEnd, BiFunction<? super TLeft, ? super Flowable<TRight>, ? extends R> resultSelector)
	FlowableJoin(Flowable<TLeft> source, org.reactivestreams.Publisher<? extends TRight> other, Function<? super TLeft, ? extends org.reactivestreams.Publisher<TLeftEnd>> leftEnd, Function<? super TRight, ? extends org.reactivestreams.Publisher<TRightEnd>> rightEnd, BiFunction<? super TLeft, ? super TRight, ? extends R> resultSelector)
	FlowableMap(Flowable<T> source, Function<? super T, ? extends U> mapper)
	FlowableMapNotification(Flowable<T> source, Function<? super T, ? extends R> onNextMapper, Function<? super Throwable, ? extends R> onErrorMapper, Supplier<? extends R> onCompleteSupplier)
	FlowableMapPublisher(org.reactivestreams.Publisher<T> source, Function<? super T, ? extends U> mapper)
	FlowableOnErrorNext(Flowable<T> source, Function<? super Throwable, ? extends org.reactivestreams.Publisher<? extends T>> nextSupplier)
	FlowableOnErrorReturn(Flowable<T> source, Function<? super Throwable, ? extends T> valueSupplier)
	FlowablePublishMulticast(Flowable<T> source, Function<? super Flowable<T>, ? extends org.reactivestreams.Publisher<? extends R>> selector, int prefetch, boolean delayError)
	FlowableRepeatWhen(Flowable<T> source, Function<? super Flowable<Object>, ? extends org.reactivestreams.Publisher<?>> handler)
	FlowableRetryWhen(Flowable<T> source, Function<? super Flowable<Throwable>, ? extends org.reactivestreams.Publisher<?>> handler)
	FlowableSwitchMap(Flowable<T> source, Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>> mapper, int bufferSize, boolean delayErrors)
	FlowableTimeout(Flowable<T> source, org.reactivestreams.Publisher<U> firstTimeoutIndicator, Function<? super T, ? extends org.reactivestreams.Publisher<V>> itemTimeoutIndicator, org.reactivestreams.Publisher<? extends T> other)
	FlowableUsing(Supplier<? extends D> resourceSupplier, Function<? super D, ? extends org.reactivestreams.Publisher<? extends T>> sourceSupplier, Consumer<? super D> disposer, boolean eager)
	FlowableWindowBoundarySelector(Flowable<T> source, org.reactivestreams.Publisher<B> open, Function<? super B, ? extends org.reactivestreams.Publisher<V>> closingIndicator, int bufferSize)
	FlowableWithLatestFromMany(@NonNull Flowable<T> source, @NonNull Iterable<? extends org.reactivestreams.Publisher<?>> otherIterable, @NonNull Function<? super Object[], R> combiner)
	FlowableWithLatestFromMany(@NonNull Flowable<T> source, @NonNull org.reactivestreams.Publisher<?>[] otherArray, Function<? super Object[], R> combiner)
	FlowableZip(org.reactivestreams.Publisher<? extends T>[] sources, Iterable<? extends org.reactivestreams.Publisher<? extends T>> sourcesIterable, Function<? super Object[], ? extends R> zipper, int bufferSize, boolean delayError)
	GroupBySubscriber(org.reactivestreams.Subscriber<? super GroupedFlowable<K,V>> actual, Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector, int bufferSize, boolean delayError, Map<Object, FlowableGroupBy.GroupedUnicast<K,V>> groups, Queue<FlowableGroupBy.GroupedUnicast<K,V>> evictedGroups)
(package private)	GroupJoinSubscription(org.reactivestreams.Subscriber<? super R> actual, Function<? super TLeft, ? extends org.reactivestreams.Publisher<TLeftEnd>> leftEnd, Function<? super TRight, ? extends org.reactivestreams.Publisher<TRightEnd>> rightEnd, BiFunction<? super TLeft, ? super Flowable<TRight>, ? extends R> resultSelector)
(package private)	ItemDelayFunction(Function<? super T, ? extends org.reactivestreams.Publisher<U>> itemDelay)
(package private)	JoinSubscription(org.reactivestreams.Subscriber<? super R> actual, Function<? super TLeft, ? extends org.reactivestreams.Publisher<TLeftEnd>> leftEnd, Function<? super TRight, ? extends org.reactivestreams.Publisher<TRightEnd>> rightEnd, BiFunction<? super TLeft, ? super TRight, ? extends R> resultSelector)
(package private)	MapConditionalSubscriber(ConditionalSubscriber<? super U> actual, Function<? super T, ? extends U> function)
(package private)	MapNotificationSubscriber(org.reactivestreams.Subscriber<? super R> actual, Function<? super T, ? extends R> onNextMapper, Function<? super Throwable, ? extends R> onErrorMapper, Supplier<? extends R> onCompleteSupplier)
(package private)	MapSubscriber(org.reactivestreams.Subscriber<? super U> actual, Function<? super T, ? extends U> mapper)
(package private)	MergeSubscriber(org.reactivestreams.Subscriber<? super U> actual, Function<? super T, ? extends org.reactivestreams.Publisher<? extends U>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize)
(package private)	MulticastFlowable(Supplier<? extends ConnectableFlowable<U>> connectableFactory, Function<? super Flowable<U>, ? extends org.reactivestreams.Publisher<R>> selector)
(package private)	OnErrorNextSubscriber(org.reactivestreams.Subscriber<? super T> actual, Function<? super Throwable, ? extends org.reactivestreams.Publisher<? extends T>> nextSupplier)
(package private)	OnErrorReturnSubscriber(org.reactivestreams.Subscriber<? super T> actual, Function<? super Throwable, ? extends T> valueSupplier)
(package private)	ScalarXMapFlowable(T value, Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>> mapper)
(package private)	SwitchMapSubscriber(org.reactivestreams.Subscriber<? super R> actual, Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>> mapper, int bufferSize, boolean delayErrors)
(package private)	TimeoutFallbackSubscriber(org.reactivestreams.Subscriber<? super T> actual, Function<? super T, ? extends org.reactivestreams.Publisher<?>> itemTimeoutIndicator, org.reactivestreams.Publisher<? extends T> fallback)
(package private)	TimeoutSubscriber(org.reactivestreams.Subscriber<? super T> actual, Function<? super T, ? extends org.reactivestreams.Publisher<?>> itemTimeoutIndicator)
(package private)	WindowBoundaryMainSubscriber(org.reactivestreams.Subscriber<? super Flowable<T>> actual, org.reactivestreams.Publisher<B> open, Function<? super B, ? extends org.reactivestreams.Publisher<V>> closingIndicator, int bufferSize)
(package private)	WithLatestFromSubscriber(org.reactivestreams.Subscriber<? super R> actual, Function<? super Object[], R> combiner, int n)
(package private)	ZipCoordinator(org.reactivestreams.Subscriber<? super R> actual, Function<? super Object[], ? extends R> zipper, int n, int prefetch, boolean delayErrors)

Uses of Function in io.reactivex.rxjava3.internal.operators.maybe

Classes in io.reactivex.rxjava3.internal.operators.maybe that implement Function

Modifier and Type	Class	Description
enum	MaybeToPublisher	Helper function to merge/concat values of each MaybeSource provided by a Publisher.
(package private) final class	MaybeZipArray.SingletonArrayFunc
(package private) final class	MaybeZipIterable.SingletonArrayFunc

Fields in io.reactivex.rxjava3.internal.operators.maybe declared as Function

Modifier and Type	Field	Description
(package private) final Function<? super Throwable, ? extends T>	MaybeOnErrorReturn.itemSupplier
(package private) final Function<? super Throwable, ? extends T>	MaybeOnErrorReturn.OnErrorReturnMaybeObserver.itemSupplier
(package private) final Function<? super T, ? extends MaybeSource<? extends U>>	MaybeFlatMapBiSelector.FlatMapBiMainObserver.mapper
(package private) final Function<? super T, ? extends MaybeSource<? extends U>>	MaybeFlatMapBiSelector.mapper
(package private) final Function<? super T, ? extends CompletableSource>	MaybeFlatMapCompletable.FlatMapCompletableObserver.mapper
(package private) final Function<? super T, ? extends CompletableSource>	MaybeFlatMapCompletable.mapper
(package private) final Function<? super T, ? extends Iterable<? extends R>>	MaybeFlatMapIterableFlowable.FlatMapIterableObserver.mapper
(package private) final Function<? super T, ? extends Iterable<? extends R>>	MaybeFlatMapIterableFlowable.mapper
(package private) final Function<? super T, ? extends Iterable<? extends R>>	MaybeFlatMapIterableObservable.FlatMapIterableObserver.mapper
(package private) final Function<? super T, ? extends Iterable<? extends R>>	MaybeFlatMapIterableObservable.mapper
(package private) final Function<? super T, ? extends SingleSource<? extends R>>	MaybeFlatMapSingle.FlatMapMaybeObserver.mapper
(package private) final Function<? super T, ? extends SingleSource<? extends R>>	MaybeFlatMapSingle.mapper
(package private) final Function<? super T, ? extends MaybeSource<? extends R>>	MaybeFlatten.FlatMapMaybeObserver.mapper
(package private) final Function<? super T, ? extends MaybeSource<? extends R>>	MaybeFlatten.mapper
(package private) final Function<? super T, ? extends R>	MaybeMap.MapMaybeObserver.mapper
(package private) final Function<? super T, ? extends R>	MaybeMap.mapper
(package private) final Function<? super Throwable, ? extends MaybeSource<? extends R>>	MaybeFlatMapNotification.FlatMapMaybeObserver.onErrorMapper
(package private) final Function<? super Throwable, ? extends MaybeSource<? extends R>>	MaybeFlatMapNotification.onErrorMapper
(package private) final Function<? super T, ? extends MaybeSource<? extends R>>	MaybeFlatMapNotification.FlatMapMaybeObserver.onSuccessMapper
(package private) final Function<? super T, ? extends MaybeSource<? extends R>>	MaybeFlatMapNotification.onSuccessMapper
(package private) final Function<? super Throwable, ? extends MaybeSource<? extends T>>	MaybeOnErrorNext.OnErrorNextMaybeObserver.resumeFunction
(package private) final Function<? super Throwable, ? extends MaybeSource<? extends T>>	MaybeOnErrorNext.resumeFunction
(package private) final Function<? super T, Notification<R>>	MaybeDematerialize.DematerializeObserver.selector
(package private) final Function<? super T, Notification<R>>	MaybeDematerialize.selector
(package private) final Function<? super D, ? extends MaybeSource<? extends T>>	MaybeUsing.sourceSupplier
(package private) final Function<? super Object[], ? extends R>	MaybeZipArray.ZipCoordinator.zipper
(package private) final Function<? super Object[], ? extends R>	MaybeZipArray.zipper
(package private) final Function<? super Object[], ? extends R>	MaybeZipIterable.zipper

Methods in io.reactivex.rxjava3.internal.operators.maybe that return Function

Modifier and Type	Method	Description
static <T> Function<MaybeSource<T>, org.reactivestreams.Publisher<T>>	MaybeToPublisher.instance()

Constructors in io.reactivex.rxjava3.internal.operators.maybe with parameters of type Function

Modifier	Constructor	Description
(package private)	DematerializeObserver(MaybeObserver<? super R> downstream, Function<? super T, Notification<R>> selector)
(package private)	FlatMapBiMainObserver(MaybeObserver<? super R> actual, Function<? super T, ? extends MaybeSource<? extends U>> mapper, BiFunction<? super T, ? super U, ? extends R> resultSelector)
(package private)	FlatMapCompletableObserver(CompletableObserver actual, Function<? super T, ? extends CompletableSource> mapper)
(package private)	FlatMapIterableObserver(org.reactivestreams.Subscriber<? super R> actual, Function<? super T, ? extends Iterable<? extends R>> mapper)
(package private)	FlatMapIterableObserver(Observer<? super R> actual, Function<? super T, ? extends Iterable<? extends R>> mapper)
(package private)	FlatMapMaybeObserver(MaybeObserver<? super R> actual, Function<? super T, ? extends MaybeSource<? extends R>> onSuccessMapper, Function<? super Throwable, ? extends MaybeSource<? extends R>> onErrorMapper, Supplier<? extends MaybeSource<? extends R>> onCompleteSupplier)
(package private)	FlatMapMaybeObserver(MaybeObserver<? super R> actual, Function<? super T, ? extends SingleSource<? extends R>> mapper)
(package private)	FlatMapMaybeObserver(MaybeObserver<? super R> actual, Function<? super T, ? extends MaybeSource<? extends R>> mapper)
(package private)	MapMaybeObserver(MaybeObserver<? super R> actual, Function<? super T, ? extends R> mapper)
	MaybeDematerialize(Maybe<T> source, Function<? super T, Notification<R>> selector)
	MaybeFlatMapBiSelector(MaybeSource<T> source, Function<? super T, ? extends MaybeSource<? extends U>> mapper, BiFunction<? super T, ? super U, ? extends R> resultSelector)
	MaybeFlatMapCompletable(MaybeSource<T> source, Function<? super T, ? extends CompletableSource> mapper)
	MaybeFlatMapIterableFlowable(MaybeSource<T> source, Function<? super T, ? extends Iterable<? extends R>> mapper)
	MaybeFlatMapIterableObservable(MaybeSource<T> source, Function<? super T, ? extends Iterable<? extends R>> mapper)
	MaybeFlatMapNotification(MaybeSource<T> source, Function<? super T, ? extends MaybeSource<? extends R>> onSuccessMapper, Function<? super Throwable, ? extends MaybeSource<? extends R>> onErrorMapper, Supplier<? extends MaybeSource<? extends R>> onCompleteSupplier)
	MaybeFlatMapSingle(MaybeSource<T> source, Function<? super T, ? extends SingleSource<? extends R>> mapper)
	MaybeFlatten(MaybeSource<T> source, Function<? super T, ? extends MaybeSource<? extends R>> mapper)
	MaybeMap(MaybeSource<T> source, Function<? super T, ? extends R> mapper)
	MaybeOnErrorNext(MaybeSource<T> source, Function<? super Throwable, ? extends MaybeSource<? extends T>> resumeFunction)
	MaybeOnErrorReturn(MaybeSource<T> source, Function<? super Throwable, ? extends T> itemSupplier)
	MaybeUsing(Supplier<? extends D> resourceSupplier, Function<? super D, ? extends MaybeSource<? extends T>> sourceSupplier, Consumer<? super D> resourceDisposer, boolean eager)
	MaybeZipArray(MaybeSource<? extends T>[] sources, Function<? super Object[], ? extends R> zipper)
	MaybeZipIterable(Iterable<? extends MaybeSource<? extends T>> sources, Function<? super Object[], ? extends R> zipper)
(package private)	OnErrorNextMaybeObserver(MaybeObserver<? super T> actual, Function<? super Throwable, ? extends MaybeSource<? extends T>> resumeFunction)
(package private)	OnErrorReturnMaybeObserver(MaybeObserver<? super T> actual, Function<? super Throwable, ? extends T> valueSupplier)
(package private)	ZipCoordinator(MaybeObserver<? super R> observer, int n, Function<? super Object[], ? extends R> zipper)

Uses of Function in io.reactivex.rxjava3.internal.operators.mixed

Fields in io.reactivex.rxjava3.internal.operators.mixed declared as Function

Modifier and Type	Field	Description
(package private) final Function<? super T, ? extends CompletableSource>	FlowableConcatMapCompletable.ConcatMapCompletableObserver.mapper
(package private) final Function<? super T, ? extends CompletableSource>	FlowableConcatMapCompletable.mapper
(package private) final Function<? super T, ? extends MaybeSource<? extends R>>	FlowableConcatMapMaybe.ConcatMapMaybeSubscriber.mapper
(package private) final Function<? super T, ? extends MaybeSource<? extends R>>	FlowableConcatMapMaybe.mapper
(package private) final Function<? super T, ? extends MaybeSource<? extends R>>	FlowableConcatMapMaybePublisher.mapper
(package private) final Function<? super T, ? extends SingleSource<? extends R>>	FlowableConcatMapSingle.ConcatMapSingleSubscriber.mapper
(package private) final Function<? super T, ? extends SingleSource<? extends R>>	FlowableConcatMapSingle.mapper
(package private) final Function<? super T, ? extends SingleSource<? extends R>>	FlowableConcatMapSinglePublisher.mapper
(package private) final Function<? super T, ? extends CompletableSource>	FlowableSwitchMapCompletable.mapper
(package private) final Function<? super T, ? extends CompletableSource>	FlowableSwitchMapCompletable.SwitchMapCompletableObserver.mapper
(package private) final Function<? super T, ? extends CompletableSource>	FlowableSwitchMapCompletablePublisher.mapper
(package private) final Function<? super T, ? extends MaybeSource<? extends R>>	FlowableSwitchMapMaybe.mapper
(package private) final Function<? super T, ? extends MaybeSource<? extends R>>	FlowableSwitchMapMaybe.SwitchMapMaybeSubscriber.mapper
(package private) final Function<? super T, ? extends MaybeSource<? extends R>>	FlowableSwitchMapMaybePublisher.mapper
(package private) final Function<? super T, ? extends SingleSource<? extends R>>	FlowableSwitchMapSingle.mapper
(package private) final Function<? super T, ? extends SingleSource<? extends R>>	FlowableSwitchMapSingle.SwitchMapSingleSubscriber.mapper
(package private) final Function<? super T, ? extends SingleSource<? extends R>>	FlowableSwitchMapSinglePublisher.mapper
(package private) final Function<? super T, ? extends ObservableSource<? extends R>>	MaybeFlatMapObservable.FlatMapObserver.mapper
(package private) final Function<? super T, ? extends ObservableSource<? extends R>>	MaybeFlatMapObservable.mapper
(package private) final Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>>	MaybeFlatMapPublisher.FlatMapPublisherSubscriber.mapper
(package private) final Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>>	MaybeFlatMapPublisher.mapper
(package private) final Function<? super T, ? extends CompletableSource>	ObservableConcatMapCompletable.ConcatMapCompletableObserver.mapper
(package private) final Function<? super T, ? extends CompletableSource>	ObservableConcatMapCompletable.mapper
(package private) final Function<? super T, ? extends MaybeSource<? extends R>>	ObservableConcatMapMaybe.ConcatMapMaybeMainObserver.mapper
(package private) final Function<? super T, ? extends MaybeSource<? extends R>>	ObservableConcatMapMaybe.mapper
(package private) final Function<? super T, ? extends SingleSource<? extends R>>	ObservableConcatMapSingle.ConcatMapSingleMainObserver.mapper
(package private) final Function<? super T, ? extends SingleSource<? extends R>>	ObservableConcatMapSingle.mapper
(package private) final Function<? super T, ? extends CompletableSource>	ObservableSwitchMapCompletable.mapper
(package private) final Function<? super T, ? extends CompletableSource>	ObservableSwitchMapCompletable.SwitchMapCompletableObserver.mapper
(package private) final Function<? super T, ? extends MaybeSource<? extends R>>	ObservableSwitchMapMaybe.mapper
(package private) final Function<? super T, ? extends MaybeSource<? extends R>>	ObservableSwitchMapMaybe.SwitchMapMaybeMainObserver.mapper
(package private) final Function<? super T, ? extends SingleSource<? extends R>>	ObservableSwitchMapSingle.mapper
(package private) final Function<? super T, ? extends SingleSource<? extends R>>	ObservableSwitchMapSingle.SwitchMapSingleMainObserver.mapper
(package private) final Function<? super T, ? extends ObservableSource<? extends R>>	SingleFlatMapObservable.FlatMapObserver.mapper
(package private) final Function<? super T, ? extends ObservableSource<? extends R>>	SingleFlatMapObservable.mapper

Methods in io.reactivex.rxjava3.internal.operators.mixed with parameters of type Function

Modifier and Type	Method	Description
(package private) static <T> boolean	ScalarXMapZHelper.tryAsCompletable(Object source, Function<? super T, ? extends CompletableSource> mapper, CompletableObserver observer)	Try subscribing to a CompletableSource mapped from a scalar source (which implements Supplier).
(package private) static <T,R> boolean	ScalarXMapZHelper.tryAsMaybe(Object source, Function<? super T, ? extends MaybeSource<? extends R>> mapper, Observer<? super R> observer)	Try subscribing to a MaybeSource mapped from a scalar source (which implements Supplier).
(package private) static <T,R> boolean	ScalarXMapZHelper.tryAsSingle(Object source, Function<? super T, ? extends SingleSource<? extends R>> mapper, Observer<? super R> observer)	Try subscribing to a SingleSource mapped from a scalar source (which implements Supplier).

Constructors in io.reactivex.rxjava3.internal.operators.mixed with parameters of type Function

Modifier	Constructor	Description
(package private)	ConcatMapCompletableObserver(CompletableObserver downstream, Function<? super T, ? extends CompletableSource> mapper, ErrorMode errorMode, int prefetch)
(package private)	ConcatMapCompletableObserver(CompletableObserver downstream, Function<? super T, ? extends CompletableSource> mapper, ErrorMode errorMode, int prefetch)
(package private)	ConcatMapMaybeMainObserver(Observer<? super R> downstream, Function<? super T, ? extends MaybeSource<? extends R>> mapper, int prefetch, ErrorMode errorMode)
(package private)	ConcatMapMaybeSubscriber(org.reactivestreams.Subscriber<? super R> downstream, Function<? super T, ? extends MaybeSource<? extends R>> mapper, int prefetch, ErrorMode errorMode)
(package private)	ConcatMapSingleMainObserver(Observer<? super R> downstream, Function<? super T, ? extends SingleSource<? extends R>> mapper, int prefetch, ErrorMode errorMode)
(package private)	ConcatMapSingleSubscriber(org.reactivestreams.Subscriber<? super R> downstream, Function<? super T, ? extends SingleSource<? extends R>> mapper, int prefetch, ErrorMode errorMode)
(package private)	FlatMapObserver(Observer<? super R> downstream, Function<? super T, ? extends ObservableSource<? extends R>> mapper)
(package private)	FlatMapObserver(Observer<? super R> downstream, Function<? super T, ? extends ObservableSource<? extends R>> mapper)
(package private)	FlatMapPublisherSubscriber(org.reactivestreams.Subscriber<? super R> downstream, Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>> mapper)
	FlowableConcatMapCompletable(Flowable<T> source, Function<? super T, ? extends CompletableSource> mapper, ErrorMode errorMode, int prefetch)
	FlowableConcatMapMaybe(Flowable<T> source, Function<? super T, ? extends MaybeSource<? extends R>> mapper, ErrorMode errorMode, int prefetch)
	FlowableConcatMapMaybePublisher(org.reactivestreams.Publisher<T> source, Function<? super T, ? extends MaybeSource<? extends R>> mapper, ErrorMode errorMode, int prefetch)
	FlowableConcatMapSingle(Flowable<T> source, Function<? super T, ? extends SingleSource<? extends R>> mapper, ErrorMode errorMode, int prefetch)
	FlowableConcatMapSinglePublisher(org.reactivestreams.Publisher<T> source, Function<? super T, ? extends SingleSource<? extends R>> mapper, ErrorMode errorMode, int prefetch)
	FlowableSwitchMapCompletable(Flowable<T> source, Function<? super T, ? extends CompletableSource> mapper, boolean delayErrors)
	FlowableSwitchMapCompletablePublisher(org.reactivestreams.Publisher<T> source, Function<? super T, ? extends CompletableSource> mapper, boolean delayErrors)
	FlowableSwitchMapMaybe(Flowable<T> source, Function<? super T, ? extends MaybeSource<? extends R>> mapper, boolean delayErrors)
	FlowableSwitchMapMaybePublisher(org.reactivestreams.Publisher<T> source, Function<? super T, ? extends MaybeSource<? extends R>> mapper, boolean delayErrors)
	FlowableSwitchMapSingle(Flowable<T> source, Function<? super T, ? extends SingleSource<? extends R>> mapper, boolean delayErrors)
	FlowableSwitchMapSinglePublisher(org.reactivestreams.Publisher<T> source, Function<? super T, ? extends SingleSource<? extends R>> mapper, boolean delayErrors)
	MaybeFlatMapObservable(MaybeSource<T> source, Function<? super T, ? extends ObservableSource<? extends R>> mapper)
	MaybeFlatMapPublisher(MaybeSource<T> source, Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>> mapper)
	ObservableConcatMapCompletable(Observable<T> source, Function<? super T, ? extends CompletableSource> mapper, ErrorMode errorMode, int prefetch)
	ObservableConcatMapMaybe(Observable<T> source, Function<? super T, ? extends MaybeSource<? extends R>> mapper, ErrorMode errorMode, int prefetch)
	ObservableConcatMapSingle(ObservableSource<T> source, Function<? super T, ? extends SingleSource<? extends R>> mapper, ErrorMode errorMode, int prefetch)
	ObservableSwitchMapCompletable(Observable<T> source, Function<? super T, ? extends CompletableSource> mapper, boolean delayErrors)
	ObservableSwitchMapMaybe(Observable<T> source, Function<? super T, ? extends MaybeSource<? extends R>> mapper, boolean delayErrors)
	ObservableSwitchMapSingle(Observable<T> source, Function<? super T, ? extends SingleSource<? extends R>> mapper, boolean delayErrors)
	SingleFlatMapObservable(SingleSource<T> source, Function<? super T, ? extends ObservableSource<? extends R>> mapper)
(package private)	SwitchMapCompletableObserver(CompletableObserver downstream, Function<? super T, ? extends CompletableSource> mapper, boolean delayErrors)
(package private)	SwitchMapCompletableObserver(CompletableObserver downstream, Function<? super T, ? extends CompletableSource> mapper, boolean delayErrors)
(package private)	SwitchMapMaybeMainObserver(Observer<? super R> downstream, Function<? super T, ? extends MaybeSource<? extends R>> mapper, boolean delayErrors)
(package private)	SwitchMapMaybeSubscriber(org.reactivestreams.Subscriber<? super R> downstream, Function<? super T, ? extends MaybeSource<? extends R>> mapper, boolean delayErrors)
(package private)	SwitchMapSingleMainObserver(Observer<? super R> downstream, Function<? super T, ? extends SingleSource<? extends R>> mapper, boolean delayErrors)
(package private)	SwitchMapSingleSubscriber(org.reactivestreams.Subscriber<? super R> downstream, Function<? super T, ? extends SingleSource<? extends R>> mapper, boolean delayErrors)

Uses of Function in io.reactivex.rxjava3.internal.operators.observable

Classes in io.reactivex.rxjava3.internal.operators.observable that implement Function

Modifier and Type	Class	Description
(package private) static final class	ObservableInternalHelper.FlatMapIntoIterable<T,U>
(package private) static final class	ObservableInternalHelper.FlatMapWithCombinerInner<U,R,T>
(package private) static final class	ObservableInternalHelper.FlatMapWithCombinerOuter<T,R,U>
(package private) static final class	ObservableInternalHelper.ItemDelayFunction<T,U>
(package private) static enum	ObservableInternalHelper.MapToInt
(package private) final class	ObservableWithLatestFromMany.SingletonArrayFunc

Fields in io.reactivex.rxjava3.internal.operators.observable declared as Function

Modifier and Type	Field	Description
(package private) final Function<? super Open, ? extends ObservableSource<? extends Close>>	ObservableBufferBoundary.BufferBoundaryObserver.bufferClose
(package private) final Function<? super Open, ? extends ObservableSource<? extends Close>>	ObservableBufferBoundary.bufferClose
(package private) final Function<? super B, ? extends ObservableSource<V>>	ObservableWindowBoundarySelector.closingIndicator
(package private) final Function<? super B, ? extends ObservableSource<V>>	ObservableWindowBoundarySelector.WindowBoundaryMainObserver.closingIndicator
(package private) final Function<? super Object[], ? extends R>	ObservableCombineLatest.combiner
(package private) final Function<? super Object[], ? extends R>	ObservableCombineLatest.LatestCoordinator.combiner
(package private) final @NonNull Function<? super Object[], R>	ObservableWithLatestFromMany.combiner
(package private) final Function<? super Object[], R>	ObservableWithLatestFromMany.WithLatestFromObserver.combiner
(package private) final Function<? super T, ? extends ObservableSource<U>>	ObservableDebounce.DebounceObserver.debounceSelector
(package private) final Function<? super T, ? extends ObservableSource<U>>	ObservableDebounce.debounceSelector
(package private) final Function<? super T, ? extends U>	ObservableMap.function
(package private) final Function<? super Observable<Object>, ? extends ObservableSource<?>>	ObservableRepeatWhen.handler
(package private) final Function<? super Observable<Throwable>, ? extends ObservableSource<?>>	ObservableRetryWhen.handler
(package private) final Function<? super T, ? extends ObservableSource<U>>	ObservableInternalHelper.ItemDelayFunction.itemDelay
(package private) final Function<? super T, ? extends ObservableSource<V>>	ObservableTimeout.itemTimeoutIndicator
(package private) final Function<? super T, ? extends ObservableSource<?>>	ObservableTimeout.TimeoutFallbackObserver.itemTimeoutIndicator
(package private) final Function<? super T, ? extends ObservableSource<?>>	ObservableTimeout.TimeoutObserver.itemTimeoutIndicator
(package private) final Function<? super T, K>	ObservableDistinct.DistinctObserver.keySelector
(package private) final Function<? super T, K>	ObservableDistinct.keySelector
(package private) final Function<? super T, K>	ObservableDistinctUntilChanged.DistinctUntilChangedObserver.keySelector
(package private) final Function<? super T, K>	ObservableDistinctUntilChanged.keySelector
(package private) final Function<? super T, ? extends K>	ObservableGroupBy.GroupByObserver.keySelector
(package private) final Function<? super T, ? extends K>	ObservableGroupBy.keySelector
(package private) final Function<? super TLeft, ? extends ObservableSource<TLeftEnd>>	ObservableGroupJoin.GroupJoinDisposable.leftEnd
(package private) final Function<? super TLeft, ? extends ObservableSource<TLeftEnd>>	ObservableGroupJoin.leftEnd
(package private) final Function<? super TLeft, ? extends ObservableSource<TLeftEnd>>	ObservableJoin.JoinDisposable.leftEnd
(package private) final Function<? super TLeft, ? extends ObservableSource<TLeftEnd>>	ObservableJoin.leftEnd
(package private) final Function<? super T, ? extends ObservableSource<? extends R>>	ObservableConcatMap.ConcatMapDelayErrorObserver.mapper
(package private) final Function<? super T, ? extends ObservableSource<? extends U>>	ObservableConcatMap.mapper
(package private) final Function<? super T, ? extends ObservableSource<? extends U>>	ObservableConcatMap.SourceObserver.mapper
(package private) final Function<? super T, ? extends ObservableSource<? extends R>>	ObservableConcatMapEager.ConcatMapEagerMainObserver.mapper
(package private) final Function<? super T, ? extends ObservableSource<? extends R>>	ObservableConcatMapEager.mapper
(package private) final Function<? super T, ? extends ObservableSource<? extends R>>	ObservableConcatMapScheduler.ConcatMapDelayErrorObserver.mapper
(package private) final Function<? super T, ? extends ObservableSource<? extends U>>	ObservableConcatMapScheduler.ConcatMapObserver.mapper
(package private) final Function<? super T, ? extends ObservableSource<? extends U>>	ObservableConcatMapScheduler.mapper
(package private) final Function<? super T, ? extends ObservableSource<? extends U>>	ObservableFlatMap.mapper
(package private) final Function<? super T, ? extends ObservableSource<? extends U>>	ObservableFlatMap.MergeObserver.mapper
(package private) final Function<? super T, ? extends CompletableSource>	ObservableFlatMapCompletable.FlatMapCompletableMainObserver.mapper
(package private) final Function<? super T, ? extends CompletableSource>	ObservableFlatMapCompletable.mapper
(package private) final Function<? super T, ? extends CompletableSource>	ObservableFlatMapCompletableCompletable.FlatMapCompletableMainObserver.mapper
(package private) final Function<? super T, ? extends CompletableSource>	ObservableFlatMapCompletableCompletable.mapper
(package private) final Function<? super T, ? extends MaybeSource<? extends R>>	ObservableFlatMapMaybe.FlatMapMaybeObserver.mapper
(package private) final Function<? super T, ? extends MaybeSource<? extends R>>	ObservableFlatMapMaybe.mapper
(package private) final Function<? super T, ? extends SingleSource<? extends R>>	ObservableFlatMapSingle.FlatMapSingleObserver.mapper
(package private) final Function<? super T, ? extends SingleSource<? extends R>>	ObservableFlatMapSingle.mapper
(package private) final Function<? super T, ? extends Iterable<? extends R>>	ObservableFlattenIterable.FlattenIterableObserver.mapper
(package private) final Function<? super T, ? extends Iterable<? extends R>>	ObservableFlattenIterable.mapper
private final Function<? super T, ? extends Iterable<? extends U>>	ObservableInternalHelper.FlatMapIntoIterable.mapper
private final Function<? super T, ? extends ObservableSource<? extends U>>	ObservableInternalHelper.FlatMapWithCombinerOuter.mapper
(package private) final Function<? super T, ? extends U>	ObservableMap.MapObserver.mapper
(package private) final Function<? super T, ? extends ObservableSource<? extends R>>	ObservableScalarXMap.ScalarXMapObservable.mapper
(package private) final Function<? super T, ? extends ObservableSource<? extends R>>	ObservableSwitchMap.mapper
(package private) final Function<? super T, ? extends ObservableSource<? extends R>>	ObservableSwitchMap.SwitchMapObserver.mapper
(package private) final Function<? super Throwable, ? extends ObservableSource<? extends T>>	ObservableOnErrorNext.nextSupplier
(package private) final Function<? super Throwable, ? extends ObservableSource<? extends T>>	ObservableOnErrorNext.OnErrorNextObserver.nextSupplier
(package private) final Function<? super Throwable, ? extends ObservableSource<? extends R>>	ObservableMapNotification.MapNotificationObserver.onErrorMapper
(package private) final Function<? super Throwable, ? extends ObservableSource<? extends R>>	ObservableMapNotification.onErrorMapper
(package private) final Function<? super T, ? extends ObservableSource<? extends R>>	ObservableMapNotification.MapNotificationObserver.onNextMapper
(package private) final Function<? super T, ? extends ObservableSource<? extends R>>	ObservableMapNotification.onNextMapper
(package private) final Function<? super TRight, ? extends ObservableSource<TRightEnd>>	ObservableGroupJoin.GroupJoinDisposable.rightEnd
(package private) final Function<? super TRight, ? extends ObservableSource<TRightEnd>>	ObservableGroupJoin.rightEnd
(package private) final Function<? super TRight, ? extends ObservableSource<TRightEnd>>	ObservableJoin.JoinDisposable.rightEnd
(package private) final Function<? super TRight, ? extends ObservableSource<TRightEnd>>	ObservableJoin.rightEnd
(package private) final Function<? super T, ? extends Notification<R>>	ObservableDematerialize.DematerializeObserver.selector
(package private) final Function<? super T, ? extends Notification<R>>	ObservableDematerialize.selector
(package private) final Function<? super Observable<T>, ? extends ObservableSource<R>>	ObservablePublishSelector.selector
private final Function<? super Observable<U>, ? extends ObservableSource<R>>	ObservableReplay.MulticastReplay.selector
(package private) final Function<? super D, ? extends ObservableSource<? extends T>>	ObservableUsing.sourceSupplier
(package private) final Function<? super T, ? extends V>	ObservableGroupBy.GroupByObserver.valueSelector
(package private) final Function<? super T, ? extends V>	ObservableGroupBy.valueSelector
(package private) final Function<? super Throwable, ? extends T>	ObservableOnErrorReturn.OnErrorReturnObserver.valueSupplier
(package private) final Function<? super Throwable, ? extends T>	ObservableOnErrorReturn.valueSupplier
(package private) final Function<? super Object[], ? extends R>	ObservableZip.ZipCoordinator.zipper
(package private) final Function<? super Object[], ? extends R>	ObservableZip.zipper

Methods in io.reactivex.rxjava3.internal.operators.observable that return Function

Modifier and Type	Method	Description
static <T,U> Function<T, ObservableSource<U>>	ObservableInternalHelper.flatMapIntoIterable(Function<? super T, ? extends Iterable<? extends U>> mapper)
static <T,U,R> Function<T, ObservableSource<R>>	ObservableInternalHelper.flatMapWithCombiner(Function<? super T, ? extends ObservableSource<? extends U>> mapper, BiFunction<? super T, ? super U, ? extends R> combiner)
static <T,U> Function<T, ObservableSource<T>>	ObservableInternalHelper.itemDelay(Function<? super T, ? extends ObservableSource<U>> itemDelay)

Methods in io.reactivex.rxjava3.internal.operators.observable with parameters of type Function

Modifier and Type	Method	Description
static <T,U> Function<T, ObservableSource<U>>	ObservableInternalHelper.flatMapIntoIterable(Function<? super T, ? extends Iterable<? extends U>> mapper)
static <T,U,R> Function<T, ObservableSource<R>>	ObservableInternalHelper.flatMapWithCombiner(Function<? super T, ? extends ObservableSource<? extends U>> mapper, BiFunction<? super T, ? super U, ? extends R> combiner)
static <T,U> Function<T, ObservableSource<T>>	ObservableInternalHelper.itemDelay(Function<? super T, ? extends ObservableSource<U>> itemDelay)
static <U,R> Observable<R>	ObservableReplay.multicastSelector(Supplier<? extends ConnectableObservable<U>> connectableFactory, Function<? super Observable<U>, ? extends ObservableSource<R>> selector)	Given a connectable observable factory, it multicasts over the generated ConnectableObservable via a selector function.
static <T,U> Observable<U>	ObservableScalarXMap.scalarXMap(T value, Function<? super T, ? extends ObservableSource<? extends U>> mapper)	Maps a scalar value into an Observable and emits its values.
static <T,R> boolean	ObservableScalarXMap.tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper)	Tries to subscribe to a possibly Supplier source's mapped ObservableSource.

Constructors in io.reactivex.rxjava3.internal.operators.observable with parameters of type Function

Modifier	Constructor	Description
(package private)	BufferBoundaryObserver(Observer<? super C> actual, ObservableSource<? extends Open> bufferOpen, Function<? super Open, ? extends ObservableSource<? extends Close>> bufferClose, Supplier<C> bufferSupplier)
(package private)	ConcatMapDelayErrorObserver(Observer<? super R> actual, Function<? super T, ? extends ObservableSource<? extends R>> mapper, int bufferSize, boolean tillTheEnd)
(package private)	ConcatMapDelayErrorObserver(Observer<? super R> actual, Function<? super T, ? extends ObservableSource<? extends R>> mapper, int bufferSize, boolean tillTheEnd, Scheduler.Worker worker)
(package private)	ConcatMapEagerMainObserver(Observer<? super R> actual, Function<? super T, ? extends ObservableSource<? extends R>> mapper, int maxConcurrency, int prefetch, ErrorMode errorMode)
(package private)	ConcatMapObserver(Observer<? super U> actual, Function<? super T, ? extends ObservableSource<? extends U>> mapper, int bufferSize, Scheduler.Worker worker)
(package private)	DebounceObserver(Observer<? super T> actual, Function<? super T, ? extends ObservableSource<U>> debounceSelector)
(package private)	DematerializeObserver(Observer<? super R> downstream, Function<? super T, ? extends Notification<R>> selector)
(package private)	DistinctObserver(Observer<? super T> actual, Function<? super T, K> keySelector, Collection<? super K> collection)
(package private)	DistinctUntilChangedObserver(Observer<? super T> actual, Function<? super T, K> keySelector, BiPredicate<? super K, ? super K> comparer)
(package private)	FlatMapCompletableMainObserver(Observer<? super T> observer, Function<? super T, ? extends CompletableSource> mapper, boolean delayErrors)
(package private)	FlatMapCompletableMainObserver(CompletableObserver observer, Function<? super T, ? extends CompletableSource> mapper, boolean delayErrors)
(package private)	FlatMapIntoIterable(Function<? super T, ? extends Iterable<? extends U>> mapper)
(package private)	FlatMapMaybeObserver(Observer<? super R> actual, Function<? super T, ? extends MaybeSource<? extends R>> mapper, boolean delayErrors)
(package private)	FlatMapSingleObserver(Observer<? super R> actual, Function<? super T, ? extends SingleSource<? extends R>> mapper, boolean delayErrors)
(package private)	FlatMapWithCombinerOuter(BiFunction<? super T, ? super U, ? extends R> combiner, Function<? super T, ? extends ObservableSource<? extends U>> mapper)
(package private)	FlattenIterableObserver(Observer<? super R> actual, Function<? super T, ? extends Iterable<? extends R>> mapper)
	GroupByObserver(Observer<? super GroupedObservable<K,V>> actual, Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector, int bufferSize, boolean delayError)
(package private)	GroupJoinDisposable(Observer<? super R> actual, Function<? super TLeft, ? extends ObservableSource<TLeftEnd>> leftEnd, Function<? super TRight, ? extends ObservableSource<TRightEnd>> rightEnd, BiFunction<? super TLeft, ? super Observable<TRight>, ? extends R> resultSelector)
(package private)	ItemDelayFunction(Function<? super T, ? extends ObservableSource<U>> itemDelay)
(package private)	JoinDisposable(Observer<? super R> actual, Function<? super TLeft, ? extends ObservableSource<TLeftEnd>> leftEnd, Function<? super TRight, ? extends ObservableSource<TRightEnd>> rightEnd, BiFunction<? super TLeft, ? super TRight, ? extends R> resultSelector)
(package private)	LatestCoordinator(Observer<? super R> actual, Function<? super Object[], ? extends R> combiner, int count, int bufferSize, boolean delayError)
(package private)	MapNotificationObserver(Observer<? super ObservableSource<? extends R>> actual, Function<? super T, ? extends ObservableSource<? extends R>> onNextMapper, Function<? super Throwable, ? extends ObservableSource<? extends R>> onErrorMapper, Supplier<? extends ObservableSource<? extends R>> onCompleteSupplier)
(package private)	MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper)
(package private)	MergeObserver(Observer<? super U> actual, Function<? super T, ? extends ObservableSource<? extends U>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize)
(package private)	MulticastReplay(Supplier<? extends ConnectableObservable<U>> connectableFactory, Function<? super Observable<U>, ? extends ObservableSource<R>> selector)
	ObservableBufferBoundary(ObservableSource<T> source, ObservableSource<? extends Open> bufferOpen, Function<? super Open, ? extends ObservableSource<? extends Close>> bufferClose, Supplier<U> bufferSupplier)
	ObservableCombineLatest(ObservableSource<? extends T>[] sources, Iterable<? extends ObservableSource<? extends T>> sourcesIterable, Function<? super Object[], ? extends R> combiner, int bufferSize, boolean delayError)
	ObservableConcatMap(ObservableSource<T> source, Function<? super T, ? extends ObservableSource<? extends U>> mapper, int bufferSize, ErrorMode delayErrors)
	ObservableConcatMapEager(ObservableSource<T> source, Function<? super T, ? extends ObservableSource<? extends R>> mapper, ErrorMode errorMode, int maxConcurrency, int prefetch)
	ObservableConcatMapScheduler(ObservableSource<T> source, Function<? super T, ? extends ObservableSource<? extends U>> mapper, int bufferSize, ErrorMode delayErrors, Scheduler scheduler)
	ObservableDebounce(ObservableSource<T> source, Function<? super T, ? extends ObservableSource<U>> debounceSelector)
	ObservableDematerialize(ObservableSource<T> source, Function<? super T, ? extends Notification<R>> selector)
	ObservableDistinct(ObservableSource<T> source, Function<? super T, K> keySelector, Supplier<? extends Collection<? super K>> collectionSupplier)
	ObservableDistinctUntilChanged(ObservableSource<T> source, Function<? super T, K> keySelector, BiPredicate<? super K, ? super K> comparer)
	ObservableFlatMap(ObservableSource<T> source, Function<? super T, ? extends ObservableSource<? extends U>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize)
	ObservableFlatMapCompletable(ObservableSource<T> source, Function<? super T, ? extends CompletableSource> mapper, boolean delayErrors)
	ObservableFlatMapCompletableCompletable(ObservableSource<T> source, Function<? super T, ? extends CompletableSource> mapper, boolean delayErrors)
	ObservableFlatMapMaybe(ObservableSource<T> source, Function<? super T, ? extends MaybeSource<? extends R>> mapper, boolean delayError)
	ObservableFlatMapSingle(ObservableSource<T> source, Function<? super T, ? extends SingleSource<? extends R>> mapper, boolean delayError)
	ObservableFlattenIterable(ObservableSource<T> source, Function<? super T, ? extends Iterable<? extends R>> mapper)
	ObservableGroupBy(ObservableSource<T> source, Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector, int bufferSize, boolean delayError)
	ObservableGroupJoin(ObservableSource<TLeft> source, ObservableSource<? extends TRight> other, Function<? super TLeft, ? extends ObservableSource<TLeftEnd>> leftEnd, Function<? super TRight, ? extends ObservableSource<TRightEnd>> rightEnd, BiFunction<? super TLeft, ? super Observable<TRight>, ? extends R> resultSelector)
	ObservableJoin(ObservableSource<TLeft> source, ObservableSource<? extends TRight> other, Function<? super TLeft, ? extends ObservableSource<TLeftEnd>> leftEnd, Function<? super TRight, ? extends ObservableSource<TRightEnd>> rightEnd, BiFunction<? super TLeft, ? super TRight, ? extends R> resultSelector)
	ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function)
	ObservableMapNotification(ObservableSource<T> source, Function<? super T, ? extends ObservableSource<? extends R>> onNextMapper, Function<? super Throwable, ? extends ObservableSource<? extends R>> onErrorMapper, Supplier<? extends ObservableSource<? extends R>> onCompleteSupplier)
	ObservableOnErrorNext(ObservableSource<T> source, Function<? super Throwable, ? extends ObservableSource<? extends T>> nextSupplier)
	ObservableOnErrorReturn(ObservableSource<T> source, Function<? super Throwable, ? extends T> valueSupplier)
	ObservablePublishSelector(ObservableSource<T> source, Function<? super Observable<T>, ? extends ObservableSource<R>> selector)
	ObservableRepeatWhen(ObservableSource<T> source, Function<? super Observable<Object>, ? extends ObservableSource<?>> handler)
	ObservableRetryWhen(ObservableSource<T> source, Function<? super Observable<Throwable>, ? extends ObservableSource<?>> handler)
	ObservableSwitchMap(ObservableSource<T> source, Function<? super T, ? extends ObservableSource<? extends R>> mapper, int bufferSize, boolean delayErrors)
	ObservableTimeout(Observable<T> source, ObservableSource<U> firstTimeoutIndicator, Function<? super T, ? extends ObservableSource<V>> itemTimeoutIndicator, ObservableSource<? extends T> other)
	ObservableUsing(Supplier<? extends D> resourceSupplier, Function<? super D, ? extends ObservableSource<? extends T>> sourceSupplier, Consumer<? super D> disposer, boolean eager)
	ObservableWindowBoundarySelector(ObservableSource<T> source, ObservableSource<B> open, Function<? super B, ? extends ObservableSource<V>> closingIndicator, int bufferSize)
	ObservableWithLatestFromMany(@NonNull ObservableSource<T> source, @NonNull ObservableSource<?>[] otherArray, @NonNull Function<? super Object[], R> combiner)
	ObservableWithLatestFromMany(@NonNull ObservableSource<T> source, @NonNull Iterable<? extends ObservableSource<?>> otherIterable, @NonNull Function<? super Object[], R> combiner)
	ObservableZip(ObservableSource<? extends T>[] sources, Iterable<? extends ObservableSource<? extends T>> sourcesIterable, Function<? super Object[], ? extends R> zipper, int bufferSize, boolean delayError)
(package private)	OnErrorNextObserver(Observer<? super T> actual, Function<? super Throwable, ? extends ObservableSource<? extends T>> nextSupplier)
(package private)	OnErrorReturnObserver(Observer<? super T> actual, Function<? super Throwable, ? extends T> valueSupplier)
(package private)	ScalarXMapObservable(T value, Function<? super T, ? extends ObservableSource<? extends R>> mapper)
(package private)	SourceObserver(Observer<? super U> actual, Function<? super T, ? extends ObservableSource<? extends U>> mapper, int bufferSize)
(package private)	SwitchMapObserver(Observer<? super R> actual, Function<? super T, ? extends ObservableSource<? extends R>> mapper, int bufferSize, boolean delayErrors)
(package private)	TimeoutFallbackObserver(Observer<? super T> actual, Function<? super T, ? extends ObservableSource<?>> itemTimeoutIndicator, ObservableSource<? extends T> fallback)
(package private)	TimeoutObserver(Observer<? super T> actual, Function<? super T, ? extends ObservableSource<?>> itemTimeoutIndicator)
(package private)	WindowBoundaryMainObserver(Observer<? super Observable<T>> downstream, ObservableSource<B> open, Function<? super B, ? extends ObservableSource<V>> closingIndicator, int bufferSize)
(package private)	WithLatestFromObserver(Observer<? super R> actual, Function<? super Object[], R> combiner, int n)
(package private)	ZipCoordinator(Observer<? super R> actual, Function<? super Object[], ? extends R> zipper, int count, boolean delayError)

Uses of Function in io.reactivex.rxjava3.internal.operators.parallel

Fields in io.reactivex.rxjava3.internal.operators.parallel declared as Function

Modifier and Type	Field	Description
(package private) final Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>>	ParallelConcatMap.mapper
(package private) final Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>>	ParallelFlatMap.mapper
(package private) final Function<? super T, ? extends Iterable<? extends R>>	ParallelFlatMapIterable.mapper
(package private) final Function<? super T, ? extends R>	ParallelMap.mapper
(package private) final Function<? super T, ? extends R>	ParallelMap.ParallelMapConditionalSubscriber.mapper
(package private) final Function<? super T, ? extends R>	ParallelMap.ParallelMapSubscriber.mapper
(package private) final Function<? super T, ? extends R>	ParallelMapTry.mapper
(package private) final Function<? super T, ? extends R>	ParallelMapTry.ParallelMapTryConditionalSubscriber.mapper
(package private) final Function<? super T, ? extends R>	ParallelMapTry.ParallelMapTrySubscriber.mapper

Constructors in io.reactivex.rxjava3.internal.operators.parallel with parameters of type Function

Modifier	Constructor	Description
	ParallelConcatMap(ParallelFlowable<T> source, Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>> mapper, int prefetch, ErrorMode errorMode)
	ParallelFlatMap(ParallelFlowable<T> source, Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>> mapper, boolean delayError, int maxConcurrency, int prefetch)
	ParallelFlatMapIterable(ParallelFlowable<T> source, Function<? super T, ? extends Iterable<? extends R>> mapper, int prefetch)
	ParallelMap(ParallelFlowable<T> source, Function<? super T, ? extends R> mapper)
(package private)	ParallelMapConditionalSubscriber(ConditionalSubscriber<? super R> actual, Function<? super T, ? extends R> mapper)
(package private)	ParallelMapSubscriber(org.reactivestreams.Subscriber<? super R> actual, Function<? super T, ? extends R> mapper)
	ParallelMapTry(ParallelFlowable<T> source, Function<? super T, ? extends R> mapper, BiFunction<? super Long, ? super Throwable, ParallelFailureHandling> errorHandler)
(package private)	ParallelMapTryConditionalSubscriber(ConditionalSubscriber<? super R> actual, Function<? super T, ? extends R> mapper, BiFunction<? super Long, ? super Throwable, ParallelFailureHandling> errorHandler)
(package private)	ParallelMapTrySubscriber(org.reactivestreams.Subscriber<? super R> actual, Function<? super T, ? extends R> mapper, BiFunction<? super Long, ? super Throwable, ParallelFailureHandling> errorHandler)

Uses of Function in io.reactivex.rxjava3.internal.operators.single

Classes in io.reactivex.rxjava3.internal.operators.single that implement Function

Modifier and Type	Class	Description
(package private) static enum	SingleInternalHelper.ToFlowable
(package private) final class	SingleZipArray.SingletonArrayFunc
(package private) final class	SingleZipIterable.SingletonArrayFunc

Fields in io.reactivex.rxjava3.internal.operators.single declared as Function

Modifier and Type	Field	Description
(package private) final Function<? super T, ? extends SingleSource<? extends R>>	SingleFlatMap.mapper
(package private) final Function<? super T, ? extends SingleSource<? extends R>>	SingleFlatMap.SingleFlatMapCallback.mapper
(package private) final Function<? super T, ? extends SingleSource<? extends U>>	SingleFlatMapBiSelector.FlatMapBiMainObserver.mapper
(package private) final Function<? super T, ? extends SingleSource<? extends U>>	SingleFlatMapBiSelector.mapper
(package private) final Function<? super T, ? extends CompletableSource>	SingleFlatMapCompletable.FlatMapCompletableObserver.mapper
(package private) final Function<? super T, ? extends CompletableSource>	SingleFlatMapCompletable.mapper
(package private) final Function<? super T, ? extends Iterable<? extends R>>	SingleFlatMapIterableFlowable.FlatMapIterableObserver.mapper
(package private) final Function<? super T, ? extends Iterable<? extends R>>	SingleFlatMapIterableFlowable.mapper
(package private) final Function<? super T, ? extends Iterable<? extends R>>	SingleFlatMapIterableObservable.FlatMapIterableObserver.mapper
(package private) final Function<? super T, ? extends Iterable<? extends R>>	SingleFlatMapIterableObservable.mapper
(package private) final Function<? super T, ? extends MaybeSource<? extends R>>	SingleFlatMapMaybe.FlatMapSingleObserver.mapper
(package private) final Function<? super T, ? extends MaybeSource<? extends R>>	SingleFlatMapMaybe.mapper
(package private) final Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>>	SingleFlatMapPublisher.mapper
(package private) final Function<? super S, ? extends org.reactivestreams.Publisher<? extends T>>	SingleFlatMapPublisher.SingleFlatMapPublisherObserver.mapper
(package private) final Function<? super T, ? extends R>	SingleMap.mapper
(package private) final Function<? super T, ? extends R>	SingleMap.MapSingleObserver.mapper
(package private) final Function<? super Throwable, ? extends SingleSource<? extends T>>	SingleResumeNext.nextFunction
(package private) final Function<? super Throwable, ? extends SingleSource<? extends T>>	SingleResumeNext.ResumeMainSingleObserver.nextFunction
(package private) final Function<? super Throwable, ? extends SingleSource<? extends R>>	SingleFlatMapNotification.FlatMapSingleObserver.onErrorMapper
(package private) final Function<? super Throwable, ? extends SingleSource<? extends R>>	SingleFlatMapNotification.onErrorMapper
(package private) final Function<? super T, ? extends SingleSource<? extends R>>	SingleFlatMapNotification.FlatMapSingleObserver.onSuccessMapper
(package private) final Function<? super T, ? extends SingleSource<? extends R>>	SingleFlatMapNotification.onSuccessMapper
(package private) final Function<? super T, Notification<R>>	SingleDematerialize.DematerializeObserver.selector
(package private) final Function<? super T, Notification<R>>	SingleDematerialize.selector
(package private) final Function<? super U, ? extends SingleSource<? extends T>>	SingleUsing.singleFunction
(package private) final Function<? super Throwable, ? extends T>	SingleOnErrorReturn.valueSupplier
(package private) final Function<? super Object[], ? extends R>	SingleZipArray.ZipCoordinator.zipper
(package private) final Function<? super Object[], ? extends R>	SingleZipArray.zipper
(package private) final Function<? super Object[], ? extends R>	SingleZipIterable.zipper

Methods in io.reactivex.rxjava3.internal.operators.single that return Function

Modifier and Type	Method	Description
static <T> Function<SingleSource<? extends T>, org.reactivestreams.Publisher<? extends T>>	SingleInternalHelper.toFlowable()

Constructors in io.reactivex.rxjava3.internal.operators.single with parameters of type Function

Modifier	Constructor	Description
(package private)	DematerializeObserver(MaybeObserver<? super R> downstream, Function<? super T, Notification<R>> selector)
(package private)	FlatMapBiMainObserver(SingleObserver<? super R> actual, Function<? super T, ? extends SingleSource<? extends U>> mapper, BiFunction<? super T, ? super U, ? extends R> resultSelector)
(package private)	FlatMapCompletableObserver(CompletableObserver actual, Function<? super T, ? extends CompletableSource> mapper)
(package private)	FlatMapIterableObserver(org.reactivestreams.Subscriber<? super R> actual, Function<? super T, ? extends Iterable<? extends R>> mapper)
(package private)	FlatMapIterableObserver(Observer<? super R> actual, Function<? super T, ? extends Iterable<? extends R>> mapper)
(package private)	FlatMapSingleObserver(MaybeObserver<? super R> actual, Function<? super T, ? extends MaybeSource<? extends R>> mapper)
(package private)	FlatMapSingleObserver(SingleObserver<? super R> actual, Function<? super T, ? extends SingleSource<? extends R>> onSuccessMapper, Function<? super Throwable, ? extends SingleSource<? extends R>> onErrorMapper)
(package private)	MapSingleObserver(SingleObserver<? super R> t, Function<? super T, ? extends R> mapper)
(package private)	ResumeMainSingleObserver(SingleObserver<? super T> actual, Function<? super Throwable, ? extends SingleSource<? extends T>> nextFunction)
	SingleDematerialize(Single<T> source, Function<? super T, Notification<R>> selector)
	SingleFlatMap(SingleSource<? extends T> source, Function<? super T, ? extends SingleSource<? extends R>> mapper)
	SingleFlatMapBiSelector(SingleSource<T> source, Function<? super T, ? extends SingleSource<? extends U>> mapper, BiFunction<? super T, ? super U, ? extends R> resultSelector)
(package private)	SingleFlatMapCallback(SingleObserver<? super R> actual, Function<? super T, ? extends SingleSource<? extends R>> mapper)
	SingleFlatMapCompletable(SingleSource<T> source, Function<? super T, ? extends CompletableSource> mapper)
	SingleFlatMapIterableFlowable(SingleSource<T> source, Function<? super T, ? extends Iterable<? extends R>> mapper)
	SingleFlatMapIterableObservable(SingleSource<T> source, Function<? super T, ? extends Iterable<? extends R>> mapper)
	SingleFlatMapMaybe(SingleSource<? extends T> source, Function<? super T, ? extends MaybeSource<? extends R>> mapper)
	SingleFlatMapNotification(SingleSource<T> source, Function<? super T, ? extends SingleSource<? extends R>> onSuccessMapper, Function<? super Throwable, ? extends SingleSource<? extends R>> onErrorMapper)
	SingleFlatMapPublisher(SingleSource<T> source, Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>> mapper)
(package private)	SingleFlatMapPublisherObserver(org.reactivestreams.Subscriber<? super T> actual, Function<? super S, ? extends org.reactivestreams.Publisher<? extends T>> mapper)
	SingleMap(SingleSource<? extends T> source, Function<? super T, ? extends R> mapper)
	SingleOnErrorReturn(SingleSource<? extends T> source, Function<? super Throwable, ? extends T> valueSupplier, T value)
	SingleResumeNext(SingleSource<? extends T> source, Function<? super Throwable, ? extends SingleSource<? extends T>> nextFunction)
	SingleUsing(Supplier<U> resourceSupplier, Function<? super U, ? extends SingleSource<? extends T>> singleFunction, Consumer<? super U> disposer, boolean eager)
	SingleZipArray(SingleSource<? extends T>[] sources, Function<? super Object[], ? extends R> zipper)
	SingleZipIterable(Iterable<? extends SingleSource<? extends T>> sources, Function<? super Object[], ? extends R> zipper)
(package private)	ZipCoordinator(SingleObserver<? super R> observer, int n, Function<? super Object[], ? extends R> zipper)

Uses of Function in io.reactivex.rxjava3.internal.schedulers

Classes in io.reactivex.rxjava3.internal.schedulers that implement Function

Modifier and Type	Class	Description
(package private) static final class	SchedulerPoolFactory.SystemPropertyAccessor
(package private) static final class	SchedulerWhen.CreateWorkerFunction

Methods in io.reactivex.rxjava3.internal.schedulers with parameters of type Function

Modifier and Type	Method	Description
(package private) static boolean	SchedulerPoolFactory.getBooleanProperty(boolean enabled, String key, boolean defaultNotFound, boolean defaultNotEnabled, Function<String,String> propertyAccessor)

Constructors in io.reactivex.rxjava3.internal.schedulers with parameters of type Function

Modifier	Constructor	Description
	SchedulerWhen(Function<Flowable<Flowable<Completable>>, Completable> combine, Scheduler actualScheduler)

Uses of Function in io.reactivex.rxjava3.internal.util

Classes in io.reactivex.rxjava3.internal.util that implement Function

Modifier and Type	Class	Description
enum	ArrayListSupplier
final class	SorterFunction<T>

Methods in io.reactivex.rxjava3.internal.util that return Function

Modifier and Type	Method	Description
static <T,O> Function<O,List<T>>	ArrayListSupplier.asFunction()

Uses of Function in io.reactivex.rxjava3.parallel

Methods in io.reactivex.rxjava3.parallel with parameters of type Function

Modifier and Type	Method	Description
final <@NonNull R> @NonNull ParallelFlowable<R>	ParallelFlowable.concatMap(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper)	Generates and concatenates Publishers on each 'rail', signalling errors immediately and generating 2 publishers upfront.
final <@NonNull R> @NonNull ParallelFlowable<R>	ParallelFlowable.concatMap(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int prefetch)	Generates and concatenates Publishers on each 'rail', signalling errors immediately and using the given prefetch amount for generating Publishers upfront.
final <@NonNull R> @NonNull ParallelFlowable<R>	ParallelFlowable.concatMapDelayError(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean tillTheEnd)	Generates and concatenates Publishers on each 'rail', optionally delaying errors and generating 2 publishers upfront.
final <@NonNull R> @NonNull ParallelFlowable<R>	ParallelFlowable.concatMapDelayError(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int prefetch, boolean tillTheEnd)	Generates and concatenates Publishers on each 'rail', optionally delaying errors and using the given prefetch amount for generating Publishers upfront.
final <@NonNull R> @NonNull ParallelFlowable<R>	ParallelFlowable.flatMap(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper)	Generates and flattens Publishers on each 'rail'.
final <@NonNull R> @NonNull ParallelFlowable<R>	ParallelFlowable.flatMap(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayError)	Generates and flattens Publishers on each 'rail', optionally delaying errors.
final <@NonNull R> @NonNull ParallelFlowable<R>	ParallelFlowable.flatMap(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayError, int maxConcurrency)	Generates and flattens Publishers on each 'rail', optionally delaying errors and having a total number of simultaneous subscriptions to the inner Publishers.
final <@NonNull R> @NonNull ParallelFlowable<R>	ParallelFlowable.flatMap(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayError, int maxConcurrency, int prefetch)	Generates and flattens Publishers on each 'rail', optionally delaying errors, having a total number of simultaneous subscriptions to the inner Publishers and using the given prefetch amount for the inner Publishers.
final <@NonNull U> @NonNull ParallelFlowable<U>	ParallelFlowable.flatMapIterable(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper)	Returns a ParallelFlowable that merges each item emitted by the source on each rail with the values in an Iterable corresponding to that item that is generated by a selector.
final <@NonNull U> @NonNull ParallelFlowable<U>	ParallelFlowable.flatMapIterable(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper, int bufferSize)	Returns a ParallelFlowable that merges each item emitted by the source ParallelFlowable with the values in an Iterable corresponding to that item that is generated by a selector.
final <@NonNull R> @NonNull ParallelFlowable<R>	ParallelFlowable.flatMapStream(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper)	Maps each upstream item on each rail into a Stream and emits the Stream's items to the downstream in a sequential fashion.
final <@NonNull R> @NonNull ParallelFlowable<R>	ParallelFlowable.flatMapStream(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper, int prefetch)	Maps each upstream item of each rail into a Stream and emits the Stream's items to the downstream in a sequential fashion.
final <@NonNull R> @NonNull ParallelFlowable<R>	ParallelFlowable.map(@NonNull Function<? super @NonNull T, ? extends @NonNull R> mapper)	Maps the source values on each 'rail' to another value.
final <@NonNull R> @NonNull ParallelFlowable<R>	ParallelFlowable.map(@NonNull Function<? super @NonNull T, ? extends @NonNull R> mapper, @NonNull BiFunction<? super Long, ? super Throwable, ParallelFailureHandling> errorHandler)	Maps the source values on each 'rail' to another value and handles errors based on the returned value by the handler function.
final <@NonNull R> @NonNull ParallelFlowable<R>	ParallelFlowable.map(@NonNull Function<? super @NonNull T, ? extends @NonNull R> mapper, @NonNull ParallelFailureHandling errorHandler)	Maps the source values on each 'rail' to another value and handles errors based on the given ParallelFailureHandling enumeration value.
final <@NonNull R> @NonNull ParallelFlowable<R>	ParallelFlowable.mapOptional(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper)	Maps the source values on each 'rail' to an optional and emits its value if any.
final <@NonNull R> @NonNull ParallelFlowable<R>	ParallelFlowable.mapOptional(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper, @NonNull BiFunction<? super Long, ? super Throwable, ParallelFailureHandling> errorHandler)	Maps the source values on each 'rail' to an optional and emits its value if any and handles errors based on the returned value by the handler function.
final <@NonNull R> @NonNull ParallelFlowable<R>	ParallelFlowable.mapOptional(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper, @NonNull ParallelFailureHandling errorHandler)	Maps the source values on each 'rail' to an optional and emits its value if any and handles errors based on the given ParallelFailureHandling enumeration value.

Uses of Function in io.reactivex.rxjava3.plugins

Fields in io.reactivex.rxjava3.plugins declared as Function

Modifier and Type	Field	Description
(package private) static @Nullable Function<? super Completable, ? extends Completable>	RxJavaPlugins.onCompletableAssembly
(package private) static @Nullable Function<? super Scheduler, ? extends Scheduler>	RxJavaPlugins.onComputationHandler
(package private) static @Nullable Function<? super ConnectableFlowable, ? extends ConnectableFlowable>	RxJavaPlugins.onConnectableFlowableAssembly
(package private) static @Nullable Function<? super ConnectableObservable, ? extends ConnectableObservable>	RxJavaPlugins.onConnectableObservableAssembly
(package private) static @Nullable Function<? super Flowable, ? extends Flowable>	RxJavaPlugins.onFlowableAssembly
(package private) static @Nullable Function<? super Supplier<Scheduler>, ? extends Scheduler>	RxJavaPlugins.onInitComputationHandler
(package private) static @Nullable Function<? super Supplier<Scheduler>, ? extends Scheduler>	RxJavaPlugins.onInitIoHandler
(package private) static @Nullable Function<? super Supplier<Scheduler>, ? extends Scheduler>	RxJavaPlugins.onInitNewThreadHandler
(package private) static @Nullable Function<? super Supplier<Scheduler>, ? extends Scheduler>	RxJavaPlugins.onInitSingleHandler
(package private) static @Nullable Function<? super Scheduler, ? extends Scheduler>	RxJavaPlugins.onIoHandler
(package private) static @Nullable Function<? super Maybe, ? extends Maybe>	RxJavaPlugins.onMaybeAssembly
(package private) static @Nullable Function<? super Scheduler, ? extends Scheduler>	RxJavaPlugins.onNewThreadHandler
(package private) static @Nullable Function<? super Observable, ? extends Observable>	RxJavaPlugins.onObservableAssembly
(package private) static @Nullable Function<? super ParallelFlowable, ? extends ParallelFlowable>	RxJavaPlugins.onParallelAssembly
(package private) static @Nullable Function<? super Runnable, ? extends Runnable>	RxJavaPlugins.onScheduleHandler
(package private) static @Nullable Function<? super Single, ? extends Single>	RxJavaPlugins.onSingleAssembly
(package private) static @Nullable Function<? super Scheduler, ? extends Scheduler>	RxJavaPlugins.onSingleHandler

Methods in io.reactivex.rxjava3.plugins that return Function

Modifier and Type	Method	Description
static @Nullable Function<? super Scheduler, ? extends Scheduler>	RxJavaPlugins.getComputationSchedulerHandler()	Returns the current hook function.
static @Nullable Function<? super Supplier<Scheduler>, ? extends Scheduler>	RxJavaPlugins.getInitComputationSchedulerHandler()	Returns the current hook function.
static @Nullable Function<? super Supplier<Scheduler>, ? extends Scheduler>	RxJavaPlugins.getInitIoSchedulerHandler()	Returns the current hook function.
static @Nullable Function<? super Supplier<Scheduler>, ? extends Scheduler>	RxJavaPlugins.getInitNewThreadSchedulerHandler()	Returns the current hook function.
static @Nullable Function<? super Supplier<Scheduler>, ? extends Scheduler>	RxJavaPlugins.getInitSingleSchedulerHandler()	Returns the current hook function.
static @Nullable Function<? super Scheduler, ? extends Scheduler>	RxJavaPlugins.getIoSchedulerHandler()	Returns the current hook function.
static @Nullable Function<? super Scheduler, ? extends Scheduler>	RxJavaPlugins.getNewThreadSchedulerHandler()	Returns the current hook function.
static @Nullable Function<? super Completable, ? extends Completable>	RxJavaPlugins.getOnCompletableAssembly()	Returns the current hook function.
static @Nullable Function<? super ConnectableFlowable, ? extends ConnectableFlowable>	RxJavaPlugins.getOnConnectableFlowableAssembly()	Returns the current hook function.
static @Nullable Function<? super ConnectableObservable, ? extends ConnectableObservable>	RxJavaPlugins.getOnConnectableObservableAssembly()	Returns the current hook function.
static @Nullable Function<? super Flowable, ? extends Flowable>	RxJavaPlugins.getOnFlowableAssembly()	Returns the current hook function.
static @Nullable Function<? super Maybe, ? extends Maybe>	RxJavaPlugins.getOnMaybeAssembly()	Returns the current hook function.
static @Nullable Function<? super Observable, ? extends Observable>	RxJavaPlugins.getOnObservableAssembly()	Returns the current hook function.
static @Nullable Function<? super ParallelFlowable, ? extends ParallelFlowable>	RxJavaPlugins.getOnParallelAssembly()	Returns the current hook function.
static @Nullable Function<? super Single, ? extends Single>	RxJavaPlugins.getOnSingleAssembly()	Returns the current hook function.
static @Nullable Function<? super Runnable, ? extends Runnable>	RxJavaPlugins.getScheduleHandler()	Returns the current hook function.
static @Nullable Function<? super Scheduler, ? extends Scheduler>	RxJavaPlugins.getSingleSchedulerHandler()	Returns the current hook function.

Methods in io.reactivex.rxjava3.plugins with parameters of type Function

Modifier and Type	Method	Description
(package private) static <@NonNull T, @NonNull R> R	RxJavaPlugins.apply(@NonNull Function<@NonNull T, @NonNull R> f, @NonNull T t)	Wraps the call to the function in try-catch and propagates thrown checked exceptions as RuntimeException.
(package private) static @NonNull Scheduler	RxJavaPlugins.applyRequireNonNull(@NonNull Function<? super Supplier<Scheduler>, ? extends Scheduler> f, Supplier<Scheduler> s)	Wraps the call to the Scheduler creation function in try-catch and propagates thrown checked exceptions as RuntimeException and enforces that result is not null.
static void	RxJavaPlugins.setComputationSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler)	Sets the specific hook function.
static void	RxJavaPlugins.setInitComputationSchedulerHandler(@Nullable Function<? super Supplier<Scheduler>, ? extends Scheduler> handler)	Sets the specific hook function.
static void	RxJavaPlugins.setInitIoSchedulerHandler(@Nullable Function<? super Supplier<Scheduler>, ? extends Scheduler> handler)	Sets the specific hook function.
static void	RxJavaPlugins.setInitNewThreadSchedulerHandler(@Nullable Function<? super Supplier<Scheduler>, ? extends Scheduler> handler)	Sets the specific hook function.
static void	RxJavaPlugins.setInitSingleSchedulerHandler(@Nullable Function<? super Supplier<Scheduler>, ? extends Scheduler> handler)	Sets the specific hook function.
static void	RxJavaPlugins.setIoSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler)	Sets the specific hook function.
static void	RxJavaPlugins.setNewThreadSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler)	Sets the specific hook function.
static void	RxJavaPlugins.setOnCompletableAssembly(@Nullable Function<? super Completable, ? extends Completable> onCompletableAssembly)	Sets the specific hook function.
static void	RxJavaPlugins.setOnConnectableFlowableAssembly(@Nullable Function<? super ConnectableFlowable, ? extends ConnectableFlowable> onConnectableFlowableAssembly)	Sets the specific hook function.
static void	RxJavaPlugins.setOnConnectableObservableAssembly(@Nullable Function<? super ConnectableObservable, ? extends ConnectableObservable> onConnectableObservableAssembly)	Sets the specific hook function.
static void	RxJavaPlugins.setOnFlowableAssembly(@Nullable Function<? super Flowable, ? extends Flowable> onFlowableAssembly)	Sets the specific hook function.
static void	RxJavaPlugins.setOnMaybeAssembly(@Nullable Function<? super Maybe, ? extends Maybe> onMaybeAssembly)	Sets the specific hook function.
static void	RxJavaPlugins.setOnObservableAssembly(@Nullable Function<? super Observable, ? extends Observable> onObservableAssembly)	Sets the specific hook function.
static void	RxJavaPlugins.setOnParallelAssembly(@Nullable Function<? super ParallelFlowable, ? extends ParallelFlowable> handler)	Sets the specific hook function.
static void	RxJavaPlugins.setOnSingleAssembly(@Nullable Function<? super Single, ? extends Single> onSingleAssembly)	Sets the specific hook function.
static void	RxJavaPlugins.setScheduleHandler(@Nullable Function<? super Runnable, ? extends Runnable> handler)	Sets the specific hook function.
static void	RxJavaPlugins.setSingleSchedulerHandler(@Nullable Function<? super Scheduler, ? extends Scheduler> handler)	Sets the specific hook function.