Overview: confusing observation terminology (emission, push, return)

[Chealer]

RxJS version: This bug is not in the RxJS product.

Code to reproduce: This does not report a behavioral bug.

Expected behavior: This does not report a behavioral bug.

Actual behavior: This does not report a behavioral bug.

Additional information:
The Creating Observables section of the Observable page of Overview contains:

The following example creates an Observable to emit the string 'hi' every second to a subscriber.

That is the first time the overview talks about an Observable emitting something, which can be confusing. Yet, Observable's specification seems to confirm emitting is a correct and probably even the canonical term to describe that. Prior to that point, the overview seems to use the terms returning and pushing synonymously. If my understanding is correct, current documentation uses all of the following interchangeably:

emitting
returning
pushing
nexting

Given the topic is already quite complicated, it would help to either be more consistent or explicitly indicate that the above do not refer to different concepts (if that is the case).

[kwonoj]

Hi, thanks for the opinions, As pinned #5970 , we use gh issues as core team's tracking backlog & code-side bug report only. For further tracking, I'll moving these into discussions page.

[voliva]

In my mind these are all synonyms, but it just depends on the context or abstraction level I see more fit using one or the other.

• returning: This I would say it's the least correct, but the way I see it's being used in the docs is always in-between quotes (e.g. // "return" another value) when comparing it to functions which return only one value. I think it can be useful for people who's never seen an Observable to understand what scope this new concept covers.
• pushing: This concept is being used when thinking on terms of "pull vs push" - You pull values from a Function or an iterator, and you get values pushed from a promise or an observable. This is just another perspective.
• emitting: This is probably the concept specific for observables.
• nexting: An observable you can call .next(, .error( or .complete(. Nexting is just emiting new values through .next(.

I can see how it might be confusing, but I think each one of them can be used depending on the context you're in. Are you trying to get someone that only has used regular functions into Observables? Then explaining it initially in terms of "return" could make sense. Are you explaining it to someone who's played with promises and iterators and is familiar with the pull/push concepts? Then push makes all the sense. Are you abstracting over the Observable itself, then emit is the right word. Are you down to the implementation level? then .next() also works.

[Chealer]

"returning" is not always used between quotes (see the Pull versus Push section for example).

I don't know about the first 3, but "nexting" should never be used. "next" is not a verb.