refactor(interfaces): replace type aliases

[cartant]

Description:

Regarding this issue - that was opened in the TypeScript repo - there is a simple resolution: replace the type aliases with interfaces.

The TypeScript documentation for advanced types includes these comments in the Type Aliases section:

One difference is that interfaces create a new name that is used everywhere. Type aliases don’t create a new name — for instance, error messages won’t use the alias name. [...]

A second more important difference is that type aliases cannot be extended or implemented from (nor can they extend/implement other types). Because an ideal property of software is being open to extension, you should always use an interface over a type alias if possible.

I can see that the issue has been labelled as a bug, but the referenced documentation suggests otherwise.

cc/ @jayphelps @benlesh

Related issue (if exists): microsoft/TypeScript#19198

[rxjs-bot]

	Messages
📖

CJS: 1377.0KB, global: 745.2KB (gzipped: 118.5KB), min: 146.0KB (gzipped: 31.5KB)

Generated by 🚫 dangerJS

[coveralls]

Coverage remained the same at 97.204% when pulling 074f95e on cartant:type-aliases into cff9dfa on ReactiveX:master.

[jayphelps]

Seems like a good solution at first glance.

[cartant]

TIL: documentation can be out-of-date.

Anyway, with the interfaces, you could have it working now, instead of in January (maybe) with TS 2.7.

[jayphelps]

Totes. Btw rereading my last comment it might have seemed like I meant “at first glance” to mean that it’s not a good solution after all. Whoops! Not what I meant. I just meant that I haven’t tested it or seen if it has any other impacts in real usage. Someone on the core team will review hopefully.

[cartant]

No worries. I took it the way you intended it.

[jayphelps]

I started to think this would be a breaking change because OperatorFunction is exposed publicly, but unfortunately fortunately because TypeScript is structurally typed instead of nominally, it doesn't seem to care:

Playground Example

// as an alias
type UnaryFunction_alias<T, R> = (source: T) => R;
type OperatorFunction_alias<T, R> = UnaryFunction_alias<Observable<T>, Observable<R>>;

// as an interface
interface UnaryFunction_interface<T, R> { (source: T): R; }
interface OperatorFunction_interface<T, R> extends UnaryFunction_interface<Observable<T>, Observable<R>> { }

declare let usingAlias: OperatorFunction_alias<void, void>;
declare let usingInterface: OperatorFunction_interface<void, void>;

// no type error
usingAlias = usingInterface;

It would have been very unlikely anyone depended on it anyway.

[benlesh]

Interestingly, this is how I first implemented this when working on it, but switched it because I thought it was more readable for other contributors. (interfaces for functions is pretty weird, IMO, but probably a personal preference thing)

If this solves a problem that's blocking you @jayphelps or the documentation efforts in general, I'll happily merge.

[benlesh]

Also, if @jayphelps says this solves a problem for our docs, we should add a test to make sure we don't break it in the future.

[cartant]

This is another one that could use a snippet test - to ensure the inferred type is what's expected.

[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.