Movatterモバイル変換

java.lang.Object
- io.reactivex.Maybe<T>

Type Parameters:
T - the value type
All Implemented Interfaces:
MaybeSource<T>
Direct Known Subclasses:
MaybeSubject
```
public abstract classMaybe<T>extendsObjectimplementsMaybeSource<T>
```
TheMaybe class represents a deferred computation and emission of a single value, no value at all or an exception.
TheMaybe class implements theMaybeSource base interface and the default consumer type it interacts with is theMaybeObserver via thesubscribe(MaybeObserver) method.
TheMaybe operates with the following sequential protocol:
```
 onSubscribe (onSuccess | onError | onComplete)?
```
Note thatonSuccess,onError andonComplete are mutually exclusive events; unlikeObservable,onSuccess is never followed byonError oronComplete.
LikeObservable, a runningMaybe can be stopped through theDisposable instance provided to consumers throughMaybeObserver.onSubscribe(io.reactivex.disposables.Disposable).
Like anObservable, aMaybe is lazy, can be either "hot" or "cold", synchronous or asynchronous.Maybe instances returned by the methods of this class arecold and there is a standardhot implementation in the form of a subject:MaybeSubject.
The documentation for this class makes use of marble diagrams. The following legend explains these diagrams:
SeeFlowable orObservable for the implementation of the Reactive Pattern for a stream or vector of values.
Example:
```
 Disposable d = Maybe.just("Hello World") .delay(10, TimeUnit.SECONDS, Schedulers.io()) .subscribeWith(new DisposableMaybeObserver<String>() { @Override public void onStart() { System.out.println("Started"); } @Override public void onSuccess(String value) { System.out.println("Success: " + value); } @Override public void onError(Throwable error) { error.printStackTrace(); } @Override public void onComplete() { System.out.println("Done!"); } }); Thread.sleep(5000); d.dispose();
```
Note that by design, subscriptions viasubscribe(MaybeObserver) can't be disposed from the outside (hence thevoid return of thesubscribe(MaybeObserver) method) and it is the responsibility of the implementor of theMaybeObserver to allow this to happen. RxJava supports such usage with the standardDisposableMaybeObserver instance. For convenience, thesubscribeWith(MaybeObserver) method is provided as well to allow working with aMaybeObserver (or subclass) instance to be applied with in a fluent manner (such as in the example above).
Since:
2.0
See Also:
DisposableMaybeObserver

Constructor Summary
Constructors
Constructor and Description
Maybe()

Constructors
Constructor and Description
`Maybe()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`static <T> Maybe<T>`	`amb(Iterable<? extendsMaybeSource<? extends T>> sources)` Runs multiple MaybeSources and signals the events of the first one that signals (disposing the rest).
`static <T> Maybe<T>`	`ambArray(MaybeSource<? extends T>... sources)` Runs multiple MaybeSources and signals the events of the first one that signals (disposing the rest).
`Maybe<T>`	`ambWith(MaybeSource<? extendsT> other)` Mirrors the MaybeSource (current or provided) that first signals an event.
`<R> R`	`as(MaybeConverter<T,? extends R> converter)` Calls the specified converter function during assembly time and returns its resulting value.
`T`	`blockingGet()` Waits in a blocking fashion until the current Maybe signals a success value (which is returned), null if completed or an exception (which is propagated).
`T`	`blockingGet(T defaultValue)` Waits in a blocking fashion until the current Maybe signals a success value (which is returned), defaultValue if completed or an exception (which is propagated).
`Maybe<T>`	`cache()` Returns a Maybe that subscribes to this Maybe lazily, caches its event and replays it, to all the downstream subscribers.
`<U> Maybe<U>`	`cast(Class<? extends U> clazz)` Casts the success value of the current Maybe into the target type or signals a ClassCastException if not compatible.
`<R> Maybe<R>`	`compose(MaybeTransformer<? superT,? extends R> transformer)` Transform a Maybe by applying a particular Transformer function to it.
`static <T> Flowable<T>`	`concat(Iterable<? extendsMaybeSource<? extends T>> sources)` Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by an Iterable sequence.
`static <T> Flowable<T>`	`concat(MaybeSource<? extends T> source1,MaybeSource<? extends T> source2)` Returns a Flowable that emits the items emitted by two MaybeSources, one after the other.
`static <T> Flowable<T>`	`concat(MaybeSource<? extends T> source1,MaybeSource<? extends T> source2,MaybeSource<? extends T> source3)` Returns a Flowable that emits the items emitted by three MaybeSources, one after the other.
`static <T> Flowable<T>`	`concat(MaybeSource<? extends T> source1,MaybeSource<? extends T> source2,MaybeSource<? extends T> source3,MaybeSource<? extends T> source4)` Returns a Flowable that emits the items emitted by four MaybeSources, one after the other.
`static <T> Flowable<T>`	`concat(Publisher<? extendsMaybeSource<? extends T>> sources)` Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by a Publisher sequence.
`static <T> Flowable<T>`	`concat(Publisher<? extendsMaybeSource<? extends T>> sources, int prefetch)` Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by a Publisher sequence.
`static <T> Flowable<T>`	`concatArray(MaybeSource<? extends T>... sources)` Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources in the array.
`static <T> Flowable<T>`	`concatArrayDelayError(MaybeSource<? extends T>... sources)` Concatenates a variable number of MaybeSource sources and delays errors from any of them till all terminate.
`static <T> Flowable<T>`	`concatArrayEager(MaybeSource<? extends T>... sources)` Concatenates a sequence of MaybeSource eagerly into a single stream of values.
`static <T> Flowable<T>`	`concatDelayError(Iterable<? extendsMaybeSource<? extends 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.
`static <T> Flowable<T>`	`concatDelayError(Publisher<? extendsMaybeSource<? extends T>> sources)` Concatenates the Publisher sequence of Publishers into a single sequence by subscribing to each inner Publisher, one after the other, one at a time and delays any errors till the all inner and the outer Publishers terminate.
`static <T> Flowable<T>`	`concatEager(Iterable<? extendsMaybeSource<? extends T>> sources)` Concatenates a sequence of MaybeSources eagerly into a single stream of values.
`static <T> Flowable<T>`	`concatEager(Publisher<? extendsMaybeSource<? extends T>> sources)` Concatenates a Publisher sequence of MaybeSources eagerly into a single stream of values.
`<R> Maybe<R>`	`concatMap(Function<? superT,? extendsMaybeSource<? extends R>> mapper)` Returns a Maybe that is based on applying a specified function to the item emitted by the source Maybe, where that function returns a MaybeSource.
`Flowable<T>`	`concatWith(MaybeSource<? extendsT> other)` Returns a Flowable that emits the items emitted from the current MaybeSource, then the next, one after the other, without interleaving them.
`Single<Boolean>`	`contains(Object item)` Returns a Single that emits a Boolean that indicates whether the source Maybe emitted a specified item.
`Single<Long>`	`count()` Returns a Single that counts the total number of items emitted (0 or 1) by the source Maybe and emits this count as a 64-bit Long.
`static <T> Maybe<T>`	`create(MaybeOnSubscribe<T> onSubscribe)` Provides an API (via a cold Maybe) that bridges the reactive world with the callback-style world.
`Maybe<T>`	`defaultIfEmpty(T defaultItem)` Returns a Maybe that emits the item emitted by the source Maybe or a specified default item if the source Maybe is empty.
`static <T> Maybe<T>`	`defer(Callable<? extendsMaybeSource<? extends T>> maybeSupplier)` Calls a Callable for each individual MaybeObserver to return the actual MaybeSource source to be subscribed to.
`Maybe<T>`	`delay(long delay,TimeUnit unit)` Returns a Maybe that signals the events emitted by the source Maybe shifted forward in time by a specified delay.
`Maybe<T>`	`delay(long delay,TimeUnit unit,Scheduler scheduler)` Returns a Maybe that signals the events emitted by the source Maybe shifted forward in time by a specified delay running on the specified Scheduler.
`<U,V> Maybe<T>`	`delay(Publisher<U> delayIndicator)` Delays the emission of this Maybe until the given Publisher signals an item or completes.
`Maybe<T>`	`delaySubscription(long delay,TimeUnit unit)` Returns a Maybe that delays the subscription to the source Maybe by a given amount of time.
`Maybe<T>`	`delaySubscription(long delay,TimeUnit unit,Scheduler scheduler)` Returns a Maybe that delays the subscription to the source Maybe by a given amount of time, both waiting and subscribing on a given Scheduler.
`<U> Maybe<T>`	`delaySubscription(Publisher<U> subscriptionIndicator)` Returns a Maybe that delays the subscription to this Maybe until the other Publisher emits an element or completes normally.
`Maybe<T>`	`doAfterSuccess(Consumer<? superT> onAfterSuccess)` Calls the specified consumer with the success item after this item has been emitted to the downstream.
`Maybe<T>`	`doAfterTerminate(Action onAfterTerminate)` Registers an`Action` to be called when this Maybe invokes either`onSuccess`,`onComplete` or`onError`.
`Maybe<T>`	`doFinally(Action onFinally)` Calls the specified action after this Maybe signals onSuccess, onError or onComplete or gets disposed by the downstream.
`Maybe<T>`	`doOnComplete(Action onComplete)` Modifies the source Maybe so that it invokes an action when it calls`onComplete`.
`Maybe<T>`	`doOnDispose(Action onDispose)` Calls the shared`Action` if a MaybeObserver subscribed to the current Maybe disposes the common Disposable it received via onSubscribe.
`Maybe<T>`	`doOnError(Consumer<? superThrowable> onError)` Calls the shared consumer with the error sent via onError for each MaybeObserver that subscribes to the current Maybe.
`Maybe<T>`	`doOnEvent(BiConsumer<? superT,? superThrowable> 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.
`Maybe<T>`	`doOnSubscribe(Consumer<? superDisposable> onSubscribe)` Calls the shared consumer with the Disposable sent through the onSubscribe for each MaybeObserver that subscribes to the current Maybe.
`Maybe<T>`	`doOnSuccess(Consumer<? superT> onSuccess)` Calls the shared consumer with the success value sent via onSuccess for each MaybeObserver that subscribes to the current Maybe.
`Maybe<T>`	`doOnTerminate(Action onTerminate)` Returns a Maybe instance that calls the given onTerminate callback just before this Maybe completes normally or with an exception.
`static <T> Maybe<T>`	`empty()` Returns a (singleton) Maybe instance that calls`onComplete` immediately.
`static <T> Maybe<T>`	`error(Callable<? extendsThrowable> supplier)` Returns a Maybe that invokes a`MaybeObserver`'s`onError` method when the MaybeObserver subscribes to it.
`static <T> Maybe<T>`	`error(Throwable exception)` Returns a Maybe that invokes a subscriber's`onError` method when the subscriber subscribes to it.
`Maybe<T>`	`filter(Predicate<? superT> predicate)` Filters the success item of the Maybe via a predicate function and emitting it if the predicate returns true, completing otherwise.
`<R> Maybe<R>`	`flatMap(Function<? superT,? extendsMaybeSource<? extends R>> mapper)` Returns a Maybe that is based on applying a specified function to the item emitted by the source Maybe, where that function returns a MaybeSource.
`<R> Maybe<R>`	`flatMap(Function<? superT,? extendsMaybeSource<? extends R>> onSuccessMapper,Function<? superThrowable,? extendsMaybeSource<? extends R>> onErrorMapper,Callable<? extendsMaybeSource<? extends R>> onCompleteSupplier)` Maps the onSuccess, onError or onComplete signals of this Maybe into MaybeSource and emits that MaybeSource's signals.
`<U,R> Maybe<R>`	`flatMap(Function<? superT,? extendsMaybeSource<? extends U>> mapper,BiFunction<? superT,? super U,? extends R> resultSelector)` Returns a Maybe that emits the results of a specified function to the pair of values emitted by the source Maybe and a specified mapped MaybeSource.
`Completable`	`flatMapCompletable(Function<? superT,? extendsCompletableSource> mapper)` Returns a`Completable` that completes based on applying a specified function to the item emitted by the source`Maybe`, where that function returns a`Completable`.
`<R> Observable<R>`	`flatMapObservable(Function<? superT,? extendsObservableSource<? extends R>> mapper)` Returns an Observable that is based on applying a specified function to the item emitted by the source Maybe, where that function returns an ObservableSource.
`<R> Flowable<R>`	`flatMapPublisher(Function<? superT,? extendsPublisher<? extends R>> mapper)` Returns a Flowable that emits items based on applying a specified function to the item emitted by the source Maybe, where that function returns a Publisher.
`<R> Single<R>`	`flatMapSingle(Function<? superT,? extendsSingleSource<? extends R>> mapper)` Returns a`Single` based on applying a specified function to the item emitted by the source`Maybe`, where that function returns a`Single`.
`<R> Maybe<R>`	`flatMapSingleElement(Function<? superT,? extendsSingleSource<? extends R>> mapper)` Returns a`Maybe` based on applying a specified function to the item emitted by the source`Maybe`, where that function returns a`Single`.
`<U> Flowable<U>`	`flattenAsFlowable(Function<? superT,? extendsIterable<? extends U>> mapper)` Maps the success value of the upstream`Maybe` into an`Iterable` and emits its items as a`Flowable` sequence.
`<U> Observable<U>`	`flattenAsObservable(Function<? superT,? extendsIterable<? extends U>> mapper)` Maps the success value of the upstream`Maybe` into an`Iterable` and emits its items as an`Observable` sequence.
`static <T> Maybe<T>`	`fromAction(Action run)` Returns a Maybe instance that runs the given Action for each subscriber and emits either its exception or simply completes.
`static <T> Maybe<T>`	`fromCallable(Callable<? extends 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 <T> Maybe<T>`	`fromCompletable(CompletableSource completableSource)` Wraps a CompletableSource into a Maybe.
`static <T> Maybe<T>`	`fromFuture(Future<? extends T> future)` Converts a`Future` into a Maybe, treating a null result as an indication of emptiness.
`static <T> Maybe<T>`	`fromFuture(Future<? extends T> future, long timeout,TimeUnit unit)` Converts a`Future` into a Maybe, with a timeout on the Future.
`static <T> Maybe<T>`	`fromRunnable(Runnable run)` Returns a Maybe instance that runs the given Action for each subscriber and emits either its exception or simply completes.
`static <T> Maybe<T>`	`fromSingle(SingleSource<T> singleSource)` Wraps a SingleSource into a Maybe.
`Maybe<T>`	`hide()` Hides the identity of this Maybe and its Disposable.
`Completable`	`ignoreElement()` Ignores the item emitted by the source Maybe and only calls`onComplete` or`onError`.
`Single<Boolean>`	`isEmpty()` Returns a Single that emits`true` if the source Maybe is empty, otherwise`false`.
`static <T> Maybe<T>`	`just(T item)` Returns a`Maybe` that emits a specified item.
`<R> Maybe<R>`	`lift(MaybeOperator<? extends R,? superT> 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.
`<R> Maybe<R>`	`map(Function<? superT,? extends R> mapper)` Returns a Maybe that applies a specified function to the item emitted by the source Maybe and emits the result of this function application.
`Single<Notification<T>>`	`materialize()` Maps the signal types of this Maybe into a`Notification` of the same kind and emits it as a single success value to downstream.
`static <T> Flowable<T>`	`merge(Iterable<? extendsMaybeSource<? extends T>> sources)` Merges an Iterable sequence of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.
`static <T> Maybe<T>`	`merge(MaybeSource<? extendsMaybeSource<? extends 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 <T> Flowable<T>`	`merge(MaybeSource<? extends T> source1,MaybeSource<? extends T> source2)` Flattens two MaybeSources into a single Flowable, without any transformation.
`static <T> Flowable<T>`	`merge(MaybeSource<? extends T> source1,MaybeSource<? extends T> source2,MaybeSource<? extends T> source3)` Flattens three MaybeSources into a single Flowable, without any transformation.
`static <T> Flowable<T>`	`merge(MaybeSource<? extends T> source1,MaybeSource<? extends T> source2,MaybeSource<? extends T> source3,MaybeSource<? extends T> source4)` Flattens four MaybeSources into a single Flowable, without any transformation.
`static <T> Flowable<T>`	`merge(Publisher<? extendsMaybeSource<? extends T>> sources)` Merges a Flowable sequence of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.
`static <T> Flowable<T>`	`merge(Publisher<? extendsMaybeSource<? extends T>> sources, int maxConcurrency)` Merges a Flowable sequence of MaybeSource instances into a single Flowable sequence, running at most maxConcurrency MaybeSources at once.
`static <T> Flowable<T>`	`mergeArray(MaybeSource<? extends T>... sources)` Merges an array sequence of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.
`static <T> Flowable<T>`	`mergeArrayDelayError(MaybeSource<? extends 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 <T> Flowable<T>`	`mergeDelayError(Iterable<? extendsMaybeSource<? extends T>> sources)` Flattens an Iterable 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 <T> Flowable<T>`	`mergeDelayError(MaybeSource<? extends T> source1,MaybeSource<? extends 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 <T> Flowable<T>`	`mergeDelayError(MaybeSource<? extends T> source1,MaybeSource<? extends T> source2,MaybeSource<? extends 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 <T> Flowable<T>`	`mergeDelayError(MaybeSource<? extends T> source1,MaybeSource<? extends T> source2,MaybeSource<? extends T> source3,MaybeSource<? extends 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.
`static <T> Flowable<T>`	`mergeDelayError(Publisher<? extendsMaybeSource<? extends T>> sources)` Flattens a Publisher that emits MaybeSources into one Publisher, 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 <T> Flowable<T>`	`mergeDelayError(Publisher<? extendsMaybeSource<? extends T>> sources, int maxConcurrency)` Flattens a Publisher that emits MaybeSources into one Publisher, 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.
`Flowable<T>`	`mergeWith(MaybeSource<? extendsT> other)` Flattens this and another Maybe into a single Flowable, without any transformation.
`static <T> Maybe<T>`	`never()` Returns a Maybe that never sends any items or notifications to a`MaybeObserver`.
`Maybe<T>`	`observeOn(Scheduler scheduler)` Wraps a Maybe to emit its item (or notify of its error) on a specified`Scheduler`, asynchronously.
`<U> Maybe<U>`	`ofType(Class<U> clazz)` Filters the items emitted by a Maybe, only emitting its success value if that is an instance of the supplied Class.
`Maybe<T>`	`onErrorComplete()` Returns a Maybe instance that if this Maybe emits an error, it will emit an onComplete and swallow the throwable.
`Maybe<T>`	`onErrorComplete(Predicate<? superThrowable> 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.
`Maybe<T>`	`onErrorResumeNext(Function<? superThrowable,? extendsMaybeSource<? extendsT>> resumeFunction)` Instructs a Maybe to pass control to another Maybe rather than invoking`onError` if it encounters an error.
`Maybe<T>`	`onErrorResumeNext(MaybeSource<? extendsT> next)` Instructs a Maybe to pass control to another`MaybeSource` rather than invoking`onError` if it encounters an error.
`Maybe<T>`	`onErrorReturn(Function<? superThrowable,? extendsT> valueSupplier)` Instructs a Maybe to emit an item (returned by a specified function) rather than invoking`onError` if it encounters an error.
`Maybe<T>`	`onErrorReturnItem(T item)` Instructs a Maybe to emit an item (returned by a specified function) rather than invoking`onError` if it encounters an error.
`Maybe<T>`	`onExceptionResumeNext(MaybeSource<? extendsT> next)` Instructs a Maybe to pass control to another MaybeSource rather than invoking`onError` if it encounters an`Exception`.
`Maybe<T>`	`onTerminateDetach()` Nulls out references to the upstream producer and downstream MaybeObserver if the sequence is terminated or downstream calls dispose().
`Flowable<T>`	`repeat()` Returns a Flowable that repeats the sequence of items emitted by the source Maybe indefinitely.
`Flowable<T>`	`repeat(long times)` Returns a Flowable that repeats the sequence of items emitted by the source Maybe at most`count` times.
`Flowable<T>`	`repeatUntil(BooleanSupplier stop)` Returns a Flowable that repeats the sequence of items emitted by the source Maybe until the provided stop function returns true.
`Flowable<T>`	`repeatWhen(Function<? superFlowable<Object>,? extendsPublisher<?>> handler)` Returns a Flowable that emits the same values as the source Publisher with the exception of an`onComplete`.
`Maybe<T>`	`retry()` Returns a Maybe that mirrors the source Maybe, resubscribing to it if it calls`onError` (infinite retry count).
`Maybe<T>`	`retry(BiPredicate<? superInteger,? superThrowable> predicate)` Returns a Maybe that mirrors the source Maybe, resubscribing to it if it calls`onError` and the predicate returns true for that specific exception and retry count.
`Maybe<T>`	`retry(long count)` Returns a Maybe that mirrors the source Maybe, resubscribing to it if it calls`onError` up to a specified number of retries.
`Maybe<T>`	`retry(long times,Predicate<? superThrowable> predicate)` Retries at most times or until the predicate returns false, whichever happens first.
`Maybe<T>`	`retry(Predicate<? superThrowable> predicate)` Retries the current Maybe if it fails and the predicate returns true.
`Maybe<T>`	`retryUntil(BooleanSupplier stop)` Retries until the given stop function returns true.
`Maybe<T>`	`retryWhen(Function<? superFlowable<Throwable>,? extendsPublisher<?>> handler)` Returns a Maybe that emits the same values as the source Maybe with the exception of an`onError`.
`static <T> Single<Boolean>`	`sequenceEqual(MaybeSource<? extends T> source1,MaybeSource<? extends 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 <T> Single<Boolean>`	`sequenceEqual(MaybeSource<? extends T> source1,MaybeSource<? extends T> source2,BiPredicate<? super T,? super 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.
`Disposable`	`subscribe()` Subscribes to a Maybe and ignores`onSuccess` and`onComplete` emissions.
`Disposable`	`subscribe(Consumer<? superT> onSuccess)` Subscribes to a Maybe and provides a callback to handle the items it emits.
`Disposable`	`subscribe(Consumer<? superT> onSuccess,Consumer<? superThrowable> onError)` Subscribes to a Maybe and provides callbacks to handle the items it emits and any error notification it issues.
`Disposable`	`subscribe(Consumer<? superT> onSuccess,Consumer<? superThrowable> onError,Action onComplete)` Subscribes to a Maybe and provides callbacks to handle the items it emits and any error or completion notification it issues.
`void`	`subscribe(MaybeObserver<? superT> observer)` Subscribes the given MaybeObserver to this MaybeSource instance.
`protected abstract void`	`subscribeActual(MaybeObserver<? superT> observer)` Implement this method in subclasses to handle the incoming`MaybeObserver`s.
`Maybe<T>`	`subscribeOn(Scheduler scheduler)` Asynchronously subscribes subscribers to this Maybe on the specified`Scheduler`.
`<E extendsMaybeObserver<? superT>> E`	`subscribeWith(E observer)` Subscribes a given MaybeObserver (subclass) to this Maybe and returns the given MaybeObserver as is.
`Maybe<T>`	`switchIfEmpty(MaybeSource<? extendsT> other)` Returns a Maybe that emits the items emitted by the source Maybe or the items of an alternate MaybeSource if the current Maybe is empty.
`Single<T>`	`switchIfEmpty(SingleSource<? extendsT> other)` Returns a Single that emits the items emitted by the source Maybe or the item of an alternate SingleSource if the current Maybe is empty.
`<U> Maybe<T>`	`takeUntil(MaybeSource<U> other)` Returns a Maybe that emits the items emitted by the source Maybe until a second MaybeSource emits an item.
`<U> Maybe<T>`	`takeUntil(Publisher<U> other)` Returns a Maybe that emits the item emitted by the source Maybe until a second Publisher emits an item.
`TestObserver<T>`	`test()` Creates a TestObserver and subscribes it to this Maybe.
`TestObserver<T>`	`test(boolean cancelled)` Creates a TestObserver optionally in cancelled state, then subscribes it to this Maybe.
`Maybe<T>`	`timeout(long timeout,TimeUnit timeUnit)` Returns a Maybe that mirrors the source Maybe but applies a timeout policy for each emitted item.
`Maybe<T>`	`timeout(long timeout,TimeUnit timeUnit,MaybeSource<? extendsT> fallback)` Returns a Maybe that mirrors the source Maybe but applies a timeout policy for each emitted item.
`Maybe<T>`	`timeout(long timeout,TimeUnit timeUnit,Scheduler scheduler)` Returns a Maybe that mirrors the source Maybe but applies a timeout policy for each emitted item, where this policy is governed on a specified Scheduler.
`Maybe<T>`	`timeout(long timeout,TimeUnit timeUnit,Scheduler scheduler,MaybeSource<? extendsT> fallback)` Returns a Maybe that mirrors the source Maybe but applies a timeout policy for each emitted item using a specified Scheduler.
`<U> Maybe<T>`	`timeout(MaybeSource<U> timeoutIndicator)` If the current`Maybe` didn't signal an event before the`timeoutIndicatorMaybeSource` signals, a`TimeoutException` is signaled instead.
`<U> Maybe<T>`	`timeout(MaybeSource<U> timeoutIndicator,MaybeSource<? extendsT> fallback)` If the current`Maybe` didn't signal an event before the`timeoutIndicatorMaybeSource` signals, the current`Maybe` is disposed and the`fallbackMaybeSource` subscribed to as a continuation.
`<U> Maybe<T>`	`timeout(Publisher<U> timeoutIndicator)` If the current`Maybe` source didn't signal an event before the`timeoutIndicatorPublisher` signals, a`TimeoutException` is signaled instead.
`<U> Maybe<T>`	`timeout(Publisher<U> timeoutIndicator,MaybeSource<? extendsT> fallback)` If the current`Maybe` didn't signal an event before the`timeoutIndicatorPublisher` signals, the current`Maybe` is disposed and the`fallbackMaybeSource` subscribed to as a continuation.
`staticMaybe<Long>`	`timer(long delay,TimeUnit unit)` Returns a Maybe that emits`0L` after a specified delay.
`staticMaybe<Long>`	`timer(long delay,TimeUnit unit,Scheduler scheduler)` Returns a Maybe that emits`0L` after a specified delay on a specified Scheduler.
`<R> R`	`to(Function<? superMaybe<T>,R> convert)` Calls the specified converter function with the current Maybe instance during assembly time and returns its result.
`Flowable<T>`	`toFlowable()` Converts this Maybe into a backpressure-aware Flowable instance composing cancellation through.
`Observable<T>`	`toObservable()` Converts this Maybe into an Observable instance composing disposal through.
`Single<T>`	`toSingle()` Converts this Maybe into a Single instance composing disposal through and turning an empty Maybe into a signal of NoSuchElementException.
`Single<T>`	`toSingle(T defaultValue)` Converts this Maybe into a Single instance composing disposal through and turning an empty Maybe into a Single that emits the given value through onSuccess.
`static <T> Maybe<T>`	`unsafeCreate(MaybeSource<T> onSubscribe)` Advanced use only: creates a Maybe instance without any safeguards by using a callback that is called with a MaybeObserver.
`Maybe<T>`	`unsubscribeOn(Scheduler scheduler)` Returns a Maybe which makes sure when a MaybeObserver disposes the Disposable, that call is propagated up on the specified scheduler.
`static <T,D> Maybe<T>`	`using(Callable<? extends D> resourceSupplier,Function<? super D,? extendsMaybeSource<? extends T>> sourceSupplier,Consumer<? super D> resourceDisposer)` Constructs a Maybe that creates a dependent resource object which is disposed of when the upstream terminates or the downstream calls dispose().
`static <T,D> Maybe<T>`	`using(Callable<? extends D> resourceSupplier,Function<? super D,? extendsMaybeSource<? extends T>> sourceSupplier,Consumer<? super D> resourceDisposer, boolean eager)` Constructs a Maybe that creates a dependent resource object which is disposed of just before termination if you have set`disposeEagerly` to`true` and a downstream dispose() does not occur before termination.
`static <T> Maybe<T>`	`wrap(MaybeSource<T> source)` Wraps a MaybeSource instance into a new Maybe instance if not already a Maybe instance.
`static <T,R> Maybe<R>`	`zip(Iterable<? extendsMaybeSource<? extends T>> sources,Function<? superObject[],? extends 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 <T1,T2,R> Maybe<R>`	`zip(MaybeSource<? extends T1> source1,MaybeSource<? extends T2> source2,BiFunction<? super T1,? super T2,? extends 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 <T1,T2,T3,R> Maybe<R>`	`zip(MaybeSource<? extends T1> source1,MaybeSource<? extends T2> source2,MaybeSource<? extends T3> source3,Function3<? super T1,? super T2,? super T3,? extends 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 <T1,T2,T3,T4,R> Maybe<R>`	`zip(MaybeSource<? extends T1> source1,MaybeSource<? extends T2> source2,MaybeSource<? extends T3> source3,MaybeSource<? extends T4> source4,Function4<? super T1,? super T2,? super T3,? super T4,? extends 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 <T1,T2,T3,T4,T5,R> Maybe<R>`	`zip(MaybeSource<? extends T1> source1,MaybeSource<? extends T2> source2,MaybeSource<? extends T3> source3,MaybeSource<? extends T4> source4,MaybeSource<? extends T5> source5,Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends 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 <T1,T2,T3,T4,T5,T6,R> Maybe<R>`	`zip(MaybeSource<? extends T1> source1,MaybeSource<? extends T2> source2,MaybeSource<? extends T3> source3,MaybeSource<? extends T4> source4,MaybeSource<? extends T5> source5,MaybeSource<? extends T6> source6,Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends 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 <T1,T2,T3,T4,T5,T6,T7,R> Maybe<R>`	`zip(MaybeSource<? extends T1> source1,MaybeSource<? extends T2> source2,MaybeSource<? extends T3> source3,MaybeSource<? extends T4> source4,MaybeSource<? extends T5> source5,MaybeSource<? extends T6> source6,MaybeSource<? extends T7> source7,Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends 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 <T1,T2,T3,T4,T5,T6,T7,T8,R> Maybe<R>`	`zip(MaybeSource<? extends T1> source1,MaybeSource<? extends T2> source2,MaybeSource<? extends T3> source3,MaybeSource<? extends T4> source4,MaybeSource<? extends T5> source5,MaybeSource<? extends T6> source6,MaybeSource<? extends T7> source7,MaybeSource<? extends T8> source8,Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends 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 <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> Maybe<R>`	`zip(MaybeSource<? extends T1> source1,MaybeSource<? extends T2> source2,MaybeSource<? extends T3> source3,MaybeSource<? extends T4> source4,MaybeSource<? extends T5> source5,MaybeSource<? extends T6> source6,MaybeSource<? extends T7> source7,MaybeSource<? extends T8> source8,MaybeSource<? extends T9> source9,Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends 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 <T,R> Maybe<R>`	`zipArray(Function<? superObject[],? extends R> zipper,MaybeSource<? extends 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.
`<U,R> Maybe<R>`	`zipWith(MaybeSource<? extends U> other,BiFunction<? superT,? super U,? extends 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 inherited from class java.lang.Object
clone,equals,finalize,getClass,hashCode,notify,notifyAll,toString,wait,wait,wait

- Constructor Detail
 - Maybe
```
public Maybe()
```
- Method Detail
 - amb
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Maybe<T> amb(Iterable<? extendsMaybeSource<? extends T>> sources)
```
 Runs multiple MaybeSources and signals the events of the first one that signals (disposing the rest).
 Scheduler:
 amb does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 sources - the Iterable sequence of sources. A subscription to each source will occur in the same order as in the Iterable.
 Returns:
 the new Maybe instance
 - ambArray
```
@CheckReturnValue@SchedulerSupport(value="none")public static <T> Maybe<T> ambArray(MaybeSource<? extends T>... sources)
```
 Runs multiple MaybeSources and signals the events of the first one that signals (disposing the rest).
 Scheduler:
 ambArray does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 sources - the array of sources. A subscription to each source will occur in the same order as in the array.
 Returns:
 the new Maybe instance
 - concat
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Flowable<T> concat(Iterable<? extendsMaybeSource<? extends T>> sources)
```
 Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by an Iterable sequence.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 concat does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 sources - the Iterable sequence of MaybeSource instances
 Returns:
 the new Flowable instance
 - concat
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Flowable<T> concat(MaybeSource<? extends T> source1,MaybeSource<? extends T> source2)
```
 Returns a Flowable that emits the items emitted by two MaybeSources, one after the other.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 concat does not operate by default on a particularScheduler.
 Type Parameters:
 T - the common value type
 Parameters:
 source1 - a MaybeSource to be concatenated
 source2 - a MaybeSource to be concatenated
 Returns:
 a Flowable that emits items emitted by the two source MaybeSources, one after the other.
 See Also:
 ReactiveX operators documentation: Concat
 - concat
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Flowable<T> concat(MaybeSource<? extends T> source1,MaybeSource<? extends T> source2,MaybeSource<? extends T> source3)
```
 Returns a Flowable that emits the items emitted by three MaybeSources, one after the other.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 concat does not operate by default on a particularScheduler.
 Type Parameters:
 T - the common value type
 Parameters:
 source1 - a MaybeSource to be concatenated
 source2 - a MaybeSource to be concatenated
 source3 - a MaybeSource to be concatenated
 Returns:
 a Flowable that emits items emitted by the three source MaybeSources, one after the other.
 See Also:
 ReactiveX operators documentation: Concat
 - concat
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Flowable<T> concat(MaybeSource<? extends T> source1,MaybeSource<? extends T> source2,MaybeSource<? extends T> source3,MaybeSource<? extends T> source4)
```
 Returns a Flowable that emits the items emitted by four MaybeSources, one after the other.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 concat does not operate by default on a particularScheduler.
 Type Parameters:
 T - the common value type
 Parameters:
 source1 - a MaybeSource to be concatenated
 source2 - a MaybeSource to be concatenated
 source3 - a MaybeSource to be concatenated
 source4 - a MaybeSource to be concatenated
 Returns:
 a Flowable that emits items emitted by the four source MaybeSources, one after the other.
 See Also:
 ReactiveX operators documentation: Concat
 - concat
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")public static <T> Flowable<T> concat(Publisher<? extendsMaybeSource<? extends T>> sources)
```
 Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by a Publisher sequence.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer and expects thePublisher to honor backpressure as well. If the sourcesPublisher violates this, aMissingBackpressureException is signalled.
 Scheduler:
 concat does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 sources - the Publisher of MaybeSource instances
 Returns:
 the new Flowable instance
 - concat
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Flowable<T> concat(Publisher<? extendsMaybeSource<? extends T>> sources, int prefetch)
```
 Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by a Publisher sequence.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer and expects thePublisher to honor backpressure as well. If the sourcesPublisher violates this, aMissingBackpressureException is signalled.
 Scheduler:
 concat does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 sources - the Publisher of MaybeSource instances
 prefetch - the number of MaybeSources to prefetch from the Publisher
 Returns:
 the new Flowable instance
 - concatArray
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Flowable<T> concatArray(MaybeSource<? extends T>... sources)
```
 Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources in the array.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 concatArray does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 sources - the array of MaybeSource instances
 Returns:
 the new Flowable instance
 - concatArrayDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")public static <T> Flowable<T> concatArrayDelayError(MaybeSource<? extends T>... sources)
```
 Concatenates a variable number of MaybeSource sources and delays errors from any of them till all terminate.
 Backpressure:
 The operator honors backpressure from downstream.
 Scheduler:
 concatArrayDelayError does not operate by default on a particularScheduler.
 Type Parameters:
 T - the common base value type
 Parameters:
 sources - the array of sources
 Returns:
 the new Flowable instance
 Throws:
 NullPointerException - if sources is null
 - concatArrayEager
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")public static <T> Flowable<T> concatArrayEager(MaybeSource<? extends T>... sources)
```
 Concatenates a sequence of MaybeSource eagerly into a single stream of values.
 Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source MaybeSources. The operator buffers the value emitted by these MaybeSources and then drains them in order, each one after the previous one completes.
 Backpressure:
 The operator honors backpressure from downstream.
 Scheduler:
 This method does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 sources - a sequence of MaybeSources that need to be eagerly concatenated
 Returns:
 the new Flowable instance with the specified concatenation behavior
 - concatDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Flowable<T> concatDelayError(Iterable<? extendsMaybeSource<? extends 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.
 Backpressure:
 The operator honors backpressure from downstream.
 Scheduler:
 concatDelayError does not operate by default on a particularScheduler.
 Type Parameters:
 T - the common element base type
 Parameters:
 sources - the Iterable sequence of MaybeSources
 Returns:
 the new Flowable with the concatenating behavior
 - concatDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")public static <T> Flowable<T> concatDelayError(Publisher<? extendsMaybeSource<? extends T>> sources)
```
 Concatenates the Publisher sequence of Publishers into a single sequence by subscribing to each inner Publisher, one after the other, one at a time and delays any errors till the all inner and the outer Publishers terminate.
 Backpressure:
 concatDelayError fully supports backpressure.
 Scheduler:
 concatDelayError does not operate by default on a particularScheduler.
 Type Parameters:
 T - the common element base type
 Parameters:
 sources - the Publisher sequence of Publishers
 Returns:
 the new Publisher with the concatenating behavior
 - concatEager
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")public static <T> Flowable<T> concatEager(Iterable<? extendsMaybeSource<? extends T>> sources)
```
 Concatenates a sequence of MaybeSources eagerly into a single stream of values.
 Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source MaybeSources. The operator buffers the values emitted by these MaybeSources and then drains them in order, each one after the previous one completes.
 Backpressure:
 Backpressure is honored towards the downstream.
 Scheduler:
 This method does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 sources - a sequence of MaybeSource that need to be eagerly concatenated
 Returns:
 the new Flowable instance with the specified concatenation behavior
 - concatEager
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")public static <T> Flowable<T> concatEager(Publisher<? extendsMaybeSource<? extends T>> sources)
```
 Concatenates a Publisher sequence of MaybeSources eagerly into a single stream of values.
 Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the emitted source Publishers as they are observed. The operator buffers the values emitted by these Publishers and then drains them in order, each one after the previous one completes.
 Backpressure:
 Backpressure is honored towards the downstream and the outer Publisher is expected to support backpressure. Violating this assumption, the operator will signalMissingBackpressureException.
 Scheduler:
 This method does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 sources - a sequence of Publishers that need to be eagerly concatenated
 Returns:
 the new Publisher instance with the specified concatenation behavior
 - create
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Maybe<T> create(MaybeOnSubscribe<T> onSubscribe)
```
 Provides an API (via a cold Maybe) that bridges the reactive world with the callback-style world.
 Example:
```
 Maybe.<Event>create(emitter -> { Callback listener = new Callback() { @Override public void onEvent(Event e) { if (e.isNothing()) { emitter.onComplete(); } else { emitter.onSuccess(e); } } @Override public void onFailure(Exception e) { emitter.onError(e); } }; AutoCloseable c = api.someMethod(listener); emitter.setCancellable(c::close); });
```
 Scheduler:
 create does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 onSubscribe - the emitter that is called when a MaybeObserver subscribes to the returnedMaybe
 Returns:
 the new Maybe instance
 See Also:
 MaybeOnSubscribe,Cancellable
 - defer
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Maybe<T> defer(Callable<? extendsMaybeSource<? extends T>> maybeSupplier)
```
 Calls a Callable for each individual MaybeObserver to return the actual MaybeSource source to be subscribed to.
 Scheduler:
 defer does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 maybeSupplier - the Callable that is called for each individual MaybeObserver and returns a MaybeSource instance to subscribe to
 Returns:
 the new Maybe instance
 - empty
```
@CheckReturnValue@SchedulerSupport(value="none")public static <T> Maybe<T> empty()
```
 Returns a (singleton) Maybe instance that callsonComplete immediately.
 Scheduler:
 empty does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Returns:
 the new Maybe instance
 - error
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Maybe<T> error(Throwable exception)
```
 Returns a Maybe that invokes a subscriber'sonError method when the subscriber subscribes to it.
 Scheduler:
 error does not operate by default on a particularScheduler.
 Type Parameters:
 T - the type of the item (ostensibly) emitted by the Maybe
 Parameters:
 exception - the particular Throwable to pass toonError
 Returns:
 a Maybe that invokes the subscriber'sonError method when the subscriber subscribes to it
 See Also:
 ReactiveX operators documentation: Throw
 - error
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Maybe<T> error(Callable<? extendsThrowable> supplier)
```
 Returns a Maybe that invokes aMaybeObserver'sonError method when the MaybeObserver subscribes to it.
 Scheduler:
 error does not operate by default on a particularScheduler.
 Type Parameters:
 T - the type of the items (ostensibly) emitted by the Maybe
 Parameters:
 supplier - a Callable factory to return a Throwable for each individual MaybeObserver
 Returns:
 a Maybe that invokes theMaybeObserver'sonError method when the MaybeObserver subscribes to it
 See Also:
 ReactiveX operators documentation: Throw
 - fromAction
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Maybe<T> fromAction(Action run)
```
 Returns a Maybe instance that runs the given Action for each subscriber and emits either its exception or simply completes.
 Scheduler:
 fromAction does not operate by default on a particularScheduler.
 Error handling:
 If theAction throws an exception, the respectiveThrowable is delivered to the downstream viaMaybeObserver.onError(Throwable), except when the downstream has disposed thisMaybe source. In this latter case, theThrowable is delivered to the global error handler viaRxJavaPlugins.onError(Throwable) as anUndeliverableException.
 Type Parameters:
 T - the target type
 Parameters:
 run - the runnable to run for each subscriber
 Returns:
 the new Maybe instance
 Throws:
 NullPointerException - if run is null
 - fromCompletable
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Maybe<T> fromCompletable(CompletableSource completableSource)
```
 Wraps a CompletableSource into a Maybe.
 Scheduler:
 fromCompletable does not operate by default on a particularScheduler.
 Type Parameters:
 T - the target type
 Parameters:
 completableSource - the CompletableSource to convert from
 Returns:
 the new Maybe instance
 Throws:
 NullPointerException - if completable is null
 - fromSingle
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Maybe<T> fromSingle(SingleSource<T> singleSource)
```
 Wraps a SingleSource into a Maybe.
 Scheduler:
 fromSingle does not operate by default on a particularScheduler.
 Type Parameters:
 T - the target type
 Parameters:
 singleSource - the SingleSource to convert from
 Returns:
 the new Maybe instance
 Throws:
 NullPointerException - if single is null
 - fromCallable
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Maybe<T> fromCallable(@NonNullCallable<? extends T> callable)
```
 Returns aMaybe that invokes the givenCallable for each individualMaybeObserver that subscribes and emits the resulting non-null item viaonSuccess while considering anull result from theCallable as indication for valueless completion viaonComplete.
 This operator allows you to defer the execution of the givenCallable until aMaybeObserver subscribes to the returnedMaybe. In other terms, this source operator evaluates the givenCallable "lazily".
 Note that thenull handling of this operator differs from the similar source operators in the otherbase reactive classes. Those operators signal aNullPointerException if the value returned by theirCallable isnull while thisfromCallable considers it to indicate the returnedMaybe is empty.
 Scheduler:
 fromCallable does not operate by default on a particularScheduler.
 Error handling:
 Any non-fatal exception thrown byCallable.call() will be forwarded toonError, except if theMaybeObserver disposed the subscription in the meantime. In this latter case, the exception is forwarded to the global error handler viaRxJavaPlugins.onError(Throwable) wrapped into aUndeliverableException. Fatal exceptions are rethrown and usually will end up in the executing thread'sThread.UncaughtExceptionHandler.uncaughtException(Thread, Throwable) handler.
 Type Parameters:
 T - the type of the item emitted by theMaybe.
 Parameters:
 callable - aCallable instance whose execution should be deferred and performed for each individualMaybeObserver that subscribes to the returnedMaybe.
 Returns:
 a new Maybe instance
 - fromFuture
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Maybe<T> fromFuture(Future<? extends T> future)
```
 Converts aFuture into a Maybe, treating a null result as an indication of emptiness.
 You can convert any object that supports theFuture interface into a Maybe that emits the return value of theFuture.get() method of that object, by passing the object into thefrom method.
 Important note: This Maybe is blocking; you cannot dispose it.
 Unlike 1.x, disposing the Maybe won't cancel the future. If necessary, one can use composition to achieve the cancellation effect:futureMaybe.doOnDispose(() -> future.cancel(true));.
 Scheduler:
 fromFuture does not operate by default on a particularScheduler.
 Type Parameters:
 T - the type of object that theFuture returns, and also the type of item to be emitted by the resulting Maybe
 Parameters:
 future - the sourceFuture
 Returns:
 a Maybe that emits the item from the sourceFuture
 See Also:
 ReactiveX operators documentation: From
 - fromFuture
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Maybe<T> fromFuture(Future<? extends T> future, long timeout,TimeUnit unit)
```
 Converts aFuture into a Maybe, with a timeout on the Future.
 You can convert any object that supports theFuture interface into a Maybe that emits the return value of theFuture.get() method of that object, by passing the object into thefromFuture method.
 Unlike 1.x, disposing the Maybe won't cancel the future. If necessary, one can use composition to achieve the cancellation effect:futureMaybe.doOnCancel(() -> future.cancel(true));.
 Important note: This Maybe is blocking on the thread it gets subscribed on; you cannot dispose it.
 Scheduler:
 fromFuture does not operate by default on a particularScheduler.
 Type Parameters:
 T - the type of object that theFuture returns, and also the type of item to be emitted by the resulting Maybe
 Parameters:
 future - the sourceFuture
 timeout - the maximum time to wait before callingget
 unit - theTimeUnit of thetimeout argument
 Returns:
 a Maybe that emits the item from the sourceFuture
 See Also:
 ReactiveX operators documentation: From
 - fromRunnable
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Maybe<T> fromRunnable(Runnable run)
```
 Returns a Maybe instance that runs the given Action for each subscriber and emits either its exception or simply completes.
 Scheduler:
 fromRunnable does not operate by default on a particularScheduler.
 Type Parameters:
 T - the target type
 Parameters:
 run - the runnable to run for each subscriber
 Returns:
 the new Maybe instance
 Throws:
 NullPointerException - if run is null
 - just
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Maybe<T> just(T item)
```
 Returns aMaybe that emits a specified item.
 To convert any object into aMaybe that emits that object, pass that object into thejust method.
 Scheduler:
 just does not operate by default on a particularScheduler.
 Type Parameters:
 T - the type of that item
 Parameters:
 item - the item to emit
 Returns:
 aMaybe that emitsitem
 See Also:
 ReactiveX operators documentation: Just
 - merge
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")public static <T> Flowable<T> merge(Iterable<? extendsMaybeSource<? extends T>> sources)
```
 Merges an Iterable sequence of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.
 Backpressure:
 The operator honors backpressure from downstream.
 Scheduler:
 merge does not operate by default on a particularScheduler.
 Error handling:
 If any of the sourceMaybeSources signal aThrowable viaonError, the resultingFlowable terminates with thatThrowable and all other sourceMaybeSources are disposed. If more than oneMaybeSource signals an error, the resultingFlowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException containing two or more of the various error signals.Throwables that didn't make into the composite will be sent (individually) to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedFlowable has been cancelled or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(Iterable) to merge sources and terminate only when all sourceMaybeSources have completed or failed with an error.
 Type Parameters:
 T - the common and resulting value type
 Parameters:
 sources - the Iterable sequence of MaybeSource sources
 Returns:
 the new Flowable instance
 See Also:
 mergeDelayError(Iterable)
 - merge
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")public static <T> Flowable<T> merge(Publisher<? extendsMaybeSource<? extends T>> sources)
```
 Merges a Flowable sequence of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.
 Backpressure:
 The operator honors backpressure from downstream.
 Scheduler:
 merge does not operate by default on a particularScheduler.
 Error handling:
 If any of the sourceMaybeSources signal aThrowable viaonError, the resultingFlowable terminates with thatThrowable and all other sourceMaybeSources are disposed. If more than oneMaybeSource signals an error, the resultingFlowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException containing two or more of the various error signals.Throwables that didn't make into the composite will be sent (individually) to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedFlowable has been cancelled or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(Publisher) to merge sources and terminate only when all sourceMaybeSources have completed or failed with an error.
 Type Parameters:
 T - the common and resulting value type
 Parameters:
 sources - the Flowable sequence of MaybeSource sources
 Returns:
 the new Flowable instance
 See Also:
 mergeDelayError(Publisher)
 - merge
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Flowable<T> merge(Publisher<? extendsMaybeSource<? extends T>> sources, int maxConcurrency)
```
 Merges a Flowable sequence of MaybeSource instances into a single Flowable sequence, running at most maxConcurrency MaybeSources at once.
 Backpressure:
 The operator honors backpressure from downstream.
 Scheduler:
 merge does not operate by default on a particularScheduler.
 Error handling:
 If any of the sourceMaybeSources signal aThrowable viaonError, the resultingFlowable terminates with thatThrowable and all other sourceMaybeSources are disposed. If more than oneMaybeSource signals an error, the resultingFlowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException containing two or more of the various error signals.Throwables that didn't make into the composite will be sent (individually) to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedFlowable has been cancelled or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(Publisher, int) to merge sources and terminate only when all sourceMaybeSources have completed or failed with an error.
 Type Parameters:
 T - the common and resulting value type
 Parameters:
 sources - the Flowable sequence of MaybeSource sources
 maxConcurrency - the maximum number of concurrently running MaybeSources
 Returns:
 the new Flowable instance
 See Also:
 mergeDelayError(Publisher, int)
 - merge
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Maybe<T> merge(MaybeSource<? extendsMaybeSource<? extends T>> source)
```
 Flattens aMaybeSource that emits aMaybeSource into a singleMaybeSource that emits the item emitted by the nestedMaybeSource, without any transformation.
 Scheduler:
 merge does not operate by default on a particularScheduler.
 Error handling:
 The resultingMaybe emits the outer source's or the innerMaybeSource'sThrowable as is. Unlike the othermerge() operators, this operator won't and can't produce aCompositeException because there is only one possibility for the outer or the innerMaybeSource to emit anonError signal. Therefore, there is no need for amergeDelayError(MaybeSource<MaybeSource<T>>) operator.
 Type Parameters:
 T - the value type of the sources and the output
 Parameters:
 source - aMaybeSource that emits aMaybeSource
 Returns:
 aMaybe that emits the item that is the result of flattening theMaybeSource emitted bysource
 See Also:
 ReactiveX operators documentation: Merge
 - merge
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Flowable<T> merge(MaybeSource<? extends T> source1,MaybeSource<? extends T> source2)
```
 Flattens two MaybeSources into a single Flowable, without any transformation.
 You can combine items emitted by multiple MaybeSources so that they appear as a single Flowable, by using themerge method.
 Backpressure:
 The operator honors backpressure from downstream.
 Scheduler:
 merge does not operate by default on a particularScheduler.
 Error handling:
 If any of the sourceMaybeSources signal aThrowable viaonError, the resultingFlowable terminates with thatThrowable and all other sourceMaybeSources are disposed. If more than oneMaybeSource signals an error, the resultingFlowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException containing two or more of the various error signals.Throwables that didn't make into the composite will be sent (individually) to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedFlowable has been cancelled or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(MaybeSource, MaybeSource) to merge sources and terminate only when all sourceMaybeSources have completed or failed with an error.
 Type Parameters:
 T - the common value type
 Parameters:
 source1 - a MaybeSource to be merged
 source2 - a MaybeSource to be merged
 Returns:
 a Flowable that emits all of the items emitted by the source MaybeSources
 See Also:
 ReactiveX operators documentation: Merge,mergeDelayError(MaybeSource, MaybeSource)
 - merge
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Flowable<T> merge(MaybeSource<? extends T> source1,MaybeSource<? extends T> source2,MaybeSource<? extends T> source3)
```
 Flattens three MaybeSources into a single Flowable, without any transformation.
 You can combine items emitted by multiple MaybeSources so that they appear as a single Flowable, by using themerge method.
 Backpressure:
 The operator honors backpressure from downstream.
 Scheduler:
 merge does not operate by default on a particularScheduler.
 Error handling:
 If any of the sourceMaybeSources signal aThrowable viaonError, the resultingFlowable terminates with thatThrowable and all other sourceMaybeSources are disposed. If more than oneMaybeSource signals an error, the resultingFlowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException containing two or more of the various error signals.Throwables that didn't make into the composite will be sent (individually) to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedFlowable has been cancelled or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(MaybeSource, MaybeSource, MaybeSource) to merge sources and terminate only when all sourceMaybeSources have completed or failed with an error.
 Type Parameters:
 T - the common value type
 Parameters:
 source1 - a MaybeSource to be merged
 source2 - a MaybeSource to be merged
 source3 - a MaybeSource to be merged
 Returns:
 a Flowable that emits all of the items emitted by the source MaybeSources
 See Also:
 ReactiveX operators documentation: Merge,mergeDelayError(MaybeSource, MaybeSource, MaybeSource)
 - merge
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Flowable<T> merge(MaybeSource<? extends T> source1,MaybeSource<? extends T> source2,MaybeSource<? extends T> source3,MaybeSource<? extends T> source4)
```
 Flattens four MaybeSources into a single Flowable, without any transformation.
 You can combine items emitted by multiple MaybeSources so that they appear as a single Flowable, by using themerge method.
 Backpressure:
 The operator honors backpressure from downstream.
 Scheduler:
 merge does not operate by default on a particularScheduler.
 Error handling:
 If any of the sourceMaybeSources signal aThrowable viaonError, the resultingFlowable terminates with thatThrowable and all other sourceMaybeSources are disposed. If more than oneMaybeSource signals an error, the resultingFlowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException containing two or more of the various error signals.Throwables that didn't make into the composite will be sent (individually) to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedFlowable has been cancelled or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(MaybeSource, MaybeSource, MaybeSource, MaybeSource) to merge sources and terminate only when all sourceMaybeSources have completed or failed with an error.
 Type Parameters:
 T - the common value type
 Parameters:
 source1 - a MaybeSource to be merged
 source2 - a MaybeSource to be merged
 source3 - a MaybeSource to be merged
 source4 - a MaybeSource to be merged
 Returns:
 a Flowable that emits all of the items emitted by the source MaybeSources
 See Also:
 ReactiveX operators documentation: Merge,mergeDelayError(MaybeSource, MaybeSource, MaybeSource, MaybeSource)
 - mergeArray
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Flowable<T> mergeArray(MaybeSource<? extends T>... sources)
```
 Merges an array sequence of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.
 Backpressure:
 The operator honors backpressure from downstream.
 Scheduler:
 mergeArray does not operate by default on a particularScheduler.
 Error handling:
 If any of the sourceMaybeSources signal aThrowable viaonError, the resultingFlowable terminates with thatThrowable and all other sourceMaybeSources are disposed. If more than oneMaybeSource signals an error, the resultingFlowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException containing two or more of the various error signals.Throwables that didn't make into the composite will be sent (individually) to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedFlowable has been cancelled or terminated with a (composite) error will be sent to the same global error handler. UsemergeArrayDelayError(MaybeSource...) to merge sources and terminate only when all sourceMaybeSources have completed or failed with an error.
 Type Parameters:
 T - the common and resulting value type
 Parameters:
 sources - the array sequence of MaybeSource sources
 Returns:
 the new Flowable instance
 See Also:
 mergeArrayDelayError(MaybeSource...)
 - mergeArrayDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")public static <T> Flowable<T> mergeArrayDelayError(MaybeSource<? extends 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.
 This behaves likemerge(Publisher) except that if any of the merged MaybeSources notify of an error viaonError,mergeDelayError will refrain from propagating that error notification until all of the merged MaybeSources have finished emitting items.
 Even if multiple merged MaybeSources sendonError notifications,mergeDelayError will only invoke theonError method of its Subscribers once.
 Backpressure:
 The operator honors backpressure from downstream.
 Scheduler:
 mergeArrayDelayError does not operate by default on a particularScheduler.
 Type Parameters:
 T - the common element base type
 Parameters:
 sources - the Iterable of MaybeSources
 Returns:
 a Flowable that emits items that are the result of flattening the items emitted by the MaybeSources in the Iterable
 See Also:
 ReactiveX operators documentation: Merge
 - mergeDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")public static <T> Flowable<T> mergeDelayError(Iterable<? extendsMaybeSource<? extends T>> sources)
```
 Flattens an Iterable 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.
 This behaves likemerge(Publisher) except that if any of the merged MaybeSources notify of an error viaonError,mergeDelayError will refrain from propagating that error notification until all of the merged MaybeSources have finished emitting items.
 Even if multiple merged MaybeSources sendonError notifications,mergeDelayError will only invoke theonError method of its Subscribers once.
 Backpressure:
 The operator honors backpressure from downstream.
 Scheduler:
 mergeDelayError does not operate by default on a particularScheduler.
 Type Parameters:
 T - the common element base type
 Parameters:
 sources - the Iterable of MaybeSources
 Returns:
 a Flowable that emits items that are the result of flattening the items emitted by the MaybeSources in the Iterable
 See Also:
 ReactiveX operators documentation: Merge
 - mergeDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")public static <T> Flowable<T> mergeDelayError(Publisher<? extendsMaybeSource<? extends T>> sources)
```
 Flattens a Publisher that emits MaybeSources into one Publisher, 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.
 This behaves likemerge(Publisher) except that if any of the merged MaybeSources notify of an error viaonError,mergeDelayError will refrain from propagating that error notification until all of the merged MaybeSources and the main Publisher have finished emitting items.
 Even if multiple merged Publishers sendonError notifications,mergeDelayError will only invoke theonError method of its Subscribers once.
 Backpressure:
 The operator honors backpressure from downstream. The outerPublisher is consumed in unbounded mode (i.e., no backpressure is applied to it).
 Scheduler:
 mergeDelayError does not operate by default on a particularScheduler.
 Type Parameters:
 T - the common element base type
 Parameters:
 sources - a Publisher that emits MaybeSources
 Returns:
 a Flowable that emits all of the items emitted by the Publishers emitted by thesource Publisher
 See Also:
 ReactiveX operators documentation: Merge
 - mergeDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Flowable<T> mergeDelayError(Publisher<? extendsMaybeSource<? extends T>> sources, int maxConcurrency)
```
 Flattens a Publisher that emits MaybeSources into one Publisher, 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.
 This behaves likemerge(Publisher, int) except that if any of the merged MaybeSources notify of an error viaonError,mergeDelayError will refrain from propagating that error notification until all of the merged MaybeSources and the main Publisher have finished emitting items.
 Even if multiple merged Publishers sendonError notifications,mergeDelayError will only invoke theonError method of its Subscribers once.
 Backpressure:
 The operator honors backpressure from downstream. The outerPublisher is consumed in unbounded mode (i.e., no backpressure is applied to it).
 Scheduler:
 mergeDelayError does not operate by default on a particularScheduler.
 History: 2.1.9 - experimental
 Type Parameters:
 T - the common element base type
 Parameters:
 sources - a Publisher that emits MaybeSources
 maxConcurrency - the maximum number of active inner MaybeSources to be merged at a time
 Returns:
 a Flowable that emits all of the items emitted by the Publishers emitted by thesource Publisher
 Since:
 2.2
 See Also:
 ReactiveX operators documentation: Merge
 - mergeDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Flowable<T> mergeDelayError(MaybeSource<? extends T> source1,MaybeSource<? extends 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.
 This behaves likemerge(MaybeSource, MaybeSource) except that if any of the merged MaybeSources notify of an error viaonError,mergeDelayError will refrain from propagating that error notification until all of the merged MaybeSources have finished emitting items.
 Even if both merged MaybeSources sendonError notifications,mergeDelayError will only invoke theonError method of its Subscribers once.
 Backpressure:
 The operator honors backpressure from downstream.
 Scheduler:
 mergeDelayError does not operate by default on a particularScheduler.
 Type Parameters:
 T - the common element base type
 Parameters:
 source1 - a MaybeSource to be merged
 source2 - a MaybeSource to be merged
 Returns:
 a Flowable that emits all of the items that are emitted by the two source MaybeSources
 See Also:
 ReactiveX operators documentation: Merge
 - mergeDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Flowable<T> mergeDelayError(MaybeSource<? extends T> source1,MaybeSource<? extends T> source2,MaybeSource<? extends 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.
 This behaves likemerge(MaybeSource, MaybeSource, MaybeSource) except that if any of the merged MaybeSources notify of an error viaonError,mergeDelayError will refrain from propagating that error notification until all of the merged MaybeSources have finished emitting items.
 Even if multiple merged MaybeSources sendonError notifications,mergeDelayError will only invoke theonError method of its Subscribers once.
 Backpressure:
 The operator honors backpressure from downstream.
 Scheduler:
 mergeDelayError does not operate by default on a particularScheduler.
 Type Parameters:
 T - the common element base type
 Parameters:
 source1 - a MaybeSource to be merged
 source2 - a MaybeSource to be merged
 source3 - a MaybeSource to be merged
 Returns:
 a Flowable that emits all of the items that are emitted by the source MaybeSources
 See Also:
 ReactiveX operators documentation: Merge
 - mergeDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Flowable<T> mergeDelayError(MaybeSource<? extends T> source1,MaybeSource<? extends T> source2,MaybeSource<? extends T> source3,MaybeSource<? extends 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.
 This behaves likemerge(MaybeSource, MaybeSource, MaybeSource, MaybeSource) except that if any of the merged MaybeSources notify of an error viaonError,mergeDelayError will refrain from propagating that error notification until all of the merged MaybeSources have finished emitting items.
 Even if multiple merged MaybeSources sendonError notifications,mergeDelayError will only invoke theonError method of its Subscribers once.
 Backpressure:
 The operator honors backpressure from downstream.
 Scheduler:
 mergeDelayError does not operate by default on a particularScheduler.
 Type Parameters:
 T - the common element base type
 Parameters:
 source1 - a MaybeSource to be merged
 source2 - a MaybeSource to be merged
 source3 - a MaybeSource to be merged
 source4 - a MaybeSource to be merged
 Returns:
 a Flowable that emits all of the items that are emitted by the source MaybeSources
 See Also:
 ReactiveX operators documentation: Merge
 - never
```
@CheckReturnValue@SchedulerSupport(value="none")public static <T> Maybe<T> never()
```
 Returns a Maybe that never sends any items or notifications to aMaybeObserver.
 This Maybe is useful primarily for testing purposes.
 Scheduler:
 never does not operate by default on a particularScheduler.
 Type Parameters:
 T - the type of items (not) emitted by the Maybe
 Returns:
 a Maybe that never emits any items or sends any notifications to aMaybeObserver
 See Also:
 ReactiveX operators documentation: Never
 - sequenceEqual
```
@CheckReturnValue@SchedulerSupport(value="none")public static <T> Single<Boolean> sequenceEqual(MaybeSource<? extends T> source1,MaybeSource<? extends 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.
 Scheduler:
 sequenceEqual does not operate by default on a particularScheduler.
 Type Parameters:
 T - the type of items emitted by each MaybeSource
 Parameters:
 source1 - the first MaybeSource to compare
 source2 - the second MaybeSource to compare
 Returns:
 a Single that emits a Boolean value that indicates whether the two sequences are the same
 See Also:
 ReactiveX operators documentation: SequenceEqual
 - sequenceEqual
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Single<Boolean> sequenceEqual(MaybeSource<? extends T> source1,MaybeSource<? extends T> source2,BiPredicate<? super T,? super 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.
 Scheduler:
 sequenceEqual does not operate by default on a particularScheduler.
 Type Parameters:
 T - the type of items emitted by each MaybeSource
 Parameters:
 source1 - the first MaybeSource to compare
 source2 - the second MaybeSource to compare
 isEqual - a function used to compare items emitted by each MaybeSource
 Returns:
 a Single that emits a Boolean value that indicates whether the two MaybeSource sequences are the same according to the specified function
 See Also:
 ReactiveX operators documentation: SequenceEqual
 - timer
```
@CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public static Maybe<Long> timer(long delay,TimeUnit unit)
```
 Returns a Maybe that emits0L after a specified delay.
 Scheduler:
 timer operates by default on thecomputationScheduler.
 Parameters:
 delay - the initial delay before emitting a single0L
 unit - time units to use fordelay
 Returns:
 a Maybe that emits0L after a specified delay
 See Also:
 ReactiveX operators documentation: Timer
 - timer
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public static Maybe<Long> timer(long delay,TimeUnit unit,Scheduler scheduler)
```
 Returns a Maybe that emits0L after a specified delay on a specified Scheduler.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 delay - the initial delay before emitting a single 0L
 unit - time units to use fordelay
 scheduler - theScheduler to use for scheduling the item
 Returns:
 a Maybe that emits0L after a specified delay, on a specified Scheduler
 See Also:
 ReactiveX operators documentation: Timer
 - unsafeCreate
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Maybe<T> unsafeCreate(MaybeSource<T> onSubscribe)
```
 Advanced use only: creates a Maybe instance without any safeguards by using a callback that is called with a MaybeObserver.
 Scheduler:
 unsafeCreate does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 onSubscribe - the function that is called with the subscribing MaybeObserver
 Returns:
 the new Maybe instance
 - using
```
@CheckReturnValue@SchedulerSupport(value="none")public static <T,D> Maybe<T> using(Callable<? extends D> resourceSupplier,Function<? super D,? extendsMaybeSource<? extends T>> sourceSupplier,Consumer<? super D> resourceDisposer)
```
 Constructs a Maybe that creates a dependent resource object which is disposed of when the upstream terminates or the downstream calls dispose().
 Scheduler:
 using does not operate by default on a particularScheduler.
 Type Parameters:
 T - the element type of the generated MaybeSource
 D - the type of the resource associated with the output sequence
 Parameters:
 resourceSupplier - the factory function to create a resource object that depends on the Maybe
 sourceSupplier - the factory function to create a MaybeSource
 resourceDisposer - the function that will dispose of the resource
 Returns:
 the Maybe whose lifetime controls the lifetime of the dependent resource object
 See Also:
 ReactiveX operators documentation: Using
 - using
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T,D> Maybe<T> using(Callable<? extends D> resourceSupplier,Function<? super D,? extendsMaybeSource<? extends T>> sourceSupplier,Consumer<? super D> resourceDisposer, boolean eager)
```
 Constructs a Maybe that creates a dependent resource object which is disposed of just before termination if you have setdisposeEagerly totrue and a downstream dispose() does not occur before termination. Otherwise resource disposal will occur on call to dispose(). Eager disposal is particularly appropriate for a synchronous Maybe that reuses resources.disposeAction will only be called once per subscription.
 Scheduler:
 using does not operate by default on a particularScheduler.
 Type Parameters:
 T - the element type of the generated MaybeSource
 D - the type of the resource associated with the output sequence
 Parameters:
 resourceSupplier - the factory function to create a resource object that depends on the Maybe
 sourceSupplier - the factory function to create a MaybeSource
 resourceDisposer - the function that will dispose of the resource
 eager - iftrue then disposal will happen either on a dispose() call or just before emission of a terminal event (onComplete oronError).
 Returns:
 the Maybe whose lifetime controls the lifetime of the dependent resource object
 See Also:
 ReactiveX operators documentation: Using
 - wrap
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Maybe<T> wrap(MaybeSource<T> source)
```
 Wraps a MaybeSource instance into a new Maybe instance if not already a Maybe instance.
 Scheduler:
 wrap does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 source - the source to wrap
 Returns:
 the Maybe wrapper or the source cast to Maybe (if possible)
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T,R> Maybe<R> zip(Iterable<? extendsMaybeSource<? extends T>> sources,Function<? superObject[],? extends 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.
 Note on method signature: since Java doesn't allow creating a generic array withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.
 This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 Type Parameters:
 T - the common value type
 R - the zipped result type
 Parameters:
 sources - an Iterable of source MaybeSources
 zipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in an item that will be emitted by the resulting Maybe
 Returns:
 a Maybe that emits the zipped results
 See Also:
 ReactiveX operators documentation: Zip
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T1,T2,R> Maybe<R> zip(MaybeSource<? extends T1> source1,MaybeSource<? extends T2> source2,BiFunction<? super T1,? super T2,? extends 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.
 This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 Type Parameters:
 T1 - the value type of the first source
 T2 - the value type of the second source
 R - the zipped result type
 Parameters:
 source1 - the first source MaybeSource
 source2 - a second source MaybeSource
 zipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in an item that will be emitted by the resulting Maybe
 Returns:
 a Maybe that emits the zipped results
 See Also:
 ReactiveX operators documentation: Zip
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T1,T2,T3,R> Maybe<R> zip(MaybeSource<? extends T1> source1,MaybeSource<? extends T2> source2,MaybeSource<? extends T3> source3,Function3<? super T1,? super T2,? super T3,? extends 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.
 This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 Type Parameters:
 T1 - the value type of the first source
 T2 - the value type of the second source
 T3 - the value type of the third source
 R - the zipped result type
 Parameters:
 source1 - the first source MaybeSource
 source2 - a second source MaybeSource
 source3 - a third source MaybeSource
 zipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in an item that will be emitted by the resulting Maybe
 Returns:
 a Maybe that emits the zipped results
 See Also:
 ReactiveX operators documentation: Zip
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T1,T2,T3,T4,R> Maybe<R> zip(MaybeSource<? extends T1> source1,MaybeSource<? extends T2> source2,MaybeSource<? extends T3> source3,MaybeSource<? extends T4> source4,Function4<? super T1,? super T2,? super T3,? super T4,? extends 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.
 This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 Type Parameters:
 T1 - the value type of the first source
 T2 - the value type of the second source
 T3 - the value type of the third source
 T4 - the value type of the fourth source
 R - the zipped result type
 Parameters:
 source1 - the first source MaybeSource
 source2 - a second source MaybeSource
 source3 - a third source MaybeSource
 source4 - a fourth source MaybeSource
 zipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in an item that will be emitted by the resulting Maybe
 Returns:
 a Maybe that emits the zipped results
 See Also:
 ReactiveX operators documentation: Zip
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T1,T2,T3,T4,T5,R> Maybe<R> zip(MaybeSource<? extends T1> source1,MaybeSource<? extends T2> source2,MaybeSource<? extends T3> source3,MaybeSource<? extends T4> source4,MaybeSource<? extends T5> source5,Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends 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.
 This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 Type Parameters:
 T1 - the value type of the first source
 T2 - the value type of the second source
 T3 - the value type of the third source
 T4 - the value type of the fourth source
 T5 - the value type of the fifth source
 R - the zipped result type
 Parameters:
 source1 - the first source MaybeSource
 source2 - a second source MaybeSource
 source3 - a third source MaybeSource
 source4 - a fourth source MaybeSource
 source5 - a fifth source MaybeSource
 zipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in an item that will be emitted by the resulting Maybe
 Returns:
 a Maybe that emits the zipped results
 See Also:
 ReactiveX operators documentation: Zip
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T1,T2,T3,T4,T5,T6,R> Maybe<R> zip(MaybeSource<? extends T1> source1,MaybeSource<? extends T2> source2,MaybeSource<? extends T3> source3,MaybeSource<? extends T4> source4,MaybeSource<? extends T5> source5,MaybeSource<? extends T6> source6,Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends 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.
 This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 Type Parameters:
 T1 - the value type of the first source
 T2 - the value type of the second source
 T3 - the value type of the third source
 T4 - the value type of the fourth source
 T5 - the value type of the fifth source
 T6 - the value type of the sixth source
 R - the zipped result type
 Parameters:
 source1 - the first source MaybeSource
 source2 - a second source MaybeSource
 source3 - a third source MaybeSource
 source4 - a fourth source MaybeSource
 source5 - a fifth source MaybeSource
 source6 - a sixth source MaybeSource
 zipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in an item that will be emitted by the resulting Maybe
 Returns:
 a Maybe that emits the zipped results
 See Also:
 ReactiveX operators documentation: Zip
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T1,T2,T3,T4,T5,T6,T7,R> Maybe<R> zip(MaybeSource<? extends T1> source1,MaybeSource<? extends T2> source2,MaybeSource<? extends T3> source3,MaybeSource<? extends T4> source4,MaybeSource<? extends T5> source5,MaybeSource<? extends T6> source6,MaybeSource<? extends T7> source7,Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends 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.
 This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 Type Parameters:
 T1 - the value type of the first source
 T2 - the value type of the second source
 T3 - the value type of the third source
 T4 - the value type of the fourth source
 T5 - the value type of the fifth source
 T6 - the value type of the sixth source
 T7 - the value type of the seventh source
 R - the zipped result type
 Parameters:
 source1 - the first source MaybeSource
 source2 - a second source MaybeSource
 source3 - a third source MaybeSource
 source4 - a fourth source MaybeSource
 source5 - a fifth source MaybeSource
 source6 - a sixth source MaybeSource
 source7 - a seventh source MaybeSource
 zipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in an item that will be emitted by the resulting Maybe
 Returns:
 a Maybe that emits the zipped results
 See Also:
 ReactiveX operators documentation: Zip
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T1,T2,T3,T4,T5,T6,T7,T8,R> Maybe<R> zip(MaybeSource<? extends T1> source1,MaybeSource<? extends T2> source2,MaybeSource<? extends T3> source3,MaybeSource<? extends T4> source4,MaybeSource<? extends T5> source5,MaybeSource<? extends T6> source6,MaybeSource<? extends T7> source7,MaybeSource<? extends T8> source8,Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends 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.
 This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 Type Parameters:
 T1 - the value type of the first source
 T2 - the value type of the second source
 T3 - the value type of the third source
 T4 - the value type of the fourth source
 T5 - the value type of the fifth source
 T6 - the value type of the sixth source
 T7 - the value type of the seventh source
 T8 - the value type of the eighth source
 R - the zipped result type
 Parameters:
 source1 - the first source MaybeSource
 source2 - a second source MaybeSource
 source3 - a third source MaybeSource
 source4 - a fourth source MaybeSource
 source5 - a fifth source MaybeSource
 source6 - a sixth source MaybeSource
 source7 - a seventh source MaybeSource
 source8 - an eighth source MaybeSource
 zipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in an item that will be emitted by the resulting Maybe
 Returns:
 a Maybe that emits the zipped results
 See Also:
 ReactiveX operators documentation: Zip
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> Maybe<R> zip(MaybeSource<? extends T1> source1,MaybeSource<? extends T2> source2,MaybeSource<? extends T3> source3,MaybeSource<? extends T4> source4,MaybeSource<? extends T5> source5,MaybeSource<? extends T6> source6,MaybeSource<? extends T7> source7,MaybeSource<? extends T8> source8,MaybeSource<? extends T9> source9,Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends 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.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.
 Type Parameters:
 T1 - the value type of the first source
 T2 - the value type of the second source
 T3 - the value type of the third source
 T4 - the value type of the fourth source
 T5 - the value type of the fifth source
 T6 - the value type of the sixth source
 T7 - the value type of the seventh source
 T8 - the value type of the eighth source
 T9 - the value type of the ninth source
 R - the zipped result type
 Parameters:
 source1 - the first source MaybeSource
 source2 - a second source MaybeSource
 source3 - a third source MaybeSource
 source4 - a fourth source MaybeSource
 source5 - a fifth source MaybeSource
 source6 - a sixth source MaybeSource
 source7 - a seventh source MaybeSource
 source8 - an eighth source MaybeSource
 source9 - a ninth source MaybeSource
 zipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in an item that will be emitted by the resulting MaybeSource
 Returns:
 a Maybe that emits the zipped results
 See Also:
 ReactiveX operators documentation: Zip
 - zipArray
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T,R> Maybe<R> zipArray(Function<? superObject[],? extends R> zipper,MaybeSource<? extends 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.
 Note on method signature: since Java doesn't allow creating a generic array withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.
 This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.
 Scheduler:
 zipArray does not operate by default on a particularScheduler.
 Type Parameters:
 T - the common element type
 R - the result type
 Parameters:
 sources - an array of source MaybeSources
 zipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in an item that will be emitted by the resulting MaybeSource
 Returns:
 a Maybe that emits the zipped results
 See Also:
 ReactiveX operators documentation: Zip
 - ambWith
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Maybe<T> ambWith(MaybeSource<? extendsT> other)
```
 Mirrors the MaybeSource (current or provided) that first signals an event.
 Scheduler:
 ambWith does not operate by default on a particularScheduler.
 Parameters:
 other - a MaybeSource competing to react first. A subscription to this provided source will occur after subscribing to the current source.
 Returns:
 a Maybe that emits the same sequence as whichever of the source MaybeSources first signalled
 See Also:
 ReactiveX operators documentation: Amb
 - as
```
@CheckReturnValue@SchedulerSupport(value="none")public final <R> R as(@NonNullMaybeConverter<T,? extends R> converter)
```
 Calls the specified converter function during assembly time and returns its resulting value.
 This allows fluent conversion to any other type.
 Scheduler:
 as does not operate by default on a particularScheduler.
 History: 2.1.7 - experimental
 Type Parameters:
 R - the resulting object type
 Parameters:
 converter - the function that receives the current Maybe instance and returns a value
 Returns:
 the converted value
 Throws:
 NullPointerException - if converter is null
 Since:
 2.2
 - blockingGet
```
@CheckReturnValue@SchedulerSupport(value="none")public final T blockingGet()
```
 Waits in a blocking fashion until the current Maybe signals a success value (which is returned), null if completed or an exception (which is propagated).
 Scheduler:
 blockingGet does not operate by default on a particularScheduler.
 Error handling:
 If the source signals an error, the operator wraps a checkedException intoRuntimeException and throws that. Otherwise,RuntimeExceptions andErrors are rethrown as they are.
 Returns:
 the success value
 - blockingGet
```
@CheckReturnValue@SchedulerSupport(value="none")public final T blockingGet(T defaultValue)
```
 Waits in a blocking fashion until the current Maybe signals a success value (which is returned), defaultValue if completed or an exception (which is propagated).
 Scheduler:
 blockingGet does not operate by default on a particularScheduler.
 Error handling:
 If the source signals an error, the operator wraps a checkedException intoRuntimeException and throws that. Otherwise,RuntimeExceptions andErrors are rethrown as they are.
 Parameters:
 defaultValue - the default item to return if this Maybe is empty
 Returns:
 the success value
 - cache
```
@CheckReturnValue@SchedulerSupport(value="none")public final Maybe<T> cache()
```
 Returns a Maybe that subscribes to this Maybe lazily, caches its event and replays it, to all the downstream subscribers.
 The operator subscribes only when the first downstream subscriber subscribes and maintains a single subscription towards this Maybe.
 Note: You sacrifice the ability to dispose the origin when you use thecache.
 Scheduler:
 cache does not operate by default on a particularScheduler.
 Returns:
 a Maybe that, when first subscribed to, caches all of its items and notifications for the benefit of subsequent subscribers
 See Also:
 ReactiveX operators documentation: Replay
 - cast
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  Maybe cast(Class<? extends U> clazz)
```
 Casts the success value of the current Maybe into the target type or signals a ClassCastException if not compatible.
 Scheduler:
 cast does not operate by default on a particularScheduler.
 Type Parameters:
 U - the target type
 Parameters:
 clazz - the type token to use for casting the success result from the current Maybe
 Returns:
 the new Maybe instance
 - compose
```
@CheckReturnValue@SchedulerSupport(value="none")public final <R> Maybe<R> compose(MaybeTransformer<? superT,? extends R> transformer)
```
 Transform a Maybe by applying a particular Transformer function to it.
 This method operates on the Maybe itself whereaslift(io.reactivex.MaybeOperator<? extends R, ? super T>) operates on the Maybe's MaybeObservers.
 If the operator you are creating is designed to act on the individual item emitted by a Maybe, uselift(io.reactivex.MaybeOperator<? extends R, ? super T>). If your operator is designed to transform the source Maybe as a whole (for instance, by applying a particular set of existing RxJava operators to it) usecompose.
 Scheduler:
 compose does not operate by default on a particularScheduler.
 Type Parameters:
 R - the value type of the Maybe returned by the transformer function
 Parameters:
 transformer - the transformer function, not null
 Returns:
 a Maybe, transformed by the transformer function
 See Also:
 RxJava wiki: Implementing Your Own Operators
 - concatMap
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> Maybe<R> concatMap(Function<? superT,? extendsMaybeSource<? extends R>> mapper)
```
 Returns a Maybe that is based on applying a specified function to the item emitted by the source Maybe, where that function returns a MaybeSource.
 Scheduler:
 concatMap does not operate by default on a particularScheduler.
 Note that flatMap and concatMap for Maybe is the same operation.
 Type Parameters:
 R - the result value type
 Parameters:
 mapper - a function that, when applied to the item emitted by the source Maybe, returns a MaybeSource
 Returns:
 the Maybe returned fromfunc when applied to the item emitted by the source Maybe
 See Also:
 ReactiveX operators documentation: FlatMap
 - concatWith
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Flowable<T> concatWith(MaybeSource<? extendsT> other)
```
 Returns a Flowable that emits the items emitted from the current MaybeSource, then the next, one after the other, without interleaving them.
 Backpressure:
 The operator honors backpressure from downstream.
 Scheduler:
 concatWith does not operate by default on a particularScheduler.
 Parameters:
 other - a MaybeSource to be concatenated after the current
 Returns:
 a Flowable that emits items emitted by the two source MaybeSources, one after the other, without interleaving them
 See Also:
 ReactiveX operators documentation: Concat
 - contains
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Single<Boolean> contains(Object item)
```
 Returns a Single that emits a Boolean that indicates whether the source Maybe emitted a specified item.
 Scheduler:
 contains does not operate by default on a particularScheduler.
 Parameters:
 item - the item to search for in the emissions from the source Maybe, not null
 Returns:
 a Single that emitstrue if the specified item is emitted by the source Maybe, orfalse if the source Maybe completes without emitting that item
 See Also:
 ReactiveX operators documentation: Contains
 - count
```
@CheckReturnValue@SchedulerSupport(value="none")public final Single<Long> count()
```
 Returns a Single that counts the total number of items emitted (0 or 1) by the source Maybe and emits this count as a 64-bit Long.
 Scheduler:
 count does not operate by default on a particularScheduler.
 Returns:
 a Single that emits a single item: the number of items emitted by the source Maybe as a 64-bit Long item
 See Also:
 ReactiveX operators documentation: Count,count()
 - defaultIfEmpty
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Maybe<T> defaultIfEmpty(T defaultItem)
```
 Returns a Maybe that emits the item emitted by the source Maybe or a specified default item if the source Maybe is empty.
 Note that the result Maybe is semantically equivalent to aSingle, since it's guaranteed to emit exactly one item or an error. SeetoSingle(Object) for a method with equivalent behavior which returns aSingle.
 Scheduler:
 defaultIfEmpty does not operate by default on a particularScheduler.
 Parameters:
 defaultItem - the item to emit if the source Maybe emits no items
 Returns:
 a Maybe that emits either the specified default item if the source Maybe emits no items, or the items emitted by the source Maybe
 See Also:
 ReactiveX operators documentation: DefaultIfEmpty
 - delay
```
@CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Maybe<T> delay(long delay,TimeUnit unit)
```
 Returns a Maybe that signals the events emitted by the source Maybe shifted forward in time by a specified delay.
 Scheduler:
 This version ofdelay operates by default on thecomputationScheduler.
 Parameters:
 delay - the delay to shift the source by
 unit - theTimeUnit in whichperiod is defined
 Returns:
 the new Maybe instance
 See Also:
 ReactiveX operators documentation: Delay
 - delay
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public final Maybe<T> delay(long delay,TimeUnit unit,Scheduler scheduler)
```
 Returns a Maybe that signals the events emitted by the source Maybe shifted forward in time by a specified delay running on the specified Scheduler.
 Scheduler:
 you specify whichScheduler this operator will use.
 Parameters:
 delay - the delay to shift the source by
 unit - the time unit ofdelay
 scheduler - theScheduler to use for delaying
 Returns:
 the new Maybe instance
 See Also:
 ReactiveX operators documentation: Delay
 - delay
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")@BackpressureSupport(value=UNBOUNDED_IN)public final <U,V> Maybe<T> delay(Publisher delayIndicator)
```
 Delays the emission of this Maybe until the given Publisher signals an item or completes.
 Backpressure:
 ThedelayIndicator is consumed in an unbounded manner but is cancelled after the first item it produces.
 Scheduler:
 This version ofdelay does not operate by default on a particularScheduler.
 Type Parameters:
 U - the subscription delay value type (ignored)
 V - the item delay value type (ignored)
 Parameters:
 delayIndicator - the Publisher that gets subscribed to when this Maybe signals an event and that signal is emitted when the Publisher signals an item or completes
 Returns:
 the new Maybe instance
 See Also:
 ReactiveX operators documentation: Delay
 - delaySubscription
```
@BackpressureSupport(value=UNBOUNDED_IN)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  Maybe<T> delaySubscription(Publisher subscriptionIndicator)
```
 Returns a Maybe that delays the subscription to this Maybe until the other Publisher emits an element or completes normally.
 Backpressure:
 ThePublisher source is consumed in an unbounded fashion (without applying backpressure).
 Scheduler:
 This method does not operate by default on a particularScheduler.
 Type Parameters:
 U - the value type of the other Publisher, irrelevant
 Parameters:
 subscriptionIndicator - the other Publisher that should trigger the subscription to this Publisher.
 Returns:
 a Maybe that delays the subscription to this Maybe until the other Publisher emits an element or completes normally.
 - delaySubscription
```
@CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Maybe<T> delaySubscription(long delay,TimeUnit unit)
```
 Returns a Maybe that delays the subscription to the source Maybe by a given amount of time.
 Scheduler:
 This version ofdelaySubscription operates by default on thecomputationScheduler.
 Parameters:
 delay - the time to delay the subscription
 unit - the time unit ofdelay
 Returns:
 a Maybe that delays the subscription to the source Maybe by the given amount
 See Also:
 ReactiveX operators documentation: Delay
 - delaySubscription
```
@CheckReturnValue@SchedulerSupport(value="custom")public final Maybe<T> delaySubscription(long delay,TimeUnit unit,Scheduler scheduler)
```
 Returns a Maybe that delays the subscription to the source Maybe by a given amount of time, both waiting and subscribing on a given Scheduler.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 delay - the time to delay the subscription
 unit - the time unit ofdelay
 scheduler - the Scheduler on which the waiting and subscription will happen
 Returns:
 a Maybe that delays the subscription to the source Maybe by a given amount, waiting and subscribing on the given Scheduler
 See Also:
 ReactiveX operators documentation: Delay
 - doAfterSuccess
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Maybe<T> doAfterSuccess(Consumer<? superT> onAfterSuccess)
```
 Calls the specified consumer with the success item after this item has been emitted to the downstream.
 Note that theonAfterNext action is shared between subscriptions and as such should be thread-safe.
 Scheduler:
 doAfterSuccess does not operate by default on a particularScheduler.
 History: 2.0.1 - experimental
 Parameters:
 onAfterSuccess - the Consumer that will be called after emitting an item from upstream to the downstream
 Returns:
 the new Maybe instance
 Since:
 2.1
 - doAfterTerminate
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Maybe<T> doAfterTerminate(Action onAfterTerminate)
```
 Registers anAction to be called when this Maybe invokes eitheronSuccess,onComplete oronError.
 Scheduler:
 doAfterTerminate does not operate by default on a particularScheduler.
 Parameters:
 onAfterTerminate - anAction to be invoked when the source Maybe finishes
 Returns:
 a Maybe that emits the same items as the source Maybe, then invokes theAction
 See Also:
 ReactiveX operators documentation: Do
 - doFinally
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Maybe<T> doFinally(Action onFinally)
```
 Calls the specified action after this Maybe signals onSuccess, onError or onComplete or gets disposed by the downstream.
 In case of a race between a terminal event and a dispose call, the providedonFinally action is executed once per subscription.
 Note that theonFinally action is shared between subscriptions and as such should be thread-safe.
 Scheduler:
 doFinally does not operate by default on a particularScheduler.
 History: 2.0.1 - experimental
 Parameters:
 onFinally - the action called when this Maybe terminates or gets disposed
 Returns:
 the new Maybe instance
 Since:
 2.1
 - doOnDispose
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Maybe<T> doOnDispose(Action onDispose)
```
 Calls the sharedAction if a MaybeObserver subscribed to the current Maybe disposes the common Disposable it received via onSubscribe.
 Scheduler:
 doOnDispose does not operate by default on a particularScheduler.
 Parameters:
 onDispose - the action called when the subscription is disposed
 Returns:
 the new Maybe instance
 Throws:
 NullPointerException - if onDispose is null
 - doOnComplete
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Maybe<T> doOnComplete(Action onComplete)
```
 Modifies the source Maybe so that it invokes an action when it callsonComplete.
 Scheduler:
 doOnComplete does not operate by default on a particularScheduler.
 Parameters:
 onComplete - the action to invoke when the source Maybe callsonComplete
 Returns:
 the new Maybe with the side-effecting behavior applied
 See Also:
 ReactiveX operators documentation: Do
 - doOnError
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Maybe<T> doOnError(Consumer<? superThrowable> onError)
```
 Calls the shared consumer with the error sent via onError for each MaybeObserver that subscribes to the current Maybe.
 Scheduler:
 doOnError does not operate by default on a particularScheduler.
 Parameters:
 onError - the consumer called with the success value of onError
 Returns:
 the new Maybe instance
 - doOnEvent
```
@CheckReturnValue@SchedulerSupport(value="none")public final Maybe<T> doOnEvent(BiConsumer<? superT,? superThrowable> 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.
 Exceptions thrown from the callback will override the event so the downstream receives the error instead of the original signal.
 Scheduler:
 doOnEvent does not operate by default on a particularScheduler.
 Parameters:
 onEvent - the callback to call with the terminal event tuple
 Returns:
 the new Maybe instance
 - doOnSubscribe
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Maybe<T> doOnSubscribe(Consumer<? superDisposable> onSubscribe)
```
 Calls the shared consumer with the Disposable sent through the onSubscribe for each MaybeObserver that subscribes to the current Maybe.
 Scheduler:
 doOnSubscribe does not operate by default on a particularScheduler.
 Parameters:
 onSubscribe - the consumer called with the Disposable sent via onSubscribe
 Returns:
 the new Maybe instance
 - doOnTerminate
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Maybe<T> doOnTerminate(Action onTerminate)
```
 Returns a Maybe instance that calls the given onTerminate callback just before this Maybe completes normally or with an exception.
 This differs fromdoAfterTerminate in that this happensbefore theonComplete oronError notification.
 Scheduler:
 doOnTerminate does not operate by default on a particularScheduler.
 Parameters:
 onTerminate - the action to invoke when the consumer callsonComplete oronError
 Returns:
 the new Maybe instance
 Since:
 2.2.7 - experimental
 See Also:
 ReactiveX operators documentation: Do,doOnTerminate(Action)
 - doOnSuccess
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Maybe<T> doOnSuccess(Consumer<? superT> onSuccess)
```
 Calls the shared consumer with the success value sent via onSuccess for each MaybeObserver that subscribes to the current Maybe.
 Scheduler:
 doOnSuccess does not operate by default on a particularScheduler.
 Parameters:
 onSuccess - the consumer called with the success value of onSuccess
 Returns:
 the new Maybe instance
 - filter
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Maybe<T> filter(Predicate<? superT> predicate)
```
 Filters the success item of the Maybe via a predicate function and emitting it if the predicate returns true, completing otherwise.
 Scheduler:
 filter does not operate by default on a particularScheduler.
 Parameters:
 predicate - a function that evaluates the item emitted by the source Maybe, returningtrue if it passes the filter
 Returns:
 a Maybe that emit the item emitted by the source Maybe that the filter evaluates astrue
 See Also:
 ReactiveX operators documentation: Filter
 - flatMap
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> Maybe<R> flatMap(Function<? superT,? extendsMaybeSource<? extends R>> mapper)
```
 Returns a Maybe that is based on applying a specified function to the item emitted by the source Maybe, where that function returns a MaybeSource.
 Scheduler:
 flatMap does not operate by default on a particularScheduler.
 Note that flatMap and concatMap for Maybe is the same operation.
 Type Parameters:
 R - the result value type
 Parameters:
 mapper - a function that, when applied to the item emitted by the source Maybe, returns a MaybeSource
 Returns:
 the Maybe returned fromfunc when applied to the item emitted by the source Maybe
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMap
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> Maybe<R> flatMap(Function<? superT,? extendsMaybeSource<? extends R>> onSuccessMapper,Function<? superThrowable,? extendsMaybeSource<? extends R>> onErrorMapper,Callable<? extendsMaybeSource<? extends R>> onCompleteSupplier)
```
 Maps the onSuccess, onError or onComplete signals of this Maybe into MaybeSource and emits that MaybeSource's signals.
 Scheduler:
 flatMap does not operate by default on a particularScheduler.
 Type Parameters:
 R - the result type
 Parameters:
 onSuccessMapper - a function that returns a MaybeSource to merge for the onSuccess item emitted by this Maybe
 onErrorMapper - a function that returns a MaybeSource to merge for an onError notification from this Maybe
 onCompleteSupplier - a function that returns a MaybeSource to merge for an onComplete notification this Maybe
 Returns:
 the new Maybe instance
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMap
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <U,R> Maybe<R> flatMap(Function<? superT,? extendsMaybeSource<? extends U>> mapper,BiFunction<? superT,? super U,? extends R> resultSelector)
```
 Returns a Maybe that emits the results of a specified function to the pair of values emitted by the source Maybe and a specified mapped MaybeSource.
 Scheduler:
 flatMap does not operate by default on a particularScheduler.
 Type Parameters:
 U - the type of items emitted by the MaybeSource returned by themapper function
 R - the type of items emitted by the resulting Maybe
 Parameters:
 mapper - a function that returns a MaybeSource for the item emitted by the source Maybe
 resultSelector - a function that combines one item emitted by each of the source and collection MaybeSource and returns an item to be emitted by the resulting MaybeSource
 Returns:
 the new Maybe instance
 See Also:
 ReactiveX operators documentation: FlatMap
 - flattenAsFlowable
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  Flowable flattenAsFlowable(Function<? superT,? extendsIterable<? extends U>> mapper)
```
 Maps the success value of the upstreamMaybe into anIterable and emits its items as aFlowable sequence.
 Backpressure:
 The operator honors backpressure from downstream.
 Scheduler:
 flattenAsFlowable does not operate by default on a particularScheduler.
 Type Parameters:
 U - the type of item emitted by the resulting Iterable
 Parameters:
 mapper - a function that returns an Iterable sequence of values for when given an item emitted by the source Maybe
 Returns:
 the new Flowable instance
 See Also:
 ReactiveX operators documentation: FlatMap
 - flattenAsObservable
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  Observable flattenAsObservable(Function<? superT,? extendsIterable<? extends U>> mapper)
```
 Maps the success value of the upstreamMaybe into anIterable and emits its items as anObservable sequence.
 Scheduler:
 flattenAsObservable does not operate by default on a particularScheduler.
 Type Parameters:
 U - the type of item emitted by the resulting Iterable
 Parameters:
 mapper - a function that returns an Iterable sequence of values for when given an item emitted by the source Maybe
 Returns:
 the new Observable instance
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMapObservable
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> Observable<R> flatMapObservable(Function<? superT,? extendsObservableSource<? extends R>> mapper)
```
 Returns an Observable that is based on applying a specified function to the item emitted by the source Maybe, where that function returns an ObservableSource.
 Scheduler:
 flatMapObservable does not operate by default on a particularScheduler.
 Type Parameters:
 R - the result value type
 Parameters:
 mapper - a function that, when applied to the item emitted by the source Maybe, returns an ObservableSource
 Returns:
 the Observable returned fromfunc when applied to the item emitted by the source Maybe
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMapPublisher
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> Flowable<R> flatMapPublisher(Function<? superT,? extendsPublisher<? extends R>> mapper)
```
 Returns a Flowable that emits items based on applying a specified function to the item emitted by the source Maybe, where that function returns a Publisher.
 Backpressure:
 The returned Flowable honors the downstream backpressure.
 Scheduler:
 flatMapPublisher does not operate by default on a particularScheduler.
 Type Parameters:
 R - the result value type
 Parameters:
 mapper - a function that, when applied to the item emitted by the source Maybe, returns a Flowable
 Returns:
 the Flowable returned fromfunc when applied to the item emitted by the source Maybe
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMapSingle
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> Single<R> flatMapSingle(Function<? superT,? extendsSingleSource<? extends R>> mapper)
```
 Returns aSingle based on applying a specified function to the item emitted by the sourceMaybe, where that function returns aSingle. When this Maybe completes aNoSuchElementException will be thrown.
 Scheduler:
 flatMapSingle does not operate by default on a particularScheduler.
 Type Parameters:
 R - the result value type
 Parameters:
 mapper - a function that, when applied to the item emitted by the source Maybe, returns a Single
 Returns:
 the Single returned frommapper when applied to the item emitted by the source Maybe
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMapSingleElement
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> Maybe<R> flatMapSingleElement(Function<? superT,? extendsSingleSource<? extends R>> mapper)
```
 Returns aMaybe based on applying a specified function to the item emitted by the sourceMaybe, where that function returns aSingle. When this Maybe just completes the resultingMaybe completes as well.
 Scheduler:
 flatMapSingleElement does not operate by default on a particularScheduler.
 History: 2.0.2 - experimental
 Type Parameters:
 R - the result value type
 Parameters:
 mapper - a function that, when applied to the item emitted by the source Maybe, returns a Single
 Returns:
 the new Maybe instance
 Since:
 2.1
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMapCompletable
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Completable flatMapCompletable(Function<? superT,? extendsCompletableSource> mapper)
```
 Returns aCompletable that completes based on applying a specified function to the item emitted by the sourceMaybe, where that function returns aCompletable.
 Scheduler:
 flatMapCompletable does not operate by default on a particularScheduler.
 Parameters:
 mapper - a function that, when applied to the item emitted by the source Maybe, returns a Completable
 Returns:
 the Completable returned frommapper when applied to the item emitted by the source Maybe
 See Also:
 ReactiveX operators documentation: FlatMap
 - hide
```
@CheckReturnValue@SchedulerSupport(value="none")public final Maybe<T> hide()
```
 Hides the identity of this Maybe and its Disposable.
 Allows preventing certain identity-based optimizations (fusion).
 Scheduler:
 hide does not operate by default on a particularScheduler.
 Returns:
 the new Maybe instance
 - ignoreElement
```
@CheckReturnValue@SchedulerSupport(value="none")public final Completable ignoreElement()
```
 Ignores the item emitted by the source Maybe and only callsonComplete oronError.
 Scheduler:
 ignoreElement does not operate by default on a particularScheduler.
 Returns:
 an empty Completable that only callsonComplete oronError, based on which one is called by the source Maybe
 See Also:
 ReactiveX operators documentation: IgnoreElements
 - isEmpty
```
@CheckReturnValue@SchedulerSupport(value="none")public final Single<Boolean> isEmpty()
```
 Returns a Single that emitstrue if the source Maybe is empty, otherwisefalse.
 Scheduler:
 isEmpty does not operate by default on a particularScheduler.
 Returns:
 a Single that emits a Boolean
 See Also:
 ReactiveX operators documentation: Contains
 - lift
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> Maybe<R> lift(MaybeOperator<? extends R,? superT> lift)
```
 This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns aMaybe which, when subscribed to, invokes theapply(MaybeObserver) method of the providedMaybeOperator for each individual downstreamMaybe and allows the insertion of a custom operator by accessing the downstream'sMaybeObserver during this subscription phase and providing a newMaybeObserver, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.
 Generally, such a newMaybeObserver will wrap the downstream'sMaybeObserver and forwards theonSuccess,onError andonComplete events from the upstream directly or according to the emission pattern the custom operator's business logic requires. In addition, such operator can intercept the flow control calls ofdispose andisDisposed that would have traveled upstream and perform additional actions depending on the same business logic requirements.
 Example:
```
 // Step 1: Create the consumer type that will be returned by the MaybeOperator.apply(): public final class CustomMaybeObserver<T> implements MaybeObserver<T>, Disposable { // The downstream's MaybeObserver that will receive the onXXX events final MaybeObserver<? super String> downstream; // The connection to the upstream source that will call this class' onXXX methods Disposable upstream; // The constructor takes the downstream subscriber and usually any other parameters public CustomMaybeObserver(MaybeObserver<? super String> downstream) { this.downstream = downstream; } // In the subscription phase, the upstream sends a Disposable to this class // and subsequently this class has to send a Disposable to the downstream. // Note that relaying the upstream's Disposable directly is not allowed in RxJava @Override public void onSubscribe(Disposable d) { if (upstream != null) { d.dispose(); } else { upstream = d; downstream.onSubscribe(this); } } // The upstream calls this with the next item and the implementation's // responsibility is to emit an item to the downstream based on the intended // business logic, or if it can't do so for the particular item, // request more from the upstream @Override public void onSuccess(T item) { String str = item.toString(); if (str.length() < 2) { downstream.onSuccess(str); } else { // Maybe is usually expected to produce one of the onXXX events downstream.onComplete(); } } // Some operators may handle the upstream's error while others // could just forward it to the downstream. @Override public void onError(Throwable throwable) { downstream.onError(throwable); } // When the upstream completes, usually the downstream should complete as well. @Override public void onComplete() { downstream.onComplete(); } // Some operators may use their own resources which should be cleaned up if // the downstream disposes the flow before it completed. Operators without // resources can simply forward the dispose to the upstream. // In some cases, a disposed flag may be set by this method so that other parts // of this class may detect the dispose and stop sending events // to the downstream. @Override public void dispose() { upstream.dispose(); } // Some operators may simply forward the call to the upstream while others // can return the disposed flag set in dispose(). @Override public boolean isDisposed() { return upstream.isDisposed(); } } // Step 2: Create a class that implements the MaybeOperator interface and // returns the custom consumer type from above in its apply() method. // Such class may define additional parameters to be submitted to // the custom consumer type. final class CustomMaybeOperator<T> implements MaybeOperator<String> { @Override public MaybeObserver<? super String> apply(MaybeObserver<? super T> upstream) { return new CustomMaybeObserver<T>(upstream); } } // Step 3: Apply the custom operator via lift() in a flow by creating an instance of it // or reusing an existing one. Maybe.just(5) .lift(new CustomMaybeOperator<Integer>()) .test() .assertResult("5"); Maybe.just(15) .lift(new CustomMaybeOperator<Integer>()) .test() .assertResult();
```
 Creating custom operators can be complicated and it is recommended one consults theRxJava wiki: Writing operators page about the tools, requirements, rules, considerations and pitfalls of implementing them.
 Note that implementing custom operators via thislift() method adds slightly more overhead by requiring an additional allocation and indirection per assembled flows. Instead, extending the abstractMaybe class and creating aMaybeTransformer with it is recommended.
 Note also that it is not possible to stop the subscription phase inlift() as theapply() method requires a non-nullMaybeObserver instance to be returned, which is then unconditionally subscribed to the upstreamMaybe. For example, if the operator decided there is no reason to subscribe to the upstream source because of some optimization possibility or a failure to prepare the operator, it still has to return aMaybeObserver that should immediately dispose the upstream'sDisposable in itsonSubscribe method. Again, using aMaybeTransformer and extending theMaybe is a better option assubscribeActual(io.reactivex.MaybeObserver<? super T>) can decide to not subscribe to its upstream after all.
 Scheduler:
 lift does not operate by default on a particularScheduler, however, theMaybeOperator may use aScheduler to support its own asynchronous behavior.
 Type Parameters:
 R - the output value type
 Parameters:
 lift - theMaybeOperator that receives the downstream'sMaybeObserver and should return aMaybeObserver with custom behavior to be used as the consumer for the currentMaybe.
 Returns:
 the new Maybe instance
 See Also:
 RxJava wiki: Writing operators,compose(MaybeTransformer)
 - map
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> Maybe<R> map(Function<? superT,? extends R> mapper)
```
 Returns a Maybe that applies a specified function to the item emitted by the source Maybe and emits the result of this function application.
 Scheduler:
 map does not operate by default on a particularScheduler.
 Type Parameters:
 R - the result value type
 Parameters:
 mapper - a function to apply to the item emitted by the Maybe
 Returns:
 a Maybe that emits the item from the source Maybe, transformed by the specified function
 See Also:
 ReactiveX operators documentation: Map
 - materialize
```
@CheckReturnValue@SchedulerSupport(value="none")public final Single<Notification<T>> materialize()
```
 Maps the signal types of this Maybe into aNotification of the same kind and emits it as a single success value to downstream.
 Scheduler:
 materialize does not operate by default on a particularScheduler.
 Returns:
 the new Single instance
 Since:
 2.2.4 - experimental
 See Also:
 Single.dematerialize(Function)
 - mergeWith
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Flowable<T> mergeWith(MaybeSource<? extendsT> other)
```
 Flattens this and another Maybe into a single Flowable, without any transformation.
 You can combine items emitted by multiple Maybes so that they appear as a single Flowable, by using themergeWith method.
 Backpressure:
 The operator honors backpressure from downstream.
 Scheduler:
 mergeWith does not operate by default on a particularScheduler.
 Parameters:
 other - a MaybeSource to be merged
 Returns:
 a new Flowable instance
 See Also:
 ReactiveX operators documentation: Merge
 - observeOn
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public final Maybe<T> observeOn(Scheduler scheduler)
```
 Wraps a Maybe to emit its item (or notify of its error) on a specifiedScheduler, asynchronously.
 Scheduler:
 you specify whichScheduler this operator will use.
 Parameters:
 scheduler - theScheduler to notify subscribers on
 Returns:
 the new Maybe instance that its subscribers are notified on the specifiedScheduler
 See Also:
 ReactiveX operators documentation: ObserveOn,RxJava Threading Examples,subscribeOn(io.reactivex.Scheduler)
 - ofType
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  Maybe ofType(Class clazz)
```
 Filters the items emitted by a Maybe, only emitting its success value if that is an instance of the supplied Class.
 Scheduler:
 ofType does not operate by default on a particularScheduler.
 Type Parameters:
 U - the output type
 Parameters:
 clazz - the class type to filter the items emitted by the source Maybe
 Returns:
 the new Maybe instance
 See Also:
 ReactiveX operators documentation: Filter
 - to
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> R to(Function<? superMaybe<T>,R> convert)
```
 Calls the specified converter function with the current Maybe instance during assembly time and returns its result.
 Scheduler:
 to does not operate by default on a particularScheduler.
 Type Parameters:
 R - the result type
 Parameters:
 convert - the function that is called with the current Maybe instance during assembly time that should return some value to be the result
 Returns:
 the value returned by the convert function
 - toFlowable
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")public final Flowable<T> toFlowable()
```
 Converts this Maybe into a backpressure-aware Flowable instance composing cancellation through.
 Backpressure:
 The returned Flowable honors the backpressure of the downstream.
 Scheduler:
 toFlowable does not operate by default on a particularScheduler.
 Returns:
 the new Flowable instance
 - toObservable
```
@CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> toObservable()
```
 Converts this Maybe into an Observable instance composing disposal through.
 Scheduler:
 toObservable does not operate by default on a particularScheduler.
 Returns:
 the new Observable instance
 - toSingle
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Single<T> toSingle(T defaultValue)
```
 Converts this Maybe into a Single instance composing disposal through and turning an empty Maybe into a Single that emits the given value through onSuccess.
 Scheduler:
 toSingle does not operate by default on a particularScheduler.
 Parameters:
 defaultValue - the default item to signal in Single if this Maybe is empty
 Returns:
 the new Single instance
 - toSingle
```
@CheckReturnValue@SchedulerSupport(value="none")public final Single<T> toSingle()
```
 Converts this Maybe into a Single instance composing disposal through and turning an empty Maybe into a signal of NoSuchElementException.
 Scheduler:
 toSingle does not operate by default on a particularScheduler.
 Returns:
 the new Single instance
 - onErrorComplete
```
@CheckReturnValue@SchedulerSupport(value="none")public final Maybe<T> onErrorComplete()
```
 Returns a Maybe instance that if this Maybe emits an error, it will emit an onComplete and swallow the throwable.
 Scheduler:
 onErrorComplete does not operate by default on a particularScheduler.
 Returns:
 the new Maybe instance
 - onErrorComplete
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Maybe<T> onErrorComplete(Predicate<? superThrowable> 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.
 Scheduler:
 onErrorComplete does not operate by default on a particularScheduler.
 Parameters:
 predicate - the predicate to call when an Throwable is emitted which should return true if the Throwable should be swallowed and replaced with an onComplete.
 Returns:
 the new Maybe instance
 - onErrorResumeNext
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Maybe<T> onErrorResumeNext(MaybeSource<? extendsT> next)
```
 Instructs a Maybe to pass control to anotherMaybeSource rather than invokingonError if it encounters an error.
 You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.
 Scheduler:
 onErrorResumeNext does not operate by default on a particularScheduler.
 Parameters:
 next - the nextMaybeSource that will take over if the source Maybe encounters an error
 Returns:
 the new Maybe instance
 See Also:
 ReactiveX operators documentation: Catch
 - onErrorResumeNext
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Maybe<T> onErrorResumeNext(Function<? superThrowable,? extendsMaybeSource<? extendsT>> resumeFunction)
```
 Instructs a Maybe to pass control to another Maybe rather than invokingonError if it encounters an error.
 You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.
 Scheduler:
 onErrorResumeNext does not operate by default on a particularScheduler.
 Parameters:
 resumeFunction - a function that returns a MaybeSource that will take over if the source Maybe encounters an error
 Returns:
 the new Maybe instance
 See Also:
 ReactiveX operators documentation: Catch
 - onErrorReturn
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Maybe<T> onErrorReturn(Function<? superThrowable,? extendsT> valueSupplier)
```
 Instructs a Maybe to emit an item (returned by a specified function) rather than invokingonError if it encounters an error.
 You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.
 Scheduler:
 onErrorReturn does not operate by default on a particularScheduler.
 Parameters:
 valueSupplier - a function that returns a single value that will be emitted as success value the current Maybe signals an onError event
 Returns:
 the new Maybe instance
 See Also:
 ReactiveX operators documentation: Catch
 - onErrorReturnItem
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Maybe<T> onErrorReturnItem(T item)
```
 Instructs a Maybe to emit an item (returned by a specified function) rather than invokingonError if it encounters an error.
 You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.
 Scheduler:
 onErrorReturnItem does not operate by default on a particularScheduler.
 Parameters:
 item - the value that is emitted as onSuccess in case this Maybe signals an onError
 Returns:
 the new Maybe instance
 See Also:
 ReactiveX operators documentation: Catch
 - onExceptionResumeNext
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Maybe<T> onExceptionResumeNext(MaybeSource<? extendsT> next)
```
 Instructs a Maybe to pass control to another MaybeSource rather than invokingonError if it encounters anException.
 This differs fromonErrorResumeNext(io.reactivex.MaybeSource<? extends T>) in that this one does not handleThrowable orError but lets those continue through.
 You can use this to prevent exceptions from propagating or to supply fallback data should exceptions be encountered.
 Scheduler:
 onExceptionResumeNext does not operate by default on a particularScheduler.
 Parameters:
 next - the next MaybeSource that will take over if the source Maybe encounters an exception
 Returns:
 the new Maybe instance
 See Also:
 ReactiveX operators documentation: Catch
 - onTerminateDetach
```
@CheckReturnValue@SchedulerSupport(value="none")public final Maybe<T> onTerminateDetach()
```
 Nulls out references to the upstream producer and downstream MaybeObserver if the sequence is terminated or downstream calls dispose().
 Scheduler:
 onTerminateDetach does not operate by default on a particularScheduler.
 Returns:
 a Maybe which nulls out references to the upstream producer and downstream MaybeObserver if the sequence is terminated or downstream calls dispose()
 - repeat
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")public final Flowable<T> repeat()
```
 Returns a Flowable that repeats the sequence of items emitted by the source Maybe indefinitely.
 Backpressure:
 The operator honors downstream backpressure.
 Scheduler:
 repeat does not operate by default on a particularScheduler.
 Returns:
 a Flowable that emits the items emitted by the source Maybe repeatedly and in sequence
 See Also:
 ReactiveX operators documentation: Repeat
 - repeat
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")public final Flowable<T> repeat(long times)
```
 Returns a Flowable that repeats the sequence of items emitted by the source Maybe at mostcount times.
 Backpressure:
 This operator honors downstream backpressure.
 Scheduler:
 repeat does not operate by default on a particularScheduler.
 Parameters:
 times - the number of times the source Maybe items are repeated, a count of 0 will yield an empty sequence
 Returns:
 a Flowable that repeats the sequence of items emitted by the source Maybe at mostcount times
 Throws:
 IllegalArgumentException - ifcount is less than zero
 See Also:
 ReactiveX operators documentation: Repeat
 - repeatUntil
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")public final Flowable<T> repeatUntil(BooleanSupplier stop)
```
 Returns a Flowable that repeats the sequence of items emitted by the source Maybe until the provided stop function returns true.
 Backpressure:
 This operator honors downstream backpressure.
 Scheduler:
 repeatUntil does not operate by default on a particularScheduler.
 Parameters:
 stop - a boolean supplier that is called when the current Flowable completes and unless it returns false, the current Flowable is resubscribed
 Returns:
 the new Flowable instance
 Throws:
 NullPointerException - ifstop is null
 See Also:
 ReactiveX operators documentation: Repeat
 - repeatWhen
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")public final Flowable<T> repeatWhen(Function<? superFlowable<Object>,? extendsPublisher<?>> handler)
```
 Returns a Flowable that emits the same values as the source Publisher with the exception of anonComplete. AnonComplete notification from the source will result in the emission of avoid item to the Publisher provided as an argument to thenotificationHandler function. If that Publisher callsonComplete oronError thenrepeatWhen will callonComplete oronError on the child subscription. Otherwise, this Publisher will resubscribe to the source Publisher.
 Backpressure:
 The operator honors downstream backpressure and expects the sourcePublisher to honor backpressure as well. If this expectation is violated, the operatormay throw anIllegalStateException.
 Scheduler:
 repeatWhen does not operate by default on a particularScheduler.
 Parameters:
 handler - receives a Publisher of notifications with which a user can complete or error, aborting the repeat.
 Returns:
 the source Publisher modified with repeat logic
 See Also:
 ReactiveX operators documentation: Repeat
 - retry
```
@CheckReturnValue@SchedulerSupport(value="none")public final Maybe<T> retry()
```
 Returns a Maybe that mirrors the source Maybe, resubscribing to it if it callsonError (infinite retry count).
 If the source Maybe callsMaybeObserver.onError(java.lang.Throwable), this method will resubscribe to the source Maybe rather than propagating theonError call.
 Scheduler:
 retry does not operate by default on a particularScheduler.
 Returns:
 the new Maybe instance
 See Also:
 ReactiveX operators documentation: Retry
 - retry
```
@CheckReturnValue@SchedulerSupport(value="none")public final Maybe<T> retry(BiPredicate<? superInteger,? superThrowable> predicate)
```
 Returns a Maybe that mirrors the source Maybe, resubscribing to it if it callsonError and the predicate returns true for that specific exception and retry count.
 Scheduler:
 retry does not operate by default on a particularScheduler.
 Parameters:
 predicate - the predicate that determines if a resubscription may happen in case of a specific exception and retry count
 Returns:
 the new Maybe instance
 See Also:
 retry(),ReactiveX operators documentation: Retry
 - retry
```
@CheckReturnValue@SchedulerSupport(value="none")public final Maybe<T> retry(long count)
```
 Returns a Maybe that mirrors the source Maybe, resubscribing to it if it callsonError up to a specified number of retries.
 If the source Maybe callsMaybeObserver.onError(java.lang.Throwable), this method will resubscribe to the source Maybe for a maximum ofcount resubscriptions rather than propagating theonError call.
 Scheduler:
 retry does not operate by default on a particularScheduler.
 Parameters:
 count - the number of times to resubscribe if the current Maybe fails
 Returns:
 the new Maybe instance
 See Also:
 ReactiveX operators documentation: Retry
 - retry
```
@CheckReturnValue@SchedulerSupport(value="none")public final Maybe<T> retry(long times,Predicate<? superThrowable> predicate)
```
 Retries at most times or until the predicate returns false, whichever happens first.
 Scheduler:
 retry does not operate by default on a particularScheduler.
 Parameters:
 times - the number of times to resubscribe if the current Maybe fails
 predicate - the predicate called with the failure Throwable and should return true to trigger a retry.
 Returns:
 the new Maybe instance
 - retry
```
@CheckReturnValue@SchedulerSupport(value="none")public final Maybe<T> retry(Predicate<? superThrowable> predicate)
```
 Retries the current Maybe if it fails and the predicate returns true.
 Scheduler:
 retry does not operate by default on a particularScheduler.
 Parameters:
 predicate - the predicate that receives the failure Throwable and should return true to trigger a retry.
 Returns:
 the new Maybe instance
 - retryUntil
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Maybe<T> retryUntil(BooleanSupplier stop)
```
 Retries until the given stop function returns true.
 Scheduler:
 retryUntil does not operate by default on a particularScheduler.
 Parameters:
 stop - the function that should return true to stop retrying
 Returns:
 the new Maybe instance
 - retryWhen
```
@CheckReturnValue@SchedulerSupport(value="none")public final Maybe<T> retryWhen(Function<? superFlowable<Throwable>,? extendsPublisher<?>> handler)
```
 Returns a Maybe that emits the same values as the source Maybe with the exception of anonError. AnonError notification from the source will result in the emission of aThrowable item to the Publisher provided as an argument to thenotificationHandler function. If that Publisher callsonComplete oronError thenretry will callonComplete oronError on the child subscription. Otherwise, this Publisher will resubscribe to the source Publisher.
 Example: This retries 3 times, each time incrementing the number of seconds it waits.
```
 Maybe.create((MaybeEmitter<? super String> s) -> { System.out.println("subscribing"); s.onError(new RuntimeException("always fails")); }, BackpressureStrategy.BUFFER).retryWhen(attempts -> { return attempts.zipWith(Publisher.range(1, 3), (n, i) -> i).flatMap(i -> { System.out.println("delay retry by " + i + " second(s)"); return Flowable.timer(i, TimeUnit.SECONDS); }); }).blockingForEach(System.out::println);
```
 Output is:
```
 subscribing delay retry by 1 second(s) subscribing delay retry by 2 second(s) subscribing delay retry by 3 second(s) subscribing
```
 Note that the innerPublisher returned by the handler function should signal eitheronNext,onError oronComplete in response to the receivedThrowable to indicate the operator should retry or terminate. If the upstream to the operator is asynchronous, signalling onNext followed by onComplete immediately may result in the sequence to be completed immediately. Similarly, if this innerPublisher signalsonError oronComplete while the upstream is active, the sequence is terminated with the same signal immediately.
 The following example demonstrates how to retry an asynchronous source with a delay:
```
 Maybe.timer(1, TimeUnit.SECONDS) .doOnSubscribe(s -> System.out.println("subscribing")) .map(v -> { throw new RuntimeException(); }) .retryWhen(errors -> { AtomicInteger counter = new AtomicInteger(); return errors .takeWhile(e -> counter.getAndIncrement() != 3) .flatMap(e -> { System.out.println("delay retry by " + counter.get() + " second(s)"); return Flowable.timer(counter.get(), TimeUnit.SECONDS); }); }) .blockingGet();
```
 Scheduler:
 retryWhen does not operate by default on a particularScheduler.
 Parameters:
 handler - receives a Publisher of notifications with which a user can complete or error, aborting the retry
 Returns:
 the new Maybe instance
 See Also:
 ReactiveX operators documentation: Retry
 - subscribe
```
@SchedulerSupport(value="none")public final Disposable subscribe()
```
 Subscribes to a Maybe and ignoresonSuccess andonComplete emissions.
 If the Maybe emits an error, it is wrapped into anOnErrorNotImplementedException and routed to the RxJavaPlugins.onError handler.
 Scheduler:
 subscribe does not operate by default on a particularScheduler.
 Returns:
 aDisposable reference with which the caller can stop receiving items before the Maybe has finished sending them
 See Also:
 ReactiveX operators documentation: Subscribe
 - subscribe
```
@CheckReturnValue@SchedulerSupport(value="none")public final Disposable subscribe(Consumer<? superT> onSuccess)
```
 Subscribes to a Maybe and provides a callback to handle the items it emits.
 If the Maybe emits an error, it is wrapped into anOnErrorNotImplementedException and routed to the RxJavaPlugins.onError handler.
 Scheduler:
 subscribe does not operate by default on a particularScheduler.
 Parameters:
 onSuccess - theConsumer<T> you have designed to accept a success value from the Maybe
 Returns:
 aDisposable reference with which the caller can stop receiving items before the Maybe has finished sending them
 Throws:
 NullPointerException - ifonSuccess is null
 See Also:
 ReactiveX operators documentation: Subscribe
 - subscribe
```
@CheckReturnValue@SchedulerSupport(value="none")public final Disposable subscribe(Consumer<? superT> onSuccess,Consumer<? superThrowable> onError)
```
 Subscribes to a Maybe and provides callbacks to handle the items it emits and any error notification it issues.
 Scheduler:
 subscribe does not operate by default on a particularScheduler.
 Parameters:
 onSuccess - theConsumer<T> you have designed to accept a success value from the Maybe
 onError - theConsumer<Throwable> you have designed to accept any error notification from the Maybe
 Returns:
 aDisposable reference with which the caller can stop receiving items before the Maybe has finished sending them
 Throws:
 NullPointerException - ifonSuccess is null, or ifonError is null
 See Also:
 ReactiveX operators documentation: Subscribe
 - subscribe
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Disposable subscribe(Consumer<? superT> onSuccess,Consumer<? superThrowable> onError,Action onComplete)
```
 Subscribes to a Maybe and provides callbacks to handle the items it emits and any error or completion notification it issues.
 Scheduler:
 subscribe does not operate by default on a particularScheduler.
 Parameters:
 onSuccess - theConsumer<T> you have designed to accept a success value from the Maybe
 onError - theConsumer<Throwable> you have designed to accept any error notification from the Maybe
 onComplete - theAction you have designed to accept a completion notification from the Maybe
 Returns:
 aDisposable reference with which the caller can stop receiving items before the Maybe has finished sending them
 Throws:
 NullPointerException - ifonSuccess is null, or ifonError is null, or ifonComplete is null
 See Also:
 ReactiveX operators documentation: Subscribe
 - subscribe
```
@SchedulerSupport(value="none")public final void subscribe(MaybeObserver<? superT> observer)
```
 Description copied from interface: MaybeSource
 Subscribes the given MaybeObserver to this MaybeSource instance.
 Specified by:
 subscribe in interface MaybeSource<T>
 Parameters:
 observer - the MaybeObserver, not null
 - subscribeActual
```
protected abstract void subscribeActual(MaybeObserver<? superT> observer)
```
 Implement this method in subclasses to handle the incomingMaybeObservers.
 There is no need to call any of the plugin hooks on the currentMaybe instance or theMaybeObserver; all hooks and basic safeguards have been applied bysubscribe(MaybeObserver) before this method gets called.
 Parameters:
 observer - the MaybeObserver to handle, not null
 - subscribeOn
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public final Maybe<T> subscribeOn(Scheduler scheduler)
```
 Asynchronously subscribes subscribers to this Maybe on the specifiedScheduler.
 Scheduler:
 you specify whichScheduler this operator will use.
 Parameters:
 scheduler - theScheduler to perform subscription actions on
 Returns:
 the new Maybe instance that its subscriptions happen on the specifiedScheduler
 See Also:
 ReactiveX operators documentation: SubscribeOn,RxJava Threading Examples,observeOn(io.reactivex.Scheduler)
 - subscribeWith
```
@CheckReturnValue@SchedulerSupport(value="none")public final <E extendsMaybeObserver<? superT>> E subscribeWith(E observer)
```
 Subscribes a given MaybeObserver (subclass) to this Maybe and returns the given MaybeObserver as is.
 Usage example:
```
 Maybe<Integer> source = Maybe.just(1); CompositeDisposable composite = new CompositeDisposable(); DisposableMaybeObserver<Integer> ds = new DisposableMaybeObserver<>() { // ... }; composite.add(source.subscribeWith(ds));
```
 Scheduler:
 subscribeWith does not operate by default on a particularScheduler.
 Type Parameters:
 E - the type of the MaybeObserver to use and return
 Parameters:
 observer - the MaybeObserver (subclass) to use and return, not null
 Returns:
 the inputsubscriber
 Throws:
 NullPointerException - ifsubscriber is null
 - switchIfEmpty
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Maybe<T> switchIfEmpty(MaybeSource<? extendsT> other)
```
 Returns a Maybe that emits the items emitted by the source Maybe or the items of an alternate MaybeSource if the current Maybe is empty.
 Scheduler:
 switchIfEmpty does not operate by default on a particularScheduler.
 Parameters:
 other - the alternate MaybeSource to subscribe to if the main does not emit any items
 Returns:
 a Maybe that emits the items emitted by the source Maybe or the items of an alternate MaybeSource if the source Maybe is empty.
 - switchIfEmpty
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Single<T> switchIfEmpty(SingleSource<? extendsT> other)
```
 Returns a Single that emits the items emitted by the source Maybe or the item of an alternate SingleSource if the current Maybe is empty.
 Scheduler:
 switchIfEmpty does not operate by default on a particularScheduler.
 History: 2.1.4 - experimental
 Parameters:
 other - the alternate SingleSource to subscribe to if the main does not emit any items
 Returns:
 a Single that emits the items emitted by the source Maybe or the item of an alternate SingleSource if the source Maybe is empty.
 Since:
 2.2
 - takeUntil
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  Maybe<T> takeUntil(MaybeSource other)
```
 Returns a Maybe that emits the items emitted by the source Maybe until a second MaybeSource emits an item.
 Scheduler:
 takeUntil does not operate by default on a particularScheduler.
 Type Parameters:
 U - the type of items emitted byother
 Parameters:
 other - the MaybeSource whose first emitted item will causetakeUntil to stop emitting items from the source Maybe
 Returns:
 a Maybe that emits the items emitted by the source Maybe until such time asother emits its first item
 See Also:
 ReactiveX operators documentation: TakeUntil
 - takeUntil
```
@BackpressureSupport(value=UNBOUNDED_IN)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  Maybe<T> takeUntil(Publisher other)
```
 Returns a Maybe that emits the item emitted by the source Maybe until a second Publisher emits an item.
 Backpressure:
 ThePublisher is consumed in an unbounded fashion and is cancelled after the first item emitted.
 Scheduler:
 takeUntil does not operate by default on a particularScheduler.
 Type Parameters:
 U - the type of items emitted byother
 Parameters:
 other - the Publisher whose first emitted item will causetakeUntil to stop emitting items from the source Publisher
 Returns:
 a Maybe that emits the items emitted by the source Maybe until such time asother emits its first item
 See Also:
 ReactiveX operators documentation: TakeUntil
 - timeout
```
@CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Maybe<T> timeout(long timeout,TimeUnit timeUnit)
```
 Returns a Maybe that mirrors the source Maybe but applies a timeout policy for each emitted item. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the resulting Maybe terminates and notifies MaybeObservers of aTimeoutException.
 Scheduler:
 This version oftimeout operates by default on thecomputationScheduler.
 Parameters:
 timeout - maximum duration between emitted items before a timeout occurs
 timeUnit - the unit of time that applies to thetimeout argument.
 Returns:
 the new Maybe instance
 See Also:
 ReactiveX operators documentation: Timeout
 - timeout
```
@CheckReturnValue@NonNull@SchedulerSupport(value="io.reactivex:computation")public final Maybe<T> timeout(long timeout,TimeUnit timeUnit,MaybeSource<? extendsT> fallback)
```
 Returns a Maybe that mirrors the source Maybe but applies a timeout policy for each emitted item. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the source MaybeSource is disposed and resulting Maybe begins instead to mirror a fallback MaybeSource.
 Scheduler:
 This version oftimeout operates by default on thecomputationScheduler.
 Parameters:
 timeout - maximum duration between items before a timeout occurs
 timeUnit - the unit of time that applies to thetimeout argument
 fallback - the fallback MaybeSource to use in case of a timeout
 Returns:
 the new Maybe instance
 See Also:
 ReactiveX operators documentation: Timeout
 - timeout
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public final Maybe<T> timeout(long timeout,TimeUnit timeUnit,Scheduler scheduler,MaybeSource<? extendsT> fallback)
```
 Returns a Maybe that mirrors the source Maybe but applies a timeout policy for each emitted item using a specified Scheduler. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the source MaybeSource is disposed and resulting Maybe begins instead to mirror a fallback MaybeSource.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 timeout - maximum duration between items before a timeout occurs
 timeUnit - the unit of time that applies to thetimeout argument
 fallback - the MaybeSource to use as the fallback in case of a timeout
 scheduler - theScheduler to run the timeout timers on
 Returns:
 the new Maybe instance
 See Also:
 ReactiveX operators documentation: Timeout
 - timeout
```
@CheckReturnValue@SchedulerSupport(value="custom")public final Maybe<T> timeout(long timeout,TimeUnit timeUnit,Scheduler scheduler)
```
 Returns a Maybe that mirrors the source Maybe but applies a timeout policy for each emitted item, where this policy is governed on a specified Scheduler. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the resulting Maybe terminates and notifies MaybeObservers of aTimeoutException.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 timeout - maximum duration between items before a timeout occurs
 timeUnit - the unit of time that applies to thetimeout argument
 scheduler - the Scheduler to run the timeout timers on
 Returns:
 the new Maybe instance
 See Also:
 ReactiveX operators documentation: Timeout
 - timeout
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  Maybe<T> timeout(MaybeSource timeoutIndicator)
```
 If the currentMaybe didn't signal an event before thetimeoutIndicatorMaybeSource signals, aTimeoutException is signaled instead.
 Scheduler:
 timeout does not operate by default on a particularScheduler.
 Type Parameters:
 U - the value type of the
 Parameters:
 timeoutIndicator - theMaybeSource that indicates the timeout by signaling onSuccess or onComplete.
 Returns:
 the new Maybe instance
 - timeout
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  Maybe<T> timeout(MaybeSource timeoutIndicator,MaybeSource<? extendsT> fallback)
```
 If the currentMaybe didn't signal an event before thetimeoutIndicatorMaybeSource signals, the currentMaybe is disposed and thefallbackMaybeSource subscribed to as a continuation.
 Scheduler:
 timeout does not operate by default on a particularScheduler.
 Type Parameters:
 U - the value type of the
 Parameters:
 timeoutIndicator - theMaybeSource that indicates the timeout by signalingonSuccess oronComplete.
 fallback - theMaybeSource that is subscribed to if the currentMaybe times out
 Returns:
 the new Maybe instance
 - timeout
```
@BackpressureSupport(value=UNBOUNDED_IN)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  Maybe<T> timeout(Publisher timeoutIndicator)
```
 If the currentMaybe source didn't signal an event before thetimeoutIndicatorPublisher signals, aTimeoutException is signaled instead.
 Backpressure:
 ThetimeoutIndicatorPublisher is consumed in an unbounded manner and is cancelled after its first item.
 Scheduler:
 timeout does not operate by default on a particularScheduler.
 Type Parameters:
 U - the value type of the
 Parameters:
 timeoutIndicator - theMaybeSource that indicates the timeout by signalingonSuccess oronComplete.
 Returns:
 the new Maybe instance
 - timeout
```
@BackpressureSupport(value=UNBOUNDED_IN)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  Maybe<T> timeout(Publisher timeoutIndicator,MaybeSource<? extendsT> fallback)
```
 If the currentMaybe didn't signal an event before thetimeoutIndicatorPublisher signals, the currentMaybe is disposed and thefallbackMaybeSource subscribed to as a continuation.
 Backpressure:
 ThetimeoutIndicatorPublisher is consumed in an unbounded manner and is cancelled after its first item.
 Scheduler:
 timeout does not operate by default on a particularScheduler.
 Type Parameters:
 U - the value type of the
 Parameters:
 timeoutIndicator - theMaybeSource that indicates the timeout by signalingonSuccess oronComplete
 fallback - theMaybeSource that is subscribed to if the currentMaybe times out
 Returns:
 the new Maybe instance
 - unsubscribeOn
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public final Maybe<T> unsubscribeOn(Scheduler scheduler)
```
 Returns a Maybe which makes sure when a MaybeObserver disposes the Disposable, that call is propagated up on the specified scheduler.
 Scheduler:
 unsubscribeOn calls dispose() of the upstream on theScheduler you specify.
 Parameters:
 scheduler - the target scheduler where to execute the disposal
 Returns:
 the new Maybe instance
 Throws:
 NullPointerException - if scheduler is null
 - zipWith
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <U,R> Maybe<R> zipWith(MaybeSource<? extends U> other,BiFunction<? superT,? super U,? extends 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.
 If either this or the other MaybeSource is empty or signals an error, the resulting Maybe will terminate immediately and dispose the other source.
 Scheduler:
 zipWith does not operate by default on a particularScheduler.
 Type Parameters:
 U - the type of items emitted by theother MaybeSource
 R - the type of items emitted by the resulting Maybe
 Parameters:
 other - the other MaybeSource
 zipper - a function that combines the pairs of items from the two MaybeSources to generate the items to be emitted by the resulting Maybe
 Returns:
 the new Maybe instance
 See Also:
 ReactiveX operators documentation: Zip
 - test
```
@CheckReturnValue@SchedulerSupport(value="none")public final TestObserver<T> test()
```
 Creates a TestObserver and subscribes it to this Maybe.
 Scheduler:
 test does not operate by default on a particularScheduler.
 Returns:
 the new TestObserver instance
 - test
```
@CheckReturnValue@SchedulerSupport(value="none")public final TestObserver<T> test(boolean cancelled)
```
 Creates a TestObserver optionally in cancelled state, then subscribes it to this Maybe.
 Scheduler:
 test does not operate by default on a particularScheduler.
 Parameters:
 cancelled - if true, the TestObserver will be cancelled before subscribing to this Maybe.
 Returns:
 the new TestObserver instance

Movatterモバイル変換

Class Maybe<T>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Maybe

Method Detail

amb

ambArray

concat

concat

concat

concat

concat

concat

concatArray

concatArrayDelayError

concatArrayEager

concatDelayError

concatDelayError

concatEager

concatEager

create

defer

empty

error

error

fromAction

fromCompletable

fromSingle

fromCallable

fromFuture

fromFuture

fromRunnable

just

merge

merge

merge

merge

merge

merge

merge

mergeArray

mergeArrayDelayError

mergeDelayError

mergeDelayError

mergeDelayError

mergeDelayError

mergeDelayError

mergeDelayError

never

sequenceEqual

sequenceEqual

timer

timer

unsafeCreate

using

using

wrap

zip

zip

zip

zip

zip

zip

zip

zip

zip

zipArray

ambWith

as

blockingGet

blockingGet

cache

cast

compose

concatMap

concatWith

contains