1.x: Single's subscribe(Observable) and subscribe(Subscription) receive onCompleted

[JakeWharton]

This should be documented on these methods since it's in direct violation with the contract specified in Single's documentation:

Single behaves the same as Observable except that it can only emit either a single successful value, or an error (there is no "onComplete" notification as there is for Observable)

(emphasis mine)

[akarnokd]

Just add a PR with your suggested changes.

[akarnokd]

subscribe(Observable) and subscribe(Subscription)

Not sure what methods you mean by these.

[akarnokd]

I'm closing this issue due to inactivity. If you have further input on the issue, don't hesitate to reopen this issue or post a new one.

[ashughes]

Just ran into this. I didn't actually realize that using a Single shouldn't call onComplete until I happened to read that part of the documentation. But after testing it, I found that it did, in fact, call onComplete despite the documentation.

The documentation appears to be identical to 2.x. I assume this is actually true on 2.x since there is no onComplete when subscribing to a Single. However, it's still unclear to me if onComplete would be called if Single.toObservable() is called on 2.x (I haven't tested this).

[akarnokd]

I couldn't decipher which documentation this issue referred to. PR welcome of course.

The toObservable performs protocol conversion where onSuccess is equal to onNext followed by onComplete.

[ashughes]

I'm not sure I understand enough to provide a PR. ;-) Let me see if I can explain better:

Both the 1.x and 2.x documentation for Single appear to be the same. As @JakeWharton pointed out, the documentation states:

there is no "onComplete" notification as there is for Observable

On 1.x, this does not appear to be true. I'm receiving onComplete when using a Single.

On 2.x, my understanding is that this is no onComplete to even be called, so in that sense, the documentation appears to be true. However, you can get an onComplete by calling toObservable, but it sounds like you're saying that this would convert the Single's onSuccess to an onNext and onComplete. If that's the case, then it would seem this is essentially behaving the same as it does in 1.x.

So maybe the documentation is simply meant to convey that there isn't an onComplete to be called (in 2.x), unless the Single is converted to an Observable?

[akarnokd]

On 1.x, this does not appear to be true. I'm receiving onComplete when using a Single.

How? Could you post a code example?

There is a more recent Maybe type where the javadoc mentions the protocol (which does include onComplete that triggers some confusion about onSuccess not followed by an onComplete).

[ashughes]

On 1.x:

Single.fromCallable(this::getSomething)
    .subscribe(new Subscriber<Something>() {
        @Override
        public void onCompleted() {
            // Gets called
        }

        @Override
        public void onError(Throwable e) {
        }

        @Override
        public void onNext(Something result) {
            // Gets called
        }
    });

I believe Maybe is not in 1.x, is that correct?

[akarnokd]

I see. 1.x has a convenience subscribe overload that takes a Subscriber designed for consuming Observables. Internally, this method will perform the same protocol switch so you don't have to use toObservable manually. SingleSubscriber is the main consumer type for Single in 1.x.