Uses of Class
io.reactivex.rxjava3.core.Maybe

Packages that use Maybe

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.observable
io.reactivex.rxjava3.internal.operators.single
io.reactivex.rxjava3.plugins	Contains the central plugin handler RxJavaPlugins class to hook into the lifecycle of the base reactive types and schedulers.
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 Maybe in io.reactivex.rxjava3.core

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

Modifier and Type	Method	Description
static <@NonNull T> @NonNull Maybe<T>	Maybe.amb(@NonNull Iterable<@NonNull ? 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 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).
final @NonNull Maybe<T>	Maybe.ambWith(@NonNull MaybeSource<? extends @NonNull T> other)	Mirrors the MaybeSource (current or provided) that first signals an event.
final <@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.
final @NonNull Maybe<T>	Maybe.cache()	Returns a Maybe that subscribes to this Maybe lazily, caches its event and replays it, to all the downstream subscribers.
final <@NonNull U> @NonNull Maybe<U>	Maybe.cast(@NonNull Class<? extends @NonNull U> clazz)	Casts the success value of the current Maybe into the target type or signals a ClassCastException if not compatible.
final <@NonNull R> @NonNull Maybe<R>	Maybe.compose(@NonNull MaybeTransformer<? super @NonNull T, ? extends @NonNull R> transformer)	Transform a Maybe by applying a particular MaybeTransformer function to it.
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 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 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.
static <@NonNull T> @NonNull Maybe<T>	Maybe.create(@NonNull MaybeOnSubscribe<@NonNull T> onSubscribe)	Provides an API (via a cold Maybe) that bridges the reactive world with the callback-style world.
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.
final @NonNull Maybe<T>	Maybe.delay(long time, @NonNull TimeUnit unit)	Returns a Maybe that signals the events emitted by the current Maybe shifted forward in time by a specified delay.
final @NonNull Maybe<T>	Maybe.delay(long time, @NonNull TimeUnit unit, boolean delayError)	Returns a Maybe that signals the events emitted by the current Maybe shifted forward in time by a specified delay.
final @NonNull Maybe<T>	Maybe.delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Maybe that signals the events emitted by the current Maybe shifted forward in time by a specified delay.
final @NonNull Maybe<T>	Maybe.delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError)	Returns a Maybe that signals the events emitted by the current Maybe shifted forward in time by a specified delay running on the specified Scheduler.
final <@NonNull U> @NonNull Maybe<T>	Maybe.delay(@NonNull org.reactivestreams.Publisher<@NonNull U> delayIndicator)	Delays the emission of this Maybe until the given Publisher signals an item or completes.
final @NonNull Maybe<T>	Maybe.delaySubscription(long time, @NonNull TimeUnit unit)	Returns a Maybe that delays the subscription to the current Maybe by a given amount of time.
final @NonNull Maybe<T>	Maybe.delaySubscription(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Maybe that delays the subscription to the current Maybe by a given amount of time, both waiting and subscribing on a given Scheduler.
final <@NonNull U> @NonNull Maybe<T>	Maybe.delaySubscription(@NonNull org.reactivestreams.Publisher<@NonNull U> subscriptionIndicator)	Returns a Maybe that delays the subscription to this Maybe until the other Publisher emits an element or completes normally.
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 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 Maybe<T>	Maybe.doAfterSuccess(@NonNull Consumer<? super @NonNull T> onAfterSuccess)	Calls the specified Consumer with the success item after this item has been emitted to the downstream.
final @NonNull Maybe<T>	Maybe.doAfterTerminate(@NonNull Action onAfterTerminate)	Registers an Action to be called when this Maybe invokes either onSuccess, onComplete or onError.
final @NonNull Maybe<T>	Maybe.doFinally(@NonNull Action onFinally)	Calls the specified action after this Maybe signals onSuccess, onError or onComplete or gets disposed by the downstream.
final @NonNull Maybe<T>	Maybe.doOnComplete(@NonNull Action onComplete)	Invokes an Action just before the current Maybe calls onComplete.
final @NonNull Maybe<T>	Maybe.doOnDispose(@NonNull Action onDispose)	Calls the shared Action if a MaybeObserver subscribed to the current Maybe disposes the common Disposable it received via onSubscribe.
final @NonNull Maybe<T>	Maybe.doOnError(@NonNull Consumer<? super Throwable> onError)	Calls the shared Consumer with the error sent via onError for each MaybeObserver that subscribes to the current Maybe.
final @NonNull Maybe<T>	Maybe.doOnEvent(@NonNull BiConsumer<@Nullable ? super @NonNull T, @Nullable ? super Throwable> onEvent)	Calls the given onEvent callback with the (success value, null) for an onSuccess, (null, throwable) for an onError or (null, null) for an onComplete signal from this Maybe before delivering said signal to the downstream.
final @NonNull Maybe<T>	Maybe.doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose)	Calls the appropriate onXXX method (shared between all MaybeObservers) for the lifecycle events of the sequence (subscription, disposal).
final @NonNull Maybe<T>	Maybe.doOnSubscribe(@NonNull Consumer<? super Disposable> onSubscribe)	Calls the shared Consumer with the Disposable sent through the onSubscribe for each MaybeObserver that subscribes to the current Maybe.
final @NonNull Maybe<T>	Maybe.doOnSuccess(@NonNull Consumer<? super @NonNull T> onSuccess)	Calls the shared Consumer with the success value sent via onSuccess for each MaybeObserver that subscribes to the current Maybe.
final @NonNull Maybe<T>	Maybe.doOnTerminate(@NonNull Action onTerminate)	Returns a Maybe instance that calls the given onTerminate callback just before this Maybe completes normally or with an exception.
final @NonNull Maybe<T>	Flowable.elementAt(long index)	Returns a Maybe that emits the single item at a specified index in a sequence of emissions from this Flowable or completes if this Flowable sequence has fewer elements than index.
final @NonNull Maybe<T>	Observable.elementAt(long index)	Returns a Maybe that emits the single item at a specified index in a sequence of emissions from the current Observable or completes if the current Observable signals fewer elements than index.
static <@NonNull T> @NonNull Maybe<T>	Maybe.empty()	Returns a (singleton) Maybe instance that calls onComplete immediately.
static <@NonNull T> @NonNull Maybe<T>	Maybe.error(@NonNull Supplier<? extends @NonNull Throwable> supplier)	Returns a Maybe that invokes a MaybeObserver's onError method when the MaybeObserver subscribes to it.
static <@NonNull T> @NonNull Maybe<T>	Maybe.error(@NonNull Throwable throwable)	Returns a Maybe that invokes a subscriber's onError method when the subscriber subscribes to it.
final @NonNull Maybe<T>	Maybe.filter(@NonNull Predicate<? super @NonNull T> predicate)	Filters the success item of the Maybe via a predicate function and emitting it if the predicate returns true, completing otherwise.
final @NonNull Maybe<T>	Single.filter(@NonNull Predicate<? super @NonNull T> predicate)	Filters the success item of the Single via a predicate function and emitting it if the predicate returns true, completing otherwise.
final @NonNull Maybe<T>	Flowable.firstElement()	Returns a Maybe that emits only the very first item emitted by this Flowable or completes if this Flowable is empty.
final @NonNull Maybe<T>	Observable.firstElement()	Returns a Maybe that emits only the very first item emitted by the current Observable, or completes if the current Observable is empty.
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 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 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.
static <@NonNull T> @NonNull Maybe<T>	Maybe.fromAction(@NonNull Action action)	Returns a Maybe instance that runs the given Action for each MaybeObserver and emits either its exception or simply completes.
static <T> @NonNull Maybe<@NonNull T>	Maybe.fromCallable(@NonNull Callable<? extends @Nullable T> callable)	Returns a Maybe that invokes the given Callable for each individual MaybeObserver that subscribes and emits the resulting non-null item via onSuccess while considering a null result from the Callable as indication for valueless completion via onComplete.
static <@NonNull T> @NonNull Maybe<T>	Maybe.fromCompletable(@NonNull CompletableSource completableSource)	Wraps a CompletableSource into a Maybe.
static <@NonNull T> @NonNull Maybe<@NonNull T>	Maybe.fromCompletionStage(@NonNull CompletionStage<@NonNull T> stage)	Signals the completion value or error of the given (hot) CompletionStage-based asynchronous calculation.
static <@NonNull T> @NonNull Maybe<T>	Maybe.fromFuture(@NonNull Future<? extends @NonNull T> future)	Converts a Future into a Maybe, treating a null result as an indication of emptiness.
static <@NonNull T> @NonNull Maybe<T>	Maybe.fromFuture(@NonNull Future<? extends @NonNull T> future, long timeout, @NonNull TimeUnit unit)	Converts a Future into a Maybe, with a timeout on the Future.
static <@NonNull T> @NonNull Maybe<T>	Maybe.fromObservable(@NonNull ObservableSource<@NonNull T> source)	Wraps an ObservableSource into a Maybe and emits the very first item or completes if the source is empty.
static <@NonNull T> @NonNull Maybe<@NonNull T>	Maybe.fromOptional(@NonNull Optional<@NonNull T> optional)	Converts the existing value of the provided optional into a Maybe.just(Object) or an empty optional into an Maybe.empty() Maybe instance.
static <@NonNull T> @NonNull Maybe<T>	Maybe.fromPublisher(@NonNull org.reactivestreams.Publisher<@NonNull T> source)	Wraps a Publisher into a Maybe and emits the very first item or completes if the source is empty.
static <@NonNull T> @NonNull Maybe<T>	Maybe.fromRunnable(@NonNull Runnable run)	Returns a Maybe instance that runs the given Runnable for each MaybeObserver and emits either its unchecked exception or simply completes.
static <@NonNull T> @NonNull Maybe<T>	Maybe.fromSingle(@NonNull SingleSource<@NonNull T> single)	Wraps a SingleSource into a Maybe.
static <T> @NonNull Maybe<@NonNull T>	Maybe.fromSupplier(@NonNull Supplier<? extends @Nullable T> supplier)	Returns a Maybe that invokes the given Supplier for each individual MaybeObserver that subscribes and emits the resulting non-null item via onSuccess while considering a null result from the Supplier as indication for valueless completion via onComplete.
final @NonNull Maybe<T>	Maybe.hide()	Hides the identity of this Maybe and its Disposable.
static <@NonNull T> @NonNull Maybe<T>	Maybe.just(@NonNull T item)	Returns a Maybe that emits a specified item.
final @NonNull Maybe<T>	Flowable.lastElement()	Returns a Maybe that emits the last item emitted by this Flowable or completes if this Flowable is empty.
final @NonNull Maybe<T>	Observable.lastElement()	Returns a Maybe that emits the last item emitted by the current Observable or completes if the current Observable is empty.
final <@NonNull R> @NonNull Maybe<R>	Maybe.lift(@NonNull MaybeOperator<? extends @NonNull R, ? super @NonNull T> lift)	This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns a Maybe which, when subscribed to, invokes the apply(MaybeObserver) method of the provided MaybeOperator for each individual downstream Maybe and allows the insertion of a custom operator by accessing the downstream's MaybeObserver during this subscription phase and providing a new MaybeObserver, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.
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 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 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.
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 Maybe<T>	Maybe.never()	Returns a Maybe that never sends any items or notifications to a MaybeObserver.
final @NonNull Maybe<T>	Maybe.observeOn(@NonNull Scheduler scheduler)	Wraps a Maybe to emit its item (or notify of its error) on a specified Scheduler, asynchronously.
final <@NonNull U> @NonNull Maybe<U>	Maybe.ofType(@NonNull Class<@NonNull U> clazz)	Filters the items emitted by the current Maybe, only emitting its success value if that is an instance of the supplied Class.
final <@NonNull U> @NonNull Maybe<U>	Single.ofType(@NonNull Class<@NonNull U> clazz)	Filters the items emitted by the current Single, only emitting its success value if that is an instance of the supplied Class.
final @NonNull Maybe<T>	Maybe.onErrorComplete()	Returns a Maybe instance that if this Maybe emits an error, it will emit an onComplete and swallow the throwable.
final @NonNull Maybe<T>	Maybe.onErrorComplete(@NonNull Predicate<? super Throwable> predicate)	Returns a Maybe instance that if this Maybe emits an error and the predicate returns true, it will emit an onComplete and swallow the throwable.
final @NonNull Maybe<T>	Single.onErrorComplete()	Returns a Maybe instance that if the current Single emits an error, it will emit an onComplete and swallow the throwable.
final @NonNull Maybe<T>	Single.onErrorComplete(@NonNull Predicate<? super Throwable> predicate)	Returns a Maybe instance that if this Single emits an error and the predicate returns true, it will emit an onComplete and swallow the throwable.
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 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.
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 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 T> @NonNull Maybe<T>	Completable.onErrorReturnItem(@NonNull T item)	Ends the flow with the given success item when the current Completable fails instead of signaling the error via onError.
final @NonNull Maybe<T>	Maybe.onErrorReturnItem(@NonNull T item)	Ends the flow with the given success item when the current Maybe fails instead of signaling the error via onError.
final @NonNull Maybe<T>	Maybe.onTerminateDetach()	Nulls out references to the upstream producer and downstream MaybeObserver if the sequence is terminated or downstream calls dispose().
final @NonNull Maybe<T>	Flowable.reduce(@NonNull BiFunction<@NonNull T, @NonNull T, @NonNull T> reducer)	Returns a Maybe that applies a specified accumulator function to the first item emitted by the current Flowable, then feeds the result of that function along with the second item emitted by the current Flowable into the same function, and so on until all items have been emitted by the current and finite Flowable, and emits the final result from the final call to your function as its sole item.
final @NonNull Maybe<T>	Observable.reduce(@NonNull BiFunction<@NonNull T, @NonNull T, @NonNull T> reducer)	Returns a Maybe that applies a specified accumulator function to the first item emitted by the current Observable, then feeds the result of that function along with the second item emitted by the current Observable into the same function, and so on until all items have been emitted by the current and finite Observable, and emits the final result from the final call to your function as its sole item.
final @NonNull Maybe<T>	Maybe.retry()	Returns a Maybe that mirrors the current Maybe, resubscribing to it if it calls onError (infinite retry count).
final @NonNull Maybe<T>	Maybe.retry(long times)	Returns a Maybe that mirrors the current Maybe, resubscribing to it if it calls onError up to a specified number of retries.
final @NonNull Maybe<T>	Maybe.retry(long times, @NonNull Predicate<? super Throwable> predicate)	Retries at most times or until the predicate returns false, whichever happens first.
final @NonNull Maybe<T>	Maybe.retry(@NonNull BiPredicate<? super Integer, ? super Throwable> predicate)	Returns a Maybe that mirrors the current Maybe, resubscribing to it if it calls onError and the predicate returns true for that specific exception and retry count.
final @NonNull Maybe<T>	Maybe.retry(@NonNull Predicate<? super Throwable> predicate)	Retries the current Maybe if it fails and the predicate returns true.
final @NonNull Maybe<T>	Maybe.retryUntil(@NonNull BooleanSupplier stop)	Retries until the given stop function returns true.
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 Maybe<T>	Flowable.singleElement()	Returns a Maybe that completes if this Flowable is empty, signals one item if this Flowable signals exactly one item or signals an IllegalArgumentException if this Flowable signals more than one item.
final @NonNull Maybe<T>	Observable.singleElement()	Returns a Maybe that completes if the current Observable is empty or emits the single item emitted by the current Observable, or signals an IllegalArgumentException if the current Observable emits more than one item.
final @NonNull Maybe<T>	Maybe.subscribeOn(@NonNull Scheduler scheduler)	Asynchronously subscribes subscribers to this Maybe on the specified Scheduler.
final @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.
final <@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.
final <@NonNull U> @NonNull Maybe<T>	Maybe.takeUntil(@NonNull org.reactivestreams.Publisher<@NonNull U> other)	Returns a Maybe that emits the item emitted by the current Maybe until a second Publisher emits an item.
final @NonNull Maybe<Timed<T>>	Maybe.timeInterval()	Measures the time (in milliseconds) between the subscription and success item emission of the current Maybe and signals it as a tuple (Timed) success value.
final @NonNull Maybe<Timed<T>>	Maybe.timeInterval(@NonNull Scheduler scheduler)	Measures the time (in milliseconds) between the subscription and success item emission of the current Maybe and signals it as a tuple (Timed) success value.
final @NonNull Maybe<Timed<T>>	Maybe.timeInterval(@NonNull TimeUnit unit)	Measures the time between the subscription and success item emission of the current Maybe and signals it as a tuple (Timed) success value.
final @NonNull Maybe<Timed<T>>	Maybe.timeInterval(@NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Measures the time between the subscription and success item emission of the current Maybe and signals it as a tuple (Timed) success value.
final @NonNull Maybe<T>	Maybe.timeout(long timeout, @NonNull TimeUnit unit)	Returns a Maybe that mirrors the current Maybe but applies a timeout policy for each emitted item.
final @NonNull Maybe<T>	Maybe.timeout(long timeout, @NonNull 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.
final @NonNull Maybe<T>	Maybe.timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Maybe that mirrors the current Maybe but applies a timeout policy for each emitted item, where this policy is governed on a specified Scheduler.
final @NonNull Maybe<T>	Maybe.timeout(long timeout, @NonNull 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.
final <@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.
final <@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.
final <@NonNull U> @NonNull Maybe<T>	Maybe.timeout(@NonNull org.reactivestreams.Publisher<@NonNull U> timeoutIndicator)	If the current Maybe source didn't signal an event before the timeoutIndicator Publisher signals, a TimeoutException is signaled instead.
final <@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 Maybe<Long>	Maybe.timer(long delay, @NonNull TimeUnit unit)	Returns a Maybe that emits 0L after a specified delay.
static @NonNull Maybe<Long>	Maybe.timer(long delay, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Maybe that emits 0L after a specified delay on a specified Scheduler.
final @NonNull Maybe<Timed<T>>	Maybe.timestamp()	Combines the success value from the current Maybe with the current time (in milliseconds) of its reception, using the computation Scheduler as time source, then signals them as a Timed instance.
final @NonNull Maybe<Timed<T>>	Maybe.timestamp(@NonNull Scheduler scheduler)	Combines the success value from the current Maybe with the current time (in milliseconds) of its reception, using the given Scheduler as time source, then signals them as a Timed instance.
final @NonNull Maybe<Timed<T>>	Maybe.timestamp(@NonNull TimeUnit unit)	Combines the success value from the current Maybe with the current time of its reception, using the computation Scheduler as time source, then signals it as a Timed instance.
final @NonNull Maybe<Timed<T>>	Maybe.timestamp(@NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Combines the success value from the current Maybe with the current time of its reception, using the given Scheduler as time source, then signals it as a Timed instance.
final <@NonNull T> @NonNull Maybe<T>	Completable.toMaybe()	Converts this Completable into a Maybe.
final @NonNull Maybe<T>	Single.toMaybe()	Converts this Single into a Maybe.
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.
final @NonNull Maybe<T>	Maybe.unsubscribeOn(@NonNull Scheduler scheduler)	Returns a Maybe which makes sure when a MaybeObserver disposes the Disposable, that call is propagated up on the specified Scheduler.
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 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.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 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.
final <@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.

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

Modifier and Type	Method	Description
R	MaybeConverter.apply(@NonNull Maybe<@NonNull T> upstream)	Applies a function to the upstream Maybe and returns a converted value of type R.
@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.

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

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

Modifier and Type	Method	Description
@NonNull Maybe<T>	FuseToMaybe.fuseToMaybe()	Returns a (direct) Maybe for the operator.

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

Subclasses of Maybe in io.reactivex.rxjava3.internal.jdk8

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

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

Modifier and Type	Field	Description
(package private) final Maybe<T>	MaybeFlattenStreamAsFlowable.source
(package private) final Maybe<T>	MaybeFlattenStreamAsObservable.source
(package private) final Maybe<T>	MaybeMapOptional.source

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

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

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

Subclasses of Maybe in io.reactivex.rxjava3.internal.operators.completable

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

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

Subclasses of Maybe in io.reactivex.rxjava3.internal.operators.flowable

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

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

Subclasses of Maybe in io.reactivex.rxjava3.internal.operators.maybe

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

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

Modifier and Type	Field	Description
(package private) final Maybe<T>	MaybeMaterialize.source

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

Modifier and Type	Method	Description
Maybe<T>	MaybeIgnoreElementCompletable.fuseToMaybe()
Maybe<Boolean>	MaybeIsEmptySingle.fuseToMaybe()

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

Modifier	Constructor	Description
	MaybeDematerialize(Maybe<T> source, Function<? super T, Notification<R>> selector)
	MaybeDoOnLifecycle(Maybe<T> upstream, Consumer<? super Disposable> onSubscribe, Action onDispose)
	MaybeMaterialize(Maybe<T> source)

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

Subclasses of Maybe in io.reactivex.rxjava3.internal.operators.observable

Modifier and Type	Class	Description
final class	ObservableElementAtMaybe<T>
final 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.
final 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.
final class	ObservableSingleMaybe<T>

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

Subclasses of Maybe in io.reactivex.rxjava3.internal.operators.single

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

Uses of Maybe in io.reactivex.rxjava3.plugins

Fields in io.reactivex.rxjava3.plugins with type parameters of type Maybe

Modifier and Type	Field	Description
(package private) static @Nullable Function<? super Maybe, ? extends Maybe>	RxJavaPlugins.onMaybeAssembly
(package private) static @Nullable Function<? super Maybe, ? extends Maybe>	RxJavaPlugins.onMaybeAssembly
(package private) static @Nullable BiFunction<? super Maybe, @NonNull ? super MaybeObserver, @NonNull ? extends MaybeObserver>	RxJavaPlugins.onMaybeSubscribe

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

Modifier and Type	Method	Description
static <@NonNull T> @NonNull Maybe<T>	RxJavaPlugins.onAssembly(@NonNull Maybe<@NonNull T> source)	Calls the associated hook function.

Methods in io.reactivex.rxjava3.plugins that return types with arguments of type Maybe

Modifier and Type	Method	Description
static @Nullable Function<? super Maybe, ? extends Maybe>	RxJavaPlugins.getOnMaybeAssembly()	Returns the current hook function.
static @Nullable Function<? super Maybe, ? extends Maybe>	RxJavaPlugins.getOnMaybeAssembly()	Returns the current hook function.
static @Nullable BiFunction<? super Maybe, @NonNull ? super MaybeObserver, @NonNull ? extends MaybeObserver>	RxJavaPlugins.getOnMaybeSubscribe()	Returns the current hook function.

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

Modifier and Type	Method	Description
static <@NonNull T> @NonNull Maybe<T>	RxJavaPlugins.onAssembly(@NonNull Maybe<@NonNull T> source)	Calls the associated hook function.
static <@NonNull T> @NonNull MaybeObserver<? super T>	RxJavaPlugins.onSubscribe(@NonNull Maybe<@NonNull T> source, @NonNull MaybeObserver<? super @NonNull T> observer)	Calls the associated hook function.

Method parameters in io.reactivex.rxjava3.plugins with type arguments of type Maybe

Modifier and Type	Method	Description
static void	RxJavaPlugins.setOnMaybeAssembly(@Nullable Function<? super Maybe, ? extends Maybe> onMaybeAssembly)	Sets the specific hook function.
static void	RxJavaPlugins.setOnMaybeAssembly(@Nullable Function<? super Maybe, ? extends Maybe> onMaybeAssembly)	Sets the specific hook function.
static void	RxJavaPlugins.setOnMaybeSubscribe(@Nullable BiFunction<? super Maybe, @NonNull MaybeObserver, @NonNull ? extends MaybeObserver> onMaybeSubscribe)	Sets the specific hook function.

Uses of Maybe in io.reactivex.rxjava3.subjects

Subclasses of Maybe in io.reactivex.rxjava3.subjects

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