Uses of Interface
io.reactivex.rxjava3.core.MaybeSource

Packages that use MaybeSource

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.fuseable	Base interfaces and types for supporting operator-fusion.
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.single
io.reactivex.rxjava3.subjects	Classes representing so-called hot sources, aka subjects, that implement a base reactive class and the respective consumer type at once to allow forms of multicasting events to multiple consumers as well as consuming another base reactive type of their kind.

Uses of MaybeSource in io.reactivex.rxjava3.core

Classes in io.reactivex.rxjava3.core that implement MaybeSource

Modifier and Type	Class	Description
class	Maybe<T>	The Maybe class represents a deferred computation and emission of a single value, no value at all or an exception.

Methods in io.reactivex.rxjava3.core that return MaybeSource

Modifier and Type	Method	Description
@NonNull MaybeSource<Downstream>	MaybeTransformer.apply(@NonNull Maybe<@NonNull Upstream> upstream)	Applies a function to the upstream Maybe and returns a MaybeSource with optionally different element type.

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

Modifier and Type	Method	Description
static <@NonNull T> @NonNull Maybe<T>	Maybe.ambArray(@NonNull MaybeSource<? extends @NonNull T>... sources)	Runs multiple MaybeSources and signals the events of the first one that signals (disposing the rest).
@NonNull Maybe<T>	Maybe.ambWith(@NonNull MaybeSource<? extends @NonNull T> other)	Mirrors the MaybeSource (current or provided) that first signals an event.
<@NonNull T> @NonNull Maybe<T>	Completable.andThen(@NonNull MaybeSource<@NonNull T> next)	Returns a Maybe which will subscribe to this Completable and once that is completed then will subscribe to the next MaybeSource.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concat(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2)	Returns a Flowable that emits the items emitted by two MaybeSources, one after the other.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concat(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3)	Returns a Flowable that emits the items emitted by three MaybeSources, one after the other.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concat(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3, @NonNull MaybeSource<? extends @NonNull T> source4)	Returns a Flowable that emits the items emitted by four MaybeSources, one after the other.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatArray(@NonNull MaybeSource<? extends @NonNull T>... sources)	Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources in the array as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatArrayDelayError(@NonNull MaybeSource<? extends @NonNull T>... sources)	Concatenates a variable number of MaybeSource sources and delays errors from any of them till all terminate as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatArrayEager(@NonNull MaybeSource<? extends @NonNull T>... sources)	Concatenates a sequence of MaybeSource eagerly into a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatArrayEagerDelayError(@NonNull MaybeSource<? extends @NonNull T>... sources)	Concatenates a sequence of MaybeSource eagerly into a Flowable sequence.
@NonNull Flowable<T>	Flowable.concatWith(@NonNull MaybeSource<? extends @NonNull T> other)	Returns a Flowable that emits the items from this Flowable followed by the success item or terminal events of the other MaybeSource.
@NonNull Flowable<T>	Maybe.concatWith(@NonNull MaybeSource<? extends @NonNull T> other)	Returns a Flowable that emits the items emitted from the current Maybe, then the other MaybeSource, one after the other, without interleaving them.
@NonNull Observable<T>	Observable.concatWith(@NonNull MaybeSource<? extends @NonNull T> other)	Returns an Observable that emits the items from the current Observable followed by the success item or terminal events of the other MaybeSource.
static <@NonNull T> @NonNull Completable	Completable.fromMaybe(@NonNull MaybeSource<@NonNull T> maybe)	Returns a Completable instance that when subscribed to, subscribes to the MaybeSource instance and emits an onComplete event if the maybe emits onSuccess/onComplete or forwards any onError events.
static <@NonNull T> @NonNull Flowable<T>	Flowable.fromMaybe(@NonNull MaybeSource<@NonNull T> maybe)	Returns a Flowable instance that when subscribed to, subscribes to the MaybeSource instance and emits onSuccess as a single item or forwards any onComplete or onError signal.
static <@NonNull T> @NonNull Observable<T>	Observable.fromMaybe(@NonNull MaybeSource<@NonNull T> maybe)	Returns an Observable instance that when subscribed to, subscribes to the MaybeSource instance and emits onSuccess as a single item or forwards any onComplete or onError signal.
static <@NonNull T> @NonNull Single<T>	Single.fromMaybe(@NonNull MaybeSource<@NonNull T> maybe)	Returns a Single instance that when subscribed to, subscribes to the MaybeSource instance and emits onSuccess as a single item, turns an onComplete into NoSuchElementException error signal or forwards the onError signal.
static <@NonNull T> @NonNull Single<T>	Single.fromMaybe(@NonNull MaybeSource<@NonNull T> maybe, @NonNull T defaultItem)	Returns a Single instance that when subscribed to, subscribes to the MaybeSource instance and emits onSuccess as a single item, emits the defaultItem for an onComplete signal or forwards the onError signal.
static <@NonNull T> @NonNull Maybe<T>	Maybe.merge(@NonNull MaybeSource<? extends MaybeSource<? extends @NonNull T>> source)	Flattens a MaybeSource that emits a MaybeSource into a single MaybeSource that emits the item emitted by the nested MaybeSource, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	Maybe.merge(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2)	Flattens two MaybeSources into a single Flowable, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	Maybe.merge(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3)	Flattens three MaybeSources into a single Flowable, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	Maybe.merge(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3, @NonNull MaybeSource<? extends @NonNull T> source4)	Flattens four MaybeSources into a single Flowable, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	Maybe.mergeArray(MaybeSource<? extends @NonNull T>... sources)	Merges an array of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.
static <@NonNull T> @NonNull Flowable<T>	Maybe.mergeArrayDelayError(@NonNull MaybeSource<? extends @NonNull T>... sources)	Flattens an array of MaybeSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from each of the source MaybeSources without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Flowable<T>	Maybe.mergeDelayError(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2)	Flattens two MaybeSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from each of the source MaybeSources without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Flowable<T>	Maybe.mergeDelayError(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3)	Flattens three MaybeSource into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from all of the source MaybeSources without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Flowable<T>	Maybe.mergeDelayError(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3, @NonNull MaybeSource<? extends @NonNull T> source4)	Flattens four MaybeSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from all of the source MaybeSources without being interrupted by an error notification from one of them.
@NonNull Flowable<T>	Flowable.mergeWith(@NonNull MaybeSource<? extends @NonNull T> other)	Merges the sequence of items of this Flowable with the success value of the other MaybeSource or waits for both to complete normally if the MaybeSource is empty.
@NonNull Flowable<T>	Maybe.mergeWith(@NonNull MaybeSource<? extends @NonNull T> other)	Flattens this Maybe and another MaybeSource into a single Flowable, without any transformation.
@NonNull Observable<T>	Observable.mergeWith(@NonNull MaybeSource<? extends @NonNull T> other)	Merges the sequence of items of the current Observable with the success value of the other MaybeSource or waits both to complete normally if the MaybeSource is empty.
@NonNull Maybe<T>	Maybe.onErrorResumeWith(@NonNull MaybeSource<? extends @NonNull T> fallback)	Resumes the flow with the given MaybeSource when the current Maybe fails instead of signaling the error via onError.
static <@NonNull T> @NonNull Single<java.lang.Boolean>	Maybe.sequenceEqual(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2)	Returns a Single that emits a Boolean value that indicates whether two MaybeSource sequences are the same by comparing the items emitted by each MaybeSource pairwise.
static <@NonNull T> @NonNull Single<java.lang.Boolean>	Maybe.sequenceEqual(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull BiPredicate<? super @NonNull T,? super @NonNull T> isEqual)	Returns a Single that emits a Boolean value that indicates whether two MaybeSources are the same by comparing the items emitted by each MaybeSource pairwise based on the results of a specified equality function.
<@NonNull T> @NonNull Flowable<T>	Completable.startWith(@NonNull MaybeSource<@NonNull T> other)	Returns a Flowable which first runs the other MaybeSource then the current Completable if the other succeeded or completed normally.
@NonNull Flowable<T>	Flowable.startWith(@NonNull MaybeSource<@NonNull T> other)	Returns a Flowable which first runs the other MaybeSource then the current Flowable if the other succeeded or completed normally.
@NonNull Flowable<T>	Maybe.startWith(@NonNull MaybeSource<@NonNull T> other)	Returns a Flowable which first runs the other MaybeSource then the current Maybe if the other succeeded or completed normally.
@NonNull Observable<T>	Observable.startWith(@NonNull MaybeSource<@NonNull T> other)	Returns an Observable which first runs the other MaybeSource then the current Observable if the other succeeded or completed normally.
@NonNull Flowable<T>	Single.startWith(@NonNull MaybeSource<@NonNull T> other)	Returns a Flowable which first runs the other MaybeSource then the current Single if the other succeeded or completed normally.
@NonNull Maybe<T>	Maybe.switchIfEmpty(@NonNull MaybeSource<? extends @NonNull T> other)	Returns a Maybe that emits the items emitted by the current Maybe or the items of an alternate MaybeSource if the current Maybe is empty.
<@NonNull U> @NonNull Maybe<T>	Maybe.takeUntil(@NonNull MaybeSource<@NonNull U> other)	Returns a Maybe that emits the items emitted by the current Maybe until a second MaybeSource emits an item.
@NonNull Maybe<T>	Maybe.timeout(long timeout, @NonNull java.util.concurrent.TimeUnit unit, @NonNull MaybeSource<? extends @NonNull T> fallback)	Returns a Maybe that mirrors the current Maybe but applies a timeout policy for each emitted item.
@NonNull Maybe<T>	Maybe.timeout(long timeout, @NonNull java.util.concurrent.TimeUnit unit, @NonNull Scheduler scheduler, @NonNull MaybeSource<? extends @NonNull T> fallback)	Returns a Maybe that mirrors the current Maybe but applies a timeout policy for each emitted item using a specified Scheduler.
<@NonNull U> @NonNull Maybe<T>	Maybe.timeout(@NonNull MaybeSource<@NonNull U> timeoutIndicator)	If the current Maybe didn't signal an event before the timeoutIndicator MaybeSource signals, a TimeoutException is signaled instead.
<@NonNull U> @NonNull Maybe<T>	Maybe.timeout(@NonNull MaybeSource<@NonNull U> timeoutIndicator, @NonNull MaybeSource<? extends @NonNull T> fallback)	If the current Maybe didn't signal an event before the timeoutIndicator MaybeSource signals, the current Maybe is disposed and the fallback MaybeSource subscribed to as a continuation.
<@NonNull U> @NonNull Maybe<T>	Maybe.timeout(@NonNull org.reactivestreams.Publisher<@NonNull U> timeoutIndicator, @NonNull MaybeSource<? extends @NonNull T> fallback)	If the current Maybe didn't signal an event before the timeoutIndicator Publisher signals, the current Maybe is disposed and the fallback MaybeSource subscribed to as a continuation.
static <@NonNull T> @NonNull Maybe<T>	Maybe.unsafeCreate(@NonNull MaybeSource<@NonNull T> onSubscribe)	Advanced use only: creates a Maybe instance without any safeguards by using a callback that is called with a MaybeObserver.
static <@NonNull T> @NonNull Maybe<T>	Maybe.wrap(@NonNull MaybeSource<@NonNull T> source)	Wraps a MaybeSource instance into a new Maybe instance if not already a Maybe instance.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull T5,@NonNull T6,@NonNull T7,@NonNull T8,@NonNull T9,@NonNull R> @NonNull Maybe<R>	Maybe.zip(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull MaybeSource<? extends @NonNull T8> source8, @NonNull MaybeSource<? extends @NonNull T9> source9, @NonNull Function9<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? super @NonNull T6,? super @NonNull T7,? super @NonNull T8,? super @NonNull T9,? extends @NonNull R> zipper)	Returns a Maybe that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine other MaybeSources.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull T5,@NonNull T6,@NonNull T7,@NonNull T8,@NonNull R> @NonNull Maybe<R>	Maybe.zip(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull MaybeSource<? extends @NonNull T8> source8, @NonNull Function8<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? super @NonNull T6,? super @NonNull T7,? super @NonNull T8,? extends @NonNull R> zipper)	Returns a Maybe that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight other MaybeSources.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull T5,@NonNull T6,@NonNull T7,@NonNull R> @NonNull Maybe<R>	Maybe.zip(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull Function7<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? super @NonNull T6,? super @NonNull T7,? extends @NonNull R> zipper)	Returns a Maybe that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven other MaybeSources.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull T5,@NonNull T6,@NonNull R> @NonNull Maybe<R>	Maybe.zip(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull Function6<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? super @NonNull T6,? extends @NonNull R> zipper)	Returns a Maybe that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six other MaybeSources.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull T5,@NonNull R> @NonNull Maybe<R>	Maybe.zip(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull Function5<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? extends @NonNull R> zipper)	Returns a Maybe that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five other MaybeSources.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull R> @NonNull Maybe<R>	Maybe.zip(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? extends @NonNull R> zipper)	Returns a Maybe that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four other MaybeSources.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull R> @NonNull Maybe<R>	Maybe.zip(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? extends @NonNull R> zipper)	Returns a Maybe that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three other MaybeSources.
static <@NonNull T1,@NonNull T2,@NonNull R> @NonNull Maybe<R>	Maybe.zip(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1,? super @NonNull T2,? extends @NonNull R> zipper)	Returns a Maybe that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other MaybeSources.
static <@NonNull T,@NonNull R> @NonNull Maybe<R>	Maybe.zipArray(@NonNull Function<? super java.lang.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.
<@NonNull U,@NonNull R> @NonNull Maybe<R>	Maybe.zipWith(@NonNull MaybeSource<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull R> zipper)	Waits until this and the other MaybeSource signal a success value then applies the given BiFunction to those values and emits the BiFunction's resulting value to downstream.

Method parameters in io.reactivex.rxjava3.core with type arguments of type MaybeSource

Modifier and Type	Method	Description
static <@NonNull T> @NonNull Maybe<T>	Maybe.amb(@NonNull java.lang.Iterable<? extends MaybeSource<? extends @NonNull T>> sources)	Runs multiple MaybeSources provided by an Iterable sequence and signals the events of the first one that signals (disposing the rest).
static <@NonNull T> @NonNull Flowable<T>	Maybe.concat(@NonNull java.lang.Iterable<? extends MaybeSource<? extends @NonNull T>> sources)	Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by an Iterable sequence as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concat(@NonNull org.reactivestreams.Publisher<? extends MaybeSource<? extends @NonNull T>> sources)	Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by a Publisher sequence as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concat(@NonNull org.reactivestreams.Publisher<? extends MaybeSource<? extends @NonNull T>> sources, int prefetch)	Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by a Publisher sequence as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatDelayError(@NonNull java.lang.Iterable<? extends MaybeSource<? extends @NonNull T>> sources)	Concatenates the Iterable sequence of MaybeSources into a single sequence by subscribing to each MaybeSource, one after the other, one at a time and delays any errors till the all inner MaybeSources terminate as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatDelayError(@NonNull org.reactivestreams.Publisher<? extends MaybeSource<? extends @NonNull T>> sources)	Concatenates the Publisher sequence of MaybeSources into a single sequence by subscribing to each inner MaybeSource, one after the other, one at a time and delays any errors till the all inner and the outer Publisher terminate as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatDelayError(@NonNull org.reactivestreams.Publisher<? extends MaybeSource<? extends @NonNull T>> sources, int prefetch)	Concatenates the Publisher sequence of MaybeSources into a single sequence by subscribing to each inner MaybeSource, one after the other, one at a time and delays any errors till the all inner and the outer Publisher terminate as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatEager(@NonNull java.lang.Iterable<? extends MaybeSource<? extends @NonNull T>> sources)	Concatenates a sequence of MaybeSources eagerly into a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatEager(@NonNull java.lang.Iterable<? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency)	Concatenates a sequence of MaybeSources eagerly into a Flowable sequence and runs a limited number of the inner sequences at once.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatEager(@NonNull org.reactivestreams.Publisher<? extends MaybeSource<? extends @NonNull T>> sources)	Concatenates a Publisher sequence of MaybeSources eagerly into a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatEager(@NonNull org.reactivestreams.Publisher<? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency)	Concatenates a Publisher sequence of MaybeSources eagerly into a Flowable sequence, running at most the given number of inner MaybeSources at once.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatEagerDelayError(@NonNull java.lang.Iterable<? extends MaybeSource<? extends @NonNull T>> sources)	Concatenates a sequence of MaybeSources eagerly into a Flowable sequence, delaying errors until all inner MaybeSources terminate.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatEagerDelayError(@NonNull java.lang.Iterable<? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency)	Concatenates a sequence of MaybeSources eagerly into a Flowable sequence, delaying errors until all inner MaybeSources terminate and runs a limited number of inner MaybeSources at once.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatEagerDelayError(@NonNull org.reactivestreams.Publisher<? extends MaybeSource<? extends @NonNull T>> sources)	Concatenates a Publisher sequence of MaybeSources eagerly into a Flowable sequence, delaying errors until all the inner and the outer sequence terminate.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatEagerDelayError(@NonNull org.reactivestreams.Publisher<? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency)	Concatenates a Publisher sequence of MaybeSources eagerly into a Flowable sequence, delaying errors until all the inner and the outer sequence terminate and runs a limited number of the inner MaybeSources at once.
<@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.
<@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.
<@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.
<@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.
<@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.
<@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.
<@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.
<@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.
<@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.
<@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.
<@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.
<@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.
static <@NonNull T> @NonNull Maybe<T>	Maybe.defer(@NonNull Supplier<? extends @NonNull MaybeSource<? extends @NonNull T>> supplier)	Calls a Supplier for each individual MaybeObserver to return the actual MaybeSource source to be subscribed to.
<@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.
<@NonNull R> @NonNull Maybe<R>	Maybe.flatMap(@NonNull Function<? super @NonNull T,? extends MaybeSource<? extends @NonNull R>> onSuccessMapper, @NonNull Function<? super java.lang.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.
<@NonNull R> @NonNull Maybe<R>	Maybe.flatMap(@NonNull Function<? super @NonNull T,? extends MaybeSource<? extends @NonNull R>> onSuccessMapper, @NonNull Function<? super java.lang.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.
<@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.
<@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.
<@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.
<@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.
<@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.
<@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.
static <@NonNull T> @NonNull Maybe<T>	Maybe.merge(@NonNull MaybeSource<? extends MaybeSource<? extends @NonNull T>> source)	Flattens a MaybeSource that emits a MaybeSource into a single MaybeSource that emits the item emitted by the nested MaybeSource, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	Maybe.merge(@NonNull java.lang.Iterable<? extends MaybeSource<? extends @NonNull T>> sources)	Merges an Iterable sequence of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.
static <@NonNull T> @NonNull Flowable<T>	Maybe.merge(@NonNull org.reactivestreams.Publisher<? extends MaybeSource<? extends @NonNull T>> sources)	Merges a Publisher sequence of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.
static <@NonNull T> @NonNull Flowable<T>	Maybe.merge(@NonNull org.reactivestreams.Publisher<? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency)	Merges a Publisher sequence of MaybeSource instances into a single Flowable sequence, running at most maxConcurrency MaybeSources at once.
static <@NonNull T> @NonNull Flowable<T>	Maybe.mergeDelayError(@NonNull java.lang.Iterable<? extends MaybeSource<? extends @NonNull T>> sources)	Flattens an Iterable sequence of MaybeSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from each of the source MaybeSources without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Flowable<T>	Maybe.mergeDelayError(@NonNull org.reactivestreams.Publisher<? extends MaybeSource<? extends @NonNull T>> sources)	Flattens a Publisher that emits MaybeSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from all of the source MaybeSources without being interrupted by an error notification from one of them or even the main Publisher.
static <@NonNull T> @NonNull Flowable<T>	Maybe.mergeDelayError(@NonNull org.reactivestreams.Publisher<? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency)	Flattens a Publisher that emits MaybeSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from all of the source MaybeSources without being interrupted by an error notification from one of them or even the main Publisher as well as limiting the total number of active MaybeSources.
@NonNull Maybe<T>	Maybe.onErrorResumeNext(@NonNull Function<? super java.lang.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.
<@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.
<@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.
<@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.
<@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.
static <@NonNull T> @NonNull Flowable<T>	Maybe.switchOnNext(@NonNull org.reactivestreams.Publisher<? extends MaybeSource<? extends @NonNull T>> sources)	Switches between MaybeSources emitted by the source Publisher whenever a new MaybeSource is emitted, disposing the previously running MaybeSource, exposing the success items as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Maybe.switchOnNextDelayError(@NonNull org.reactivestreams.Publisher<? extends MaybeSource<? extends @NonNull T>> sources)	Switches between MaybeSources emitted by the source Publisher whenever a new MaybeSource is emitted, disposing the previously running MaybeSource, exposing the success items as a Flowable sequence and delaying all errors from all of them until all terminate.
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 R> @NonNull Maybe<R>	Maybe.zip(@NonNull java.lang.Iterable<? extends MaybeSource<? extends @NonNull T>> sources, @NonNull Function<? super java.lang.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.

Uses of MaybeSource in io.reactivex.rxjava3.internal.fuseable

Methods in io.reactivex.rxjava3.internal.fuseable that return MaybeSource

Modifier and Type	Method	Description
@NonNull MaybeSource<T>	HasUpstreamMaybeSource.source()	Returns the upstream source of this Maybe.

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

Classes in io.reactivex.rxjava3.internal.jdk8 that implement MaybeSource

Modifier and Type	Class	Description
class	MaybeFromCompletionStage<T>	Wrap a CompletionStage and signal its outcome.
class	MaybeMapOptional<T,R>	Maps the success value to an Optional and emits its non-empty value or completes.
class	SingleMapOptional<T,R>	Maps the success value to an Optional and emits its non-empty value or completes.

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

Classes in io.reactivex.rxjava3.internal.operators.completable that implement MaybeSource

Modifier and Type	Class	Description
class	CompletableOnErrorReturn<T>	Returns a value generated via a function if the main source signals an onError.

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

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

Modifier and Type	Class	Description
class	FlowableElementAtMaybe<T>
class	FlowableElementAtMaybePublisher<T>	Emits the indexth element from a Publisher as a Maybe.
class	FlowableLastMaybe<T>	Consumes the source Publisher and emits its last item or completes.
class	FlowableReduceMaybe<T>	Reduce a Flowable into a single value exposed as Single or signal NoSuchElementException.
class	FlowableSingleMaybe<T>

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

Modifier and Type	Field	Description
(package private) MaybeSource<? extends T>	FlowableConcatWithMaybe.ConcatWithSubscriber.other
(package private) MaybeSource<? extends T>	FlowableConcatWithMaybe.other
(package private) MaybeSource<? extends T>	FlowableMergeWithMaybe.other

Fields in io.reactivex.rxjava3.internal.operators.flowable with type parameters of type MaybeSource

Modifier and Type	Field	Description
(package private) Function<? super T,? extends MaybeSource<? extends R>>	FlowableFlatMapMaybe.FlatMapMaybeSubscriber.mapper
(package private) Function<? super T,? extends MaybeSource<? extends R>>	FlowableFlatMapMaybe.mapper
(package private) Function<? super T,? extends MaybeSource<? extends R>>	FlowableFlatMapMaybePublisher.mapper

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

Constructor	Description
ConcatWithSubscriber(org.reactivestreams.Subscriber<? super T> actual, MaybeSource<? extends T> other)
FlowableConcatWithMaybe(Flowable<T> source, MaybeSource<? extends T> other)
FlowableMergeWithMaybe(Flowable<T> source, MaybeSource<? extends T> other)

Constructor parameters in io.reactivex.rxjava3.internal.operators.flowable with type arguments of type MaybeSource

Constructor	Description
FlatMapMaybeSubscriber(org.reactivestreams.Subscriber<? super R> actual, Function<? super T,? extends MaybeSource<? extends R>> 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)

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

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

Modifier and Type	Class	Description
(package private) class	AbstractMaybeWithUpstream<T,R>	Abstract base class for intermediate Maybe operators that take an upstream MaybeSource.
class	MaybeAmb<T>	Signals the event of the first MaybeSource that signals.
class	MaybeCache<T>	Consumes the source once and replays its signal to any current or future MaybeObservers.
class	MaybeCreate<T>	Provides an API over MaybeObserver that serializes calls to onXXX and manages cancellation in a safe manner.
class	MaybeDefer<T>	Defers the creation of the actual Maybe the incoming MaybeObserver is subscribed to.
class	MaybeDelay<T>	Delays all signal types by the given amount and re-emits them on the given scheduler.
class	MaybeDelayOtherPublisher<T,U>	Delay the emission of the main signal until the other signals an item or completes.
class	MaybeDelaySubscriptionOtherPublisher<T,U>	Delay the subscription to the main Maybe until the other signals an item or completes.
class	MaybeDelayWithCompletable<T>
class	MaybeDematerialize<T,R>	Maps the success value of the source to a Notification, then maps it back to the corresponding signal type.
class	MaybeDetach<T>	Breaks the references between the upstream and downstream when the Maybe terminates.
class	MaybeDoAfterSuccess<T>	Calls a consumer after pushing the current item to the downstream.
class	MaybeDoFinally<T>	Execute an action after an onSuccess, onError, onComplete or a dispose event.
class	MaybeDoOnEvent<T>	Calls a BiConsumer with the success, error values of the upstream Maybe or with two nulls if the Maybe completed.
class	MaybeDoOnLifecycle<T>	Invokes callbacks upon onSubscribe from upstream and dispose from downstream.
class	MaybeDoOnTerminate<T>
class	MaybeEmpty	Signals an onComplete.
class	MaybeError<T>	Signals a constant Throwable.
class	MaybeErrorCallable<T>	Signals a Throwable returned by a Supplier.
class	MaybeFilter<T>	Filters the upstream via a predicate, returning the success item or completing if the predicate returns false.
class	MaybeFilterSingle<T>	Filters the upstream SingleSource via a predicate, returning the success item or completing if the predicate returns false.
class	MaybeFlatMapBiSelector<T,U,R>	Maps a source item to another MaybeSource then calls a BiFunction with the original item and the secondary item to generate the final result.
class	MaybeFlatMapNotification<T,R>	Maps a value into a MaybeSource and relays its signal.
class	MaybeFlatMapSingle<T,R>	Maps the success value of the source MaybeSource into a Single.
class	MaybeFlatten<T,R>	Maps a value into a MaybeSource and relays its signal.
class	MaybeFromAction<T>	Executes an Action and signals its exception or completes normally.
class	MaybeFromCallable<T>	Executes a callable and signals its value as success or signals an exception.
class	MaybeFromCompletable<T>	Wrap a Completable into a Maybe.
class	MaybeFromFuture<T>	Waits until the source Future completes or the wait times out; treats a null result as indication to signal onComplete instead of onSuccess.
class	MaybeFromRunnable<T>	Executes an Runnable and signals its exception or completes normally.
class	MaybeFromSingle<T>	Wrap a Single into a Maybe.
class	MaybeFromSupplier<T>	Executes a supplier and signals its value as success or signals an exception.
class	MaybeHide<T>	Hides the identity of the upstream Maybe and its Disposable sent through onSubscribe.
class	MaybeIgnoreElement<T>	Turns an onSuccess into an onComplete, onError and onComplete is relayed as is.
class	MaybeIsEmpty<T>	Signals true if the source Maybe signals onComplete, signals false if the source Maybe signals onSuccess.
class	MaybeJust<T>	Signals a constant value.
class	MaybeLift<T,R>	Calls a MaybeOperator for the incoming MaybeObserver.
class	MaybeMap<T,R>	Maps the upstream success value into some other value.
class	MaybeNever	Doesn't signal any event other than onSubscribe.
class	MaybeObserveOn<T>	Signals the onSuccess, onError or onComplete events on a the specific scheduler.
class	MaybeOnErrorComplete<T>	Emits an onComplete if the source emits an onError and the predicate returns true for that Throwable.
class	MaybeOnErrorNext<T>	Subscribes to the MaybeSource returned by a function if the main source signals an onError.
class	MaybeOnErrorReturn<T>	Returns a value generated via a function if the main source signals an onError.
class	MaybePeek<T>	Peeks into the lifecycle of a Maybe and MaybeObserver.
class	MaybeSubscribeOn<T>	Subscribes to the upstream MaybeSource on the specified scheduler.
class	MaybeSwitchIfEmpty<T>	Subscribes to the other source if the main source is empty.
class	MaybeTakeUntilMaybe<T,U>	Relays the main source's event unless the other Maybe signals an item first or just completes at which point the resulting Maybe is completed.
class	MaybeTakeUntilPublisher<T,U>	Relays the main source's event unless the other Publisher signals an item first or just completes at which point the resulting Maybe is completed.
class	MaybeTimeInterval<T>	Measures the time between subscription and the success item emission from the upstream and emits this as a Timed success value.
class	MaybeTimeoutMaybe<T,U>	Switches to the fallback Maybe if the other MaybeSource signals a success or completes, or signals TimeoutException if fallback is null.
class	MaybeTimeoutPublisher<T,U>	Switches to the fallback Maybe if the other Publisher signals a success or completes, or signals TimeoutException if fallback is null.
class	MaybeTimer	Signals a 0L after the specified delay.
class	MaybeUnsafeCreate<T>	Wraps a MaybeSource without safeguard and calls its subscribe() method for each MaybeObserver.
class	MaybeUnsubscribeOn<T>	Makes sure a dispose() call from downstream happens on the specified scheduler.
class	MaybeUsing<T,D>	Creates a resource and a dependent Maybe for each incoming Observer and optionally disposes the resource eagerly (before the terminal event is send out).
class	MaybeZipArray<T,R>
class	MaybeZipIterable<T,R>

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

Modifier and Type	Field	Description
(package private) MaybeSource<? extends T>	MaybeTimeoutMaybe.fallback
(package private) MaybeSource<? extends T>	MaybeTimeoutMaybe.TimeoutMainMaybeObserver.fallback
(package private) MaybeSource<? extends T>	MaybeTimeoutPublisher.fallback
(package private) MaybeSource<? extends T>	MaybeTimeoutPublisher.TimeoutMainMaybeObserver.fallback
(package private) MaybeSource<? extends T>	MaybeSwitchIfEmpty.other
(package private) MaybeSource<? extends T>	MaybeSwitchIfEmpty.SwitchIfEmptyMaybeObserver.other
(package private) MaybeSource<U>	MaybeTakeUntilMaybe.other
(package private) MaybeSource<U>	MaybeTimeoutMaybe.other
protected MaybeSource<T>	AbstractMaybeWithUpstream.source
(package private) MaybeSource<T>	MaybeContains.source
(package private) MaybeSource<T>	MaybeCount.source
(package private) MaybeSource<T>	MaybeDelaySubscriptionOtherPublisher.OtherSubscriber.source
(package private) MaybeSource<T>	MaybeDelayWithCompletable.OtherObserver.source
(package private) MaybeSource<T>	MaybeDelayWithCompletable.source
(package private) MaybeSource<T>	MaybeDoOnTerminate.source
(package private) MaybeSource<T>	MaybeFlatMapCompletable.source
(package private) MaybeSource<T>	MaybeFlatMapIterableFlowable.source
(package private) MaybeSource<T>	MaybeFlatMapIterableObservable.source
(package private) MaybeSource<T>	MaybeFlatMapSingle.source
(package private) MaybeSource<T>	MaybeIgnoreElementCompletable.source
(package private) MaybeSource<T>	MaybeIsEmptySingle.source
(package private) MaybeSource<T>	MaybeSubscribeOn.SubscribeTask.source
(package private) MaybeSource<T>	MaybeSwitchIfEmptySingle.source
(package private) MaybeSource<T>	MaybeTimeInterval.source
(package private) MaybeSource<T>	MaybeToFlowable.source
(package private) MaybeSource<T>	MaybeToObservable.source
(package private) MaybeSource<T>	MaybeToSingle.source
(package private) MaybeSource<? extends T>	MaybeEqualSingle.source1
(package private) MaybeSource<? extends T>	MaybeEqualSingle.source2
private MaybeSource<? extends T>[]	MaybeAmb.sources
(package private) MaybeSource<? extends T>[]	MaybeConcatArray.ConcatMaybeObserver.sources
(package private) MaybeSource<? extends T>[]	MaybeConcatArray.sources
(package private) MaybeSource<? extends T>[]	MaybeConcatArrayDelayError.ConcatMaybeObserver.sources
(package private) MaybeSource<? extends T>[]	MaybeConcatArrayDelayError.sources
(package private) MaybeSource<? extends T>[]	MaybeMergeArray.sources
(package private) MaybeSource<? extends T>[]	MaybeZipArray.sources

Fields in io.reactivex.rxjava3.internal.operators.maybe with type parameters of type MaybeSource

Modifier and Type	Field	Description
(package private) Function<? super T,? extends MaybeSource<? extends U>>	MaybeFlatMapBiSelector.FlatMapBiMainObserver.mapper
(package private) Function<? super T,? extends MaybeSource<? extends U>>	MaybeFlatMapBiSelector.mapper
(package private) Function<? super T,? extends MaybeSource<? extends R>>	MaybeFlatten.FlatMapMaybeObserver.mapper
(package private) Function<? super T,? extends MaybeSource<? extends R>>	MaybeFlatten.mapper
(package private) Supplier<? extends MaybeSource<? extends T>>	MaybeDefer.maybeSupplier
(package private) Supplier<? extends MaybeSource<? extends R>>	MaybeFlatMapNotification.FlatMapMaybeObserver.onCompleteSupplier
(package private) Supplier<? extends MaybeSource<? extends R>>	MaybeFlatMapNotification.onCompleteSupplier
(package private) Function<? super java.lang.Throwable,? extends MaybeSource<? extends R>>	MaybeFlatMapNotification.FlatMapMaybeObserver.onErrorMapper
(package private) Function<? super java.lang.Throwable,? extends MaybeSource<? extends R>>	MaybeFlatMapNotification.onErrorMapper
(package private) Function<? super T,? extends MaybeSource<? extends R>>	MaybeFlatMapNotification.FlatMapMaybeObserver.onSuccessMapper
(package private) Function<? super T,? extends MaybeSource<? extends R>>	MaybeFlatMapNotification.onSuccessMapper
(package private) Function<? super java.lang.Throwable,? extends MaybeSource<? extends T>>	MaybeOnErrorNext.OnErrorNextMaybeObserver.resumeFunction
(package private) Function<? super java.lang.Throwable,? extends MaybeSource<? extends T>>	MaybeOnErrorNext.resumeFunction
(package private) java.util.concurrent.atomic.AtomicReference<MaybeSource<T>>	MaybeCache.source
(package private) java.util.Iterator<? extends MaybeSource<? extends T>>	MaybeConcatIterable.ConcatMaybeObserver.sources
(package private) java.lang.Iterable<? extends MaybeSource<? extends T>>	MaybeConcatIterable.sources
(package private) java.lang.Iterable<? extends MaybeSource<? extends T>>	MaybeZipIterable.sources
private java.lang.Iterable<? extends MaybeSource<? extends T>>	MaybeAmb.sourcesIterable
(package private) Function<? super D,? extends MaybeSource<? extends T>>	MaybeUsing.sourceSupplier

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

Modifier and Type	Method	Description
MaybeSource<T>	AbstractMaybeWithUpstream.source()
MaybeSource<T>	MaybeContains.source()
MaybeSource<T>	MaybeCount.source()
MaybeSource<T>	MaybeIsEmptySingle.source()
MaybeSource<T>	MaybeSwitchIfEmptySingle.source()
MaybeSource<T>	MaybeToFlowable.source()
MaybeSource<T>	MaybeToObservable.source()
MaybeSource<T>	MaybeToSingle.source()

Methods in io.reactivex.rxjava3.internal.operators.maybe that return types with arguments of type MaybeSource

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

Methods in io.reactivex.rxjava3.internal.operators.maybe with parameters of type MaybeSource

Modifier and Type	Method	Description
org.reactivestreams.Publisher<java.lang.Object>	MaybeToPublisher.apply(MaybeSource<java.lang.Object> t)
(package private) void	MaybeEqualSingle.EqualCoordinator.subscribe(MaybeSource<? extends T> source1, MaybeSource<? extends T> source2)

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

Constructor	Description
AbstractMaybeWithUpstream(MaybeSource<T> source)
ConcatMaybeObserver(org.reactivestreams.Subscriber<? super T> actual, MaybeSource<? extends T>[] sources)
ConcatMaybeObserver(org.reactivestreams.Subscriber<? super T> actual, MaybeSource<? extends T>[] sources)
MaybeAmb(MaybeSource<? extends T>[] sources, java.lang.Iterable<? extends MaybeSource<? extends T>> sourcesIterable)
MaybeCache(MaybeSource<T> source)
MaybeConcatArray(MaybeSource<? extends T>[] sources)
MaybeConcatArrayDelayError(MaybeSource<? extends T>[] sources)
MaybeContains(MaybeSource<T> source, java.lang.Object value)
MaybeCount(MaybeSource<T> source)
MaybeDelay(MaybeSource<T> source, long delay, java.util.concurrent.TimeUnit unit, Scheduler scheduler, boolean delayError)
MaybeDelayOtherPublisher(MaybeSource<T> source, org.reactivestreams.Publisher<U> other)
MaybeDelaySubscriptionOtherPublisher(MaybeSource<T> source, org.reactivestreams.Publisher<U> other)
MaybeDelayWithCompletable(MaybeSource<T> source, CompletableSource other)
MaybeDetach(MaybeSource<T> source)
MaybeDoAfterSuccess(MaybeSource<T> source, Consumer<? super T> onAfterSuccess)
MaybeDoFinally(MaybeSource<T> source, Action onFinally)
MaybeDoOnEvent(MaybeSource<T> source, BiConsumer<? super T,? super java.lang.Throwable> onEvent)
MaybeDoOnTerminate(MaybeSource<T> source, Action onTerminate)
MaybeEqualSingle(MaybeSource<? extends T> source1, MaybeSource<? extends T> source2, BiPredicate<? super T,? super T> isEqual)
MaybeFilter(MaybeSource<T> source, Predicate<? super T> predicate)
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 java.lang.Iterable<? extends R>> mapper)
MaybeFlatMapIterableObservable(MaybeSource<T> source, Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
MaybeFlatMapNotification(MaybeSource<T> source, Function<? super T,? extends MaybeSource<? extends R>> onSuccessMapper, Function<? super java.lang.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)
MaybeHide(MaybeSource<T> source)
MaybeIgnoreElement(MaybeSource<T> source)
MaybeIgnoreElementCompletable(MaybeSource<T> source)
MaybeIsEmpty(MaybeSource<T> source)
MaybeIsEmptySingle(MaybeSource<T> source)
MaybeLift(MaybeSource<T> source, MaybeOperator<? extends R,? super T> operator)
MaybeMap(MaybeSource<T> source, Function<? super T,? extends R> mapper)
MaybeMergeArray(MaybeSource<? extends T>[] sources)
MaybeObserveOn(MaybeSource<T> source, Scheduler scheduler)
MaybeOnErrorComplete(MaybeSource<T> source, Predicate<? super java.lang.Throwable> predicate)
MaybeOnErrorNext(MaybeSource<T> source, Function<? super java.lang.Throwable,? extends MaybeSource<? extends T>> resumeFunction)
MaybeOnErrorReturn(MaybeSource<T> source, Function<? super java.lang.Throwable,? extends T> itemSupplier)
MaybePeek(MaybeSource<T> source, Consumer<? super Disposable> onSubscribeCall, Consumer<? super T> onSuccessCall, Consumer<? super java.lang.Throwable> onErrorCall, Action onCompleteCall, Action onAfterTerminate, Action onDispose)
MaybeSubscribeOn(MaybeSource<T> source, Scheduler scheduler)
MaybeSwitchIfEmpty(MaybeSource<T> source, MaybeSource<? extends T> other)
MaybeSwitchIfEmptySingle(MaybeSource<T> source, SingleSource<? extends T> other)
MaybeTakeUntilMaybe(MaybeSource<T> source, MaybeSource<U> other)
MaybeTakeUntilPublisher(MaybeSource<T> source, org.reactivestreams.Publisher<U> other)
MaybeTimeInterval(MaybeSource<T> source, java.util.concurrent.TimeUnit unit, Scheduler scheduler, boolean start)
MaybeTimeoutMaybe(MaybeSource<T> source, MaybeSource<U> other, MaybeSource<? extends T> fallback)
MaybeTimeoutPublisher(MaybeSource<T> source, org.reactivestreams.Publisher<U> other, MaybeSource<? extends T> fallback)
MaybeToFlowable(MaybeSource<T> source)
MaybeToObservable(MaybeSource<T> source)
MaybeToSingle(MaybeSource<T> source, T defaultValue)
MaybeUnsafeCreate(MaybeSource<T> source)
MaybeUnsubscribeOn(MaybeSource<T> source, Scheduler scheduler)
MaybeZipArray(MaybeSource<? extends T>[] sources, Function<? super java.lang.Object[],? extends R> zipper)
OtherObserver(MaybeObserver<? super T> actual, MaybeSource<T> source)
OtherSubscriber(MaybeObserver<? super T> actual, MaybeSource<T> source)
SubscribeTask(MaybeObserver<? super T> observer, MaybeSource<T> source)
SwitchIfEmptyMaybeObserver(MaybeObserver<? super T> actual, MaybeSource<? extends T> other)
TimeoutMainMaybeObserver(MaybeObserver<? super T> actual, MaybeSource<? extends T> fallback)
TimeoutMainMaybeObserver(MaybeObserver<? super T> actual, MaybeSource<? extends T> fallback)

Constructor parameters in io.reactivex.rxjava3.internal.operators.maybe with type arguments of type MaybeSource

Constructor	Description
ConcatMaybeObserver(org.reactivestreams.Subscriber<? super T> actual, java.util.Iterator<? extends MaybeSource<? extends T>> sources)
FlatMapBiMainObserver(MaybeObserver<? super R> actual, Function<? super T,? extends MaybeSource<? extends U>> mapper, BiFunction<? super T,? super U,? extends R> resultSelector)
FlatMapMaybeObserver(MaybeObserver<? super R> actual, Function<? super T,? extends MaybeSource<? extends R>> onSuccessMapper, Function<? super java.lang.Throwable,? extends MaybeSource<? extends R>> onErrorMapper, Supplier<? extends MaybeSource<? extends R>> onCompleteSupplier)
FlatMapMaybeObserver(MaybeObserver<? super R> actual, Function<? super T,? extends MaybeSource<? extends R>> onSuccessMapper, Function<? super java.lang.Throwable,? extends MaybeSource<? extends R>> onErrorMapper, Supplier<? extends MaybeSource<? extends R>> onCompleteSupplier)
FlatMapMaybeObserver(MaybeObserver<? super R> actual, Function<? super T,? extends MaybeSource<? extends R>> mapper)
MaybeAmb(MaybeSource<? extends T>[] sources, java.lang.Iterable<? extends MaybeSource<? extends T>> sourcesIterable)
MaybeConcatIterable(java.lang.Iterable<? extends MaybeSource<? extends T>> sources)
MaybeDefer(Supplier<? extends MaybeSource<? extends T>> maybeSupplier)
MaybeFlatMapBiSelector(MaybeSource<T> source, Function<? super T,? extends MaybeSource<? extends U>> mapper, BiFunction<? super T,? super U,? extends R> resultSelector)
MaybeFlatMapNotification(MaybeSource<T> source, Function<? super T,? extends MaybeSource<? extends R>> onSuccessMapper, Function<? super java.lang.Throwable,? extends MaybeSource<? extends R>> onErrorMapper, Supplier<? extends MaybeSource<? extends R>> onCompleteSupplier)
MaybeFlatMapNotification(MaybeSource<T> source, Function<? super T,? extends MaybeSource<? extends R>> onSuccessMapper, Function<? super java.lang.Throwable,? extends MaybeSource<? extends R>> onErrorMapper, Supplier<? extends MaybeSource<? extends R>> onCompleteSupplier)
MaybeFlatten(MaybeSource<T> source, Function<? super T,? extends MaybeSource<? extends R>> mapper)
MaybeOnErrorNext(MaybeSource<T> source, Function<? super java.lang.Throwable,? extends MaybeSource<? extends T>> resumeFunction)
MaybeUsing(Supplier<? extends D> resourceSupplier, Function<? super D,? extends MaybeSource<? extends T>> sourceSupplier, Consumer<? super D> resourceDisposer, boolean eager)
MaybeZipIterable(java.lang.Iterable<? extends MaybeSource<? extends T>> sources, Function<? super java.lang.Object[],? extends R> zipper)
OnErrorNextMaybeObserver(MaybeObserver<? super T> actual, Function<? super java.lang.Throwable,? extends MaybeSource<? extends T>> resumeFunction)

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

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

Modifier and Type	Field	Description
(package private) MaybeSource<T>	MaybeFlatMapObservable.source
(package private) MaybeSource<T>	MaybeFlatMapPublisher.source

Fields in io.reactivex.rxjava3.internal.operators.mixed with type parameters of type MaybeSource

Modifier and Type	Field	Description
(package private) Function<? super T,? extends MaybeSource<? extends R>>	FlowableConcatMapMaybe.ConcatMapMaybeSubscriber.mapper
(package private) Function<? super T,? extends MaybeSource<? extends R>>	FlowableConcatMapMaybe.mapper
(package private) Function<? super T,? extends MaybeSource<? extends R>>	FlowableConcatMapMaybePublisher.mapper
(package private) Function<? super T,? extends MaybeSource<? extends R>>	FlowableSwitchMapMaybe.mapper
(package private) Function<? super T,? extends MaybeSource<? extends R>>	FlowableSwitchMapMaybe.SwitchMapMaybeSubscriber.mapper
(package private) Function<? super T,? extends MaybeSource<? extends R>>	FlowableSwitchMapMaybePublisher.mapper
(package private) Function<? super T,? extends MaybeSource<? extends R>>	ObservableConcatMapMaybe.ConcatMapMaybeMainObserver.mapper
(package private) Function<? super T,? extends MaybeSource<? extends R>>	ObservableConcatMapMaybe.mapper
(package private) Function<? super T,? extends MaybeSource<? extends R>>	ObservableSwitchMapMaybe.mapper
(package private) Function<? super T,? extends MaybeSource<? extends R>>	ObservableSwitchMapMaybe.SwitchMapMaybeMainObserver.mapper

Method parameters in io.reactivex.rxjava3.internal.operators.mixed with type arguments of type MaybeSource

Modifier and Type	Method	Description
(package private) static <T,R> boolean	ScalarXMapZHelper.tryAsMaybe(java.lang.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).

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

Constructor	Description
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)

Constructor parameters in io.reactivex.rxjava3.internal.operators.mixed with type arguments of type MaybeSource

Constructor	Description
ConcatMapMaybeMainObserver(Observer<? super R> downstream, Function<? super T,? extends MaybeSource<? extends R>> mapper, int prefetch, ErrorMode errorMode)
ConcatMapMaybeSubscriber(org.reactivestreams.Subscriber<? super R> downstream, Function<? super T,? extends MaybeSource<? extends R>> mapper, int prefetch, ErrorMode errorMode)
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)
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)
ObservableConcatMapMaybe(Observable<T> source, Function<? super T,? extends MaybeSource<? extends R>> mapper, ErrorMode errorMode, int prefetch)
ObservableSwitchMapMaybe(Observable<T> source, Function<? super T,? extends MaybeSource<? extends R>> mapper, boolean delayErrors)
SwitchMapMaybeMainObserver(Observer<? super R> downstream, Function<? super T,? extends MaybeSource<? extends R>> mapper, boolean delayErrors)
SwitchMapMaybeSubscriber(org.reactivestreams.Subscriber<? super R> downstream, Function<? super T,? extends MaybeSource<? extends R>> mapper, boolean delayErrors)

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

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

Modifier and Type	Class	Description
class	ObservableElementAtMaybe<T>
class	ObservableLastMaybe<T>	Consumes the source ObservableSource and emits its last item, the defaultItem if empty or a NoSuchElementException if even the defaultItem is null.
class	ObservableReduceMaybe<T>	Reduce a sequence of values into a single value via an aggregator function and emit the final value or complete if the source is empty.
class	ObservableSingleMaybe<T>

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

Modifier and Type	Field	Description
(package private) MaybeSource<? extends T>	ObservableConcatWithMaybe.ConcatWithObserver.other
(package private) MaybeSource<? extends T>	ObservableConcatWithMaybe.other
(package private) MaybeSource<? extends T>	ObservableMergeWithMaybe.other

Fields in io.reactivex.rxjava3.internal.operators.observable with type parameters of type MaybeSource

Modifier and Type	Field	Description
(package private) Function<? super T,? extends MaybeSource<? extends R>>	ObservableFlatMapMaybe.FlatMapMaybeObserver.mapper
(package private) Function<? super T,? extends MaybeSource<? extends R>>	ObservableFlatMapMaybe.mapper

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

Constructor	Description
ConcatWithObserver(Observer<? super T> actual, MaybeSource<? extends T> other)
ObservableConcatWithMaybe(Observable<T> source, MaybeSource<? extends T> other)
ObservableMergeWithMaybe(Observable<T> source, MaybeSource<? extends T> other)

Constructor parameters in io.reactivex.rxjava3.internal.operators.observable with type arguments of type MaybeSource

Constructor	Description
FlatMapMaybeObserver(Observer<? super R> actual, Function<? super T,? extends MaybeSource<? extends R>> mapper, boolean delayErrors)
ObservableFlatMapMaybe(ObservableSource<T> source, Function<? super T,? extends MaybeSource<? extends R>> mapper, boolean delayError)

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

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

Modifier and Type	Class	Description
class	SingleDematerialize<T,R>	Maps the success value of the source to a Notification, then maps it back to the corresponding signal type.
class	SingleFlatMapMaybe<T,R>
class	SingleOnErrorComplete<T>	Emits an onComplete if the source emits an onError and the predicate returns true for that Throwable.

Fields in io.reactivex.rxjava3.internal.operators.single with type parameters of type MaybeSource

Modifier and Type	Field	Description
(package private) Function<? super T,? extends MaybeSource<? extends R>>	SingleFlatMapMaybe.FlatMapSingleObserver.mapper
(package private) Function<? super T,? extends MaybeSource<? extends R>>	SingleFlatMapMaybe.mapper

Constructor parameters in io.reactivex.rxjava3.internal.operators.single with type arguments of type MaybeSource

Constructor	Description
FlatMapSingleObserver(MaybeObserver<? super R> actual, Function<? super T,? extends MaybeSource<? extends R>> mapper)
SingleFlatMapMaybe(SingleSource<? extends T> source, Function<? super T,? extends MaybeSource<? extends R>> mapper)

Uses of MaybeSource in io.reactivex.rxjava3.subjects

Classes in io.reactivex.rxjava3.subjects that implement MaybeSource

Modifier and Type	Class	Description
class	MaybeSubject<T>	Represents a hot Maybe-like source and consumer of events similar to Subjects.