Single fromCallable implementation

[klemzy]

Hi,

I have noticed that implementation of fromCallable on a Single is:

return create(new OnSubscribe<T>() {
    @Override
    public void call(SingleSubscriber<? super T> singleSubscriber) {
        final T value;
        try {
            value = func.call();
        } catch (Throwable t) {
            Exceptions.throwIfFatal(t);
            singleSubscriber.onError(t);
            return;
        }
        singleSubscriber.onSuccess(value);
    }
});

Is this for some specific reason? Because it could be replaced with:

return new Single<T>(new OnSubscribeFromCallable<>(func));

similarly as from implementation on Single.

[akarnokd]

When the design of Single happened, the focus was too much on reusing Observable's ˙OperatorXXX` classes which added an unnecessary layer of indicrection. I wish it could be remodelled like it is in 2.x so it isn't such a mix of the two worlds.

[klemzy]

Thanks for a prompt reply. I understand. So reusing Observable method, converting Single to observable and using Obserable's Operators is discouraged? Actually I am working on this feature #3548 and of the solutions I see it is using Observable's operators and methods.

[akarnokd]

I wouldn't bother reimplementing them from Single but make the Single.retryWhen() just toObservable().retryWhen().toSingle()

[klemzy]

Got it. Thanks!