Support Implicit Generics Inference

[ChayimFriedman2]

Search Terms

implicit generics, broader type inference, better type inference

Suggestion

I'd like TypeScript to know when two types are unknown, but equal.
That is, say I've function equals():

type T = { type: 'a', p1: boolean } | { type: 'b', p2: string };

function equals(a: T, b: T) {
  // Currently, we have to write:
  if (a.type === 'a' && b.type === 'a') { return a.p1 === b.p1;  }
  if (a.type === 'b' && b.type === 'b') { return a.p2 === b.p2; }
  return false;

  // But I'd like to be able to write:
  if (a.type !== b.type) { return false; }
  return a.type === 'a' ? a.p1 === b.p1 : a.p2 === b.p2;
}

Use Cases

I can't think about other use cases except comparisons (if you know let me know), but I think they're common enough. This will also make them somewhat faster (no need to check both's type).

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

[RyanCavanaugh]

I'm not entirely convinced this is feasible with the current narrowing logic, but we can look into it if there's sufficient demand

[BickelLukas]

I ran into a similar issue. Consider the following code:

interface Config {
    enabled: boolean;
}

interface EnabledConfig extends Config {
    enabled: true;
    other: boolean;
}

interface IService {
    doSomething(): void;
}

interface IEnabledService extends IService {
    doSomethingElse(): void;
}

class Service implements IService {
    public doSomething(): void {}
}

class EnabledService extends Service implements IEnabledService {
    public doSomethingElse(): void {}
}

type GenericService<T extends Config> = IService & (T extends EnabledConfig ? IEnabledService : IService);

// type guard
function isEnabled(config: Config): config is EnabledConfig {
    return config.enabled;
}

function test<T extends Config>(config: T, service: GenericService<T>): void {
    service.doSomething();

    if (isEnabled(config)) {
        config.other = true; // works
        service.doSomethingElse(); // does not work
    }
}

In the test function, after the type guard the type of config gets narrowed down to EnabledService allowing me to access the other property. But the type of service does not get narrowed although they both use the same T.

playground link

[c-vetter]

@BickelLukas
The reason that doesn't work is that T gets set when the parameters are getting typed. Look at config's type:

T is unchanged, but config itself is more narrowly typed.

Therefore, you can at least work around your issue:

    if (isEnabled(config)) {
        config.other = true; // works
        (service as GenericService<typeof config>).doSomethingElse(); // works
    }

It is somewhat verbose but you still get the proper type inference so that it'll still work apropriately if you perform additional checks that may result in different subtypes.