Return type of .ignoreElements() and .empty() should be Observable<never>

[felixfbecker]

RxJS version: 5.4.0

Code to reproduce:

/** Returns an Observable of files */
function fetchFiles(): Observable<string> {
  return Observable.of('foo', 'bar', 'baz')
}

const files = new Set<string>()

/** Returns an Observable that emits no items and completes when the task is done */
function updateFiles() {
  return fetchFiles()
    .do(file => {
      files.add(file)
    })
    .ignoreElements()
}

Expected behavior:
Inferred return type of updateFiles should be Observable<never>. The Observable never emits items, so the items don't have a type, similar to how a function that always throws has no return type - it never emits/returns.

Actual behavior:
Emitted return type is Observable<string>

[felixfbecker]

Observable.empty() should too. Consider this example:

const obs = condition ? Observable.empty() : Observable.of(1, 2, 3)

obs becomes either an Observable that emits numbers, or an Observable that emits no items. If the return type of Observable.empty() was Observable<never>, TS would correctly infer this type as Observable<number> (since in a union with never, the never disappears). But because the return type is Observable<T>, and T cannot be inferred here, TS infers the type of obs as Observable<{}> (the empty interface, no mention of number).

[staltz]

Hi @felixfbecker.
Would a.concat(b) type check correctly in TypeScript if a: Observable<never> and b: Observable<number>? That's the only concern I have, otherwise I agree with you in doing this change.

[felixfbecker]

Yep. As said, in a union with never, the never disappears:

declare let a: Observable<never>;
declare let b: Observable<number>;

const c = a.concat(b); // Observable<number>

[lock]

This thread has been automatically locked since there has not been any recent activity after it was closed. Please open a new issue for related bugs.