Mapped type index access does not work well with Extract utility type

[Harpush]

Bug Report

🔎 Search Terms

indexed access types

🕗 Version & Regression Information

Not a regression

⏯ Playground Link

link

💻 Code

enum Type {
  A = 'a',
  B = 'b'
}

interface One {
  type: Type.A;
  x: number;
}

interface Two {
  type: Type.B;
  y: string;
}

type Both = One | Two;

type GetByType<T extends Type> = Extract<Both, {type: T}>;

const mapper: {[P in Type]: (val: GetByType<P>) => boolean} = {/* ... */};

// Doesn't work :(
const getIt = <T extends Both>(b: T) => mapper[b.type](b);
// Works?
const getIt2 = <T extends Type>(b: T, c: GetByType<T>) => mapper[b](c);
// Doesn't work :(
const getIt3 = <T extends Type>(b: GetByType<T>) => mapper[b.type](b);

🙁 Actual behavior

getIt and getIt3 doesn't compile although somehow getIt2 compiles.

🙂 Expected behavior

All three examples should compile or at least getIt3

[RyanCavanaugh]

From TypeScript's perspective, getIt and getIt3 are not distinguishable from this version, which is unsoundly callable:

const getIt = <T extends Both>(b1: T, b2: T) => {
    mapper[b1.type](b2);
}
getIt<Both>({ type: Type.A, x: 0 }, { type: Type.B, y: "" });

4.7 added support for getIt2-style signatures, but that logic doesn't cover forms like getIt and getIt3.

[Harpush]

@RyanCavanaugh Is there no way to make it work with a single parameter? as it is now it requires me to use getIt2 like this: getIt2(Type.B, {type: Type.B, y: '4'}); which is annoying.
Concerning unsound - getIt2 is even worse so that's not a good reason....
All the below examples compile although they will fail in runtime (the second one is especially dangerous):

getIt2<Type>(Type.A, {type: Type.B, y: '4'});
getIt2(Type.B, {type: Type.A, x: 5});

On the other hand getIt3 is totally safe as written now.
What's more your example uses two parameters while my example uses one which has no way to be unsound... You can even see at getIt3 that the type is almost correct (property) type: (T & Type.A) | (T & Type.B).
To be honest out of the three - getIt2 is the most dangerous in terms of unsoundness

[RyanCavanaugh]

What's more your example uses two parameters while my example uses one which has no way to be unsound

Using multiple parameters isn't required to induce unsoundness. You could take b: { left: T, right: T }

[Harpush]

What's more your example uses two parameters while my example uses one which has no way to be unsound

Using multiple parameters isn't required to induce unsoundness. You could take b: { left: T, right: T }

Which is exactly the case for getIt2 that works - so what's the difference?

[RyanCavanaugh]

#47109 outlines the decision of which sorts of signatures/usages get this treatment and which don't.

[Harpush]

@RyanCavanaugh so back to the original question then - is there any way to pass a single parameter and make the types work? Maybe without extract? I am kind of lost how to tackle it

[Harpush]

@RyanCavanaugh After revisiting this issue I think the main issue is:

type GetByType<T extends Type> = Extract<Both, {type: T}>;

const a = <T extends Type>(value: GetByType<T>) => value.type;

I expect that value.type will be T extends Type but in reality it is (T & Type.A) | (T & Type.B). The usage works as expected and returns T but trying to use it as if it was T as part of other generics fails. I can always cast as T but seems like I shouldn't need to do it.
I believe it is because the extract. Is there a better way? Design limitation still? Maybe a bug after all? Open a new issue?