Movatterモバイル変換

java.lang.Object
- io.reactivex.rxjava3.core.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.rxjava3.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> @NonNullMaybe<T>`	`amb(@NonNullIterable<? extendsMaybeSource<? extends T>> sources)` Runs multiple`MaybeSource`s provided by an`Iterable` sequence and signals the events of the first one that signals (disposing the rest).
`static <T> @NonNullMaybe<T>`	`ambArray(MaybeSource<? extends T>... sources)` Runs multiple`MaybeSource`s and signals the events of the first one that signals (disposing the rest).
`@NonNullMaybe<T>`	`ambWith(@NonNullMaybeSource<? extendsT> other)` Mirrors the`MaybeSource` (current or provided) that first signals an event.
`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).
`void`	`blockingSubscribe()` Subscribes to the current`Maybe` andblocks the current thread until it terminates.
`void`	`blockingSubscribe(@NonNullConsumer<? superT> onSuccess)` Subscribes to the current`Maybe` and calls given`onSuccess` callback on thecurrent thread when it completes normally.
`void`	`blockingSubscribe(@NonNullConsumer<? superT> onSuccess,@NonNullConsumer<? superThrowable> onError)` Subscribes to the current`Maybe` and calls the appropriate callback on thecurrent thread when it terminates.
`void`	`blockingSubscribe(@NonNullConsumer<? superT> onSuccess,@NonNullConsumer<? superThrowable> onError,@NonNullAction onComplete)` Subscribes to the current`Maybe` and calls the appropriate callback on thecurrent thread when it terminates.
`void`	`blockingSubscribe(@NonNullMaybeObserver<? superT> observer)` Subscribes to the current`Maybe` and calls the appropriate`MaybeObserver` method on thecurrent thread.
`@NonNullMaybe<T>`	`cache()` Returns a`Maybe` that subscribes to this`Maybe` lazily, caches its event and replays it, to all the downstream subscribers.
`<U> @NonNullMaybe<U>`	`cast(@NonNullClass<? extends U> clazz)` Casts the success value of the current`Maybe` into the target type or signals a`ClassCastException` if not compatible.
`<R> @NonNullMaybe<R>`	`compose(@NonNullMaybeTransformer<? superT,? extends R> transformer)` Transform a`Maybe` by applying a particular`MaybeTransformer` function to it.
`static <T> @NonNullFlowable<T>`	`concat(@NonNullIterable<? extendsMaybeSource<? extends T>> sources)` Concatenate the single values, in a non-overlapping fashion, of the`MaybeSource` sources provided by an`Iterable` sequence as a`Flowable` sequence.
`static <T> @NonNullFlowable<T>`	`concat(@NonNullMaybeSource<? extends T> source1,@NonNullMaybeSource<? extends T> source2)` Returns a`Flowable` that emits the items emitted by two`MaybeSource`s, one after the other.
`static <T> @NonNullFlowable<T>`	`concat(@NonNullMaybeSource<? extends T> source1,@NonNullMaybeSource<? extends T> source2,@NonNullMaybeSource<? extends T> source3)` Returns a`Flowable` that emits the items emitted by three`MaybeSource`s, one after the other.
`static <T> @NonNullFlowable<T>`	`concat(@NonNullMaybeSource<? extends T> source1,@NonNullMaybeSource<? extends T> source2,@NonNullMaybeSource<? extends T> source3,@NonNullMaybeSource<? extends T> source4)` Returns a`Flowable` that emits the items emitted by four`MaybeSource`s, one after the other.
`static <T> @NonNullFlowable<T>`	`concat(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources)` Concatenate the single values, in a non-overlapping fashion, of the`MaybeSource` sources provided by a`Publisher` sequence as a`Flowable` sequence.
`static <T> @NonNullFlowable<T>`	`concat(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources, int prefetch)` Concatenate the single values, in a non-overlapping fashion, of the`MaybeSource` sources provided by a`Publisher` sequence as a`Flowable` sequence.
`static <T> @NonNullFlowable<T>`	`concatArray(MaybeSource<? extends T>... sources)` Concatenate the single values, in a non-overlapping fashion, of the`MaybeSource` sources in the array as a`Flowable` sequence.
`static <T> @NonNullFlowable<T>`	`concatArrayDelayError(MaybeSource<? extends T>... sources)` Concatenates a variable number of`MaybeSource` sources and delays errors from any of them till all terminate as a`Flowable` sequence.
`static <T> @NonNullFlowable<T>`	`concatArrayEager(MaybeSource<? extends T>... sources)` Concatenates a sequence of`MaybeSource` eagerly into a`Flowable` sequence.
`static <T> @NonNullFlowable<T>`	`concatArrayEagerDelayError(MaybeSource<? extends T>... sources)` Concatenates a sequence of`MaybeSource` eagerly into a`Flowable` sequence.
`static <T> @NonNullFlowable<T>`	`concatDelayError(@NonNullIterable<? extendsMaybeSource<? extends T>> sources)` Concatenates the`Iterable` sequence of`MaybeSource`s 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`MaybeSource`s terminate as a`Flowable` sequence.
`static <T> @NonNullFlowable<T>`	`concatDelayError(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources)` Concatenates the`Publisher` sequence of`MaybeSource`s into a single sequence by subscribing to each inner`MaybeSource`, one after the other, one at a time and delays any errors till the all inner and the outer`Publisher` terminate as a`Flowable` sequence.
`static <T> @NonNullFlowable<T>`	`concatDelayError(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources, int prefetch)` Concatenates the`Publisher` sequence of`MaybeSource`s into a single sequence by subscribing to each inner`MaybeSource`, one after the other, one at a time and delays any errors till the all inner and the outer`Publisher` terminate as a`Flowable` sequence.
`static <T> @NonNullFlowable<T>`	`concatEager(@NonNullIterable<? extendsMaybeSource<? extends T>> sources)` Concatenates a sequence of`MaybeSource`s eagerly into a`Flowable` sequence.
`static <T> @NonNullFlowable<T>`	`concatEager(@NonNullIterable<? extendsMaybeSource<? extends T>> sources, int maxConcurrency)` Concatenates a sequence of`MaybeSource`s eagerly into a`Flowable` sequence and runs a limited number of the inner sequences at once.
`static <T> @NonNullFlowable<T>`	`concatEager(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources)` Concatenates a`Publisher` sequence of`MaybeSource`s eagerly into a`Flowable` sequence.
`static <T> @NonNullFlowable<T>`	`concatEager(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources, int maxConcurrency)` Concatenates a`Publisher` sequence of`MaybeSource`s eagerly into a`Flowable` sequence, running at most the given number of inner`MaybeSource`s at once.
`static <T> @NonNullFlowable<T>`	`concatEagerDelayError(@NonNullIterable<? extendsMaybeSource<? extends T>> sources)` Concatenates a sequence of`MaybeSource`s eagerly into a`Flowable` sequence, delaying errors until all inner`MaybeSource`s terminate.
`static <T> @NonNullFlowable<T>`	`concatEagerDelayError(@NonNullIterable<? extendsMaybeSource<? extends T>> sources, int maxConcurrency)` Concatenates a sequence of`MaybeSource`s eagerly into a`Flowable` sequence, delaying errors until all inner`MaybeSource`s terminate and runs a limited number of inner`MaybeSource`s at once.
`static <T> @NonNullFlowable<T>`	`concatEagerDelayError(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources)` Concatenates a`Publisher` sequence of`MaybeSource`s eagerly into a`Flowable` sequence, delaying errors until all the inner and the outer sequence terminate.
`static <T> @NonNullFlowable<T>`	`concatEagerDelayError(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources, int maxConcurrency)` Concatenates a`Publisher` sequence of`MaybeSource`s eagerly into a`Flowable` sequence, delaying errors until all the inner and the outer sequence terminate and runs a limited number of the inner`MaybeSource`s at once.
`<R> @NonNullMaybe<R>`	`concatMap(@NonNullFunction<? superT,? extendsMaybeSource<? extends R>> mapper)` Returns a`Maybe` that is based on applying a specified function to the item emitted by the current`Maybe`, where that function returns a`MaybeSource`.
`@NonNullCompletable`	`concatMapCompletable(@NonNullFunction<? superT,? extendsCompletableSource> mapper)` Returns a`Completable` that completes based on applying a specified function to the item emitted by the current`Maybe`, where that function returns a`Completable`.
`<R> @NonNullMaybe<R>`	`concatMapSingle(@NonNullFunction<? superT,? extendsSingleSource<? extends R>> mapper)` Returns a`Maybe` based on applying a specified function to the item emitted by the current`Maybe`, where that function returns a`Single`.
`@NonNullFlowable<T>`	`concatWith(@NonNullMaybeSource<? extendsT> other)` Returns a`Flowable` that emits the items emitted from the current`Maybe`, then the`otherMaybeSource`, one after the other, without interleaving them.
`@NonNullSingle<Boolean>`	`contains(@NonNullObject item)` Returns a`Single` that emits a`Boolean` that indicates whether the current`Maybe` emitted a specified item.
`@NonNullSingle<Long>`	`count()` Returns a`Single` that counts the total number of items emitted (0 or 1) by the current`Maybe` and emits this count as a 64-bit`Long`.
`static <T> @NonNullMaybe<T>`	`create(@NonNullMaybeOnSubscribe<T> onSubscribe)` Provides an API (via a cold`Maybe`) that bridges the reactive world with the callback-style world.
`@NonNullSingle<T>`	`defaultIfEmpty(T defaultItem)` Returns a`Single` that emits the item emitted by the current`Maybe` or a specified default item if the current`Maybe` is empty.
`static <T> @NonNullMaybe<T>`	`defer(@NonNullSupplier<? extendsMaybeSource<? extends T>> supplier)` Calls a`Supplier` for each individual`MaybeObserver` to return the actual`MaybeSource` source to be subscribed to.
`@NonNullMaybe<T>`	`delay(long time,@NonNullTimeUnit unit)` Returns a`Maybe` that signals the events emitted by the current`Maybe` shifted forward in time by a specified delay.
`@NonNullMaybe<T>`	`delay(long time,@NonNullTimeUnit unit, boolean delayError)` Returns a`Maybe` that signals the events emitted by the current`Maybe` shifted forward in time by a specified delay.
`@NonNullMaybe<T>`	`delay(long time,@NonNullTimeUnit unit,@NonNullScheduler scheduler)` Returns a`Maybe` that signals the events emitted by the current`Maybe` shifted forward in time by a specified delay.
`@NonNullMaybe<T>`	`delay(long time,@NonNullTimeUnit unit,@NonNullScheduler scheduler, boolean delayError)` Returns a`Maybe` that signals the events emitted by the current`Maybe` shifted forward in time by a specified delay running on the specified`Scheduler`.
`<U> @NonNullMaybe<T>`	`delay(@NonNullPublisher<U> delayIndicator)` Delays the emission of this`Maybe` until the given`Publisher` signals an item or completes.
`@NonNullMaybe<T>`	`delaySubscription(long time,@NonNullTimeUnit unit)` Returns a`Maybe` that delays the subscription to the current`Maybe` by a given amount of time.
`@NonNullMaybe<T>`	`delaySubscription(long time,@NonNullTimeUnit unit,@NonNullScheduler scheduler)` Returns a`Maybe` that delays the subscription to the current`Maybe` by a given amount of time, both waiting and subscribing on a given`Scheduler`.
`<U> @NonNullMaybe<T>`	`delaySubscription(@NonNullPublisher<U> subscriptionIndicator)` Returns a`Maybe` that delays the subscription to this`Maybe` until the other`Publisher` emits an element or completes normally.
`<R> @NonNullMaybe<R>`	`dematerialize(@NonNullFunction<? superT,Notification<R>> selector)` Maps the`Notification` success value of the current`Maybe` back into normal`onSuccess`,`onError` or`onComplete` signals.
`@NonNullMaybe<T>`	`doAfterSuccess(@NonNullConsumer<? superT> onAfterSuccess)` Calls the specified`Consumer` with the success item after this item has been emitted to the downstream.
`@NonNullMaybe<T>`	`doAfterTerminate(@NonNullAction onAfterTerminate)` Registers an`Action` to be called when this`Maybe` invokes either`onSuccess`,`onComplete` or`onError`.
`@NonNullMaybe<T>`	`doFinally(@NonNullAction onFinally)` Calls the specified action after this`Maybe` signals`onSuccess`,`onError` or`onComplete` or gets disposed by the downstream.
`@NonNullMaybe<T>`	`doOnComplete(@NonNullAction onComplete)` Invokes an`Action` just before the current`Maybe` calls`onComplete`.
`@NonNullMaybe<T>`	`doOnDispose(@NonNullAction onDispose)` Calls the shared`Action` if a`MaybeObserver` subscribed to the current`Maybe` disposes the common`Disposable` it received via`onSubscribe`.
`@NonNullMaybe<T>`	`doOnError(@NonNullConsumer<? superThrowable> onError)` Calls the shared`Consumer` with the error sent via`onError` for each`MaybeObserver` that subscribes to the current`Maybe`.
`@NonNullMaybe<T>`	`doOnEvent(@NonNullBiConsumer<? 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.
`@NonNullMaybe<T>`	`doOnLifecycle(@NonNullConsumer<? superDisposable> onSubscribe,@NonNullAction onDispose)` Calls the appropriate`onXXX` method (shared between all`MaybeObserver`s) for the lifecycle events of the sequence (subscription, disposal).
`@NonNullMaybe<T>`	`doOnSubscribe(@NonNullConsumer<? superDisposable> onSubscribe)` Calls the shared`Consumer` with the`Disposable` sent through the`onSubscribe` for each`MaybeObserver` that subscribes to the current`Maybe`.
`@NonNullMaybe<T>`	`doOnSuccess(@NonNullConsumer<? superT> onSuccess)` Calls the shared`Consumer` with the success value sent via`onSuccess` for each`MaybeObserver` that subscribes to the current`Maybe`.
`@NonNullMaybe<T>`	`doOnTerminate(@NonNullAction onTerminate)` Returns a`Maybe` instance that calls the given onTerminate callback just before this`Maybe` completes normally or with an exception.
`static <T> @NonNullMaybe<T>`	`empty()` Returns a (singleton)`Maybe` instance that calls`onComplete` immediately.
`static <T> @NonNullMaybe<T>`	`error(@NonNullSupplier<? extendsThrowable> supplier)` Returns a`Maybe` that invokes a`MaybeObserver`'s`onError` method when the`MaybeObserver` subscribes to it.
`static <T> @NonNullMaybe<T>`	`error(@NonNullThrowable throwable)` Returns a`Maybe` that invokes a subscriber's`onError` method when the subscriber subscribes to it.
`@NonNullMaybe<T>`	`filter(@NonNullPredicate<? superT> predicate)` Filters the success item of the`Maybe` via a predicate function and emitting it if the predicate returns`true`, completing otherwise.
`<R> @NonNullMaybe<R>`	`flatMap(@NonNullFunction<? superT,? extendsMaybeSource<? extends R>> mapper)` Returns a`Maybe` that is based on applying a specified function to the item emitted by the current`Maybe`, where that function returns a`MaybeSource`.
`<R> @NonNullMaybe<R>`	`flatMap(@NonNullFunction<? superT,? extendsMaybeSource<? extends R>> onSuccessMapper,@NonNullFunction<? superThrowable,? extendsMaybeSource<? extends R>> onErrorMapper,@NonNullSupplier<? extendsMaybeSource<? extends R>> onCompleteSupplier)` Maps the`onSuccess`,`onError` or`onComplete` signals of the current`Maybe` into a`MaybeSource` and emits that`MaybeSource`'s signals.
`<U,R> @NonNullMaybe<R>`	`flatMap(@NonNullFunction<? superT,? extendsMaybeSource<? extends U>> mapper,@NonNullBiFunction<? superT,? super U,? extends R> combiner)` Returns a`Maybe` that emits the results of a specified function to the pair of values emitted by the current`Maybe` and a specified mapped`MaybeSource`.
`@NonNullCompletable`	`flatMapCompletable(@NonNullFunction<? superT,? extendsCompletableSource> mapper)` Returns a`Completable` that completes based on applying a specified function to the item emitted by the current`Maybe`, where that function returns a`Completable`.
`<R> @NonNullObservable<R>`	`flatMapObservable(@NonNullFunction<? superT,? extendsObservableSource<? extends R>> mapper)` Returns an`Observable` that is based on applying a specified function to the item emitted by the current`Maybe`, where that function returns an`ObservableSource`.
`<R> @NonNullFlowable<R>`	`flatMapPublisher(@NonNullFunction<? superT,? extendsPublisher<? extends R>> mapper)` Returns a`Flowable` that emits items based on applying a specified function to the item emitted by the current`Maybe`, where that function returns a`Publisher`.
`<R> @NonNullMaybe<R>`	`flatMapSingle(@NonNullFunction<? superT,? extendsSingleSource<? extends R>> mapper)` Returns a`Maybe` based on applying a specified function to the item emitted by the current`Maybe`, where that function returns a`Single`.
`<U> @NonNullFlowable<U>`	`flattenAsFlowable(@NonNullFunction<? superT,? extendsIterable<? extends U>> mapper)` Maps the success value of the current`Maybe` into an`Iterable` and emits its items as a`Flowable` sequence.
`<U> @NonNullObservable<U>`	`flattenAsObservable(@NonNullFunction<? superT,? extendsIterable<? extends U>> mapper)` Maps the success value of the current`Maybe` into an`Iterable` and emits its items as an`Observable` sequence.
`<R> @NonNullFlowable<R>`	`flattenStreamAsFlowable(@NonNullFunction<? superT,? extendsStream<? extends R>> mapper)` Maps the upstream succecss value into a Java`Stream` and emits its items to the downstream consumer as a`Flowable`.
`<R> @NonNullObservable<R>`	`flattenStreamAsObservable(@NonNullFunction<? superT,? extendsStream<? extends R>> mapper)` Maps the upstream succecss value into a Java`Stream` and emits its items to the downstream consumer as an`Observable`.
`static <T> @NonNullMaybe<T>`	`fromAction(@NonNullAction action)` Returns a`Maybe` instance that runs the given`Action` for each`MaybeObserver` and emits either its exception or simply completes.
`static <T> @NonNullMaybe<T>`	`fromCallable(@NonNullCallable<? 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> @NonNullMaybe<T>`	`fromCompletable(@NonNullCompletableSource completableSource)` Wraps a`CompletableSource` into a`Maybe`.
`static <T> @NonNullMaybe<T>`	`fromCompletionStage(@NonNullCompletionStage<T> stage)` Signals the completion value or error of the given (hot)`CompletionStage`-based asynchronous calculation.
`static <T> @NonNullMaybe<T>`	`fromFuture(@NonNullFuture<? extends T> future)` Converts a`Future` into a`Maybe`, treating a`null` result as an indication of emptiness.
`static <T> @NonNullMaybe<T>`	`fromFuture(@NonNullFuture<? extends T> future, long timeout,@NonNullTimeUnit unit)` Converts a`Future` into a`Maybe`, with a timeout on the`Future`.
`static <T> @NonNullMaybe<T>`	`fromObservable(@NonNullObservableSource<T> source)` Wraps an`ObservableSource` into a`Maybe` and emits the very first item or completes if the source is empty.
`static <T> @NonNullMaybe<T>`	`fromOptional(@NonNullOptional<T> optional)` Converts the existing value of the provided optional into a`just(Object)` or an empty optional into an`empty()Maybe` instance.
`static <T> @NonNullMaybe<T>`	`fromPublisher(@NonNullPublisher<T> source)` Wraps a`Publisher` into a`Maybe` and emits the very first item or completes if the source is empty.
`static <T> @NonNullMaybe<T>`	`fromRunnable(@NonNullRunnable run)` Returns a`Maybe` instance that runs the given`Runnable` for each`MaybeObserver` and emits either its unchecked exception or simply completes.
`static <T> @NonNullMaybe<T>`	`fromSingle(@NonNullSingleSource<T> single)` Wraps a`SingleSource` into a`Maybe`.
`static <T> @NonNullMaybe<T>`	`fromSupplier(@NonNullSupplier<? extends T> supplier)` Returns a`Maybe` that invokes the given`Supplier` for each individual`MaybeObserver` that subscribes and emits the resulting non-`null` item via`onSuccess` while considering a`null` result from the`Supplier` as indication for valueless completion via`onComplete`.
`@NonNullMaybe<T>`	`hide()` Hides the identity of this`Maybe` and its`Disposable`.
`@NonNullCompletable`	`ignoreElement()` Returns a`Completable` that ignores the item emitted by the current`Maybe` and only calls`onComplete` or`onError`.
`@NonNullSingle<Boolean>`	`isEmpty()` Returns a`Single` that emits`true` if the current`Maybe` is empty, otherwise`false`.
`static <T> @NonNullMaybe<T>`	`just(T item)` Returns a`Maybe` that emits a specified item.
`<R> @NonNullMaybe<R>`	`lift(@NonNullMaybeOperator<? 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> @NonNullMaybe<R>`	`map(@NonNullFunction<? superT,? extends R> mapper)` Returns a`Maybe` that applies a specified function to the item emitted by the current`Maybe` and emits the result of this function application.
`<R> @NonNullMaybe<R>`	`mapOptional(@NonNullFunction<? superT,Optional<? extends R>> mapper)` Maps the upstream success value into an`Optional` and emits the contained item if not empty.
`@NonNullSingle<Notification<T>>`	`materialize()` Maps the signal types of this`Maybe` into a`Notification` of the same kind and emits it as a`Single`'s`onSuccess` value to downstream.
`static <T> @NonNullFlowable<T>`	`merge(@NonNullIterable<? extendsMaybeSource<? extends T>> sources)` Merges an`Iterable` sequence of`MaybeSource` instances into a single`Flowable` sequence, running all`MaybeSource`s at once.
`static <T> @NonNullMaybe<T>`	`merge(@NonNullMaybeSource<? 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> @NonNullFlowable<T>`	`merge(@NonNullMaybeSource<? extends T> source1,@NonNullMaybeSource<? extends T> source2)` Flattens two`MaybeSource`s into a single`Flowable`, without any transformation.
`static <T> @NonNullFlowable<T>`	`merge(@NonNullMaybeSource<? extends T> source1,@NonNullMaybeSource<? extends T> source2,@NonNullMaybeSource<? extends T> source3)` Flattens three`MaybeSource`s into a single`Flowable`, without any transformation.
`static <T> @NonNullFlowable<T>`	`merge(@NonNullMaybeSource<? extends T> source1,@NonNullMaybeSource<? extends T> source2,@NonNullMaybeSource<? extends T> source3,@NonNullMaybeSource<? extends T> source4)` Flattens four`MaybeSource`s into a single`Flowable`, without any transformation.
`static <T> @NonNullFlowable<T>`	`merge(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources)` Merges a`Publisher` sequence of`MaybeSource` instances into a single`Flowable` sequence, running all`MaybeSource`s at once.
`static <T> @NonNullFlowable<T>`	`merge(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources, int maxConcurrency)` Merges a`Publisher` sequence of`MaybeSource` instances into a single`Flowable` sequence, running at most maxConcurrency`MaybeSource`s at once.
`static <T> @NonNullFlowable<T>`	`mergeArray(MaybeSource<? extends T>... sources)` Merges an array of`MaybeSource` instances into a single`Flowable` sequence, running all`MaybeSource`s at once.
`static <T> @NonNullFlowable<T>`	`mergeArrayDelayError(MaybeSource<? extends T>... sources)` Flattens an array of`MaybeSource`s into one`Flowable`, in a way that allows a subscriber to receive all successfully emitted items from each of the source`MaybeSource`s without being interrupted by an error notification from one of them.
`static <T> @NonNullFlowable<T>`	`mergeDelayError(@NonNullIterable<? extendsMaybeSource<? extends T>> sources)` Flattens an`Iterable` sequence of`MaybeSource`s into one`Flowable`, in a way that allows a subscriber to receive all successfully emitted items from each of the source`MaybeSource`s without being interrupted by an error notification from one of them.
`static <T> @NonNullFlowable<T>`	`mergeDelayError(@NonNullMaybeSource<? extends T> source1,@NonNullMaybeSource<? extends T> source2)` Flattens two`MaybeSource`s into one`Flowable`, in a way that allows a subscriber to receive all successfully emitted items from each of the source`MaybeSource`s without being interrupted by an error notification from one of them.
`static <T> @NonNullFlowable<T>`	`mergeDelayError(@NonNullMaybeSource<? extends T> source1,@NonNullMaybeSource<? extends T> source2,@NonNullMaybeSource<? 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`MaybeSource`s without being interrupted by an error notification from one of them.
`static <T> @NonNullFlowable<T>`	`mergeDelayError(@NonNullMaybeSource<? extends T> source1,@NonNullMaybeSource<? extends T> source2,@NonNullMaybeSource<? extends T> source3,@NonNullMaybeSource<? extends T> source4)` Flattens four`MaybeSource`s into one`Flowable`, in a way that allows a subscriber to receive all successfully emitted items from all of the source`MaybeSource`s without being interrupted by an error notification from one of them.
`static <T> @NonNullFlowable<T>`	`mergeDelayError(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources)` Flattens a`Publisher` that emits`MaybeSource`s into one`Flowable`, in a way that allows a subscriber to receive all successfully emitted items from all of the source`MaybeSource`s without being interrupted by an error notification from one of them or even the main`Publisher`.
`static <T> @NonNullFlowable<T>`	`mergeDelayError(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources, int maxConcurrency)` Flattens a`Publisher` that emits`MaybeSource`s into one`Flowable`, in a way that allows a subscriber to receive all successfully emitted items from all of the source`MaybeSource`s 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`MaybeSource`s.
`@NonNullFlowable<T>`	`mergeWith(@NonNullMaybeSource<? extendsT> other)` Flattens this`Maybe` and another`MaybeSource` into a single`Flowable`, without any transformation.
`static <T> @NonNullMaybe<T>`	`never()` Returns a`Maybe` that never sends any items or notifications to a`MaybeObserver`.
`@NonNullMaybe<T>`	`observeOn(@NonNullScheduler scheduler)` Wraps a`Maybe` to emit its item (or notify of its error) on a specified`Scheduler`, asynchronously.
`<U> @NonNullMaybe<U>`	`ofType(@NonNullClass<U> clazz)` Filters the items emitted by the current`Maybe`, only emitting its success value if that is an instance of the supplied`Class`.
`@NonNullMaybe<T>`	`onErrorComplete()` Returns a`Maybe` instance that if this`Maybe` emits an error, it will emit an`onComplete` and swallow the throwable.
`@NonNullMaybe<T>`	`onErrorComplete(@NonNullPredicate<? 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.
`@NonNullMaybe<T>`	`onErrorResumeNext(@NonNullFunction<? superThrowable,? extendsMaybeSource<? extendsT>> fallbackSupplier)` Resumes the flow with a`MaybeSource` returned for the failure`Throwable` of the current`Maybe` by a function instead of signaling the error via`onError`.
`@NonNullMaybe<T>`	`onErrorResumeWith(@NonNullMaybeSource<? extendsT> fallback)` Resumes the flow with the given`MaybeSource` when the current`Maybe` fails instead of signaling the error via`onError`.
`@NonNullMaybe<T>`	`onErrorReturn(@NonNullFunction<? superThrowable,? extendsT> itemSupplier)` Ends the flow with a success item returned by a function for the`Throwable` error signaled by the current`Maybe` instead of signaling the error via`onError`.
`@NonNullMaybe<T>`	`onErrorReturnItem(T item)` Ends the flow with the given success item when the current`Maybe` fails instead of signaling the error via`onError`.
`@NonNullMaybe<T>`	`onTerminateDetach()` Nulls out references to the upstream producer and downstream`MaybeObserver` if the sequence is terminated or downstream calls`dispose()`.
`@NonNullFlowable<T>`	`repeat()` Returns a`Flowable` that repeats the sequence of items emitted by the current`Maybe` indefinitely.
`@NonNullFlowable<T>`	`repeat(long times)` Returns a`Flowable` that repeats the sequence of items emitted by the current`Maybe` at most`count` times.
`@NonNullFlowable<T>`	`repeatUntil(@NonNullBooleanSupplier stop)` Returns a`Flowable` that repeats the sequence of items emitted by the current`Maybe` until the provided stop function returns`true`.
`@NonNullFlowable<T>`	`repeatWhen(@NonNullFunction<? superFlowable<Object>,? extendsPublisher<?>> handler)` Returns a`Flowable` that emits the same values as the current`Maybe` with the exception of an`onComplete`.
`@NonNullMaybe<T>`	`retry()` Returns a`Maybe` that mirrors the current`Maybe`, resubscribing to it if it calls`onError` (infinite retry count).
`@NonNullMaybe<T>`	`retry(@NonNullBiPredicate<? superInteger,? superThrowable> predicate)` Returns a`Maybe` that mirrors the current`Maybe`, resubscribing to it if it calls`onError` and the predicate returns`true` for that specific exception and retry count.
`@NonNullMaybe<T>`	`retry(long times)` Returns a`Maybe` that mirrors the current`Maybe`, resubscribing to it if it calls`onError` up to a specified number of retries.
`@NonNullMaybe<T>`	`retry(long times,@NonNullPredicate<? superThrowable> predicate)` Retries at most`times` or until the predicate returns`false`, whichever happens first.
`@NonNullMaybe<T>`	`retry(@NonNullPredicate<? superThrowable> predicate)` Retries the current`Maybe` if it fails and the predicate returns`true`.
`@NonNullMaybe<T>`	`retryUntil(@NonNullBooleanSupplier stop)` Retries until the given stop function returns`true`.
`@NonNullMaybe<T>`	`retryWhen(@NonNullFunction<? superFlowable<Throwable>,? extendsPublisher<?>> handler)` Returns a`Maybe` that emits the same values as the current`Maybe` with the exception of an`onError`.
`void`	`safeSubscribe(@NonNullMaybeObserver<? superT> observer)` Wraps the given`MaybeObserver`, catches any`RuntimeException`s thrown by its`MaybeObserver.onSubscribe(Disposable)`,`MaybeObserver.onSuccess(Object)`,`MaybeObserver.onError(Throwable)` or`MaybeObserver.onComplete()` methods and routes those to the global error handler via`RxJavaPlugins.onError(Throwable)`.
`static <T> @NonNullSingle<Boolean>`	`sequenceEqual(@NonNullMaybeSource<? extends T> source1,@NonNullMaybeSource<? 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> @NonNullSingle<Boolean>`	`sequenceEqual(@NonNullMaybeSource<? extends T> source1,@NonNullMaybeSource<? extends T> source2,@NonNullBiPredicate<? super T,? super T> isEqual)` Returns a`Single` that emits a`Boolean` value that indicates whether two`MaybeSource`s are the same by comparing the items emitted by each`MaybeSource` pairwise based on the results of a specified equality function.
`@NonNullFlowable<T>`	`startWith(@NonNullCompletableSource other)` Returns a`Flowable` which first runs the other`CompletableSource` then the current`Maybe` if the other completed normally.
`@NonNullFlowable<T>`	`startWith(@NonNullMaybeSource<T> other)` Returns a`Flowable` which first runs the other`MaybeSource` then the current`Maybe` if the other succeeded or completed normally.
`@NonNullObservable<T>`	`startWith(@NonNullObservableSource<T> other)` Returns an`Observable` which first delivers the events of the other`ObservableSource` then runs the current`Maybe`.
`@NonNullFlowable<T>`	`startWith(@NonNullPublisher<T> other)` Returns a`Flowable` which first delivers the events of the other`Publisher` then runs the current`Maybe`.
`@NonNullFlowable<T>`	`startWith(@NonNullSingleSource<T> other)` Returns a`Flowable` which first runs the other`SingleSource` then the current`Maybe` if the other succeeded normally.
`@NonNullDisposable`	`subscribe()` Subscribes to a`Maybe` and ignores`onSuccess` and`onComplete` emissions.
`@NonNullDisposable`	`subscribe(@NonNullConsumer<? superT> onSuccess)` Subscribes to a`Maybe` and provides a callback to handle the items it emits.
`@NonNullDisposable`	`subscribe(@NonNullConsumer<? superT> onSuccess,@NonNullConsumer<? superThrowable> onError)` Subscribes to a`Maybe` and provides callbacks to handle the items it emits and any error notification it issues.
`@NonNullDisposable`	`subscribe(@NonNullConsumer<? superT> onSuccess,@NonNullConsumer<? superThrowable> onError,@NonNullAction onComplete)` Subscribes to a`Maybe` and provides callbacks to handle the items it emits and any error or completion notification it issues.
`@NonNullDisposable`	`subscribe(@NonNullConsumer<? superT> onSuccess,@NonNullConsumer<? superThrowable> onError,@NonNullAction onComplete,@NonNullDisposableContainer container)` Wraps the given onXXX callbacks into a`DisposableMaybeObserver`, adds it to the given`DisposableContainer` and ensures, that if the upstream terminates or this particular`Disposable` is disposed, the`MaybeObserver` is removed from the given composite.
`void`	`subscribe(@NonNullMaybeObserver<? superT> observer)` Subscribes the given`MaybeObserver` to this`MaybeSource` instance.
`protected abstract void`	`subscribeActual(@NonNullMaybeObserver<? superT> observer)` Implement this method in subclasses to handle the incoming`MaybeObserver`s.
`@NonNullMaybe<T>`	`subscribeOn(@NonNullScheduler 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.
`@NonNullMaybe<T>`	`switchIfEmpty(@NonNullMaybeSource<? extendsT> other)` Returns a`Maybe` that emits the items emitted by the current`Maybe` or the items of an alternate`MaybeSource` if the current`Maybe` is empty.
`@NonNullSingle<T>`	`switchIfEmpty(@NonNullSingleSource<? extendsT> other)` Returns a`Single` that emits the items emitted by the current`Maybe` or the item of an alternate`SingleSource` if the current`Maybe` is empty.
`static <T> @NonNullFlowable<T>`	`switchOnNext(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources)` Switches between`MaybeSource`s emitted by the source`Publisher` whenever a new`MaybeSource` is emitted, disposing the previously running`MaybeSource`, exposing the success items as a`Flowable` sequence.
`static <T> @NonNullFlowable<T>`	`switchOnNextDelayError(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources)` Switches between`MaybeSource`s emitted by the source`Publisher` whenever a new`MaybeSource` is emitted, disposing the previously running`MaybeSource`, exposing the success items as a`Flowable` sequence and delaying all errors from all of them until all terminate.
`<U> @NonNullMaybe<T>`	`takeUntil(@NonNullMaybeSource<U> other)` Returns a`Maybe` that emits the items emitted by the current`Maybe` until a second`MaybeSource` emits an item.
`<U> @NonNullMaybe<T>`	`takeUntil(@NonNullPublisher<U> other)` Returns a`Maybe` that emits the item emitted by the current`Maybe` until a second`Publisher` emits an item.
`@NonNullTestObserver<T>`	`test()` Creates a`TestObserver` and subscribes it to this`Maybe`.
`@NonNullTestObserver<T>`	`test(boolean dispose)` Creates a`TestObserver` optionally in cancelled state, then subscribes it to this`Maybe`.
`@NonNullMaybe<Timed<T>>`	`timeInterval()` Measures the time (in milliseconds) between the subscription and success item emission of the current`Maybe` and signals it as a tuple (`Timed`) success value.
`@NonNullMaybe<Timed<T>>`	`timeInterval(@NonNullScheduler scheduler)` Measures the time (in milliseconds) between the subscription and success item emission of the current`Maybe` and signals it as a tuple (`Timed`) success value.
`@NonNullMaybe<Timed<T>>`	`timeInterval(@NonNullTimeUnit unit)` Measures the time between the subscription and success item emission of the current`Maybe` and signals it as a tuple (`Timed`) success value.
`@NonNullMaybe<Timed<T>>`	`timeInterval(@NonNullTimeUnit unit,@NonNullScheduler scheduler)` Measures the time between the subscription and success item emission of the current`Maybe` and signals it as a tuple (`Timed`) success value.
`@NonNullMaybe<T>`	`timeout(long timeout,@NonNullTimeUnit unit)` Returns a`Maybe` that mirrors the current`Maybe` but applies a timeout policy for each emitted item.
`@NonNullMaybe<T>`	`timeout(long timeout,@NonNullTimeUnit unit,@NonNullMaybeSource<? extendsT> fallback)` Returns a`Maybe` that mirrors the current`Maybe` but applies a timeout policy for each emitted item.
`@NonNullMaybe<T>`	`timeout(long timeout,@NonNullTimeUnit unit,@NonNullScheduler scheduler)` Returns a`Maybe` that mirrors the current`Maybe` but applies a timeout policy for each emitted item, where this policy is governed on a specified`Scheduler`.
`@NonNullMaybe<T>`	`timeout(long timeout,@NonNullTimeUnit unit,@NonNullScheduler scheduler,@NonNullMaybeSource<? extendsT> fallback)` Returns a`Maybe` that mirrors the current`Maybe` but applies a timeout policy for each emitted item using a specified`Scheduler`.
`<U> @NonNullMaybe<T>`	`timeout(@NonNullMaybeSource<U> timeoutIndicator)` If the current`Maybe` didn't signal an event before the`timeoutIndicatorMaybeSource` signals, a`TimeoutException` is signaled instead.
`<U> @NonNullMaybe<T>`	`timeout(@NonNullMaybeSource<U> timeoutIndicator,@NonNullMaybeSource<? 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> @NonNullMaybe<T>`	`timeout(@NonNullPublisher<U> timeoutIndicator)` If the current`Maybe` source didn't signal an event before the`timeoutIndicatorPublisher` signals, a`TimeoutException` is signaled instead.
`<U> @NonNullMaybe<T>`	`timeout(@NonNullPublisher<U> timeoutIndicator,@NonNullMaybeSource<? 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.
`static@NonNullMaybe<Long>`	`timer(long delay,@NonNullTimeUnit unit)` Returns a`Maybe` that emits`0L` after a specified delay.
`static@NonNullMaybe<Long>`	`timer(long delay,@NonNullTimeUnit unit,@NonNullScheduler scheduler)` Returns a`Maybe` that emits`0L` after a specified delay on a specified`Scheduler`.
`@NonNullMaybe<Timed<T>>`	`timestamp()` Combines the success value from the current`Maybe` with the current time (in milliseconds) of its reception, using the`computationScheduler` as time source, then signals them as a`Timed` instance.
`@NonNullMaybe<Timed<T>>`	`timestamp(@NonNullScheduler scheduler)` Combines the success value from the current`Maybe` with the current time (in milliseconds) of its reception, using the given`Scheduler` as time source, then signals them as a`Timed` instance.
`@NonNullMaybe<Timed<T>>`	`timestamp(@NonNullTimeUnit unit)` Combines the success value from the current`Maybe` with the current time of its reception, using the`computationScheduler` as time source, then signals it as a`Timed` instance.
`@NonNullMaybe<Timed<T>>`	`timestamp(@NonNullTimeUnit unit,@NonNullScheduler scheduler)` Combines the success value from the current`Maybe` with the current time of its reception, using the given`Scheduler` as time source, then signals it as a`Timed` instance.
`<R> R`	`to(@NonNullMaybeConverter<T,? extends R> converter)` Calls the specified converter function during assembly time and returns its resulting value.
`@NonNullCompletionStage<T>`	`toCompletionStage()` Signals the upstream success item (or a`NoSuchElementException` if the upstream is empty) via a`CompletionStage`.
`@NonNullCompletionStage<T>`	`toCompletionStage(T defaultItem)` Signals the upstream success item (or the default item if the upstream is empty) via a`CompletionStage`.
`@NonNullFlowable<T>`	`toFlowable()` Converts this`Maybe` into a backpressure-aware`Flowable` instance composing cancellation through.
`@NonNullFuture<T>`	`toFuture()` Returns a`Future` representing the single value emitted by the current`Maybe` or`null` if the current`Maybe` is empty.
`@NonNullObservable<T>`	`toObservable()` Converts this`Maybe` into an`Observable` instance composing disposal through.
`@NonNullSingle<T>`	`toSingle()` Converts this`Maybe` into a`Single` instance composing disposal through and turning an empty`Maybe` into a signal of`NoSuchElementException`.
`static <T> @NonNullMaybe<T>`	`unsafeCreate(@NonNullMaybeSource<T> onSubscribe)` Advanced use only: creates a`Maybe` instance without any safeguards by using a callback that is called with a`MaybeObserver`.
`@NonNullMaybe<T>`	`unsubscribeOn(@NonNullScheduler 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> @NonNullMaybe<T>`	`using(@NonNullSupplier<? extends D> resourceSupplier,@NonNullFunction<? super D,? extendsMaybeSource<? extends T>> sourceSupplier,@NonNullConsumer<? super D> resourceCleanup)` Constructs a`Maybe` that creates a dependent resource object which is disposed of when the generated`MaybeSource` terminates or the downstream calls dispose().
`static <T,D> @NonNullMaybe<T>`	`using(@NonNullSupplier<? extends D> resourceSupplier,@NonNullFunction<? super D,? extendsMaybeSource<? extends T>> sourceSupplier,@NonNullConsumer<? super D> resourceCleanup, boolean eager)` Constructs a`Maybe` that creates a dependent resource object which is disposed first ({code eager == true}) when the generated`MaybeSource` terminates or the downstream disposes; or after ({code eager == false}).
`static <T> @NonNullMaybe<T>`	`wrap(@NonNullMaybeSource<T> source)` Wraps a`MaybeSource` instance into a new`Maybe` instance if not already a`Maybe` instance.
`static <T,R> @NonNullMaybe<R>`	`zip(@NonNullIterable<? extendsMaybeSource<? extends T>> sources,@NonNullFunction<? 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`MaybeSource`s.
`static <T1,T2,R> @NonNullMaybe<R>`	`zip(@NonNullMaybeSource<? extends T1> source1,@NonNullMaybeSource<? extends T2> source2,@NonNullBiFunction<? 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`MaybeSource`s.
`static <T1,T2,T3,R> @NonNullMaybe<R>`	`zip(@NonNullMaybeSource<? extends T1> source1,@NonNullMaybeSource<? extends T2> source2,@NonNullMaybeSource<? extends T3> source3,@NonNullFunction3<? 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`MaybeSource`s.
`static <T1,T2,T3,T4,R> @NonNullMaybe<R>`	`zip(@NonNullMaybeSource<? extends T1> source1,@NonNullMaybeSource<? extends T2> source2,@NonNullMaybeSource<? extends T3> source3,@NonNullMaybeSource<? extends T4> source4,@NonNullFunction4<? 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`MaybeSource`s.
`static <T1,T2,T3,T4,T5,R> @NonNullMaybe<R>`	`zip(@NonNullMaybeSource<? extends T1> source1,@NonNullMaybeSource<? extends T2> source2,@NonNullMaybeSource<? extends T3> source3,@NonNullMaybeSource<? extends T4> source4,@NonNullMaybeSource<? extends T5> source5,@NonNullFunction5<? 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`MaybeSource`s.
`static <T1,T2,T3,T4,T5,T6,R> @NonNullMaybe<R>`	`zip(@NonNullMaybeSource<? extends T1> source1,@NonNullMaybeSource<? extends T2> source2,@NonNullMaybeSource<? extends T3> source3,@NonNullMaybeSource<? extends T4> source4,@NonNullMaybeSource<? extends T5> source5,@NonNullMaybeSource<? extends T6> source6,@NonNullFunction6<? 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`MaybeSource`s.
`static <T1,T2,T3,T4,T5,T6,T7,R> @NonNullMaybe<R>`	`zip(@NonNullMaybeSource<? extends T1> source1,@NonNullMaybeSource<? extends T2> source2,@NonNullMaybeSource<? extends T3> source3,@NonNullMaybeSource<? extends T4> source4,@NonNullMaybeSource<? extends T5> source5,@NonNullMaybeSource<? extends T6> source6,@NonNullMaybeSource<? extends T7> source7,@NonNullFunction7<? 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`MaybeSource`s.
`static <T1,T2,T3,T4,T5,T6,T7,T8,R> @NonNullMaybe<R>`	`zip(@NonNullMaybeSource<? extends T1> source1,@NonNullMaybeSource<? extends T2> source2,@NonNullMaybeSource<? extends T3> source3,@NonNullMaybeSource<? extends T4> source4,@NonNullMaybeSource<? extends T5> source5,@NonNullMaybeSource<? extends T6> source6,@NonNullMaybeSource<? extends T7> source7,@NonNullMaybeSource<? extends T8> source8,@NonNullFunction8<? 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`MaybeSource`s.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> @NonNullMaybe<R>`	zip(@NonNullMaybeSource<? extends T1> source1,@NonNullMaybeSource<? extends T2> source2,@NonNullMaybeSource<? extends T3> source3,@NonNullMaybeSource<? extends T4> source4,@NonNullMaybeSource<? extends T5> source5,@NonNullMaybeSource<? extends T6> source6,@NonNullMaybeSource<? extends T7> source7,@NonNullMaybeSource<? extends T8> source8,@NonNullMaybeSource<? extends T9> source9,@NonNullFunction9<? 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`MaybeSource`s.
`static <T,R> @NonNullMaybe<R>`	`zipArray(@NonNullFunction<? 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`MaybeSource`s.
`<U,R> @NonNullMaybe<R>`	`zipWith(@NonNullMaybeSource<? extends U> other,@NonNullBiFunction<? 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> @NonNullMaybe<T> amb(@NonNullIterable<? extendsMaybeSource<? extends T>> sources)
```
 Runs multipleMaybeSources provided by anIterable sequence 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 - theIterable sequence of sources. A subscription to each source will occur in the same order as in theIterable.
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifsources isnull
 - ambArray
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNull@SafeVarargspublic static <T> @NonNullMaybe<T> ambArray(@NonNullMaybeSource<? extends T>... sources)
```
 Runs multipleMaybeSources 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 newMaybe instance
 Throws:
 NullPointerException - ifsources isnull
 - concat
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullFlowable<T> concat(@NonNullIterable<? extendsMaybeSource<? extends T>> sources)
```
 Concatenate the single values, in a non-overlapping fashion, of theMaybeSource sources provided by anIterable sequence as aFlowable 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 - theIterable sequence ofMaybeSource instances
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifsources isnull
 - concat
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullFlowable<T> concat(@NonNullMaybeSource<? extends T> source1,@NonNullMaybeSource<? extends T> source2)
```
 Returns aFlowable that emits the items emitted by twoMaybeSources, 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 - aMaybeSource to be concatenated
 source2 - aMaybeSource to be concatenated
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifsource1 orsource2 isnull
 See Also:
 ReactiveX operators documentation: Concat
 - concat
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullFlowable<T> concat(@NonNullMaybeSource<? extends T> source1,@NonNullMaybeSource<? extends T> source2,@NonNullMaybeSource<? extends T> source3)
```
 Returns aFlowable that emits the items emitted by threeMaybeSources, 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 - aMaybeSource to be concatenated
 source2 - aMaybeSource to be concatenated
 source3 - aMaybeSource to be concatenated
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifsource1,source2 orsource3 isnull
 See Also:
 ReactiveX operators documentation: Concat
 - concat
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullFlowable<T> concat(@NonNullMaybeSource<? extends T> source1,@NonNullMaybeSource<? extends T> source2,@NonNullMaybeSource<? extends T> source3,@NonNullMaybeSource<? extends T> source4)
```
 Returns aFlowable that emits the items emitted by fourMaybeSources, 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 - aMaybeSource to be concatenated
 source2 - aMaybeSource to be concatenated
 source3 - aMaybeSource to be concatenated
 source4 - aMaybeSource to be concatenated
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifsource1,source2,source3 orsource4 isnull
 See Also:
 ReactiveX operators documentation: Concat
 - concat
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic static <T> @NonNullFlowable<T> concat(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources)
```
 Concatenate the single values, in a non-overlapping fashion, of theMaybeSource sources provided by aPublisher sequence as aFlowable 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 signaled.
 Scheduler:
 concat does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 sources - thePublisher ofMaybeSource instances
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifsources isnull
 - concat
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullFlowable<T> concat(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources, int prefetch)
```
 Concatenate the single values, in a non-overlapping fashion, of theMaybeSource sources provided by aPublisher sequence as aFlowable 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 signaled.
 Scheduler:
 concat does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 sources - thePublisher ofMaybeSource instances
 prefetch - the number ofMaybeSources to prefetch from thePublisher
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifsources isnull
 IllegalArgumentException - ifprefetch is non-positive
 - concatArray
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")@SafeVarargspublic static <T> @NonNullFlowable<T> concatArray(@NonNullMaybeSource<? extends T>... sources)
```
 Concatenate the single values, in a non-overlapping fashion, of theMaybeSource sources in the array as aFlowable sequence.
 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 ofMaybeSource instances
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifsources isnull
 - concatArrayDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")@SafeVarargs@NonNullpublic static <T> @NonNullFlowable<T> concatArrayDelayError(@NonNullMaybeSource<? extends T>... sources)
```
 Concatenates a variable number ofMaybeSource sources and delays errors from any of them till all terminate as aFlowable sequence.
 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 newFlowable instance
 Throws:
 NullPointerException - ifsources isnull
 - concatArrayEager
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")@NonNull@SafeVarargspublic static <T> @NonNullFlowable<T> concatArrayEager(@NonNullMaybeSource<? extends T>... sources)
```
 Concatenates a sequence ofMaybeSource eagerly into aFlowable sequence.
 Eager concatenation means that once an observer subscribes, this operator subscribes to all of the sourceMaybeSources. The operator buffers the value emitted by theseMaybeSources 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 ofMaybeSources that need to be eagerly concatenated
 Returns:
 the newFlowable instance with the specified concatenation behavior
 Throws:
 NullPointerException - ifsources isnull
 - concatArrayEagerDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")@NonNull@SafeVarargspublic static <T> @NonNullFlowable<T> concatArrayEagerDelayError(@NonNullMaybeSource<? extends T>... sources)
```
 Concatenates a sequence ofMaybeSource eagerly into aFlowable sequence.
 Eager concatenation means that once an observer subscribes, this operator subscribes to all of the sourceMaybeSources. The operator buffers the value emitted by theseMaybeSources 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 ofMaybeSources that need to be eagerly concatenated
 Returns:
 the newFlowable instance with the specified concatenation behavior
 Throws:
 NullPointerException - ifsources isnull
 Since:
 3.0.0
 - concatDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullFlowable<T> concatDelayError(@NonNullIterable<? extendsMaybeSource<? extends T>> sources)
```
 Concatenates theIterable sequence ofMaybeSources into a single sequence by subscribing to eachMaybeSource, one after the other, one at a time and delays any errors till the all innerMaybeSources terminate as aFlowable sequence.
 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 - theIterable sequence ofMaybeSources
 Returns:
 the newFlowable with the concatenating behavior
 Throws:
 NullPointerException - ifsources isnull
 - concatDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic static <T> @NonNullFlowable<T> concatDelayError(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources)
```
 Concatenates thePublisher sequence ofMaybeSources into a single sequence by subscribing to each innerMaybeSource, one after the other, one at a time and delays any errors till the all inner and the outerPublisher terminate as aFlowable sequence.
 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 - thePublisher sequence ofMaybeSources
 Returns:
 the newFlowable with the concatenating behavior
 Throws:
 NullPointerException - ifsources isnull
 - concatDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic static <T> @NonNullFlowable<T> concatDelayError(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources, int prefetch)
```
 Concatenates thePublisher sequence ofMaybeSources into a single sequence by subscribing to each innerMaybeSource, one after the other, one at a time and delays any errors till the all inner and the outerPublisher terminate as aFlowable sequence.
 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 - thePublisher sequence ofMaybeSources
 prefetch - The number of upstream items to prefetch so that fresh items are ready to be mapped when a previousMaybeSource terminates. The operator replenishes after half of the prefetch amount has been consumed and turned intoMaybeSources.
 Returns:
 the newFlowable with the concatenating behavior
 Throws:
 NullPointerException - ifsources isnull
 IllegalArgumentException - ifprefetch is non-positive
 Since:
 3.0.0
 - concatEager
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic static <T> @NonNullFlowable<T> concatEager(@NonNullIterable<? extendsMaybeSource<? extends T>> sources)
```
 Concatenates a sequence ofMaybeSources eagerly into aFlowable sequence.
 Eager concatenation means that once an observer subscribes, this operator subscribes to all of the sourceMaybeSources. The operator buffers the values emitted by theseMaybeSources 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 ofMaybeSource that need to be eagerly concatenated
 Returns:
 the newFlowable instance with the specified concatenation behavior
 Throws:
 NullPointerException - ifsources isnull
 - concatEager
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic static <T> @NonNullFlowable<T> concatEager(@NonNullIterable<? extendsMaybeSource<? extends T>> sources, int maxConcurrency)
```
 Concatenates a sequence ofMaybeSources eagerly into aFlowable sequence and runs a limited number of the inner sequences at once.
 Eager concatenation means that once an observer subscribes, this operator subscribes to all of the sourceMaybeSources. The operator buffers the values emitted by theseMaybeSources 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 ofMaybeSource that need to be eagerly concatenated
 maxConcurrency - the maximum number of concurrently running innerMaybeSources;Integer.MAX_VALUE is interpreted as all innerMaybeSources can be active at the same time
 Returns:
 the newFlowable instance with the specified concatenation behavior
 Throws:
 NullPointerException - ifsources isnull
 IllegalArgumentException - ifmaxConcurrency is non-positive
 Since:
 3.0.0
 - concatEager
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic static <T> @NonNullFlowable<T> concatEager(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources)
```
 Concatenates aPublisher sequence ofMaybeSources eagerly into aFlowable sequence.
 Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the emitted sourceMaybeSources as they are observed. The operator buffers the values emitted by theseMaybeSources and then drains them in order, each one after the previous one completes.
 Backpressure:
 Backpressure is honored towards the downstream and the outerPublisher 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 ofMaybeSources that need to be eagerly concatenated
 Returns:
 the newFlowable instance with the specified concatenation behavior
 Throws:
 NullPointerException - ifsources isnull
 - concatEager
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic static <T> @NonNullFlowable<T> concatEager(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources, int maxConcurrency)
```
 Concatenates aPublisher sequence ofMaybeSources eagerly into aFlowable sequence, running at most the given number of innerMaybeSources at once.
 Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the emitted sourceMaybeSources as they are observed. The operator buffers the values emitted by theseMaybeSources and then drains them in order, each one after the previous one completes.
 Backpressure:
 Backpressure is honored towards the downstream and the outerPublisher 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 ofMaybeSources that need to be eagerly concatenated
 maxConcurrency - the maximum number of concurrently running innerMaybeSources;Integer.MAX_VALUE is interpreted as all innerMaybeSources can be active at the same time
 Returns:
 the newFlowable instance with the specified concatenation behavior
 Throws:
 NullPointerException - ifsources isnull
 IllegalArgumentException - ifmaxConcurrency is non-positive
 Since:
 3.0.0
 - concatEagerDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic static <T> @NonNullFlowable<T> concatEagerDelayError(@NonNullIterable<? extendsMaybeSource<? extends T>> sources)
```
 Concatenates a sequence ofMaybeSources eagerly into aFlowable sequence, delaying errors until all innerMaybeSources terminate.
 Eager concatenation means that once an observer subscribes, this operator subscribes to all of the sourceMaybeSources. The operator buffers the values emitted by theseMaybeSources 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 ofMaybeSource that need to be eagerly concatenated
 Returns:
 the newFlowable instance with the specified concatenation behavior
 Throws:
 NullPointerException - ifsources isnull
 Since:
 3.0.0
 - concatEagerDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic static <T> @NonNullFlowable<T> concatEagerDelayError(@NonNullIterable<? extendsMaybeSource<? extends T>> sources, int maxConcurrency)
```
 Concatenates a sequence ofMaybeSources eagerly into aFlowable sequence, delaying errors until all innerMaybeSources terminate and runs a limited number of innerMaybeSources at once.
 Eager concatenation means that once an observer subscribes, this operator subscribes to all of the sourceMaybeSources. The operator buffers the values emitted by theseMaybeSources 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 ofMaybeSource that need to be eagerly concatenated
 maxConcurrency - the maximum number of concurrently running innerMaybeSources;Integer.MAX_VALUE is interpreted as all innerMaybeSources can be active at the same time
 Returns:
 the newFlowable instance with the specified concatenation behavior
 Throws:
 NullPointerException - ifsources isnull
 IllegalArgumentException - ifmaxConcurrency is non-positive
 Since:
 3.0.0
 - concatEagerDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic static <T> @NonNullFlowable<T> concatEagerDelayError(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources)
```
 Concatenates aPublisher sequence ofMaybeSources eagerly into aFlowable sequence, delaying errors until all the inner and the outer sequence terminate.
 Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the emitted sourceMaybeSources as they are observed. The operator buffers the values emitted by theseMaybeSources and then drains them in order, each one after the previous one completes.
 Backpressure:
 Backpressure is honored towards the downstream and the outerPublisher 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 ofMaybeSources that need to be eagerly concatenated
 Returns:
 the newFlowable instance with the specified concatenation behavior
 Throws:
 NullPointerException - ifsources isnull
 Since:
 3.0.0
 - concatEagerDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic static <T> @NonNullFlowable<T> concatEagerDelayError(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources, int maxConcurrency)
```
 Concatenates aPublisher sequence ofMaybeSources eagerly into aFlowable sequence, delaying errors until all the inner and the outer sequence terminate and runs a limited number of the innerMaybeSources at once.
 Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the emitted sourceMaybeSources as they are observed. The operator buffers the values emitted by theseMaybeSources and then drains them in order, each one after the previous one completes.
 Backpressure:
 Backpressure is honored towards the downstream and the outerPublisher 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 ofMaybeSources that need to be eagerly concatenated
 maxConcurrency - the maximum number of concurrently running innerMaybeSources;Integer.MAX_VALUE is interpreted as all innerMaybeSources can be active at the same time
 Returns:
 the newFlowable instance with the specified concatenation behavior
 Throws:
 NullPointerException - ifsources isnull
 IllegalArgumentException - ifmaxConcurrency is non-positive
 Since:
 3.0.0
 - create
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullMaybe<T> create(@NonNullMaybeOnSubscribe<T> onSubscribe)
```
 Provides an API (via a coldMaybe) 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); });
```
 Whenever aMaybeObserver subscribes to the returnedMaybe, the providedMaybeOnSubscribe callback is invoked with a fresh instance of aMaybeEmitter that will interact only with that specificMaybeObserver. If thisMaybeObserver disposes the flow (makingMaybeEmitter.isDisposed() returntrue), other observers subscribed to the same returnedMaybe are not affected.
 Scheduler:
 create does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 onSubscribe - the emitter that is called when aMaybeObserver subscribes to the returnedMaybe
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifonSubscribe isnull
 See Also:
 MaybeOnSubscribe,Cancellable
 - defer
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullMaybe<T> defer(@NonNullSupplier<? extendsMaybeSource<? extends T>> supplier)
```
 Calls aSupplier for each individualMaybeObserver to return the actualMaybeSource source to be subscribed to.
 Scheduler:
 defer does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 supplier - theSupplier that is called for each individualMaybeObserver and returns aMaybeSource instance to subscribe to
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifsupplier isnull
 - empty
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic static <T> @NonNullMaybe<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 sharedMaybe instance
 - error
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullMaybe<T> error(@NonNullThrowable throwable)
```
 Returns aMaybe 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 theMaybe
 Parameters:
 throwable - the particularThrowable to pass toonError
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifthrowable isnull
 See Also:
 ReactiveX operators documentation: Throw
 - error
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullMaybe<T> error(@NonNullSupplier<? extendsThrowable> supplier)
```
 Returns aMaybe that invokes aMaybeObserver'sonError method when theMaybeObserver subscribes to it.
 Scheduler:
 error does not operate by default on a particularScheduler.
 Type Parameters:
 T - the type of the items (ostensibly) emitted by theMaybe
 Parameters:
 supplier - aSupplier factory to return aThrowable for each individualMaybeObserver
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifsupplier isnull
 See Also:
 ReactiveX operators documentation: Throw
 - fromAction
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullMaybe<T> fromAction(@NonNullAction action)
```
 Returns aMaybe instance that runs the givenAction for eachMaybeObserver 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 the resultingMaybe 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:
 action - theAction to run for eachMaybeObserver
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifaction isnull
 - fromCompletable
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullMaybe<T> fromCompletable(@NonNullCompletableSource completableSource)
```
 Wraps aCompletableSource into aMaybe.
 Scheduler:
 fromCompletable does not operate by default on a particularScheduler.
 Type Parameters:
 T - the target type
 Parameters:
 completableSource - theCompletableSource to convert from
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifcompletableSource isnull
 - fromSingle
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullMaybe<T> fromSingle(@NonNullSingleSource<T> single)
```
 Wraps aSingleSource into aMaybe.
 Scheduler:
 fromSingle does not operate by default on a particularScheduler.
 Type Parameters:
 T - the target type
 Parameters:
 single - theSingleSource to convert from
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifsingle isnull
 - fromCallable
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullMaybe<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:
 the newMaybe instance
 Throws:
 NullPointerException - ifcallable isnull
 See Also:
 defer(Supplier),fromSupplier(Supplier)
 - fromFuture
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullMaybe<T> fromFuture(@NonNullFuture<? extends T> future)
```
 Converts aFuture into aMaybe, treating anull result as an indication of emptiness.
 The operator callsFuture.get(), which is a blocking method, on the subscription thread. It is recommended applyingsubscribeOn(Scheduler) to move this blocking wait to a background thread, and if theScheduler supports it, interrupt the wait when the flow is disposed.
 Unlike 1.x, disposing theMaybe 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 resultingMaybe
 Parameters:
 future - the sourceFuture
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - iffuture isnull
 See Also:
 ReactiveX operators documentation: From,fromCompletionStage(CompletionStage)
 - fromFuture
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullMaybe<T> fromFuture(@NonNullFuture<? extends T> future, long timeout,@NonNullTimeUnit unit)
```
 Converts aFuture into aMaybe, with a timeout on theFuture.
 The operator callsFuture.get(long, TimeUnit), which is a blocking method, on the subscription thread. It is recommended applyingsubscribeOn(Scheduler) to move this blocking wait to a background thread, and if theScheduler supports it, interrupt the wait when the flow is disposed.
 Unlike 1.x, disposing theMaybe won't cancel the future. If necessary, one can use composition to achieve the cancellation effect:futureMaybe.doOnCancel(() -> 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 resultingMaybe
 Parameters:
 future - the sourceFuture
 timeout - the maximum time to wait before callingget
 unit - theTimeUnit of thetimeout argument
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - iffuture orunit isnull
 See Also:
 ReactiveX operators documentation: From,fromCompletionStage(CompletionStage)
 - fromObservable
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullMaybe<T> fromObservable(@NonNullObservableSource<T> source)
```
 Wraps anObservableSource into aMaybe and emits the very first item or completes if the source is empty.
 Scheduler:
 fromObservable does not operate by default on a particularScheduler.
 Type Parameters:
 T - the target type
 Parameters:
 source - theObservableSource to convert from
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifsource isnull
 Since:
 3.0.0
 - fromPublisher
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")@BackpressureSupport(value=UNBOUNDED_IN)public static <T> @NonNullMaybe<T> fromPublisher(@NonNullPublisher<T> source)
```
 Wraps aPublisher into aMaybe and emits the very first item or completes if the source is empty.
 Backpressure:
 The operator consumes the givenPublisher in an unbounded manner (requestingLong.MAX_VALUE) but cancels it after one item received.
 Scheduler:
 fromPublisher does not operate by default on a particularScheduler.
 Type Parameters:
 T - the target type
 Parameters:
 source - thePublisher to convert from
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifsource isnull
 Since:
 3.0.0
 - fromRunnable
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullMaybe<T> fromRunnable(@NonNullRunnable run)
```
 Returns aMaybe instance that runs the givenRunnable for eachMaybeObserver and emits either its unchecked exception or simply completes.
 If the code to be wrapped needs to throw a checked or more broaderThrowable exception, that exception has to be converted to an unchecked exception by the wrapped code itself. Alternatively, use thefromAction(Action) method which allows the wrapped code to throw anyThrowable exception and will signal it to observers as-is.
 Scheduler:
 fromRunnable does not operate by default on a particularScheduler.
 Error handling:
 If theRunnable 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 - theRunnable to run for eachMaybeObserver
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifrun isnull
 See Also:
 fromAction(Action)
 - fromSupplier
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullMaybe<T> fromSupplier(@NonNullSupplier<? extends T> supplier)
```
 Returns aMaybe that invokes the givenSupplier for each individualMaybeObserver that subscribes and emits the resulting non-null item viaonSuccess while considering anull result from theSupplier as indication for valueless completion viaonComplete.
 This operator allows you to defer the execution of the givenSupplier until aMaybeObserver subscribes to the returnedMaybe. In other terms, this source operator evaluates the givenSupplier "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 theirSupplier isnull while thisfromSupplier considers it to indicate the returnedMaybe is empty.
 Scheduler:
 fromSupplier does not operate by default on a particularScheduler.
 Error handling:
 Any non-fatal exception thrown bySupplier.get() 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:
 supplier - aSupplier instance whose execution should be deferred and performed for each individualMaybeObserver that subscribes to the returnedMaybe.
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifsupplier isnull
 Since:
 3.0.0
 See Also:
 defer(Supplier),fromCallable(Callable)
 - just
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullMaybe<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:
 the newMaybe instance
 Throws:
 NullPointerException - ifitem isnull
 See Also:
 ReactiveX operators documentation: Just
 - merge
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic static <T> @NonNullFlowable<T> merge(@NonNullIterable<? extendsMaybeSource<? extends T>> sources)
```
 Merges anIterable sequence ofMaybeSource instances into a singleFlowable sequence, running allMaybeSources 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 - theIterable sequence ofMaybeSource sources
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifsources isnull
 See Also:
 mergeDelayError(Iterable)
 - merge
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic static <T> @NonNullFlowable<T> merge(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources)
```
 Merges aPublisher sequence ofMaybeSource instances into a singleFlowable sequence, running allMaybeSources 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 - theFlowable sequence ofMaybeSource sources
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifsources isnull
 See Also:
 mergeDelayError(Publisher)
 - merge
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullFlowable<T> merge(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources, int maxConcurrency)
```
 Merges aPublisher sequence ofMaybeSource instances into a singleFlowable sequence, running at most maxConcurrencyMaybeSources 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 - theFlowable sequence ofMaybeSource sources
 maxConcurrency - the maximum number of concurrently runningMaybeSources
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifsources isnull
 IllegalArgumentException - ifmaxConcurrency is non-positive
 See Also:
 mergeDelayError(Publisher, int)
 - merge
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullMaybe<T> merge(@NonNullMaybeSource<? 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:
 the newMaybe instance
 Throws:
 NullPointerException - ifsource isnull
 See Also:
 ReactiveX operators documentation: Merge
 - merge
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullFlowable<T> merge(@NonNullMaybeSource<? extends T> source1,@NonNullMaybeSource<? extends T> source2)
```
 Flattens twoMaybeSources into a singleFlowable, without any transformation.
 You can combine items emitted by multipleMaybeSources so that they appear as a singleFlowable, 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 - aMaybeSource to be merged
 source2 - aMaybeSource to be merged
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifsource1 orsource2 isnull
 See Also:
 ReactiveX operators documentation: Merge,mergeDelayError(MaybeSource, MaybeSource)
 - merge
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullFlowable<T> merge(@NonNullMaybeSource<? extends T> source1,@NonNullMaybeSource<? extends T> source2,@NonNullMaybeSource<? extends T> source3)
```
 Flattens threeMaybeSources into a singleFlowable, without any transformation.
 You can combine items emitted by multipleMaybeSources so that they appear as a singleFlowable, 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 - aMaybeSource to be merged
 source2 - aMaybeSource to be merged
 source3 - aMaybeSource to be merged
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifsource1,source2 orsource3 isnull
 See Also:
 ReactiveX operators documentation: Merge,mergeDelayError(MaybeSource, MaybeSource, MaybeSource)
 - merge
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullFlowable<T> merge(@NonNullMaybeSource<? extends T> source1,@NonNullMaybeSource<? extends T> source2,@NonNullMaybeSource<? extends T> source3,@NonNullMaybeSource<? extends T> source4)
```
 Flattens fourMaybeSources into a singleFlowable, without any transformation.
 You can combine items emitted by multipleMaybeSources so that they appear as a singleFlowable, 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 - aMaybeSource to be merged
 source2 - aMaybeSource to be merged
 source3 - aMaybeSource to be merged
 source4 - aMaybeSource to be merged
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifsource1,source2,source3 orsource4 isnull
 See Also:
 ReactiveX operators documentation: Merge,mergeDelayError(MaybeSource, MaybeSource, MaybeSource, MaybeSource)
 - mergeArray
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")@SafeVarargspublic static <T> @NonNullFlowable<T> mergeArray(MaybeSource<? extends T>... sources)
```
 Merges an array ofMaybeSource instances into a singleFlowable sequence, running allMaybeSources 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 ofMaybeSource sources
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifsources isnull
 See Also:
 mergeArrayDelayError(MaybeSource...)
 - mergeArrayDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")@SafeVarargs@NonNullpublic static <T> @NonNullFlowable<T> mergeArrayDelayError(@NonNullMaybeSource<? extends T>... sources)
```
 Flattens an array ofMaybeSources into oneFlowable, in a way that allows a subscriber to receive all successfully emitted items from each of the sourceMaybeSources without being interrupted by an error notification from one of them.
 This behaves likemerge(Publisher) except that if any of the mergedMaybeSources notify of an error viaonError,mergeArrayDelayError will refrain from propagating that error notification until all of the mergedMaybeSources have finished emitting items.
 Even if multiple mergedMaybeSources sendonError notifications,mergeArrayDelayError 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 array ofMaybeSources
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifsources isnull
 See Also:
 ReactiveX operators documentation: Merge
 - mergeDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic static <T> @NonNullFlowable<T> mergeDelayError(@NonNullIterable<? extendsMaybeSource<? extends T>> sources)
```
 Flattens anIterable sequence ofMaybeSources into oneFlowable, in a way that allows a subscriber to receive all successfully emitted items from each of the sourceMaybeSources without being interrupted by an error notification from one of them.
 This behaves likemerge(Publisher) except that if any of the mergedMaybeSources notify of an error viaonError,mergeDelayError will refrain from propagating that error notification until all of the mergedMaybeSources have finished emitting items.
 Even if multiple mergedMaybeSources 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 - theIterable ofMaybeSources
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifsources isnull
 See Also:
 ReactiveX operators documentation: Merge
 - mergeDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic static <T> @NonNullFlowable<T> mergeDelayError(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources)
```
 Flattens aPublisher that emitsMaybeSources into oneFlowable, in a way that allows a subscriber to receive all successfully emitted items from all of the sourceMaybeSources without being interrupted by an error notification from one of them or even the mainPublisher.
 This behaves likemerge(Publisher) except that if any of the mergedMaybeSources notify of an error viaonError,mergeDelayError will refrain from propagating that error notification until all of the mergedMaybeSources and the mainPublisher have finished emitting items.
 Even if multiple mergedMaybeSources 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 - aPublisher that emitsMaybeSources
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifsources isnull
 See Also:
 ReactiveX operators documentation: Merge
 - mergeDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullFlowable<T> mergeDelayError(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources, int maxConcurrency)
```
 Flattens aPublisher that emitsMaybeSources into oneFlowable, in a way that allows a subscriber to receive all successfully emitted items from all of the sourceMaybeSources without being interrupted by an error notification from one of them or even the mainPublisher as well as limiting the total number of activeMaybeSources.
 This behaves likemerge(Publisher, int) except that if any of the mergedMaybeSources notify of an error viaonError,mergeDelayError will refrain from propagating that error notification until all of the mergedMaybeSources and the mainPublisher have finished emitting items.
 Even if multiple mergedMaybeSources 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 - aPublisher that emitsMaybeSources
 maxConcurrency - the maximum number of active innerMaybeSources to be merged at a time
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifsources isnull
 IllegalArgumentException - ifmaxConcurrency is non-positive
 Since:
 2.2
 See Also:
 ReactiveX operators documentation: Merge
 - mergeDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullFlowable<T> mergeDelayError(@NonNullMaybeSource<? extends T> source1,@NonNullMaybeSource<? extends T> source2)
```
 Flattens twoMaybeSources into oneFlowable, in a way that allows a subscriber to receive all successfully emitted items from each of the sourceMaybeSources without being interrupted by an error notification from one of them.
 This behaves likemerge(MaybeSource, MaybeSource) except that if any of the mergedMaybeSources notify of an error viaonError,mergeDelayError will refrain from propagating that error notification until all of the mergedMaybeSources have finished emitting items.
 Even if both mergedMaybeSources 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 - aMaybeSource to be merged
 source2 - aMaybeSource to be merged
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifsource1 orsource2 isnull
 See Also:
 ReactiveX operators documentation: Merge
 - mergeDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullFlowable<T> mergeDelayError(@NonNullMaybeSource<? extends T> source1,@NonNullMaybeSource<? extends T> source2,@NonNullMaybeSource<? extends T> source3)
```
 Flattens threeMaybeSource into oneFlowable, in a way that allows a subscriber to receive all successfully emitted items from all of the sourceMaybeSources without being interrupted by an error notification from one of them.
 This behaves likemerge(MaybeSource, MaybeSource, MaybeSource) except that if any of the mergedMaybeSources notify of an error viaonError,mergeDelayError will refrain from propagating that error notification until all of the mergedMaybeSources have finished emitting items.
 Even if multiple mergedMaybeSources 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 - aMaybeSource to be merged
 source2 - aMaybeSource to be merged
 source3 - aMaybeSource to be merged
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifsource1,source2 orsource3 isnull
 See Also:
 ReactiveX operators documentation: Merge
 - mergeDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullFlowable<T> mergeDelayError(@NonNullMaybeSource<? extends T> source1,@NonNullMaybeSource<? extends T> source2,@NonNullMaybeSource<? extends T> source3,@NonNullMaybeSource<? extends T> source4)
```
 Flattens fourMaybeSources into oneFlowable, in a way that allows a subscriber to receive all successfully emitted items from all of the sourceMaybeSources without being interrupted by an error notification from one of them.
 This behaves likemerge(MaybeSource, MaybeSource, MaybeSource, MaybeSource) except that if any of the mergedMaybeSources notify of an error viaonError,mergeDelayError will refrain from propagating that error notification until all of the mergedMaybeSources have finished emitting items.
 Even if multiple mergedMaybeSources 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 - aMaybeSource to be merged
 source2 - aMaybeSource to be merged
 source3 - aMaybeSource to be merged
 source4 - aMaybeSource to be merged
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifsource1,source2,source3 orsource4 isnull
 See Also:
 ReactiveX operators documentation: Merge
 - never
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic static <T> @NonNullMaybe<T> never()
```
 Returns aMaybe that never sends any items or notifications to aMaybeObserver.
 ThisMaybe 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 theMaybe
 Returns:
 the sharedMaybe instance
 See Also:
 ReactiveX operators documentation: Never
 - sequenceEqual
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic static <T> @NonNullSingle<Boolean> sequenceEqual(@NonNullMaybeSource<? extends T> source1,@NonNullMaybeSource<? extends T> source2)
```
 Returns aSingle that emits aBoolean value that indicates whether twoMaybeSource sequences are the same by comparing the items emitted by eachMaybeSource pairwise.
 Scheduler:
 sequenceEqual does not operate by default on a particularScheduler.
 Type Parameters:
 T - the type of items emitted by eachMaybeSource
 Parameters:
 source1 - the firstMaybeSource to compare
 source2 - the secondMaybeSource to compare
 Returns:
 the newSingle instance
 Throws:
 NullPointerException - ifsource1 orsource2 isnull
 See Also:
 ReactiveX operators documentation: SequenceEqual
 - sequenceEqual
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullSingle<Boolean> sequenceEqual(@NonNullMaybeSource<? extends T> source1,@NonNullMaybeSource<? extends T> source2,@NonNullBiPredicate<? super T,? super T> isEqual)
```
 Returns aSingle that emits aBoolean value that indicates whether twoMaybeSources are the same by comparing the items emitted by eachMaybeSource 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 eachMaybeSource
 Parameters:
 source1 - the firstMaybeSource to compare
 source2 - the secondMaybeSource to compare
 isEqual - a function used to compare items emitted by eachMaybeSource
 Returns:
 the newSingle instance
 Throws:
 NullPointerException - ifsource1,source2 orisEqual isnull
 See Also:
 ReactiveX operators documentation: SequenceEqual
 - switchOnNext
```
@BackpressureSupport(value=UNBOUNDED_IN)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullFlowable<T> switchOnNext(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources)
```
 Switches betweenMaybeSources emitted by the sourcePublisher whenever a newMaybeSource is emitted, disposing the previously runningMaybeSource, exposing the success items as aFlowable sequence.
 Backpressure:
 ThesourcesPublisher is consumed in an unbounded manner (requestingLong.MAX_VALUE). The returnedFlowable respects the backpressure from the downstream.
 Scheduler:
 switchOnNext does not operate by default on a particularScheduler.
 Error handling:
 The returned sequence fails with the first error signaled by thesourcesPublisher or the currently runningMaybeSource, disposing the rest. Late errors are forwarded to the global error handler viaRxJavaPlugins.onError(Throwable).
 Type Parameters:
 T - the element type of theMaybeSources
 Parameters:
 sources - thePublisher sequence of innerMaybeSources to switch between
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifsources isnull
 Since:
 3.0.0
 See Also:
 switchOnNextDelayError(Publisher),ReactiveX operators documentation: Switch
 - switchOnNextDelayError
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullFlowable<T> switchOnNextDelayError(@NonNullPublisher<? extendsMaybeSource<? extends T>> sources)
```
 Switches betweenMaybeSources emitted by the sourcePublisher whenever a newMaybeSource is emitted, disposing the previously runningMaybeSource, exposing the success items as aFlowable sequence and delaying all errors from all of them until all terminate.
 Backpressure:
 ThesourcesPublisher is consumed in an unbounded manner (requestingLong.MAX_VALUE). The returnedFlowable respects the backpressure from the downstream.
 Scheduler:
 switchOnNextDelayError does not operate by default on a particularScheduler.
 Error handling:
 The returnedFlowable collects all errors emitted by either thesourcesPublisher or any innerMaybeSource and emits them as aCompositeException when all sources terminate. If only one source ever failed, its error is emitted as-is at the end.
 Type Parameters:
 T - the element type of theMaybeSources
 Parameters:
 sources - thePublisher sequence of innerMaybeSources to switch between
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifsources isnull
 Since:
 3.0.0
 See Also:
 switchOnNext(Publisher),ReactiveX operators documentation: Switch
 - timer
```
@CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")@NonNullpublic static @NonNullMaybe<Long> timer(long delay,@NonNullTimeUnit unit)
```
 Returns aMaybe 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:
 the newMaybe instance
 Throws:
 NullPointerException - ifunit isnull
 See Also:
 ReactiveX operators documentation: Timer
 - timer
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public static @NonNullMaybe<Long> timer(long delay,@NonNullTimeUnit unit,@NonNullScheduler scheduler)
```
 Returns aMaybe that emits0L after a specified delay on a specifiedScheduler.
 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:
 the newMaybe instance
 Throws:
 NullPointerException - ifunit orscheduler isnull
 See Also:
 ReactiveX operators documentation: Timer
 - unsafeCreate
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullMaybe<T> unsafeCreate(@NonNullMaybeSource<T> onSubscribe)
```
 Advanced use only: creates aMaybe instance without any safeguards by using a callback that is called with aMaybeObserver.
 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 subscribingMaybeObserver
 Returns:
 the newMaybe instance
 Throws:
 IllegalArgumentException - ifonSubscribe is aMaybe
 NullPointerException - ifonSubscribe isnull
 - using
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic static <T,D> @NonNullMaybe<T> using(@NonNullSupplier<? extends D> resourceSupplier,@NonNullFunction<? super D,? extendsMaybeSource<? extends T>> sourceSupplier,@NonNullConsumer<? super D> resourceCleanup)
```
 Constructs aMaybe that creates a dependent resource object which is disposed of when the generatedMaybeSource terminates or the downstream calls dispose().
 Scheduler:
 using does not operate by default on a particularScheduler.
 Type Parameters:
 T - the element type of the generatedMaybeSource
 D - the type of the resource associated with the output sequence
 Parameters:
 resourceSupplier - the factory function to create a resource object that depends on theMaybe
 sourceSupplier - the factory function to create aMaybeSource
 resourceCleanup - the function that will dispose of the resource
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifresourceSupplier,sourceSupplier orresourceCleanup isnull
 See Also:
 ReactiveX operators documentation: Using
 - using
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T,D> @NonNullMaybe<T> using(@NonNullSupplier<? extends D> resourceSupplier,@NonNullFunction<? super D,? extendsMaybeSource<? extends T>> sourceSupplier,@NonNullConsumer<? super D> resourceCleanup, boolean eager)
```
 Constructs aMaybe that creates a dependent resource object which is disposed first ({code eager == true}) when the generatedMaybeSource terminates or the downstream disposes; or after ({code eager == false}).
 Eager disposal is particularly appropriate for a synchronousMaybe 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 generatedMaybeSource
 D - the type of the resource associated with the output sequence
 Parameters:
 resourceSupplier - the factory function to create a resource object that depends on theMaybe
 sourceSupplier - the factory function to create aMaybeSource
 resourceCleanup - the function that will dispose of the resource
 eager - Iftrue then resource disposal will happen either on adispose() call before the upstream is disposed or just before the emission of a terminal event (onSuccess,onComplete oronError). Iffalse the resource disposal will happen either on adispose() call after the upstream is disposed or just after the emission of a terminal event (onSuccess,onComplete oronError).
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifresourceSupplier,sourceSupplier orresourceCleanup isnull
 See Also:
 ReactiveX operators documentation: Using
 - wrap
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> @NonNullMaybe<T> wrap(@NonNullMaybeSource<T> source)
```
 Wraps aMaybeSource instance into a newMaybe instance if not already aMaybe 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 new wrapped or castMaybe instance
 Throws:
 NullPointerException - ifsource isnull
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T,R> @NonNullMaybe<R> zip(@NonNullIterable<? extendsMaybeSource<? extends T>> sources,@NonNullFunction<? superObject[],? extends R> zipper)
```
 Returns aMaybe that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by anIterable of otherMaybeSources.
 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 sourceMaybeSources signal anonError oronComplete. 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 - anIterable of sourceMaybeSources
 zipper - a function that, when applied to an item emitted by each of the sourceMaybeSources, results in an item that will be emitted by the resultingMaybe
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifzipper orsources isnull
 See Also:
 ReactiveX operators documentation: Zip
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T1,T2,R> @NonNullMaybe<R> zip(@NonNullMaybeSource<? extends T1> source1,@NonNullMaybeSource<? extends T2> source2,@NonNullBiFunction<? super T1,? super T2,? extends R> zipper)
```
 Returns aMaybe that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherMaybeSources.
 This operator terminates eagerly if any of the sourceMaybeSources signal anonError oronComplete. 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 sourceMaybeSource
 source2 - a second sourceMaybeSource
 zipper - a function that, when applied to an item emitted by each of the sourceMaybeSources, results in an item that will be emitted by the resultingMaybe
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifsource1,source2 orzipper isnull
 See Also:
 ReactiveX operators documentation: Zip
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T1,T2,T3,R> @NonNullMaybe<R> zip(@NonNullMaybeSource<? extends T1> source1,@NonNullMaybeSource<? extends T2> source2,@NonNullMaybeSource<? extends T3> source3,@NonNullFunction3<? super T1,? super T2,? super T3,? extends R> zipper)
```
 Returns aMaybe that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three otherMaybeSources.
 This operator terminates eagerly if any of the sourceMaybeSources signal anonError oronComplete. 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 sourceMaybeSource
 source2 - a second sourceMaybeSource
 source3 - a third sourceMaybeSource
 zipper - a function that, when applied to an item emitted by each of the sourceMaybeSources, results in an item that will be emitted by the resultingMaybe
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifsource1,source2,source3 orzipper isnull
 See Also:
 ReactiveX operators documentation: Zip
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T1,T2,T3,T4,R> @NonNullMaybe<R> zip(@NonNullMaybeSource<? extends T1> source1,@NonNullMaybeSource<? extends T2> source2,@NonNullMaybeSource<? extends T3> source3,@NonNullMaybeSource<? extends T4> source4,@NonNullFunction4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper)
```
 Returns aMaybe that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four otherMaybeSources.
 This operator terminates eagerly if any of the sourceMaybeSources signal anonError oronComplete. 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 sourceMaybeSource
 source2 - a second sourceMaybeSource
 source3 - a third sourceMaybeSource
 source4 - a fourth sourceMaybeSource
 zipper - a function that, when applied to an item emitted by each of the sourceMaybeSources, results in an item that will be emitted by the resultingMaybe
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifsource1,source2,source3,source4 orzipper isnull
 See Also:
 ReactiveX operators documentation: Zip
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T1,T2,T3,T4,T5,R> @NonNullMaybe<R> zip(@NonNullMaybeSource<? extends T1> source1,@NonNullMaybeSource<? extends T2> source2,@NonNullMaybeSource<? extends T3> source3,@NonNullMaybeSource<? extends T4> source4,@NonNullMaybeSource<? extends T5> source5,@NonNullFunction5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper)
```
 Returns aMaybe that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five otherMaybeSources.
 This operator terminates eagerly if any of the sourceMaybeSources signal anonError oronComplete. 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 sourceMaybeSource
 source2 - a second sourceMaybeSource
 source3 - a third sourceMaybeSource
 source4 - a fourth sourceMaybeSource
 source5 - a fifth sourceMaybeSource
 zipper - a function that, when applied to an item emitted by each of the sourceMaybeSources, results in an item that will be emitted by the resultingMaybe
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifsource1,source2,source3,source4,source5 orzipper isnull
 See Also:
 ReactiveX operators documentation: Zip
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T1,T2,T3,T4,T5,T6,R> @NonNullMaybe<R> zip(@NonNullMaybeSource<? extends T1> source1,@NonNullMaybeSource<? extends T2> source2,@NonNullMaybeSource<? extends T3> source3,@NonNullMaybeSource<? extends T4> source4,@NonNullMaybeSource<? extends T5> source5,@NonNullMaybeSource<? extends T6> source6,@NonNullFunction6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper)
```
 Returns aMaybe that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six otherMaybeSources.
 This operator terminates eagerly if any of the sourceMaybeSources signal anonError oronComplete. 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 sourceMaybeSource
 source2 - a second sourceMaybeSource
 source3 - a third sourceMaybeSource
 source4 - a fourth sourceMaybeSource
 source5 - a fifth sourceMaybeSource
 source6 - a sixth sourceMaybeSource
 zipper - a function that, when applied to an item emitted by each of the sourceMaybeSources, results in an item that will be emitted by the resultingMaybe
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifsource1,source2,source3,source4,source5,source6 orzipper isnull
 See Also:
 ReactiveX operators documentation: Zip
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T1,T2,T3,T4,T5,T6,T7,R> @NonNullMaybe<R> zip(@NonNullMaybeSource<? extends T1> source1,@NonNullMaybeSource<? extends T2> source2,@NonNullMaybeSource<? extends T3> source3,@NonNullMaybeSource<? extends T4> source4,@NonNullMaybeSource<? extends T5> source5,@NonNullMaybeSource<? extends T6> source6,@NonNullMaybeSource<? extends T7> source7,@NonNullFunction7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper)
```
 Returns aMaybe that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherMaybeSources.
 This operator terminates eagerly if any of the sourceMaybeSources signal anonError oronComplete. 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 sourceMaybeSource
 source2 - a second sourceMaybeSource
 source3 - a third sourceMaybeSource
 source4 - a fourth sourceMaybeSource
 source5 - a fifth sourceMaybeSource
 source6 - a sixth sourceMaybeSource
 source7 - a seventh sourceMaybeSource
 zipper - a function that, when applied to an item emitted by each of the sourceMaybeSources, results in an item that will be emitted by the resultingMaybe
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifsource1,source2,source3,source4,source5,source6,source7 orzipper isnull
 See Also:
 ReactiveX operators documentation: Zip
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T1,T2,T3,T4,T5,T6,T7,T8,R> @NonNullMaybe<R> zip(@NonNullMaybeSource<? extends T1> source1,@NonNullMaybeSource<? extends T2> source2,@NonNullMaybeSource<? extends T3> source3,@NonNullMaybeSource<? extends T4> source4,@NonNullMaybeSource<? extends T5> source5,@NonNullMaybeSource<? extends T6> source6,@NonNullMaybeSource<? extends T7> source7,@NonNullMaybeSource<? extends T8> source8,@NonNullFunction8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> zipper)
```
 Returns aMaybe that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherMaybeSources.
 This operator terminates eagerly if any of the sourceMaybeSources signal anonError oronComplete. 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 sourceMaybeSource
 source2 - a second sourceMaybeSource
 source3 - a third sourceMaybeSource
 source4 - a fourth sourceMaybeSource
 source5 - a fifth sourceMaybeSource
 source6 - a sixth sourceMaybeSource
 source7 - a seventh sourceMaybeSource
 source8 - an eighth sourceMaybeSource
 zipper - a function that, when applied to an item emitted by each of the sourceMaybeSources, results in an item that will be emitted by the resultingMaybe
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifsource1,source2,source3,source4,source5,source6,source7,source8 orzipper isnull
 See Also:
 ReactiveX operators documentation: Zip
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> @NonNullMaybe<R> zip(@NonNullMaybeSource<? extends T1> source1,@NonNullMaybeSource<? extends T2> source2,@NonNullMaybeSource<? extends T3> source3,@NonNullMaybeSource<? extends T4> source4,@NonNullMaybeSource<? extends T5> source5,@NonNullMaybeSource<? extends T6> source6,@NonNullMaybeSource<? extends T7> source7,@NonNullMaybeSource<? extends T8> source8,@NonNullMaybeSource<? extends T9> source9,@NonNullFunction9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> zipper)
```
 Returns aMaybe that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherMaybeSources.
 This operator terminates eagerly if any of the sourceMaybeSources signal anonError oronComplete. 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
 T9 - the value type of the ninth source
 R - the zipped result type
 Parameters:
 source1 - the first sourceMaybeSource
 source2 - a second sourceMaybeSource
 source3 - a third sourceMaybeSource
 source4 - a fourth sourceMaybeSource
 source5 - a fifth sourceMaybeSource
 source6 - a sixth sourceMaybeSource
 source7 - a seventh sourceMaybeSource
 source8 - an eighth sourceMaybeSource
 source9 - a ninth sourceMaybeSource
 zipper - a function that, when applied to an item emitted by each of the sourceMaybeSources, results in an item that will be emitted by the resultingMaybe
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifsource1,source2,source3,source4,source5,source6,source7,source8,source9 orzipper isnull
 See Also:
 ReactiveX operators documentation: Zip
 - zipArray
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")@SafeVarargspublic static <T,R> @NonNullMaybe<R> zipArray(@NonNullFunction<? superObject[],? extends R> zipper,@NonNullMaybeSource<? extends T>... sources)
```
 Returns aMaybe that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of otherMaybeSources.
 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 sourceMaybeSources signal anonError oronComplete. 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 sourceMaybeSources
 zipper - a function that, when applied to an item emitted by each of the sourceMaybeSources, results in an item that will be emitted by the resultingMaybe
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifsources orzipper isnull
 See Also:
 ReactiveX operators documentation: Zip
 - ambWith
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullMaybe<T> ambWith(@NonNullMaybeSource<? extendsT> other)
```
 Mirrors theMaybeSource (current or provided) that first signals an event.
 Scheduler:
 ambWith does not operate by default on a particularScheduler.
 Parameters:
 other - aMaybeSource competing to react first. A subscription to this provided source will occur after subscribing to the current source.
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifother isnull
 See Also:
 ReactiveX operators documentation: Amb
 - blockingGet
```
@CheckReturnValue@SchedulerSupport(value="none")@Nullablepublic final T blockingGet()
```
 Waits in a blocking fashion until the currentMaybe 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")@NonNullpublic final T blockingGet(@NonNullT defaultValue)
```
 Waits in a blocking fashion until the currentMaybe 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 thisMaybe is empty
 Returns:
 the success value
 Throws:
 NullPointerException - ifdefaultValue isnull
 - blockingSubscribe
```
@SchedulerSupport(value="none")public final void blockingSubscribe()
```
 Subscribes to the currentMaybe andblocks the current thread until it terminates.
 Scheduler:
 blockingSubscribe does not operate by default on a particularScheduler.
 Error handling:
 If the currentMaybe signals an error, theThrowable is routed to the global error handler viaRxJavaPlugins.onError(Throwable). If the current thread is interrupted, anInterruptedException is routed to the same global error handler.
 Since:
 3.0.0
 See Also:
 blockingSubscribe(Consumer),blockingSubscribe(Consumer, Consumer),blockingSubscribe(Consumer, Consumer, Action)
 - blockingSubscribe
```
@SchedulerSupport(value="none")public final void blockingSubscribe(@NonNullConsumer<? superT> onSuccess)
```
 Subscribes to the currentMaybe and calls givenonSuccess callback on thecurrent thread when it completes normally.
 Scheduler:
 blockingSubscribe does not operate by default on a particularScheduler.
 Error handling:
 If either the currentMaybe signals an error oronSuccess throws, the respectiveThrowable is routed to the global error handler viaRxJavaPlugins.onError(Throwable). If the current thread is interrupted, anInterruptedException is routed to the same global error handler.
 Parameters:
 onSuccess - theConsumer to call if the currentMaybe succeeds
 Throws:
 NullPointerException - ifonSuccess isnull
 Since:
 3.0.0
 See Also:
 blockingSubscribe(Consumer, Consumer),blockingSubscribe(Consumer, Consumer, Action)
 - blockingSubscribe
```
@SchedulerSupport(value="none")public final void blockingSubscribe(@NonNullConsumer<? superT> onSuccess,@NonNullConsumer<? superThrowable> onError)
```
 Subscribes to the currentMaybe and calls the appropriate callback on thecurrent thread when it terminates.
 Scheduler:
 blockingSubscribe does not operate by default on a particularScheduler.
 Error handling:
 If eitheronSuccess oronError throw, theThrowable is routed to the global error handler viaRxJavaPlugins.onError(Throwable). If the current thread is interrupted, theonError consumer is called with anInterruptedException.
 Parameters:
 onSuccess - theConsumer to call if the currentMaybe succeeds
 onError - theConsumer to call if the currentMaybe signals an error
 Throws:
 NullPointerException - ifonSuccess oronError isnull
 Since:
 3.0.0
 See Also:
 blockingSubscribe(Consumer, Consumer, Action)
 - blockingSubscribe
```
@SchedulerSupport(value="none")public final void blockingSubscribe(@NonNullConsumer<? superT> onSuccess,@NonNullConsumer<? superThrowable> onError,@NonNullAction onComplete)
```
 Subscribes to the currentMaybe and calls the appropriate callback on thecurrent thread when it terminates.
 Scheduler:
 blockingSubscribe does not operate by default on a particularScheduler.
 Error handling:
 If eitheronSuccess,onError oronComplete throw, theThrowable is routed to the global error handler viaRxJavaPlugins.onError(Throwable). If the current thread is interrupted, theonError consumer is called with anInterruptedException.
 Parameters:
 onSuccess - theConsumer to call if the currentMaybe succeeds
 onError - theConsumer to call if the currentMaybe signals an error
 onComplete - theAction to call if the currentMaybe completes without a value
 Throws:
 NullPointerException - ifonSuccess,onError oronComplete isnull
 Since:
 3.0.0
 - blockingSubscribe
```
@SchedulerSupport(value="none")public final void blockingSubscribe(@NonNullMaybeObserver<? superT> observer)
```
 Subscribes to the currentMaybe and calls the appropriateMaybeObserver method on thecurrent thread.
 Scheduler:
 blockingSubscribe does not operate by default on a particularScheduler.
 Error handling:
 AnonError signal is delivered to theMaybeObserver.onError(Throwable) method. If any of theMaybeObserver's methods throw, theRuntimeException is propagated to the caller of this method. If the current thread is interrupted, anInterruptedException is delivered toobserver.onError.
 Parameters:
 observer - theMaybeObserver to call methods on the current thread
 Throws:
 NullPointerException - ifobserver isnull
 Since:
 3.0.0
 - cache
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullMaybe<T> cache()
```
 Returns aMaybe that subscribes to thisMaybe 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 thisMaybe.
 Note: You sacrifice the ability to dispose the origin when you use thecache.
 Scheduler:
 cache does not operate by default on a particularScheduler.
 Returns:
 the newMaybe instance
 See Also:
 ReactiveX operators documentation: Replay
 - cast
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  @NonNullMaybe cast(@NonNullClass<? extends U> clazz)
```
 Casts the success value of the currentMaybe into the target type or signals aClassCastException 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 currentMaybe
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifclazz isnull
 - compose
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final <R> @NonNullMaybe<R> compose(@NonNullMaybeTransformer<? superT,? extends R> transformer)
```
 Transform aMaybe by applying a particularMaybeTransformer function to it.
 This method operates on theMaybe itself whereaslift(io.reactivex.rxjava3.core.MaybeOperator<? extends R, ? super T>) operates on theMaybe'sMaybeObservers.
 If the operator you are creating is designed to act on the individual item emitted by aMaybe, uselift(io.reactivex.rxjava3.core.MaybeOperator<? extends R, ? super T>). If your operator is designed to transform the currentMaybe 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 theMaybe returned by the transformer function
 Parameters:
 transformer - the transformer function, notnull
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - iftransformer isnull
 See Also:
 RxJava wiki: Implementing Your Own Operators
 - concatMap
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> @NonNullMaybe<R> concatMap(@NonNullFunction<? superT,? extendsMaybeSource<? extends R>> mapper)
```
 Returns aMaybe that is based on applying a specified function to the item emitted by the currentMaybe, where that function returns aMaybeSource.
 Note that flatMap and concatMap forMaybe is the same operation.
 Scheduler:
 concatMap 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 currentMaybe, returns aMaybeSource
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifmapper isnull
 See Also:
 ReactiveX operators documentation: FlatMap
 - concatMapCompletable
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullCompletable concatMapCompletable(@NonNullFunction<? superT,? extendsCompletableSource> mapper)
```
 Returns aCompletable that completes based on applying a specified function to the item emitted by the currentMaybe, where that function returns aCompletable.
 This operator is an alias forflatMapCompletable(Function).
 Scheduler:
 concatMapCompletable does not operate by default on a particularScheduler.
 Parameters:
 mapper - a function that, when applied to the item emitted by the currentMaybe, returns aCompletable
 Returns:
 the newCompletable instance
 Throws:
 NullPointerException - ifmapper isnull
 Since:
 3.0.0
 See Also:
 ReactiveX operators documentation: FlatMap
 - concatMapSingle
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> @NonNullMaybe<R> concatMapSingle(@NonNullFunction<? superT,? extendsSingleSource<? extends R>> mapper)
```
 Returns aMaybe based on applying a specified function to the item emitted by the currentMaybe, where that function returns aSingle. When thisMaybe just completes the resultingMaybe completes as well.
 This operator is an alias forflatMapSingle(Function).
 Scheduler:
 concatMapSingle 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 currentMaybe, returns aSingle
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifmapper isnull
 Since:
 3.0.0
 See Also:
 ReactiveX operators documentation: FlatMap
 - concatWith
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullFlowable<T> concatWith(@NonNullMaybeSource<? extendsT> other)
```
 Returns aFlowable that emits the items emitted from the currentMaybe, then theotherMaybeSource, 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 - aMaybeSource to be concatenated after the current
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifother isnull
 See Also:
 ReactiveX operators documentation: Concat
 - contains
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullSingle<Boolean> contains(@NonNullObject item)
```
 Returns aSingle that emits aBoolean that indicates whether the currentMaybe 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 currentMaybe, notnull
 Returns:
 the newSingle instance
 Throws:
 NullPointerException - ifitem isnull
 See Also:
 ReactiveX operators documentation: Contains
 - count
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullSingle<Long> count()
```
 Returns aSingle that counts the total number of items emitted (0 or 1) by the currentMaybe and emits this count as a 64-bitLong.
 Scheduler:
 count does not operate by default on a particularScheduler.
 Returns:
 the newSingle instance
 See Also:
 ReactiveX operators documentation: Count
 - defaultIfEmpty
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullSingle<T> defaultIfEmpty(@NonNullT defaultItem)
```
 Returns aSingle that emits the item emitted by the currentMaybe or a specified default item if the currentMaybe is empty.
 Scheduler:
 defaultIfEmpty does not operate by default on a particularScheduler.
 Parameters:
 defaultItem - the item to emit if the currentMaybe emits no items
 Returns:
 the newSingle instance
 Throws:
 NullPointerException - ifdefaultItem isnull
 See Also:
 ReactiveX operators documentation: DefaultIfEmpty
 - dematerialize
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> @NonNullMaybe<R> dematerialize(@NonNullFunction<? superT,Notification<R>> selector)
```
 Maps theNotification success value of the currentMaybe back into normalonSuccess,onError oronComplete signals.
 The intended use of theselector function is to perform a type-safe identity mapping (see example) on a source that is already of typeNotification<T>. The Java language doesn't allow limiting instance methods to a certain generic argument shape, therefore, a function is used to ensure the conversion remains type safe.
 RegularonError oronComplete signals from the currentMaybe are passed along to the downstream.
 Scheduler:
 dematerialize does not operate by default on a particularScheduler.
 Example:
```
 Maybe.just(Notification.createOnNext(1)) .dematerialize(notification -> notification) .test() .assertResult(1);
```
 Type Parameters:
 R - the result type
 Parameters:
 selector - the function called with the success item and should return aNotification instance.
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifselector isnull
 Since:
 3.0.0
 See Also:
 materialize()
 - delay
```
@CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")@NonNullpublic final @NonNullMaybe<T> delay(long time,@NonNullTimeUnit unit)
```
 Returns aMaybe that signals the events emitted by the currentMaybe shifted forward in time by a specified delay. An error signal will not be delayed.
 Scheduler:
 This version ofdelay operates by default on thecomputationScheduler.
 Parameters:
 time - the delay to shift the source by
 unit - theTimeUnit in whichtime is defined
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifunit isnull
 See Also:
 ReactiveX operators documentation: Delay,delay(long, TimeUnit, Scheduler, boolean)
 - delay
```
@CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")@NonNullpublic final @NonNullMaybe<T> delay(long time,@NonNullTimeUnit unit, boolean delayError)
```
 Returns aMaybe that signals the events emitted by the currentMaybe shifted forward in time by a specified delay.
 Scheduler:
 This version ofdelay operates by default on thecomputationScheduler.
 Parameters:
 time - the delay to shift the source by
 unit - theTimeUnit in whichtime is defined
 delayError - iftrue, both success and error signals are delayed. iffalse, only success signals are delayed.
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifunit isnull
 Since:
 3.0.0
 See Also:
 ReactiveX operators documentation: Delay,delay(long, TimeUnit, Scheduler, boolean)
 - delay
```
@CheckReturnValue@SchedulerSupport(value="custom")@NonNullpublic final @NonNullMaybe<T> delay(long time,@NonNullTimeUnit unit,@NonNullScheduler scheduler)
```
 Returns aMaybe that signals the events emitted by the currentMaybe shifted forward in time by a specified delay. An error signal will not be delayed.
 Scheduler:
 you specify theScheduler where the non-blocking wait and emission happens
 Parameters:
 time - the delay to shift the source by
 unit - theTimeUnit in whichtime is defined
 scheduler - theScheduler to use for delaying
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifunit orscheduler isnull
 See Also:
 ReactiveX operators documentation: Delay,delay(long, TimeUnit, Scheduler, boolean)
 - delay
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public final @NonNullMaybe<T> delay(long time,@NonNullTimeUnit unit,@NonNullScheduler scheduler, boolean delayError)
```
 Returns aMaybe that signals the events emitted by the currentMaybe shifted forward in time by a specified delay running on the specifiedScheduler.
 Scheduler:
 you specify whichScheduler this operator will use.
 Parameters:
 time - the delay to shift the source by
 unit - theTimeUnit in whichtime is defined
 scheduler - theScheduler to use for delaying
 delayError - iftrue, both success and error signals are delayed. iffalse, only success signals are delayed.
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifunit orscheduler isnull
 Since:
 3.0.0
 See Also:
 ReactiveX operators documentation: Delay
 - delay
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")@BackpressureSupport(value=UNBOUNDED_IN)public final  @NonNullMaybe<T> delay(@NonNullPublisher delayIndicator)
```
 Delays the emission of thisMaybe until the givenPublisher 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)
 Parameters:
 delayIndicator - thePublisher that gets subscribed to when thisMaybe signals an event and that signal is emitted when thePublisher signals an item or completes
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifdelayIndicator isnull
 See Also:
 ReactiveX operators documentation: Delay
 - delaySubscription
```
@BackpressureSupport(value=UNBOUNDED_IN)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  @NonNullMaybe<T> delaySubscription(@NonNullPublisher subscriptionIndicator)
```
 Returns aMaybe that delays the subscription to thisMaybe until the otherPublisher 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 otherPublisher, irrelevant
 Parameters:
 subscriptionIndicator - the otherPublisher that should trigger the subscription to thisPublisher.
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifsubscriptionIndicator isnull
 - delaySubscription
```
@CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")@NonNullpublic final @NonNullMaybe<T> delaySubscription(long time,@NonNullTimeUnit unit)
```
 Returns aMaybe that delays the subscription to the currentMaybe by a given amount of time.
 Scheduler:
 This version ofdelaySubscription operates by default on thecomputationScheduler.
 Parameters:
 time - the time to delay the subscription
 unit - the time unit ofdelay
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifunit isnull
 See Also:
 ReactiveX operators documentation: Delay,delaySubscription(long, TimeUnit, Scheduler)
 - delaySubscription
```
@CheckReturnValue@SchedulerSupport(value="custom")@NonNullpublic final @NonNullMaybe<T> delaySubscription(long time,@NonNullTimeUnit unit,@NonNullScheduler scheduler)
```
 Returns aMaybe that delays the subscription to the currentMaybe by a given amount of time, both waiting and subscribing on a givenScheduler.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 time - the time to delay the subscription
 unit - the time unit ofdelay
 scheduler - theScheduler on which the waiting and subscription will happen
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifunit orscheduler isnull
 See Also:
 ReactiveX operators documentation: Delay
 - doAfterSuccess
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullMaybe<T> doAfterSuccess(@NonNullConsumer<? superT> onAfterSuccess)
```
 Calls the specifiedConsumer with the success item after this item has been emitted to the downstream.
 Note that theonAfterSuccess 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 - theConsumer that will be called after emitting an item from upstream to the downstream
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifonAfterSuccess isnull
 Since:
 2.1
 - doAfterTerminate
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullMaybe<T> doAfterTerminate(@NonNullAction onAfterTerminate)
```
 Registers anAction to be called when thisMaybe invokes eitheronSuccess,onComplete oronError.
 Scheduler:
 doAfterTerminate does not operate by default on a particularScheduler.
 Parameters:
 onAfterTerminate - anAction to be invoked when the currentMaybe finishes
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifonAfterTerminate isnull
 See Also:
 ReactiveX operators documentation: Do
 - doFinally
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullMaybe<T> doFinally(@NonNullAction onFinally)
```
 Calls the specified action after thisMaybe signalsonSuccess,onError oronComplete 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 thisMaybe terminates or gets disposed
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifonFinally isnull
 Since:
 2.1
 - doOnDispose
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullMaybe<T> doOnDispose(@NonNullAction onDispose)
```
 Calls the sharedAction if aMaybeObserver subscribed to the currentMaybe disposes the commonDisposable it received viaonSubscribe.
 Scheduler:
 doOnDispose does not operate by default on a particularScheduler.
 Parameters:
 onDispose - the action called when the subscription is disposed
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifonDispose isnull
 - doOnComplete
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullMaybe<T> doOnComplete(@NonNullAction onComplete)
```
 Invokes anAction just before the currentMaybe callsonComplete.
 Scheduler:
 doOnComplete does not operate by default on a particularScheduler.
 Parameters:
 onComplete - the action to invoke when the currentMaybe callsonComplete
 Returns:
 the newMaybe with the side-effecting behavior applied
 Throws:
 NullPointerException - ifonComplete isnull
 See Also:
 ReactiveX operators documentation: Do
 - doOnError
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullMaybe<T> doOnError(@NonNullConsumer<? superThrowable> onError)
```
 Calls the sharedConsumer with the error sent viaonError for eachMaybeObserver that subscribes to the currentMaybe.
 Scheduler:
 doOnError does not operate by default on a particularScheduler.
 Parameters:
 onError - the consumer called with the success value ofonError
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifonError isnull
 - doOnEvent
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullMaybe<T> doOnEvent(@NonNullBiConsumer<? superT,? superThrowable> onEvent)
```
 Calls the givenonEvent callback with the (success value,null) for anonSuccess, (null, throwable) for anonError or (null,null) for anonComplete signal from thisMaybe before delivering said signal to the downstream.
 The 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 success value or the exception, whichever is notnull
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifonEvent isnull
 - doOnLifecycle
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullMaybe<T> doOnLifecycle(@NonNullConsumer<? superDisposable> onSubscribe,@NonNullAction onDispose)
```
 Calls the appropriateonXXX method (shared between allMaybeObservers) for the lifecycle events of the sequence (subscription, disposal).
 Scheduler:
 doOnLifecycle does not operate by default on a particularScheduler.
 Parameters:
 onSubscribe - aConsumer called with theDisposable sent viaMaybeObserver.onSubscribe(Disposable)
 onDispose - called when the downstream disposes theDisposable viadispose()
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifonSubscribe oronDispose isnull
 Since:
 3.0.0
 See Also:
 ReactiveX operators documentation: Do
 - doOnSubscribe
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullMaybe<T> doOnSubscribe(@NonNullConsumer<? superDisposable> onSubscribe)
```
 Calls the sharedConsumer with theDisposable sent through theonSubscribe for eachMaybeObserver that subscribes to the currentMaybe.
 Scheduler:
 doOnSubscribe does not operate by default on a particularScheduler.
 Parameters:
 onSubscribe - theConsumer called with theDisposable sent viaonSubscribe
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifonSubscribe isnull
 - doOnTerminate
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullMaybe<T> doOnTerminate(@NonNullAction onTerminate)
```
 Returns aMaybe instance that calls the given onTerminate callback just before thisMaybe 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.
 History: 2.2.7 - experimental
 Parameters:
 onTerminate - the action to invoke when the consumer callsonComplete oronError
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifonTerminate isnull
 Since:
 3.0.0
 See Also:
 ReactiveX operators documentation: Do,doOnTerminate(Action)
 - doOnSuccess
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullMaybe<T> doOnSuccess(@NonNullConsumer<? superT> onSuccess)
```
 Calls the sharedConsumer with the success value sent viaonSuccess for eachMaybeObserver that subscribes to the currentMaybe.
 Scheduler:
 doOnSuccess does not operate by default on a particularScheduler.
 Parameters:
 onSuccess - theConsumer called with the success value of the upstream
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifonSuccess isnull
 - filter
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullMaybe<T> filter(@NonNullPredicate<? superT> predicate)
```
 Filters the success item of theMaybe via a predicate function and emitting it if the predicate returnstrue, completing otherwise.
 Scheduler:
 filter does not operate by default on a particularScheduler.
 Parameters:
 predicate - a function that evaluates the item emitted by the currentMaybe, returningtrue if it passes the filter
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifpredicate isnull
 See Also:
 ReactiveX operators documentation: Filter
 - flatMap
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> @NonNullMaybe<R> flatMap(@NonNullFunction<? superT,? extendsMaybeSource<? extends R>> mapper)
```
 Returns aMaybe that is based on applying a specified function to the item emitted by the currentMaybe, where that function returns aMaybeSource.
 Scheduler:
 flatMap does not operate by default on a particularScheduler.
 Note that flatMap and concatMap forMaybe is the same operation.
 Type Parameters:
 R - the result value type
 Parameters:
 mapper - a function that, when applied to the item emitted by the currentMaybe, returns aMaybeSource
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifmapper isnull
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMap
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> @NonNullMaybe<R> flatMap(@NonNullFunction<? superT,? extendsMaybeSource<? extends R>> onSuccessMapper,@NonNullFunction<? superThrowable,? extendsMaybeSource<? extends R>> onErrorMapper,@NonNullSupplier<? extendsMaybeSource<? extends R>> onCompleteSupplier)
```
 Maps theonSuccess,onError oronComplete signals of the currentMaybe into aMaybeSource and emits thatMaybeSource's signals.
 Scheduler:
 flatMap does not operate by default on a particularScheduler.
 Type Parameters:
 R - the result type
 Parameters:
 onSuccessMapper - a function that returns aMaybeSource to merge for theonSuccess item emitted by thisMaybe
 onErrorMapper - a function that returns aMaybeSource to merge for anonError notification from thisMaybe
 onCompleteSupplier - a function that returns aMaybeSource to merge for anonComplete notification thisMaybe
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifonSuccessMapper,onErrorMapper oronCompleteSupplier isnull
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMap
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <U,R> @NonNullMaybe<R> flatMap(@NonNullFunction<? superT,? extendsMaybeSource<? extends U>> mapper,@NonNullBiFunction<? superT,? super U,? extends R> combiner)
```
 Returns aMaybe that emits the results of a specified function to the pair of values emitted by the currentMaybe and a specified mappedMaybeSource.
 Scheduler:
 flatMap does not operate by default on a particularScheduler.
 Type Parameters:
 U - the type of items emitted by theMaybeSource returned by themapper function
 R - the type of items emitted by the resultingMaybe
 Parameters:
 mapper - a function that returns aMaybeSource for the item emitted by the currentMaybe
 combiner - a function that combines one item emitted by each of the source and collectionMaybeSource and returns an item to be emitted by the resultingMaybeSource
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifmapper orcombiner isnull
 See Also:
 ReactiveX operators documentation: FlatMap
 - flattenAsFlowable
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  @NonNullFlowable flattenAsFlowable(@NonNullFunction<? superT,? extendsIterable<? extends U>> mapper)
```
 Maps the success value of the currentMaybe 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 innerIterable
 Parameters:
 mapper - a function that returns anIterable sequence of values for when given an item emitted by the currentMaybe
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifmapper isnull
 See Also:
 ReactiveX operators documentation: FlatMap,flattenStreamAsFlowable(Function)
 - flattenAsObservable
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  @NonNullObservable flattenAsObservable(@NonNullFunction<? superT,? extendsIterable<? extends U>> mapper)
```
 Maps the success value of the currentMaybe 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 resultingIterable
 Parameters:
 mapper - a function that returns anIterable sequence of values for when given an item emitted by the currentMaybe
 Returns:
 the newObservable instance
 Throws:
 NullPointerException - ifmapper isnull
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMapObservable
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> @NonNullObservable<R> flatMapObservable(@NonNullFunction<? superT,? extendsObservableSource<? extends R>> mapper)
```
 Returns anObservable that is based on applying a specified function to the item emitted by the currentMaybe, where that function returns anObservableSource.
 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 currentMaybe, returns anObservableSource
 Returns:
 the newObservable instance
 Throws:
 NullPointerException - ifmapper isnull
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMapPublisher
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> @NonNullFlowable<R> flatMapPublisher(@NonNullFunction<? superT,? extendsPublisher<? extends R>> mapper)
```
 Returns aFlowable that emits items based on applying a specified function to the item emitted by the currentMaybe, where that function returns aPublisher.
 Backpressure:
 The returnedFlowable 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 currentMaybe, returns aFlowable
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifmapper isnull
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMapSingle
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> @NonNullMaybe<R> flatMapSingle(@NonNullFunction<? superT,? extendsSingleSource<? extends R>> mapper)
```
 Returns aMaybe based on applying a specified function to the item emitted by the currentMaybe, where that function returns aSingle. When thisMaybe just completes the resultingMaybe completes as well.
 Scheduler:
 flatMapSingle 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 currentMaybe, returns aSingle
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifmapper isnull
 Since:
 2.1
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMapCompletable
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullCompletable flatMapCompletable(@NonNullFunction<? superT,? extendsCompletableSource> mapper)
```
 Returns aCompletable that completes based on applying a specified function to the item emitted by the currentMaybe, 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 currentMaybe, returns aCompletable
 Returns:
 the newCompletable instance
 Throws:
 NullPointerException - ifmapper isnull
 See Also:
 ReactiveX operators documentation: FlatMap
 - hide
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullMaybe<T> hide()
```
 Hides the identity of thisMaybe and itsDisposable.
 Allows preventing certain identity-based optimizations (fusion).
 Scheduler:
 hide does not operate by default on a particularScheduler.
 Returns:
 the newMaybe instance
 - ignoreElement
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullCompletable ignoreElement()
```
 Returns aCompletable that ignores the item emitted by the currentMaybe and only callsonComplete oronError.
 Scheduler:
 ignoreElement does not operate by default on a particularScheduler.
 Returns:
 the newCompletable instance
 See Also:
 ReactiveX operators documentation: IgnoreElements
 - isEmpty
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullSingle<Boolean> isEmpty()
```
 Returns aSingle that emitstrue if the currentMaybe is empty, otherwisefalse.
 Scheduler:
 isEmpty does not operate by default on a particularScheduler.
 Returns:
 the newSingle instance
 See Also:
 ReactiveX operators documentation: Contains
 - lift
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> @NonNullMaybe<R> lift(@NonNullMaybeOperator<? 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 expected to produce one of the onXXX events only 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 currentMaybe. 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.rxjava3.core.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 newMaybe instance
 Throws:
 NullPointerException - iflift isnull
 See Also:
 RxJava wiki: Writing operators,compose(MaybeTransformer)
 - map
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> @NonNullMaybe<R> map(@NonNullFunction<? superT,? extends R> mapper)
```
 Returns aMaybe that applies a specified function to the item emitted by the currentMaybe 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 theMaybe
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifmapper isnull
 See Also:
 ReactiveX operators documentation: Map
 - materialize
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullSingle<Notification<T>> materialize()
```
 Maps the signal types of thisMaybe into aNotification of the same kind and emits it as aSingle'sonSuccess value to downstream.
 Scheduler:
 materialize does not operate by default on a particularScheduler.
 History: 2.2.4 - experimental
 Returns:
 the newSingle instance
 Since:
 3.0.0
 See Also:
 Single.dematerialize(Function)
 - mergeWith
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullFlowable<T> mergeWith(@NonNullMaybeSource<? extendsT> other)
```
 Flattens thisMaybe and anotherMaybeSource into a singleFlowable, without any transformation.
 You can combine items emitted by multipleMaybes so that they appear as a singleFlowable, by using themergeWith method.
 Backpressure:
 The operator honors backpressure from downstream.
 Scheduler:
 mergeWith does not operate by default on a particularScheduler.
 Parameters:
 other - aMaybeSource to be merged
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifother isnull
 See Also:
 ReactiveX operators documentation: Merge
 - observeOn
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public final @NonNullMaybe<T> observeOn(@NonNullScheduler scheduler)
```
 Wraps aMaybe 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 newMaybe instance that its subscribers are notified on the specifiedScheduler
 Throws:
 NullPointerException - ifscheduler isnull
 See Also:
 ReactiveX operators documentation: ObserveOn,RxJava Threading Examples,subscribeOn(io.reactivex.rxjava3.core.Scheduler)
 - ofType
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  @NonNullMaybe ofType(@NonNullClass clazz)
```
 Filters the items emitted by the currentMaybe, only emitting its success value if that is an instance of the suppliedClass.
 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 currentMaybe
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifclazz isnull
 See Also:
 ReactiveX operators documentation: Filter
 - to
```
@CheckReturnValue@SchedulerSupport(value="none")public final <R> R to(@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:
 to 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 currentMaybe instance and returns a value
 Returns:
 the converted value
 Throws:
 NullPointerException - ifconverter isnull
 Since:
 2.2
 - toFlowable
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullFlowable<T> toFlowable()
```
 Converts thisMaybe into a backpressure-awareFlowable instance composing cancellation through.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream.
 Scheduler:
 toFlowable does not operate by default on a particularScheduler.
 Returns:
 the newFlowable instance
 - toFuture
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullFuture<T> toFuture()
```
 Returns aFuture representing the single value emitted by the currentMaybe ornull if the currentMaybe is empty.
 Cancelling theFuture will cancel the subscription to the currentMaybe.
 Scheduler:
 toFuture does not operate by default on a particularScheduler.
 Returns:
 the newFuture instance
 Since:
 3.0.0
 See Also:
 ReactiveX documentation: To
 - toObservable
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullObservable<T> toObservable()
```
 Converts thisMaybe into anObservable instance composing disposal through.
 Scheduler:
 toObservable does not operate by default on a particularScheduler.
 Returns:
 the newObservable instance
 - toSingle
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullSingle<T> toSingle()
```
 Converts thisMaybe into aSingle instance composing disposal through and turning an emptyMaybe into a signal ofNoSuchElementException.
 Scheduler:
 toSingle does not operate by default on a particularScheduler.
 Returns:
 the newSingle instance
 See Also:
 defaultIfEmpty(Object)
 - onErrorComplete
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullMaybe<T> onErrorComplete()
```
 Returns aMaybe instance that if thisMaybe emits an error, it will emit anonComplete and swallow the throwable.
 Scheduler:
 onErrorComplete does not operate by default on a particularScheduler.
 Returns:
 the newMaybe instance
 - onErrorComplete
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullMaybe<T> onErrorComplete(@NonNullPredicate<? superThrowable> predicate)
```
 Returns aMaybe instance that if thisMaybe emits an error and the predicate returnstrue, it will emit anonComplete and swallow the throwable.
 Scheduler:
 onErrorComplete does not operate by default on a particularScheduler.
 Parameters:
 predicate - the predicate to call when anThrowable is emitted which should returntrue if theThrowable should be swallowed and replaced with anonComplete.
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifpredicate isnull
 - onErrorResumeWith
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullMaybe<T> onErrorResumeWith(@NonNullMaybeSource<? extendsT> fallback)
```
 Resumes the flow with the givenMaybeSource when the currentMaybe fails instead of signaling the error viaonError.
 You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.
 Scheduler:
 onErrorResumeWith does not operate by default on a particularScheduler.
 Parameters:
 fallback - the nextMaybeSource that will take over if the currentMaybe encounters an error
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - iffallback isnull
 See Also:
 ReactiveX operators documentation: Catch
 - onErrorResumeNext
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullMaybe<T> onErrorResumeNext(@NonNullFunction<? superThrowable,? extendsMaybeSource<? extendsT>> fallbackSupplier)
```
 Resumes the flow with aMaybeSource returned for the failureThrowable of the currentMaybe by a function instead of signaling the error viaonError.
 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:
 fallbackSupplier - a function that returns aMaybeSource that will take over if the currentMaybe encounters an error
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - iffallbackSupplier isnull
 See Also:
 ReactiveX operators documentation: Catch
 - onErrorReturn
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullMaybe<T> onErrorReturn(@NonNullFunction<? superThrowable,? extendsT> itemSupplier)
```
 Ends the flow with a success item returned by a function for theThrowable error signaled by the currentMaybe instead of signaling the error viaonError.
 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:
 itemSupplier - a function that returns a single value that will be emitted as success value the currentMaybe signals anonError event
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifitemSupplier isnull
 See Also:
 ReactiveX operators documentation: Catch
 - onErrorReturnItem
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullMaybe<T> onErrorReturnItem(@NonNullT item)
```
 Ends the flow with the given success item when the currentMaybe fails instead of signaling the error viaonError.
 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 asonSuccess in case the currentMaybe signals anonError
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifitem isnull
 See Also:
 ReactiveX operators documentation: Catch
 - onTerminateDetach
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullMaybe<T> onTerminateDetach()
```
 Nulls out references to the upstream producer and downstreamMaybeObserver if the sequence is terminated or downstream callsdispose().
 Scheduler:
 onTerminateDetach does not operate by default on a particularScheduler.
 Returns:
 the newMaybe instance the sequence is terminated or downstream callsdispose()
 - repeat
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullFlowable<T> repeat()
```
 Returns aFlowable that repeats the sequence of items emitted by the currentMaybe indefinitely.
 Backpressure:
 The operator honors downstream backpressure.
 Scheduler:
 repeat does not operate by default on a particularScheduler.
 Returns:
 the newFlowable instance
 See Also:
 ReactiveX operators documentation: Repeat
 - repeat
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullFlowable<T> repeat(long times)
```
 Returns aFlowable that repeats the sequence of items emitted by the currentMaybe 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 currentMaybe items are repeated, a count of 0 will yield an empty sequence
 Returns:
 the newFlowable instance
 Throws:
 IllegalArgumentException - iftimes is negative
 See Also:
 ReactiveX operators documentation: Repeat
 - repeatUntil
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullFlowable<T> repeatUntil(@NonNullBooleanSupplier stop)
```
 Returns aFlowable that repeats the sequence of items emitted by the currentMaybe until the provided stop function returnstrue.
 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 currentFlowable completes and unless it returnsfalse, the currentFlowable is resubscribed
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifstop isnull
 See Also:
 ReactiveX operators documentation: Repeat
 - repeatWhen
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullFlowable<T> repeatWhen(@NonNullFunction<? superFlowable<Object>,? extendsPublisher<?>> handler)
```
 Returns aFlowable that emits the same values as the currentMaybe with the exception of anonComplete. AnonComplete notification from the source will result in the emission of avoid item to theFlowable provided as an argument to thenotificationHandler function. If thatPublisher callsonComplete oronError thenrepeatWhen will callonComplete oronError on the child observer. Otherwise, this operator will resubscribe to the currentMaybe.
 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 aPublisher of notifications with which a user can complete or error, aborting the repeat.
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifhandler isnull
 See Also:
 ReactiveX operators documentation: Repeat
 - retry
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullMaybe<T> retry()
```
 Returns aMaybe that mirrors the currentMaybe, resubscribing to it if it callsonError (infinite retry count).
 If the currentMaybe callsMaybeObserver.onError(java.lang.Throwable), this operator will resubscribe to the currentMaybe rather than propagating theonError call.
 Scheduler:
 retry does not operate by default on a particularScheduler.
 Returns:
 the newMaybe instance
 See Also:
 ReactiveX operators documentation: Retry
 - retry
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullMaybe<T> retry(@NonNullBiPredicate<? superInteger,? superThrowable> predicate)
```
 Returns aMaybe that mirrors the currentMaybe, resubscribing to it if it callsonError and the predicate returnstrue 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 newMaybe instance
 Throws:
 NullPointerException - ifpredicate isnull
 See Also:
 retry(),ReactiveX operators documentation: Retry
 - retry
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullMaybe<T> retry(long times)
```
 Returns aMaybe that mirrors the currentMaybe, resubscribing to it if it callsonError up to a specified number of retries.
 If the currentMaybe callsMaybeObserver.onError(java.lang.Throwable), this operator will resubscribe to the currentMaybe for a maximum ofcount resubscriptions rather than propagating theonError call.
 Scheduler:
 retry does not operate by default on a particularScheduler.
 Parameters:
 times - the number of times to resubscribe if the currentMaybe fails
 Returns:
 the newMaybe instance
 Throws:
 IllegalArgumentException - iftimes is negative
 See Also:
 ReactiveX operators documentation: Retry
 - retry
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullMaybe<T> retry(long times,@NonNullPredicate<? superThrowable> predicate)
```
 Retries at mosttimes or until the predicate returnsfalse, whichever happens first.
 Scheduler:
 retry does not operate by default on a particularScheduler.
 Parameters:
 times - the number of times to resubscribe if the currentMaybe fails
 predicate - the predicate called with the failureThrowable and should returntrue to trigger a retry.
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifpredicate isnull
 IllegalArgumentException - iftimes is negative
 - retry
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullMaybe<T> retry(@NonNullPredicate<? superThrowable> predicate)
```
 Retries the currentMaybe if it fails and the predicate returnstrue.
 Scheduler:
 retry does not operate by default on a particularScheduler.
 Parameters:
 predicate - the predicate that receives the failureThrowable and should returntrue to trigger a retry.
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifpredicate isnull
 - retryUntil
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullMaybe<T> retryUntil(@NonNullBooleanSupplier stop)
```
 Retries until the given stop function returnstrue.
 Scheduler:
 retryUntil does not operate by default on a particularScheduler.
 Parameters:
 stop - the function that should returntrue to stop retrying
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifstop isnull
 - retryWhen
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullMaybe<T> retryWhen(@NonNullFunction<? superFlowable<Throwable>,? extendsPublisher<?>> handler)
```
 Returns aMaybe that emits the same values as the currentMaybe with the exception of anonError. AnonError notification from the source will result in the emission of aThrowable item to theFlowable provided as an argument to thenotificationHandler function. If the returnedPublisher callsonComplete oronError thenretry will callonComplete oronError on the child subscription. Otherwise, this operator will resubscribe to the currentMaybe.
 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, signallingonNext followed byonComplete 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 aPublisher of notifications with which a user can complete or error, aborting the retry
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifhandler isnull
 See Also:
 ReactiveX operators documentation: Retry
 - safeSubscribe
```
@SchedulerSupport(value="none")public final void safeSubscribe(@NonNullMaybeObserver<? superT> observer)
```
 Wraps the givenMaybeObserver, catches anyRuntimeExceptions thrown by itsMaybeObserver.onSubscribe(Disposable),MaybeObserver.onSuccess(Object),MaybeObserver.onError(Throwable) orMaybeObserver.onComplete() methods and routes those to the global error handler viaRxJavaPlugins.onError(Throwable).
 By default, theMaybe protocol forbids theonXXX methods to throw, but someMaybeObserver implementation may do it anyway, causing undefined behavior in the upstream. This method and the underlying safe wrapper ensures such misbehaving consumers don't disrupt the protocol.
 Scheduler:
 safeSubscribe does not operate by default on a particularScheduler.
 Parameters:
 observer - the potentially misbehavingMaybeObserver
 Throws:
 NullPointerException - ifobserver isnull
 Since:
 3.0.0
 See Also:
 subscribe(Consumer,Consumer, Action)
 - startWith
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")@BackpressureSupport(value=FULL)public final @NonNullFlowable<T> startWith(@NonNullCompletableSource other)
```
 Returns aFlowable which first runs the otherCompletableSource then the currentMaybe if the other completed normally.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 startWith does not operate by default on a particularScheduler.
 Parameters:
 other - the otherCompletableSource to run first
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifother isnull
 Since:
 3.0.0
 - startWith
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")@BackpressureSupport(value=FULL)public final @NonNullFlowable<T> startWith(@NonNullSingleSource<T> other)
```
 Returns aFlowable which first runs the otherSingleSource then the currentMaybe if the other succeeded normally.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 startWith does not operate by default on a particularScheduler.
 Parameters:
 other - the otherSingleSource to run first
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifother isnull
 Since:
 3.0.0
 - startWith
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")@BackpressureSupport(value=FULL)public final @NonNullFlowable<T> startWith(@NonNullMaybeSource<T> other)
```
 Returns aFlowable which first runs the otherMaybeSource then the currentMaybe if the other succeeded or completed normally.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 startWith does not operate by default on a particularScheduler.
 Parameters:
 other - the otherMaybeSource to run first
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifother isnull
 Since:
 3.0.0
 - startWith
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullObservable<T> startWith(@NonNullObservableSource<T> other)
```
 Returns anObservable which first delivers the events of the otherObservableSource then runs the currentMaybe.
 Scheduler:
 startWith does not operate by default on a particularScheduler.
 Parameters:
 other - the otherObservableSource to run first
 Returns:
 the newObservable instance
 Throws:
 NullPointerException - ifother isnull
 Since:
 3.0.0
 - startWith
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final @NonNullFlowable<T> startWith(@NonNullPublisher<T> other)
```
 Returns aFlowable which first delivers the events of the otherPublisher then runs the currentMaybe.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer and expects the otherPublisher to honor it as well.
 Scheduler:
 startWith does not operate by default on a particularScheduler.
 Parameters:
 other - the otherPublisher to run first
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifother isnull
 Since:
 3.0.0
 - subscribe
```
@SchedulerSupport(value="none")@NonNullpublic final @NonNullDisposable subscribe()
```
 Subscribes to aMaybe and ignoresonSuccess andonComplete emissions.
 If theMaybe emits an error, it is wrapped into anOnErrorNotImplementedException and routed to theRxJavaPlugins.onError(Throwable) handler.
 Scheduler:
 subscribe does not operate by default on a particularScheduler.
 Returns:
 the newDisposable instance that can be used for disposing the subscription at any time
 See Also:
 ReactiveX operators documentation: Subscribe,subscribe(Consumer, Consumer, Action, DisposableContainer)
 - subscribe
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullDisposable subscribe(@NonNullConsumer<? superT> onSuccess)
```
 Subscribes to aMaybe and provides a callback to handle the items it emits.
 If theMaybe emits an error, it is wrapped into anOnErrorNotImplementedException and routed to theRxJavaPlugins.onError(Throwable) handler.
 Scheduler:
 subscribe does not operate by default on a particularScheduler.
 Parameters:
 onSuccess - theConsumer<T> you have designed to accept a success value from theMaybe
 Returns:
 the newDisposable instance that can be used for disposing the subscription at any time
 Throws:
 NullPointerException - ifonSuccess isnull
 See Also:
 ReactiveX operators documentation: Subscribe,subscribe(Consumer, Consumer, Action, DisposableContainer)
 - subscribe
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullDisposable subscribe(@NonNullConsumer<? superT> onSuccess,@NonNullConsumer<? superThrowable> onError)
```
 Subscribes to aMaybe 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 theMaybe
 onError - theConsumer<Throwable> you have designed to accept any error notification from theMaybe
 Returns:
 the newDisposable instance that can be used for disposing the subscription at any time
 Throws:
 NullPointerException - ifonSuccess isnull, or ifonError isnull
 See Also:
 ReactiveX operators documentation: Subscribe,subscribe(Consumer, Consumer, Action, DisposableContainer)
 - subscribe
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullDisposable subscribe(@NonNullConsumer<? superT> onSuccess,@NonNullConsumer<? superThrowable> onError,@NonNullAction onComplete)
```
 Subscribes to aMaybe 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 theMaybe
 onError - theConsumer<Throwable> you have designed to accept any error notification from theMaybe
 onComplete - theAction you have designed to accept a completion notification from theMaybe
 Returns:
 the newDisposable instance that can be used for disposing the subscription at any time
 Throws:
 NullPointerException - ifonSuccess,onError oronComplete isnull
 See Also:
 ReactiveX operators documentation: Subscribe,subscribe(Consumer, Consumer, Action, DisposableContainer)
 - subscribe
```
@SchedulerSupport(value="none")@NonNullpublic final @NonNullDisposable subscribe(@NonNullConsumer<? superT> onSuccess,@NonNullConsumer<? superThrowable> onError,@NonNullAction onComplete,@NonNullDisposableContainer container)
```
 Wraps the given onXXX callbacks into aDisposableMaybeObserver, adds it to the givenDisposableContainer and ensures, that if the upstream terminates or this particularDisposable is disposed, theMaybeObserver is removed from the given composite.
 TheMaybeObserver will be removed after the callback for the terminal event has been invoked.
 Scheduler:
 subscribe does not operate by default on a particularScheduler.
 Parameters:
 onSuccess - the callback for upstream items
 onError - the callback for an upstream error
 onComplete - the callback for an upstream completion without any value or error
 container - theDisposableContainer (such asCompositeDisposable) to add and remove the createdDisposableMaybeObserver
 Returns:
 theDisposable that allows disposing the particular subscription.
 Throws:
 NullPointerException - ifonSuccess,onError,onComplete orcontainer isnull
 Since:
 3.1.0
 - subscribe
```
@SchedulerSupport(value="none")public final void subscribe(@NonNullMaybeObserver<? superT> observer)
```
 Description copied from interface: MaybeSource
 Subscribes the givenMaybeObserver to thisMaybeSource instance.
 Specified by:
 subscribe in interface MaybeSource<T>
 Parameters:
 observer - theMaybeObserver, notnull
 - subscribeActual
```
protected abstract void subscribeActual(@NonNullMaybeObserver<? 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 - theMaybeObserver to handle, notnull
 - subscribeOn
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public final @NonNullMaybe<T> subscribeOn(@NonNullScheduler scheduler)
```
 Asynchronously subscribes subscribers to thisMaybe on the specifiedScheduler.
 Scheduler:
 you specify whichScheduler this operator will use.
 Parameters:
 scheduler - theScheduler to perform subscription actions on
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifscheduler isnull
 See Also:
 ReactiveX operators documentation: SubscribeOn,RxJava Threading Examples,observeOn(io.reactivex.rxjava3.core.Scheduler)
 - subscribeWith
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final <E extendsMaybeObserver<? superT>> E subscribeWith(E observer)
```
 Subscribes a givenMaybeObserver (subclass) to thisMaybe and returns the givenMaybeObserver 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 theMaybeObserver to use and return
 Parameters:
 observer - theMaybeObserver (subclass) to use and return, notnull
 Returns:
 the inputobserver
 Throws:
 NullPointerException - ifobserver isnull
 - switchIfEmpty
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullMaybe<T> switchIfEmpty(@NonNullMaybeSource<? extendsT> other)
```
 Returns aMaybe that emits the items emitted by the currentMaybe or the items of an alternateMaybeSource if the currentMaybe is empty.
 Scheduler:
 switchIfEmpty does not operate by default on a particularScheduler.
 Parameters:
 other - the alternateMaybeSource to subscribe to if the main does not emit any items
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifother isnull
 - switchIfEmpty
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final @NonNullSingle<T> switchIfEmpty(@NonNullSingleSource<? extendsT> other)
```
 Returns aSingle that emits the items emitted by the currentMaybe or the item of an alternateSingleSource if the currentMaybe is empty.
 Scheduler:
 switchIfEmpty does not operate by default on a particularScheduler.
 History: 2.1.4 - experimental
 Parameters:
 other - the alternateSingleSource to subscribe to if the main does not emit any items
 Returns:
 the newSingle instance
 Throws:
 NullPointerException - ifother isnull
 Since:
 2.2
 - takeUntil
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  @NonNullMaybe<T> takeUntil(@NonNullMaybeSource other)
```
 Returns aMaybe that emits the items emitted by the currentMaybe until a secondMaybeSource emits an item.
 Scheduler:
 takeUntil does not operate by default on a particularScheduler.
 Type Parameters:
 U - the type of items emitted byother
 Parameters:
 other - theMaybeSource whose first emitted item will causetakeUntil to stop emitting items from the currentMaybe
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifother isnull
 See Also:
 ReactiveX operators documentation: TakeUntil
 - takeUntil
```
@BackpressureSupport(value=UNBOUNDED_IN)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  @NonNullMaybe<T> takeUntil(@NonNullPublisher other)
```
 Returns aMaybe that emits the item emitted by the currentMaybe until a secondPublisher 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 - thePublisher whose first emitted item will causetakeUntil to stop emitting items from the sourcePublisher
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifother isnull
 See Also:
 ReactiveX operators documentation: TakeUntil
 - timeInterval
```
@CheckReturnValue@NonNull@SchedulerSupport(value="io.reactivex:computation")public final @NonNullMaybe<Timed<T>> timeInterval()
```
 Measures the time (in milliseconds) between the subscription and success item emission of the currentMaybe and signals it as a tuple (Timed) success value.
 If the currentMaybe is empty or fails, the resultingMaybe will pass along the signals to the downstream. To measure the time to termination, usematerialize() and applySingle.timeInterval().
 Scheduler:
 timeInterval uses thecomputationScheduler for determining the current time upon subscription and upon receiving the success item from the currentMaybe.
 Returns:
 the newMaybe instance
 Since:
 3.0.0
 - timeInterval
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public final @NonNullMaybe<Timed<T>> timeInterval(@NonNullScheduler scheduler)
```
 Measures the time (in milliseconds) between the subscription and success item emission of the currentMaybe and signals it as a tuple (Timed) success value.
 If the currentMaybe is empty or fails, the resultingMaybe will pass along the signals to the downstream. To measure the time to termination, usematerialize() and applySingle.timeInterval(Scheduler).
 Scheduler:
 timeInterval uses the providedScheduler for determining the current time upon subscription and upon receiving the success item from the currentMaybe.
 Parameters:
 scheduler - theScheduler used for providing the current time
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifscheduler isnull
 Since:
 3.0.0
 - timeInterval
```
@CheckReturnValue@NonNull@SchedulerSupport(value="io.reactivex:computation")public final @NonNullMaybe<Timed<T>> timeInterval(@NonNullTimeUnit unit)
```
 Measures the time between the subscription and success item emission of the currentMaybe and signals it as a tuple (Timed) success value.
 If the currentMaybe is empty or fails, the resultingMaybe will pass along the signals to the downstream. To measure the time to termination, usematerialize() and applySingle.timeInterval(TimeUnit).
 Scheduler:
 timeInterval uses thecomputationScheduler for determining the current time upon subscription and upon receiving the success item from the currentMaybe.
 Parameters:
 unit - the time unit for measurement
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifunit isnull
 Since:
 3.0.0
 - timeInterval
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public final @NonNullMaybe<Timed<T>> timeInterval(@NonNullTimeUnit unit,@NonNullScheduler scheduler)
```
 Measures the time between the subscription and success item emission of the currentMaybe and signals it as a tuple (Timed) success value.
 If the currentMaybe is empty or fails, the resultingMaybe will pass along the signals to the downstream. To measure the time to termination, usematerialize() and applySingle.timeInterval(TimeUnit, Scheduler).
 Scheduler:
 timeInterval uses the providedScheduler for determining the current time upon subscription and upon receiving the success item from the currentMaybe.
 Parameters:
 unit - the time unit for measurement
 scheduler - theScheduler used for providing the current time
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifunit orscheduler isnull
 Since:
 3.0.0
 - timestamp
```
@CheckReturnValue@NonNull@SchedulerSupport(value="io.reactivex:computation")public final @NonNullMaybe<Timed<T>> timestamp()
```
 Combines the success value from the currentMaybe with the current time (in milliseconds) of its reception, using thecomputationScheduler as time source, then signals them as aTimed instance.
 If the currentMaybe is empty or fails, the resultingMaybe will pass along the signals to the downstream. To measure the time to termination, usematerialize() and applySingle.timestamp().
 Scheduler:
 timestamp uses thecomputationScheduler for determining the current time upon receiving the success item from the currentMaybe.
 Returns:
 the newMaybe instance
 Since:
 3.0.0
 - timestamp
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public final @NonNullMaybe<Timed<T>> timestamp(@NonNullScheduler scheduler)
```
 Combines the success value from the currentMaybe with the current time (in milliseconds) of its reception, using the givenScheduler as time source, then signals them as aTimed instance.
 If the currentMaybe is empty or fails, the resultingMaybe will pass along the signals to the downstream. To measure the time to termination, usematerialize() and applySingle.timestamp(Scheduler).
 Scheduler:
 timestamp uses the providedScheduler for determining the current time upon receiving the success item from the currentMaybe.
 Parameters:
 scheduler - theScheduler used for providing the current time
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifscheduler isnull
 Since:
 3.0.0
 - timestamp
```
@CheckReturnValue@NonNull@SchedulerSupport(value="io.reactivex:computation")public final @NonNullMaybe<Timed<T>> timestamp(@NonNullTimeUnit unit)
```
 Combines the success value from the currentMaybe with the current time of its reception, using thecomputationScheduler as time source, then signals it as aTimed instance.
 If the currentMaybe is empty or fails, the resultingMaybe will pass along the signals to the downstream. To measure the time to termination, usematerialize() and applySingle.timestamp(TimeUnit).
 Scheduler:
 timestamp uses thecomputationScheduler, for determining the current time upon receiving the success item from the currentMaybe.
 Parameters:
 unit - the time unit for measurement
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifunit isnull
 Since:
 3.0.0
 - timestamp
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public final @NonNullMaybe<Timed<T>> timestamp(@NonNullTimeUnit unit,@NonNullScheduler scheduler)
```
 Combines the success value from the currentMaybe with the current time of its reception, using the givenScheduler as time source, then signals it as aTimed instance.
 If the currentMaybe is empty or fails, the resultingMaybe will pass along the signals to the downstream. To measure the time to termination, usematerialize() and applySingle.timestamp(TimeUnit, Scheduler).
 Scheduler:
 timestamp uses the providedScheduler, which is used for determining the current time upon receiving the success item from the currentMaybe.
 Parameters:
 unit - the time unit for measurement
 scheduler - theScheduler used for providing the current time
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifunit orscheduler isnull
 Since:
 3.0.0
 - timeout
```
@CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")@NonNullpublic final @NonNullMaybe<T> timeout(long timeout,@NonNullTimeUnit unit)
```
 Returns aMaybe that mirrors the currentMaybe 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 resultingMaybe terminates and notifiesMaybeObservers of aTimeoutException.
 Scheduler:
 This version oftimeout operates by default on thecomputationScheduler.
 Parameters:
 timeout - maximum duration between emitted items before a timeout occurs
 unit - the unit of time that applies to thetimeout argument.
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifunit isnull
 See Also:
 ReactiveX operators documentation: Timeout
 - timeout
```
@CheckReturnValue@NonNull@SchedulerSupport(value="io.reactivex:computation")public final @NonNullMaybe<T> timeout(long timeout,@NonNullTimeUnit unit,@NonNullMaybeSource<? extendsT> fallback)
```
 Returns aMaybe that mirrors the currentMaybe 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 currentMaybe is disposed and resultingMaybe begins instead to mirror a fallbackMaybeSource.
 Scheduler:
 This version oftimeout operates by default on thecomputationScheduler.
 Parameters:
 timeout - maximum duration between items before a timeout occurs
 unit - the unit of time that applies to thetimeout argument
 fallback - the fallbackMaybeSource to use in case of a timeout
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifunit orfallback isnull
 See Also:
 ReactiveX operators documentation: Timeout
 - timeout
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public final @NonNullMaybe<T> timeout(long timeout,@NonNullTimeUnit unit,@NonNullScheduler scheduler,@NonNullMaybeSource<? extendsT> fallback)
```
 Returns aMaybe that mirrors the currentMaybe but applies a timeout policy for each emitted item using a specifiedScheduler. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the currentMaybe is disposed and resultingMaybe begins instead to mirror a fallbackMaybeSource.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 timeout - maximum duration between items before a timeout occurs
 unit - the unit of time that applies to thetimeout argument
 fallback - theMaybeSource to use as the fallback in case of a timeout
 scheduler - theScheduler to run the timeout timers on
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - iffallback,unit orscheduler isnull
 See Also:
 ReactiveX operators documentation: Timeout
 - timeout
```
@CheckReturnValue@SchedulerSupport(value="custom")@NonNullpublic final @NonNullMaybe<T> timeout(long timeout,@NonNullTimeUnit unit,@NonNullScheduler scheduler)
```
 Returns aMaybe that mirrors the currentMaybe but applies a timeout policy for each emitted item, where this policy is governed on a specifiedScheduler. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the resultingMaybe terminates and notifiesMaybeObservers of aTimeoutException.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 timeout - maximum duration between items before a timeout occurs
 unit - the unit of time that applies to thetimeout argument
 scheduler - theScheduler to run the timeout timers on
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifunit orscheduler isnull
 See Also:
 ReactiveX operators documentation: Timeout
 - timeout
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  @NonNullMaybe<T> timeout(@NonNullMaybeSource 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 signalingonSuccess oronComplete.
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - iftimeoutIndicator isnull
 - timeout
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  @NonNullMaybe<T> timeout(@NonNullMaybeSource timeoutIndicator,@NonNullMaybeSource<? 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 newMaybe instance
 Throws:
 NullPointerException - iftimeoutIndicator orfallback isnull
 - timeout
```
@BackpressureSupport(value=UNBOUNDED_IN)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  @NonNullMaybe<T> timeout(@NonNullPublisher 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 - thePublisher that indicates the timeout by signalingonSuccess oronComplete.
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - iftimeoutIndicator isnull
 - timeout
```
@BackpressureSupport(value=UNBOUNDED_IN)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  @NonNullMaybe<T> timeout(@NonNullPublisher timeoutIndicator,@NonNullMaybeSource<? 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 newMaybe instance
 Throws:
 NullPointerException - iftimeoutIndicator orfallback isnull
 - unsubscribeOn
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public final @NonNullMaybe<T> unsubscribeOn(@NonNullScheduler scheduler)
```
 Returns aMaybe which makes sure when aMaybeObserver disposes theDisposable, that call is propagated up on the specifiedScheduler.
 Scheduler:
 unsubscribeOn callsdispose() of the upstream on theScheduler you specify.
 Parameters:
 scheduler - the target scheduler where to execute the disposal
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifscheduler isnull
 - zipWith
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <U,R> @NonNullMaybe<R> zipWith(@NonNullMaybeSource<? extends U> other,@NonNullBiFunction<? superT,? super U,? extends R> zipper)
```
 Waits until this and the otherMaybeSource signal a success value then applies the givenBiFunction to those values and emits theBiFunction's resulting value to downstream.
 If either this or the otherMaybeSource is empty or signals an error, the resultingMaybe 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 theotherMaybeSource
 R - the type of items emitted by the resultingMaybe
 Parameters:
 other - the otherMaybeSource
 zipper - a function that combines the pairs of items from the twoMaybeSources to generate the items to be emitted by the resultingMaybe
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifother orzipper isnull
 See Also:
 ReactiveX operators documentation: Zip
 - test
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullTestObserver<T> test()
```
 Creates aTestObserver and subscribes it to thisMaybe.
 Scheduler:
 test does not operate by default on a particularScheduler.
 Returns:
 the newTestObserver instance
 - test
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullTestObserver<T> test(boolean dispose)
```
 Creates aTestObserver optionally in cancelled state, then subscribes it to thisMaybe.
 Scheduler:
 test does not operate by default on a particularScheduler.
 Parameters:
 dispose - iftrue, theTestObserver will be disposed before subscribing to thisMaybe.
 Returns:
 the newTestObserver instance
 - fromOptional
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic static <T> @NonNullMaybe<T> fromOptional(@NonNullOptional<T> optional)
```
 Converts the existing value of the provided optional into ajust(Object) or an empty optional into anempty()Maybe instance.
 Note that the operator takes an already instantiated optional reference and does not by any means create this original optional. If the optional is to be created per consumer upon subscription, usedefer(Supplier) aroundfromOptional:
```
 Maybe.defer(() -> Maybe.fromOptional(createOptional()));
```
 Scheduler:
 fromOptional does not operate by default on a particularScheduler.
 Type Parameters:
 T - the element type of the optional value
 Parameters:
 optional - the optional value to convert into aMaybe
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifoptional isnull
 Since:
 3.0.0
 See Also:
 just(Object),empty()
 - fromCompletionStage
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic static <T> @NonNullMaybe<T> fromCompletionStage(@NonNullCompletionStage<T> stage)
```
 Signals the completion value or error of the given (hot)CompletionStage-based asynchronous calculation.
 Note that the operator takes an already instantiated, running or terminatedCompletionStage. If theCompletionStage is to be created per consumer upon subscription, usedefer(Supplier) aroundfromCompletionStage:
```
 Maybe.defer(() -> Maybe.fromCompletionStage(createCompletionStage()));
```
 If theCompletionStage completes withnull, the resultingMaybe is completed viaonComplete.
 Canceling the flow can't cancel the execution of theCompletionStage becauseCompletionStage itself doesn't support cancellation. Instead, the operator detaches from theCompletionStage.
 Scheduler:
 fromCompletionStage does not operate by default on a particularScheduler.
 Type Parameters:
 T - the element type of theCompletionStage
 Parameters:
 stage - theCompletionStage to convert toMaybe and signal its terminal value or error
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifstage isnull
 Since:
 3.0.0
 - mapOptional
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final <R> @NonNullMaybe<R> mapOptional(@NonNullFunction<? superT,Optional<? extends R>> mapper)
```
 Maps the upstream success value into anOptional and emits the contained item if not empty.
 Scheduler:
 mapOptional does not operate by default on a particularScheduler.
 Type Parameters:
 R - the non-null output type
 Parameters:
 mapper - the function that receives the upstream success item and should return anon-emptyOptional to emit as the success output or anemptyOptional to complete theMaybe
 Returns:
 the newMaybe instance
 Throws:
 NullPointerException - ifmapper isnull
 Since:
 3.0.0
 See Also:
 map(Function),filter(Predicate)
 - toCompletionStage
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullCompletionStage<T> toCompletionStage()
```
 Signals the upstream success item (or aNoSuchElementException if the upstream is empty) via aCompletionStage.
 The upstream can be canceled by converting the resultingCompletionStage intoCompletableFuture viaCompletionStage.toCompletableFuture() and callingCompletableFuture.cancel(boolean) on it. The upstream will be also cancelled if the resultingCompletionStage is converted to and completed manually byCompletableFuture.complete(Object) orCompletableFuture.completeExceptionally(Throwable).
 CompletionStages don't have a notion of emptiness and allownulls, therefore, one can either usetoCompletionStage(Object) withnull or turn the upstream into a sequence ofOptionals and default toOptional.empty():
```
 CompletionStage<Optional<T>> stage = source.map(Optional::of).toCompletionStage(Optional.empty());
```
 Scheduler:
 toCompletionStage does not operate by default on a particularScheduler.
 Returns:
 the newCompletionStage instance
 Since:
 3.0.0
 See Also:
 toCompletionStage(Object)
 - toCompletionStage
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final @NonNullCompletionStage<T> toCompletionStage(@NullableT defaultItem)
```
 Signals the upstream success item (or the default item if the upstream is empty) via aCompletionStage.
 The upstream can be canceled by converting the resultingCompletionStage intoCompletableFuture viaCompletionStage.toCompletableFuture() and callingCompletableFuture.cancel(boolean) on it. The upstream will be also cancelled if the resultingCompletionStage is converted to and completed manually byCompletableFuture.complete(Object) orCompletableFuture.completeExceptionally(Throwable).
 CompletionStages don't have a notion of emptiness and allownulls, therefore, one can either use adefaultItem ofnull or turn the flow into a sequence ofOptionals and default toOptional.empty():
```
 CompletionStage<Optional<T>> stage = source.map(Optional::of).toCompletionStage(Optional.empty());
```
 Scheduler:
 toCompletionStage does not operate by default on a particularScheduler.
 Parameters:
 defaultItem - the item to signal if the upstream is empty
 Returns:
 the newCompletionStage instance
 Since:
 3.0.0
 - flattenStreamAsFlowable
```
@CheckReturnValue@SchedulerSupport(value="none")@BackpressureSupport(value=FULL)@NonNullpublic final <R> @NonNullFlowable<R> flattenStreamAsFlowable(@NonNullFunction<? superT,? extendsStream<? extends R>> mapper)
```
 Maps the upstream succecss value into a JavaStream and emits its items to the downstream consumer as aFlowable.
 The operator closes theStream upon cancellation and when it terminates. The exceptions raised when closing aStream are routed to the global error handler (RxJavaPlugins.onError(Throwable). If aStream should not be closed, turn it into anIterable and useflattenAsFlowable(Function):
```
 source.flattenAsFlowable(item -> createStream(item)::iterator);
```
 Primitive streams are not supported and items have to be boxed manually (e.g., viaIntStream.boxed()):
```
 source.flattenStreamAsFlowable(item -> IntStream.rangeClosed(1, 10).boxed());
```
 Stream does not support concurrent usage so creating and/or consuming the same instance multiple times from multiple threads can lead to undefined behavior.
 Backpressure:
 The operator honors backpressure from downstream and iterates the givenStream on demand (i.e., when requested).
 Scheduler:
 flattenStreamAsFlowable does not operate by default on a particularScheduler.
 Type Parameters:
 R - the element type of theStream and the outputFlowable
 Parameters:
 mapper - the function that receives the upstream success item and should return aStream of values to emit.
 Returns:
 the newFlowable instance
 Throws:
 NullPointerException - ifmapper isnull
 Since:
 3.0.0
 See Also:
 flattenAsFlowable(Function),flattenStreamAsObservable(Function)
 - flattenStreamAsObservable
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final <R> @NonNullObservable<R> flattenStreamAsObservable(@NonNullFunction<? superT,? extendsStream<? extends R>> mapper)
```
 Maps the upstream succecss value into a JavaStream and emits its items to the downstream consumer as anObservable.
 The operator closes theStream upon cancellation and when it terminates. The exceptions raised when closing aStream are routed to the global error handler (RxJavaPlugins.onError(Throwable). If aStream should not be closed, turn it into anIterable and useflattenAsObservable(Function):
```
 source.flattenAsObservable(item -> createStream(item)::iterator);
```
 Primitive streams are not supported and items have to be boxed manually (e.g., viaIntStream.boxed()):
```
 source.flattenStreamAsObservable(item -> IntStream.rangeClosed(1, 10).boxed());
```
 Stream does not support concurrent usage so creating and/or consuming the same instance multiple times from multiple threads can lead to undefined behavior.
 Scheduler:
 flattenStreamAsObservable does not operate by default on a particularScheduler.
 Type Parameters:
 R - the element type of theStream and the outputObservable
 Parameters:
 mapper - the function that receives the upstream success item and should return aStream of values to emit.
 Returns:
 the newObservable instance
 Throws:
 NullPointerException - ifmapper isnull
 Since:
 3.0.0
 See Also:
 flattenAsObservable(Function),flattenStreamAsFlowable(Function)

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

concatArrayEagerDelayError

concatDelayError

concatDelayError

concatDelayError

concatEager

concatEager

concatEager

concatEager

concatEagerDelayError

concatEagerDelayError

concatEagerDelayError

concatEagerDelayError

create

defer

empty

error

error

fromAction

fromCompletable

fromSingle

fromCallable

fromFuture

fromFuture

fromObservable

fromPublisher

fromRunnable

fromSupplier

just

merge

merge

merge

merge

merge

merge

merge

mergeArray

mergeArrayDelayError

mergeDelayError

mergeDelayError

mergeDelayError

mergeDelayError

mergeDelayError

mergeDelayError

never

sequenceEqual

sequenceEqual

switchOnNext

switchOnNextDelayError

timer

timer

unsafeCreate

using

using

wrap

zip

zip

zip

zip

zip

zip

zip