Maybe (RxJava Javadoc 2.0.0-RC2)

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

Type Parameters:
T - the value type

All Implemented Interfaces:

MaybeSource<T>
```
public abstract class Maybe<T>
extends java.lang.Object
implements MaybeSource<T>
```
Represents a deferred computation and emission of a maybe value or exception.
The main consumer type of Maybe is MaybeObserver whose methods are called in a sequential fashion following this protocol:
onSubscribe (onSuccess | onError | onComplete)?.

Since:

2.0

Constructor Summary

Constructors
Constructor and Description

Maybe()

Constructors
Constructor and Description
`Maybe()`

Method Summary

Methods
Modifier and Type	Method and Description
`static <T> Maybe<T>`	`amb(java.lang.Iterable<? extends MaybeSource<? extends T>> sources)` Runs multiple Maybe sources and signals the events of the first one that signals (cancelling the rest).
`static <T> Maybe<T>`	`ambArray(MaybeSource<? extends T>... sources)` Runs multiple Maybe sources and signals the events of the first one that signals (cancelling the rest).
`<U> Maybe<U>`	`cast(java.lang.Class<? extends U> clazz)` Casts the success value of the current Maybe into the target type or signals a ClassCastException if not compatible.
`<R> Maybe<R>`	`compose(Function<? super Maybe<T>,? extends MaybeSource<R>> transformer)` Transform a Maybe by applying a particular Transformer function to it.
`static <T> Flowable<T>`	`concat(java.lang.Iterable<? extends MaybeSource<? extends T>> sources)` Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by an Iterable sequence.
`static <T> Flowable<T>`	`concat(MaybeSource<? extends T> source1, MaybeSource<? extends T> source2)` Returns a Flowable that emits the items emitted by two MaybeSources, one after the other.
`static <T> Flowable<T>`	`concat(MaybeSource<? extends T> source1, MaybeSource<? extends T> source2, MaybeSource<? extends T> source3)` Returns a Flowable that emits the items emitted by three MaybeSources, one after the other.
`static <T> Flowable<T>`	`concat(MaybeSource<? extends T> source1, MaybeSource<? extends T> source2, MaybeSource<? extends T> source3, MaybeSource<? extends T> source4)` Returns a Flowable that emits the items emitted by four MaybeSources, one after the other.
`static <T> Flowable<T>`	`concat(org.reactivestreams.Publisher<? extends MaybeSource<? extends T>> sources)` Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by a Publisher sequence.
`static <T> Flowable<T>`	`concat(org.reactivestreams.Publisher<? extends MaybeSource<? extends T>> sources, int prefetch)` Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by a Publisher sequence.
`static <T> Flowable<T>`	`concatArray(MaybeSource<? extends T>... sources)` Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources in the array.
`<R> Maybe<R>`	`concatMap(Function<? super T,? extends MaybeSource<? extends R>> mapper)` Returns a Maybe that is based on applying a specified function to the item emitted by the source Maybe, where that function returns a MaybeSource.
`static <T> Maybe<T>`	`create(MaybeOnSubscribe<T> onSubscribe)` Provides an API (via a cold Maybe) that bridges the reactive world with the callback-style world.
`static <T> Maybe<T>`	`defer(java.util.concurrent.Callable<? extends MaybeSource<? extends T>> maybeSupplier)` Calls a Callable for each individual MaybeObserver to return the actual MaybeSource source to be subscribe to.
`Maybe<T>`	`doAfterTerminate(Action onAfterTerminate)` Registers an `Action` to be called when this Maybe invokes either `onSuccess`, `onComplete` or `onError`.
`Maybe<T>`	`doOnComplete(Action onComplete)` Modifies the source Maybe so that it invokes an action when it calls `onCompleted`.
`Maybe<T>`	`doOnDispose(Action onDispose)` Calls the shared runnable if a MaybeObserver subscribed to the current Single disposes the common Disposable it received via onSubscribe.
`Maybe<T>`	`doOnError(Consumer<? super java.lang.Throwable> onError)` Calls the shared consumer with the error sent via onError for each MaybeObserver that subscribes to the current Single.
`Maybe<T>`	`doOnEvent(BiConsumer<? super T,? super java.lang.Throwable> onEvent)` Calls the given onEvent callback with the (success value, null) for an onSuccess, (null, throwabe) for an onError or (null, null) for an onComplete signal from this Maybe before delivering said signal to the downstream.
`Maybe<T>`	`doOnSubscribe(Consumer<? super Disposable> onSubscribe)` Calls the shared consumer with the Disposable sent through the onSubscribe for each MaybeObserver that subscribes to the current Single.
`Maybe<T>`	`doOnSuccess(Consumer<? super T> onSuccess)` Calls the shared consumer with the success value sent via onSuccess for each MaybeObserver that subscribes to the current Single.
`static <T> Maybe<T>`	`empty()` Returns a (singleton) Maybe instance that calls `onComplete` immediately.
`static <T> Maybe<T>`	`error(java.util.concurrent.Callable<? extends java.lang.Throwable> supplier)` Returns a Maybe that invokes an `Observer`'s `onError` method when the Observer subscribes to it.
`static <T> Maybe<T>`	`error(java.lang.Throwable exception)` Returns a Maybe that invokes a subscriber's `onError` method when the subscriber subscribes to it.
`Maybe<T>`	`filter(Predicate<? super T> predicate)` Filters the success item of the Maybe via a predicate function and emitting it if the predicate returns true, completing otherwise.
`<R> Maybe<R>`	`flatMap(Function<? super T,? extends MaybeSource<? extends R>> mapper)` Returns a Maybe that is based on applying a specified function to the item emitted by the source Maybe, where that function returns a MaybeSource.
`<R> Maybe<R>`	`flatMap(Function<? super T,? extends MaybeSource<? extends R>> onSuccessMapper, Function<? super java.lang.Throwable,? extends MaybeSource<? extends R>> onErrorMapper, java.util.concurrent.Callable<? extends MaybeSource<? extends R>> onCompleteSupplier)` Maps the onSuccess, onError or onComplete signals of this Maybe into MaybeSource and emits that MaybeSource's signals
`static <T> Maybe<T>`	`fromAction(Action run)` Returns a Maybe instance that runs the given Action for each subscriber and emits either its exception or simply completes.
`static <T> Maybe<T>`	`fromCallable(java.util.concurrent.Callable<? extends T> callable)` Returns a `Maybe` that invokes passed function and emits its result for each new MaybeObserver that subscribes while considering `null` value from the callable as indication for valueless completion.
`static <T> Maybe<T>`	`fromRunnable(java.lang.Runnable run)` Returns a Maybe instance that runs the given Action for each subscriber and emits either its exception or simply completes.
`Maybe<T>`	`ignoreElement()` Ignores the item emitted by the source Maybe and only calls `onCompleted` or `onError`.
`static <T> Maybe<T>`	`just(T item)` Returns a `Maybe` that emits a specified item.
`<R> Maybe<R>`	`lift(MaybeOperator<? extends R,? super T> lift)` Lifts a function to the current Maybe and returns a new Maybe that when subscribed to will pass the values of the current Maybe through the MaybeOperator function.
`<R> Maybe<R>`	`map(Function<? super T,? extends R> mapper)` Returns a Maybe that applies a specified function to the item emitted by the source Maybe and emits the result of this function application.
`static <T> Flowable<T>`	`merge(java.lang.Iterable<? extends MaybeSource<? extends T>> sources)` Merges an Iterable sequence of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.
`static <T> Maybe<T>`	`merge(MaybeSource<? extends MaybeSource<? extends T>> source)` Flattens a `Single` that emits a `Single` into a single `Single` that emits the item emitted by the nested `Single`, without any transformation.
`static <T> Flowable<T>`	`merge(MaybeSource<? extends T> source1, MaybeSource<? extends T> source2)` Flattens two Singles into a single Observable, without any transformation.
`static <T> Flowable<T>`	`merge(MaybeSource<? extends T> source1, MaybeSource<? extends T> source2, MaybeSource<? extends T> source3)` Flattens three Singles into a single Observable, without any transformation.
`static <T> Flowable<T>`	`merge(MaybeSource<? extends T> source1, MaybeSource<? extends T> source2, MaybeSource<? extends T> source3, MaybeSource<? extends T> source4)` Flattens four Singles into a single Observable, without any transformation.
`static <T> Flowable<T>`	`merge(org.reactivestreams.Publisher<? extends MaybeSource<? extends T>> sources)` Merges a Flowable sequence of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.
`static <T> Flowable<T>`	`merge(org.reactivestreams.Publisher<? extends MaybeSource<? extends T>> sources, int maxConcurrency)` Merges a Flowable sequence of MaybeSource instances into a single Flowable sequence, running at most maxConcurrency MaybeSources at once.
`static <T> Flowable<T>`	`mergeArray(MaybeSource<? extends T>... sources)` Merges an array sequence of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.
`static <T> Maybe<T>`	`never()` Returns a Maybe that never sends any items or notifications to an `MaybeObserver`.
`Maybe<T>`	`observeOn(Scheduler scheduler)` Wraps a Maybe to emit its item (or notify of its error) on a specified `Scheduler`, asynchronously.
`Disposable`	`subscribe()` Subscribes to a Maybe and ignores `onSuccess` and `onComplete` emissions.
`Disposable`	`subscribe(Consumer<? super T> onSuccess)` Subscribes to a Maybe and provides a callback to handle the items it emits.
`Disposable`	`subscribe(Consumer<? super T> onSuccess, Consumer<? super java.lang.Throwable> onError)` Subscribes to a Maybe and provides callbacks to handle the items it emits and any error notification it issues.
`Disposable`	`subscribe(Consumer<? super T> onSuccess, Consumer<? super java.lang.Throwable> onError, Action onComplete)` Subscribes to a Maybe and provides callbacks to handle the items it emits and any error or completion notification it issues.
`void`	`subscribe(MaybeObserver<? super T> observer)` Subscribes the given MaybeObserver to this MaybeSource instance.
`protected abstract void`	`subscribeActual(MaybeObserver<? super T> observer)` Override this method in subclasses to handle the incoming MaybeObservers.
`Maybe<T>`	`subscribeOn(Scheduler scheduler)` Asynchronously subscribes subscribers to this Maybe on the specified `Scheduler`.
`<E extends MaybeObserver<? super T>> E`	`subscribeWith(E observer)` Subscribes a given MaybeObserver (subclass) to this Maybe and returns the given MaybeObserver as is.
`TestSubscriber<T>`	`test()` Creates a TestSubscriber and subscribes it to this Maybe.
`TestSubscriber<T>`	`test(boolean cancelled)` Creates a TestSubscriber optionally in cancelled state, then subscribes it to this Maybe.
`<R> R`	`to(Function<? super Maybe<T>,R> convert)` Calls the specified converter function with the current Maybe instance during assembly time and returns its result.
`Completable`	`toCompletable()` Converts this Maybe into an Completable instance composing cancellation through and dropping a success value if emitted.
`Flowable<T>`	`toFlowable()` Converts this Maybe into a backpressure-aware Flowable instance composing cancellation through.
`Observable<T>`	`toObservable()` Converts this Maybe into an Observable instance composing cancellation through.
`Single<T>`	`toSingle()` Converts this Maybe into an Single instance composing cancellation through and turing an empty Maybe into a signal of NoSuchElementException.
`static <T> Maybe<T>`	`unsafeCreate(MaybeSource<T> onSubscribe)` Advanced use only: creates a Maybe instance without any safeguards by using a callback that is called with a MaybeObserver.
`static <T> Maybe<T>`	`wrap(MaybeSource<T> source)` Wraps a MaybeSource instance into a new Maybe instance if not already a Maybe instance.

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
```
public static <T> Maybe<T> amb(java.lang.Iterable<? extends MaybeSource<? extends T>> sources)
```
    Runs multiple Maybe sources and signals the events of the first one that signals (cancelling the rest).
    
    Scheduler:
    
    amb does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the value type
    Parameters:
    sources - the Iterable sequence of sources
    
    Returns:
    the new Maybe instance
  - ambArray
```
public static <T> Maybe<T> ambArray(MaybeSource<? extends T>... sources)
```
    Runs multiple Maybe sources and signals the events of the first one that signals (cancelling the rest).
    
    Scheduler:
    
    amb does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the value type
    Parameters:
    sources - the array of sources
    
    Returns:
    the new Maybe instance
  - create
```
public static <T> Maybe<T> create(MaybeOnSubscribe<T> onSubscribe)
```
    Provides an API (via a cold Maybe) that bridges the reactive world with the callback-style world.
    Example:
```
 Maybe.<Event>create(emitter -> {
     Callback listener = new Callback() {
         @Override
         public void onEvent(Event e) {
             if (e.isNothing()) {
                 emitter.onComplete();
             } else {
                 emitter.onSuccess(e);
             }
         }
         
         @Override
         public void onFailure(Exception e) {
             emitter.onError(e);
         }
     };
     
     AutoCloseable c = api.someMethod(listener);
     
     emitter.setCancellable(c::close);
     
 });
 
```
    Scheduler:
    
    create does not operate by default on a particular Scheduler.
    Type Parameters:
    T - the value type
    Parameters:
    onSubscribe - the emitter that is called when a MaybeObserver subscribes to the returned Flowable
    
    Returns:
    the new Maybe instance
    See Also:
    MaybeOnSubscribe, Cancellable
  - concat
```
public static <T> Flowable<T> concat(java.lang.Iterable<? extends MaybeSource<? extends T>> sources)
```
    Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by an Iterable sequence.
    
    Scheduler:
    
    concat does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the value type
    Parameters:
    sources - the Iterable sequence of MaybeSource instances
    
    Returns:
    the new Flowable instance
  - concat
```
public static <T> Flowable<T> concat(MaybeSource<? extends T> source1,
                     MaybeSource<? extends T> source2)
```
    Returns a Flowable that emits the items emitted by two MaybeSources, one after the other.
    
    Scheduler:
    
    concat does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the common value type
    Parameters:
    source1 - a MaybeSource to be concatenated
    source2 - a MaybeSource to be concatenated
    
    Returns:
    a Flowable that emits items emitted by the two source MaybeSources, one after the other.
    See Also:
    ReactiveX operators documentation: Concat
  - concat
```
public static <T> Flowable<T> concat(MaybeSource<? extends T> source1,
                     MaybeSource<? extends T> source2,
                     MaybeSource<? extends T> source3)
```
    Returns a Flowable that emits the items emitted by three MaybeSources, one after the other.
    
    Scheduler:
    
    concat does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the common value type
    Parameters:
    source1 - a MaybeSource to be concatenated
    source2 - a MaybeSource to be concatenated
    source3 - a MaybeSource to be concatenated
    
    Returns:
    a Flowable that emits items emitted by the three source MaybeSources, one after the other.
    See Also:
    ReactiveX operators documentation: Concat
  - concat
```
public static <T> Flowable<T> concat(MaybeSource<? extends T> source1,
                     MaybeSource<? extends T> source2,
                     MaybeSource<? extends T> source3,
                     MaybeSource<? extends T> source4)
```
    Returns a Flowable that emits the items emitted by four MaybeSources, one after the other.
    
    Scheduler:
    
    concat does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the common value type
    Parameters:
    source1 - a MaybeSource to be concatenated
    source2 - a MaybeSource to be concatenated
    source3 - a MaybeSource to be concatenated
    source4 - a MaybeSource to be concatenated
    
    Returns:
    a Flowable that emits items emitted by the four source MaybeSources, one after the other.
    See Also:
    ReactiveX operators documentation: Concat
  - concat
```
public static <T> Flowable<T> concat(org.reactivestreams.Publisher<? extends MaybeSource<? extends T>> sources)
```
    Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by a Publisher sequence.
    
    Scheduler:
    
    concat does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the value type
    Parameters:
    sources - the Publisher of MaybeSource instances
    
    Returns:
    the new Flowable instance
  - concat
```
public static <T> Flowable<T> concat(org.reactivestreams.Publisher<? extends MaybeSource<? extends T>> sources,
                     int prefetch)
```
    Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by a Publisher sequence.
    
    Scheduler:
    
    concat does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the value type
    Parameters:
    sources - the Publisher of MaybeSource instances
    prefetch - the number of MaybeSources to prefetch from the Publisher
    
    Returns:
    the new Flowable instance
  - concatArray
```
public static <T> Flowable<T> concatArray(MaybeSource<? extends T>... sources)
```
    Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources in the array.
    
    Scheduler:
    
    concat does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the value type
    Parameters:
    sources - the Publisher of MaybeSource instances
    
    Returns:
    the new Flowable instance
  - defer
```
public static <T> Maybe<T> defer(java.util.concurrent.Callable<? extends MaybeSource<? extends T>> maybeSupplier)
```
    Calls a Callable for each individual MaybeObserver to return the actual MaybeSource source to be subscribe to.
    
    Scheduler:
    
    defer does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the value type
    Parameters:
    maybeSupplier - the Callable that is called for each individual MaybeObserver and returns a MaybeSource instance to subscribe to
    
    Returns:
    the new Maybe instance
  - empty
```
public static <T> Maybe<T> empty()
```
    Returns a (singleton) Maybe instance that calls onComplete immediately.
    
    Scheduler:
    
    empty does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the value type
    
    Returns:
    the new Maybe instance
  - error
```
public static <T> Maybe<T> error(java.lang.Throwable exception)
```
    Returns a Maybe that invokes a subscriber's onError method when the subscriber subscribes to it.
    
    Scheduler:
    
    error does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the type of the item (ostensibly) emitted by the Maybe
    Parameters:
    exception - the particular Throwable to pass to onError
    
    Returns:
    a Maybe that invokes the subscriber's onError method when the subscriber subscribes to it
    See Also:
    ReactiveX operators documentation: Throw
  - error
```
public static <T> Maybe<T> error(java.util.concurrent.Callable<? extends java.lang.Throwable> supplier)
```
    Returns a Maybe that invokes an Observer's onError method when the Observer subscribes to it.
    
    Scheduler:
    
    error does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the type of the items (ostensibly) emitted by the Maybe
    Parameters:
    supplier - a Callable factory to return a Throwable for each individual Subscriber
    
    Returns:
    a Maybe that invokes the MaybeObserver's onError method when the MaybeObserver subscribes to it
    See Also:
    ReactiveX operators documentation: Throw
  - fromAction
```
@SchedulerSupport(value="none")
public static <T> Maybe<T> fromAction(Action run)
```
    Returns a Maybe instance that runs the given Action for each subscriber and emits either its exception or simply completes.
    
    Scheduler:
    
    fromAction does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the target type
    Parameters:
    run - the runnable to run for each subscriber
    
    Returns:
    the new Maybe instance
    
    Throws:
    
    java.lang.NullPointerException - if run is null
  - fromCallable
```
public static <T> Maybe<T> fromCallable(java.util.concurrent.Callable<? extends T> callable)
```
    Returns a Maybe that invokes passed function and emits its result for each new MaybeObserver that subscribes while considering null value from the callable as indication for valueless completion.
    Allows you to defer execution of passed function until MaybeObserver subscribes to the Maybe. It makes passed function "lazy". Result of the function invocation will be emitted by the Maybe.
    
    Scheduler:
    
    fromCallable does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the type of the item emitted by the Maybe.
    Parameters:
    callable - function which execution should be deferred, it will be invoked when MaybeObserver will subscribe to the Maybe.
    
    Returns:
    a Maybe whose MaybeObservers' subscriptions trigger an invocation of the given function.
  - fromRunnable
```
@SchedulerSupport(value="none")
public static <T> Maybe<T> fromRunnable(java.lang.Runnable run)
```
    Returns a Maybe instance that runs the given Action for each subscriber and emits either its exception or simply completes.
    
    Scheduler:
    
    fromRunnable does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the target type
    Parameters:
    run - the runnable to run for each subscriber
    
    Returns:
    the new Maybe instance
    
    Throws:
    
    java.lang.NullPointerException - if run is null
  - just
```
public static <T> Maybe<T> just(T item)
```
    Returns a Maybe that emits a specified item.
    
    To convert any object into a Single that emits that object, pass that object into the just method.
    
    Scheduler:
    
    just does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the type of that item
    Parameters:
    item - the item to emit
    
    Returns:
    a Maybe that emits item
    See Also:
    ReactiveX operators documentation: Just
  - merge
```
public static <T> Flowable<T> merge(java.lang.Iterable<? extends MaybeSource<? extends T>> sources)
```
    Merges an Iterable sequence of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.
    
    Scheduler:
    
    merge does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the common and resulting value type
    Parameters:
    sources - the Iterable sequence of MaybeSource sources
    
    Returns:
    the new Flowable instance
    Since:
    
    2.0
  - merge
```
public static <T> Flowable<T> merge(org.reactivestreams.Publisher<? extends MaybeSource<? extends T>> sources)
```
    Merges a Flowable sequence of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.
    
    Scheduler:
    
    merge does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the common and resulting value type
    Parameters:
    sources - the Flowable sequence of MaybeSource sources
    
    Returns:
    the new Flowable instance
    Since:
    
    2.0
  - merge
```
public static <T> Flowable<T> merge(org.reactivestreams.Publisher<? extends MaybeSource<? extends T>> sources,
                    int maxConcurrency)
```
    Merges a Flowable sequence of MaybeSource instances into a single Flowable sequence, running at most maxConcurrency MaybeSources at once.
    
    Scheduler:
    
    merge does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the common and resulting value type
    Parameters:
    sources - the Flowable sequence of MaybeSource sources
    maxConcurrency - the maximum number of concurrently running MaybeSources
    
    Returns:
    the new Flowable instance
    Since:
    
    2.0
  - merge
```
public static <T> Maybe<T> merge(MaybeSource<? extends MaybeSource<? extends T>> source)
```
    Flattens a Single that emits a Single into a single Single that emits the item emitted by the nested Single, without any transformation.
    
    Scheduler:
    
    merge does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the value type of the sources and the output
    Parameters:
    source - a Single that emits a Single
    
    Returns:
    a Single that emits the item that is the result of flattening the Single emitted by source
    See Also:
    ReactiveX operators documentation: Merge
  - merge
```
public static <T> Flowable<T> merge(MaybeSource<? extends T> source1,
                    MaybeSource<? extends T> source2)
```
    Flattens two Singles into a single Observable, without any transformation.
    
    You can combine items emitted by multiple Singles so that they appear as a single Observable, by using the merge method.
    
    Scheduler:
    
    merge does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the common value type
    Parameters:
    source1 - a Single to be merged
    source2 - a Single to be merged
    
    Returns:
    a Flowable that emits all of the items emitted by the source Singles
    See Also:
    ReactiveX operators documentation: Merge
  - merge
```
public static <T> Flowable<T> merge(MaybeSource<? extends T> source1,
                    MaybeSource<? extends T> source2,
                    MaybeSource<? extends T> source3)
```
    Flattens three Singles into a single Observable, without any transformation.
    
    You can combine items emitted by multiple Singles so that they appear as a single Observable, by using the merge method.
    
    Scheduler:
    
    merge does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the common value type
    Parameters:
    source1 - a Single to be merged
    source2 - a Single to be merged
    source3 - a Single to be merged
    
    Returns:
    a Flowable that emits all of the items emitted by the source Singles
    See Also:
    ReactiveX operators documentation: Merge
  - merge
```
public static <T> Flowable<T> merge(MaybeSource<? extends T> source1,
                    MaybeSource<? extends T> source2,
                    MaybeSource<? extends T> source3,
                    MaybeSource<? extends T> source4)
```
    Flattens four Singles into a single Observable, without any transformation.
    
    You can combine items emitted by multiple Singles so that they appear as a single Observable, by using the merge method.
    
    Scheduler:
    
    merge does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the common value type
    Parameters:
    source1 - a Single to be merged
    source2 - a Single to be merged
    source3 - a Single to be merged
    source4 - a Single to be merged
    
    Returns:
    a Flowable that emits all of the items emitted by the source Singles
    See Also:
    ReactiveX operators documentation: Merge
  - mergeArray
```
public static <T> Flowable<T> mergeArray(MaybeSource<? extends T>... sources)
```
    Merges an array sequence of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.
    
    Scheduler:
    
    merge does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the common and resulting value type
    Parameters:
    sources - the array sequence of MaybeSource sources
    
    Returns:
    the new Flowable instance
    Since:
    
    2.0
  - never
```
public static <T> Maybe<T> never()
```
    Returns a Maybe that never sends any items or notifications to an MaybeObserver.
    
    This Maybe is useful primarily for testing purposes.
    
    Scheduler:
    
    never does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the type of items (not) emitted by the Maybe
    
    Returns:
    a Maybe that never emits any items or sends any notifications to an MaybeObserver
    See Also:
    ReactiveX operators documentation: Never
  - unsafeCreate
```
public static <T> Maybe<T> unsafeCreate(MaybeSource<T> onSubscribe)
```
    Advanced use only: creates a Maybe instance without any safeguards by using a callback that is called with a MaybeObserver.
    
    Scheduler:
    
    unsafeCreate does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the value type
    Parameters:
    onSubscribe - the function that is called with the subscribing MaybeObserver
    
    Returns:
    the new Maybe instance
  - wrap
```
public static <T> Maybe<T> wrap(MaybeSource<T> source)
```
    Wraps a MaybeSource instance into a new Maybe instance if not already a Maybe instance.
    
    Scheduler:
    
    wrap does not operate by default on a particular Scheduler.
    
    Type Parameters:
    T - the value type
    Parameters:
    source - the source to wrap
    
    Returns:
    the Maybe wrapper or the source cast to Maybe (if possible)
  - cast
```
public final <U> Maybe<U> cast(java.lang.Class<? extends U> clazz)
```
    Casts the success value of the current Maybe into the target type or signals a ClassCastException if not compatible.
    
    Scheduler:
    
    cast does not operate by default on a particular Scheduler.
    
    Type Parameters:
    U - the target type
    Parameters:
    clazz - the type token to use for casting the success result from the current Maybe
    
    Returns:
    the new Maybe instance
    Since:
    
    2.0
  - compose
```
public final <R> Maybe<R> compose(Function<? super Maybe<T>,? extends MaybeSource<R>> transformer)
```
    Transform a Maybe by applying a particular Transformer function to it.
    This method operates on the Maybe itself whereas lift(io.reactivex.MaybeOperator<? extends R, ? super T>) operates on the Maybe's MaybeObservers.
    If the operator you are creating is designed to act on the individual item emitted by a Maybe, use lift(io.reactivex.MaybeOperator<? extends R, ? super T>). If your operator is designed to transform the source Maybe as a whole (for instance, by applying a particular set of existing RxJava operators to it) use compose.
    
    Scheduler:
    
    compose does not operate by default on a particular Scheduler.
    
    Type Parameters:
    R - the value type of the Maybe returned by the transformer function
    Parameters:
    transformer - implements the function that transforms the source Maybe
    
    Returns:
    a Maybe, transformed by the transformer function
    See Also:
    RxJava wiki: Implementing Your Own Operators
  - concatMap
```
public final <R> Maybe<R> concatMap(Function<? super T,? extends MaybeSource<? extends R>> mapper)
```
    Returns a Maybe that is based on applying a specified function to the item emitted by the source Maybe, where that function returns a MaybeSource.
    
    Scheduler:
    
    flatMap does not operate by default on a particular Scheduler.
    
    Note that flatMap and concatMap for Maybe is the same operation.
    
    Type Parameters:
    R - the result value type
    Parameters:
    mapper - a function that, when applied to the item emitted by the source Maybe, returns a MaybeSource
    
    Returns:
    the Maybe returned from func when applied to the item emitted by the source Maybe
    See Also:
    ReactiveX operators documentation: FlatMap
  - doAfterTerminate
```
@SchedulerSupport(value="none")
public final Maybe<T> doAfterTerminate(Action onAfterTerminate)
```
    Registers an Action to be called when this Maybe invokes either onSuccess, onComplete or onError.
    
    Scheduler:
    
    doAfterTerminate does not operate by default on a particular Scheduler.
    
    Parameters:
    onAfterTerminate - an Action to be invoked when the source Maybe finishes
    
    Returns:
    a Maybe that emits the same items as the source Maybe, then invokes the Action
    See Also:
    ReactiveX operators documentation: Do
  - doOnDispose
```
public final Maybe<T> doOnDispose(Action onDispose)
```
    Calls the shared runnable if a MaybeObserver subscribed to the current Single disposes the common Disposable it received via onSubscribe.
    
    Scheduler:
    
    doOnSubscribe does not operate by default on a particular Scheduler.
    
    Parameters:
    onDispose - the runnable called when the subscription is cancelled (disposed)
    
    Returns:
    the new Maybe instance
  - doOnComplete
```
@SchedulerSupport(value="none")
public final Maybe<T> doOnComplete(Action onComplete)
```
    Modifies the source Maybe so that it invokes an action when it calls onCompleted.
    
    Scheduler:
    
    doOnComplete does not operate by default on a particular Scheduler.
    
    Parameters:
    onComplete - the action to invoke when the source Maybe calls onCompleted
    
    Returns:
    the new Maybe with the side-effecting behavior applied
    See Also:
    ReactiveX operators documentation: Do
  - doOnError
```
public final Maybe<T> doOnError(Consumer<? super java.lang.Throwable> onError)
```
    Calls the shared consumer with the error sent via onError for each MaybeObserver that subscribes to the current Single.
    
    Scheduler:
    
    doOnSubscribe does not operate by default on a particular Scheduler.
    
    Parameters:
    onError - the consumer called with the success value of onError
    
    Returns:
    the new Maybe instance
  - doOnEvent
```
public final Maybe<T> doOnEvent(BiConsumer<? super T,? super java.lang.Throwable> onEvent)
```
    Calls the given onEvent callback with the (success value, null) for an onSuccess, (null, throwabe) for an onError or (null, null) for an onComplete signal from this Maybe before delivering said signal to the downstream.
    Exceptions thrown from the callback will override the event so the downstream receives the error instead of the original signal.
    
    Scheduler:
    
    doOnEvent does not operate by default on a particular Scheduler.
    
    Parameters:
    onEvent - the callback to call with the terminal event tuple
    
    Returns:
    the new Maybe instance
  - doOnSubscribe
```
public final Maybe<T> doOnSubscribe(Consumer<? super Disposable> onSubscribe)
```
    Calls the shared consumer with the Disposable sent through the onSubscribe for each MaybeObserver that subscribes to the current Single.
    
    Scheduler:
    
    doOnSubscribe does not operate by default on a particular Scheduler.
    
    Parameters:
    onSubscribe - the consumer called with the Disposable sent via onSubscribe
    
    Returns:
    the new Maybe instance
  - doOnSuccess
```
public final Maybe<T> doOnSuccess(Consumer<? super T> onSuccess)
```
    Calls the shared consumer with the success value sent via onSuccess for each MaybeObserver that subscribes to the current Single.
    
    Scheduler:
    
    doOnSubscribe does not operate by default on a particular Scheduler.
    
    Parameters:
    onSuccess - the consumer called with the success value of onSuccess
    
    Returns:
    the new Maybe instance
  - filter
```
@SchedulerSupport(value="none")
public final Maybe<T> filter(Predicate<? super T> predicate)
```
    Filters the success item of the Maybe via a predicate function and emitting it if the predicate returns true, completing otherwise.
    
    Scheduler:
    
    filter does not operate by default on a particular Scheduler.
    
    Parameters:
    predicate - a function that evaluates the item emitted by the source Maybe, returning true if it passes the filter
    
    Returns:
    a Maybe that emit the item emitted by the source Maybe that the filter evaluates as true
    See Also:
    ReactiveX operators documentation: Filter
  - flatMap
```
public final <R> Maybe<R> flatMap(Function<? super T,? extends MaybeSource<? extends R>> mapper)
```
    Returns a Maybe that is based on applying a specified function to the item emitted by the source Maybe, where that function returns a MaybeSource.
    
    Scheduler:
    
    flatMap does not operate by default on a particular Scheduler.
    
    Note that flatMap and concatMap for Maybe is the same operation.
    
    Type Parameters:
    R - the result value type
    Parameters:
    mapper - a function that, when applied to the item emitted by the source Maybe, returns a MaybeSource
    
    Returns:
    the Maybe returned from func when applied to the item emitted by the source Maybe
    See Also:
    ReactiveX operators documentation: FlatMap
  - flatMap
```
@SchedulerSupport(value="none")
public final <R> Maybe<R> flatMap(Function<? super T,? extends MaybeSource<? extends R>> onSuccessMapper,
                                         Function<? super java.lang.Throwable,? extends MaybeSource<? extends R>> onErrorMapper,
                                         java.util.concurrent.Callable<? extends MaybeSource<? extends R>> onCompleteSupplier)
```
    Maps the onSuccess, onError or onComplete signals of this Maybe into MaybeSource and emits that MaybeSource's signals
    
    Scheduler:
    
    flatMap does not operate by default on a particular Scheduler.
    
    Type Parameters:
    R - the result type
    Parameters:
    onSuccessMapper - a function that returns a MaybeSource to merge for the success item emitted by this Maybe
    onErrorMapper - a function that returns a MaybeSource to merge for an onError notification from this Maybe
    onCompleteSupplier - a function that returns a MaybeSource to merge for an onCompleted notification this Maybe
    
    Returns:
    the new Maybe instance
    See Also:
    ReactiveX operators documentation: FlatMap
  - ignoreElement
```
@SchedulerSupport(value="none")
public final Maybe<T> ignoreElement()
```
    Ignores the item emitted by the source Maybe and only calls onCompleted or onError.
    
    Scheduler:
    
    ignoreElement does not operate by default on a particular Scheduler.
    
    Returns:
    an empty Maybe that only calls onComplete or onError, based on which one is called by the source Maybe
    See Also:
    ReactiveX operators documentation: IgnoreElements
  - lift
```
public final <R> Maybe<R> lift(MaybeOperator<? extends R,? super T> lift)
```
    Lifts a function to the current Maybe and returns a new Maybe that when subscribed to will pass the values of the current Maybe through the MaybeOperator function.
    In other words, this allows chaining TaskExecutors together on a Maybe for acting on the values within the Maybe.
    task.map(...).filter(...).lift(new OperatorA()).lift(new OperatorB(...)).subscribe()
    If the operator you are creating is designed to act on the item emitted by a source Maybe, use lift. If your operator is designed to transform the source Maybe as a whole (for instance, by applying a particular set of existing RxJava operators to it) use compose(io.reactivex.functions.Function<? super io.reactivex.Maybe<T>, ? extends io.reactivex.MaybeSource<R>>).
    
    Scheduler:
    
    lift does not operate by default on a particular Scheduler.
    
    Type Parameters:
    R - the downstream's value type (output)
    Parameters:
    lift - the MaybeOperator that implements the Maybe-operating function to be applied to the source Maybe
    
    Returns:
    a Maybe that is the result of applying the lifted Operator to the source Maybe
    See Also:
    RxJava wiki: Implementing Your Own Operators
  - map
```
public final <R> Maybe<R> map(Function<? super T,? extends R> mapper)
```
    Returns a Maybe that applies a specified function to the item emitted by the source Maybe and emits the result of this function application.
    
    Scheduler:
    
    map does not operate by default on a particular Scheduler.
    
    Type Parameters:
    R - the result value type
    Parameters:
    mapper - a function to apply to the item emitted by the Maybe
    
    Returns:
    a Maybe that emits the item from the source Maybe, transformed by the specified function
    See Also:
    ReactiveX operators documentation: Map
  - observeOn
```
public final Maybe<T> observeOn(Scheduler scheduler)
```
    Wraps a Maybe to emit its item (or notify of its error) on a specified Scheduler, asynchronously.
    
    Scheduler:
    
    you specify which Scheduler this operator will use
    
    Parameters:
    scheduler - the Scheduler to notify subscribers on
    
    Returns:
    the new Maybe instance that its subscribers are notified on the specified Scheduler
    See Also:
    ReactiveX operators documentation: ObserveOn, RxJava Threading Examples, subscribeOn(io.reactivex.Scheduler)
  - to
```
public final <R> R to(Function<? super Maybe<T>,R> convert)
```
    Calls the specified converter function with the current Maybe instance during assembly time and returns its result.
    
    Scheduler:
    
    to does not operate by default on a particular Scheduler.
    
    Type Parameters:
    R - the result type
    Parameters:
    convert - the function that is called with the current Maybe instance during assembly time that should return some value to be the result
    
    Returns:
    the value returned by the convert function
  - toCompletable
```
public final Completable toCompletable()
```
    Converts this Maybe into an Completable instance composing cancellation through and dropping a success value if emitted.
    
    Scheduler:
    
    create does not operate by default on a particular Scheduler.
    
    Returns:
    the new Completable instance
  - toFlowable
```
public final Flowable<T> toFlowable()
```
    Converts this Maybe into a backpressure-aware Flowable instance composing cancellation through.
    
    Scheduler:
    
    create does not operate by default on a particular Scheduler.
    
    Returns:
    the new Flowable instance
  - toObservable
```
public final Observable<T> toObservable()
```
    Converts this Maybe into an Observable instance composing cancellation through.
    
    Scheduler:
    
    create does not operate by default on a particular Scheduler.
    
    Returns:
    the new Observable instance
  - toSingle
```
public final Single<T> toSingle()
```
    Converts this Maybe into an Single instance composing cancellation through and turing an empty Maybe into a signal of NoSuchElementException.
    
    Scheduler:
    
    create does not operate by default on a particular Scheduler.
    
    Returns:
    the new Single instance
  - subscribe
```
@SchedulerSupport(value="none")
public final Disposable subscribe()
```
    Subscribes to a Maybe and ignores onSuccess and onComplete emissions.
    If the Maybe emits an error, it is routed to the RxJavaPlugins.onError handler.
    
    Scheduler:
    
    subscribe does not operate by default on a particular Scheduler.
    
    Returns:
    a Disposable reference with which the caller can stop receiving items before the Maybe has finished sending them
    See Also:
    ReactiveX operators documentation: Subscribe
  - subscribe
```
@SchedulerSupport(value="none")
public final Disposable subscribe(Consumer<? super T> onSuccess)
```
    Subscribes to a Maybe and provides a callback to handle the items it emits.
    If the Flowable emits an error, it is routed to the RxJavaPlugins.onError handler.
    
    Scheduler:
    
    subscribe does not operate by default on a particular Scheduler.
    
    Parameters:
    onSuccess - the Consumer<T> you have designed to accept a success value from the Maybe
    
    Returns:
    a Disposable reference with which the caller can stop receiving items before the Maybe has finished sending them
    
    Throws:
    
    java.lang.NullPointerException - if onSuccess is null
    See Also:
    ReactiveX operators documentation: Subscribe
  - subscribe
```
@SchedulerSupport(value="none")
public final Disposable subscribe(Consumer<? super T> onSuccess,
                                         Consumer<? super java.lang.Throwable> onError)
```
    Subscribes to a Maybe and provides callbacks to handle the items it emits and any error notification it issues.
    
    Scheduler:
    
    subscribe does not operate by default on a particular Scheduler.
    
    Parameters:
    onSuccess - the Consumer<T> you have designed to accept a success value from the Maybe
    onError - the Consumer<Throwable> you have designed to accept any error notification from the Maybe
    
    Returns:
    a Subscription reference with which the caller can stop receiving items before the Maybe has finished sending them
    
    Throws:
    
    java.lang.IllegalArgumentException - if onSuccess is null, or if onError is null
    See Also:
    ReactiveX operators documentation: Subscribe
  - subscribe
```
@SchedulerSupport(value="none")
public final Disposable subscribe(Consumer<? super T> onSuccess,
                                         Consumer<? super java.lang.Throwable> onError,
                                         Action onComplete)
```
    Subscribes to a Maybe and provides callbacks to handle the items it emits and any error or completion notification it issues.
    
    Scheduler:
    
    subscribe does not operate by default on a particular Scheduler.
    
    Parameters:
    onSuccess - the Consumer<T> you have designed to accept a success value from the Maybe
    onError - the Consumer<Throwable> you have designed to accept any error notification from the Maybe
    onComplete - the Action you have designed to accept a completion notification from the Maybe
    
    Returns:
    a Disposable reference with which the caller can stop receiving items before the Maybe has finished sending them
    
    Throws:
    
    java.lang.IllegalArgumentException - if onSuccess is null, or if onError is null, or if onComplete is null
    See Also:
    ReactiveX operators documentation: Subscribe
  - subscribe
```
public final void subscribe(MaybeObserver<? super T> observer)
```
    Description copied from interface: MaybeSource
    
    Subscribes the given MaybeObserver to this MaybeSource instance.
    
    Specified by:
    
    subscribe in interface MaybeSource<T>
    
    Parameters:
    observer - the MaybeObserver, not null
  - subscribeActual
```
protected abstract void subscribeActual(MaybeObserver<? super T> observer)
```
    Override this method in subclasses to handle the incoming MaybeObservers.
    
    Parameters:
    observer - the MaybeObserver to handle, not null
  - subscribeOn
```
public final Maybe<T> subscribeOn(Scheduler scheduler)
```
    Asynchronously subscribes subscribers to this Maybe on the specified Scheduler.
    
    Scheduler:
    
    you specify which Scheduler this operator will use
    
    Parameters:
    scheduler - the Scheduler to perform subscription actions on
    
    Returns:
    the new Maybe instance that its subscriptions happen on the specified Scheduler
    See Also:
    ReactiveX operators documentation: SubscribeOn, RxJava Threading Examples, observeOn(io.reactivex.Scheduler)
  - subscribeWith
```
public final <E extends MaybeObserver<? super T>> E subscribeWith(E observer)
```
    Subscribes a given MaybeObserver (subclass) to this Maybe and returns the given MaybeObserver as is.
    Usage example:
```
 Maybe source = Maybe.just(1);
 CompositeDisposable composite = new CompositeDisposable();
 
 MaybeObserver<Integer> ms = new MaybeObserver<>() {
     // ...
 };
 
 composite.add(source.subscribeWith(ms));
 
```
    Type Parameters:
    E - the type of the MaybeObserver to use and return
    Parameters:
    observer - the MaybeObserver (subclass) to use and return, not null
    
    Returns:
    the input subscriber
    
    Throws:
    
    java.lang.NullPointerException - if subscriber is null
  - test
```
public final TestSubscriber<T> test()
```
    Creates a TestSubscriber and subscribes it to this Maybe.
    
    Returns:
    the new TestSubscriber instance
  - test
```
public final TestSubscriber<T> test(boolean cancelled)
```
    Creates a TestSubscriber optionally in cancelled state, then subscribes it to this Maybe.
    
    Parameters:
    cancelled - if true, the TestSubscriber will be cancelled before subscribing to this Maybe.
    
    Returns:
    the new TestSubscriber instance