src/main/java/io/reactivex/Maybe.java
@CheckReturnValue
    @NonNull
    @SchedulerSupport(SchedulerSupport.NONE)
    public static <T> Maybe<T> fromCallable(@NonNull final Callable<? extends T> callable) {
        ObjectHelper.requireNonNull(callable, "callable is null");
        return RxJavaPlugins.onAssembly(new MaybeFromCallable<T>(callable));
    }
@CheckReturnValue
    @NonNull
    @SchedulerSupport(SchedulerSupport.NONE)
    public static <T> Maybe<T> fromCallable(@NonNull final Callable<? extends T> callable) {
        ObjectHelper.requireNonNull(callable, "callable is null");
        return RxJavaPlugins.onAssembly(new MaybeFromCallable<T>(callable));
    }
@ CheckReturnValue @ NonNull @ SchedulerSupport ( SchedulerSupport . NONE ) public static < T > Maybe < T > fromCallable ( @ NonNull final Callable < ? extends T > callable ) { ObjectHelper . requireNonNull ( callable , "callable is null" ) ; return RxJavaPlugins . onAssembly ( new MaybeFromCallable < T > ( callable ) ) ; }
Returns a {@link Maybe} that invokes the given {@link Callable} for each individual {@link MaybeObserver} that
subscribes and emits the resulting non-null item via {@code onSuccess} while
considering a {@code null} result from the {@code Callable} as indication for valueless completion
via {@code onComplete}.
<p>
This operator allows you to defer the execution of the given {@code Callable} until a {@code MaybeObserver}
subscribes to the  returned {@link Maybe}. In other terms, this source operator evaluates the given
{@code Callable} "lazily".
<p>
Note that the {@code null} handling of this operator differs from the similar source operators in the other
{@link io.reactivex base reactive classes}. Those operators signal a {@code NullPointerException} if the value returned by their
{@code Callable} is {@code null} while this {@code fromCallable} considers it to indicate the
returned {@code Maybe} is empty.
<dl>
<dt><b>Scheduler:</b></dt>
<dd>{@code fromCallable} does not operate by default on a particular {@link Scheduler}.</dd>
<dt><b>Error handling:</b></dt>
<dd>Any non-fatal exception thrown by {@link Callable#call()} will be forwarded to {@code onError},
except if the {@code MaybeObserver} disposed the subscription in the meantime. In this latter case,
the exception is forwarded to the global error handler via
{@link io.reactivex.plugins.RxJavaPlugins#onError(Throwable)} wrapped into a
{@link io.reactivex.exceptions.UndeliverableException UndeliverableException}.
Fatal exceptions are rethrown and usually will end up in the executing thread's
{@link java.lang.Thread.UncaughtExceptionHandler#uncaughtException(Thread, Throwable)} handler.</dd>
</dl>

@param callable
a {@link Callable} instance whose execution should be deferred and performed for each individual
{@code MaybeObserver} that subscribes to the returned {@link Maybe}.
@param <T>
the type of the item emitted by the {@link Maybe}.
@return a new Maybe instance
Returns a { @link Maybe } that invokes the given { @link Callable } for each individual { @link MaybeObserver } that subscribes and emits the resulting non - null item via { @code onSuccess } while considering a { @code null } result from the { @code Callable } as indication for valueless completion via { @code onComplete } . <p > This operator allows you to defer the execution of the given { @code Callable } until a { @code MaybeObserver } subscribes to the returned { @link Maybe } . In other terms this source operator evaluates the given { @code Callable } lazily . <p > Note that the { @code null } handling of this operator differs from the similar source operators in the other { @link io . reactivex base reactive classes } . Those operators signal a { @code NullPointerException } if the value returned by their { @code Callable } is { @code null } while this { @code fromCallable } considers it to indicate the returned { @code Maybe } is empty . <dl > <dt > <b > Scheduler : < / b > < / dt > <dd > { @code fromCallable } does not operate by default on a particular { @link Scheduler } . < / dd > <dt > <b > Error handling : < / b > < / dt > <dd > Any non - fatal exception thrown by { @link Callable#call () } will be forwarded to { @code onError } except if the { @code MaybeObserver } disposed the subscription in the meantime . In this latter case the exception is forwarded to the global error handler via { @link io . reactivex . plugins . RxJavaPlugins#onError ( Throwable ) } wrapped into a { @link io . reactivex . exceptions . UndeliverableException UndeliverableException } . Fatal exceptions are rethrown and usually will end up in the executing thread s { @link java . lang . Thread . UncaughtExceptionHandler#uncaughtException ( Thread Throwable ) } handler . < / dd > < / dl >