Generic constraints to property of type

[amatiasq]

Search Terms

generic constraint property type keyof

Suggestion

To be able to constrain the type of the property of an object using a keyof type.

Use Cases

Code speaks better than me:

function manageArrayProperty<TObj, TKey extends keyof TObj>(obj: TObj, key: TKey) {
  // obj[key] has to extend array
  obj[key].forEach(...);
}

Examples

This requires a generic declaration that doesn't define a type but only a constraint

function manageArrayProperty<
  TObj,
  TKey extends keyof TObj,
  TObj[TKey] extends any[]
>(obj: TObj, key: TKey) {
  // this is fine
  obj[key].forEach(...);
}

Previous attempts

I tried to achieve that in different ways, I can create a type constrained to TObj[TKey] and any[] but that doesn't mean TObj[TKey] extends array.

function manageArrayProperty<
  TObj,
  TKey extends keyof TObj,
  TProp extends TObj[TKey] & any[]
>(obj: TObj, key: TKey) {
  // INVALID: obj[key] can not be an array
  obj[key].forEach(...);
}

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.

[amatiasq]

Maybe this should work? I might be missing something

Here I highlighted in red statements that are NOT true:

Playground link

function wrap<
  TObj,
  TKey extends keyof TObj,
  TProp extends TObj[TKey] & TItem[],
  TItem
>(obj: TObj, key: TKey) {
  const value: TProp = obj[key];
}

[MartinJohns]

For all properties:

function manageArrayProperty<
  TObj extends { [key: string]: string[] },
  TKey extends keyof TObj
>(obj: TObj, key: TKey) {
  obj[key].forEach(x => {});
}

For a single property:

function manageArrayProperty<
  TObj extends { [key in TKey]: string[] },
  TKey extends keyof TObj
>(obj: TObj, key: TKey) {
  obj[key].forEach(x => {});
}

Or am I misunderstanding something?

[amatiasq]

@MartinJohns no, you understood it perfectly.

I wasn't aware you could do key in TKey, thanks!

[amatiasq]

Actually @MartinJohns looks like with this approach it's not possible to assign to TObj[TKey] for some reason:

function manageArrayProperty<
  TObj extends { [key in TKey]: string[] },
  TKey extends keyof TObj
>(obj: TObj, key: TKey) {
  obj[key] = obj[key].map(x => x);
}

const myObject = {
  foo: 1,
  bar: 'test',
  quz: ['a','b','c']
};

manageArrayProperty(myObject, 'quz');

Playground

Is this a bug maybe?

[RyanCavanaugh]

This is a correct error from TypeScript's perspective, because the two utterances of key are simply expressions of type TKey, and thus not necessarily the same property name, so an invocation where TKey was a union of two different property keys could lead to an unsound assignment.

[amatiasq]

Thanks for explaining @RyanCavanaugh, I still don't get it though. Particularly when you say "the two utterances of key"

On obj[key] = obj[key].map(x => x) the two appearances of key point to the same reference, they are literally the same value in memory so it can't be different.

If you mean that key reference and key in { [key in TKey]: string[] }... let's change the name for clarity:

function manageArrayProperty<
  TObj extends { [p in TKey]: string[] },
  TKey extends keyof TObj
>(obj: TObj, key: TKey) {
  obj[key] = obj[key].map(x => x);
}

Then yes, they are different but the key variable MUST overlap one of p cases. That's how we know obj[key] is of type string[].

In other words. obj[key] = obj[key].map(x => x) shouldn't be different from a = a.map(x => x).

Even the error message is confusing:

Type 'string[]' is not assignable to type 'TObj[TKey]'

While right above you see

(parameter) obj: TObj extends { [p in TKey]: string[]; }

So any TObj[TKey] should accept to be assigned a string[].

[MartinJohns]

I think this example shows what @RyanCavanaugh means:

type TestA = { value: 'A'[] }
type TestB = { value: 'B'[] }

const testA: TestA = { value: ['A'] }
const testB: TestB = { value: ['B'] }
const aOrB: TestA | TestB = Math.random() > 0.5 ? testA : testB;

manageArrayProperty(aOrB, 'value');

In this case the type written to is either A[] or B[], but the type of the value retrieved is A[] | B[]. There is currently no way (AFAIK) to limit a generic type argument to non-union types.

---

Actually that example above doesn't make much sense, as it's always guaranteed it's the same. But I'm sure THIS example is what he meant:

type Test = { a: 'A'[], b: 'B'[] }
const test: Test = { a: ['A'], b: ['B'] };

manageArrayProperty<Test, 'a' | 'b'>(test, 'a');

[amatiasq]

Let me be clear, even in that case how is that a problem?

According to the function signature test['a'] and test['b'] should be of type string[]. So inside that function I should be able to even do

test['b'] = test['a'].map(x => x);

Sorry if I'm missing something but I insist, this looks like a bug to me.

Nevermind, I saw the issue. The fact that TObj[TKey] extends string[] doesn't mean it's assignable to one because it can be a subtype.