TypeScript generics - Type 'T[string]' is not assignable to type 'number'

Question

I am developing a function that takes in an array of objects and resamples the array based on a property of the objects. (More theory on that in my question resampling an array of objects. In typescript, the function starts like this:

export function resample<T>(
    originalArray: Array<T>,
    sortKey: keyof T,
    samplingInterval: number
): Array<T> {

  const array = [...originalArray];
  let queuedItem = array.shift();
  let t0: number = queuedItem[sortKey]; // <-------- problem here

  // ... more code

}

When trying to type t0 as a number, I get the error:

Type 'T[string]' is not assignable to type 'number'

TypeScript playground demonstrating the issue

Without explicitly defining the type, t0 is typed as T[keyof T]. Which makes sense. But later in the code, I do some simple math with t0, and I need it ot be treated as a number.

Why can T[string] not be assignable to a number type? We have no information thus far about what's in T, why does typescript prohibit that T[keyof T] from being a number?

Can I better type this function, and T? It must be that T has at least one property whose value is a number, but whose key could be any string, and when being used in the resample function, sortKey is any property of T whose value is a number?

Since T can be anything, so can queuedItem[sortKey], so it can be NOT a number. — Roberto Zvjerković
– Roberto Zvjerković, Commented Sep 23, 2021 at 7:18
Does this code meet your needs? If so I'll write up an answer; if not please edit the example code to demonstrate unsatisfied use cases. — jcalz
– jcalz, Commented Sep 23, 2021 at 14:38
@jcalz your code seems to work, but I'm not sure I understand it. Can you post an answer with explanation? — Seth Lutske
– Seth Lutske, Commented Sep 23, 2021 at 16:10

jcalz · Accepted Answer · 2021-09-23 18:11:19Z

My suggestion here is to make the resample function generic both in T, the type of the elements of originalArray, and in K, the type of sortKey:

function resample<T extends Record<K, number>, K extends keyof T>(
    originalArray: Array<T>,
    sortKey: K,
) { 
    const array = [...originalArray];
    let queuedItem = array.shift();
    let t0: number = queuedItem![sortKey]; // no error now
}

By constraining K to extend keyof T we are requiring that sortKey be one of the keys of the elements of obj, and by constraining T to extend Record<K, number> (using the Record<K, V> utility type) we are requiring that the elements of obj have a number value at the key K.

Then you should be able to call resample() and see that it works for valid calls and reports an error for invalid calls:

resample([{ a: 123, b: "hello" }], "a"); // okay
resample([{ a: 123, b: "hello" }], "b"); // error!
// ---------------> ~
// Type 'string' is not assignable to type 'number'.

Technically you don't need to do both constraints; it is sufficient to have just K:

function resample<K extends PropertyKey>(
    originalArray: Array<Record<K, number>>,
    sortKey: K,
) { /* same impl */ }

But then you run into excess property checking where the compiler complains when object literals have properties that it wasn't expecting:

resample([{ a: 123, b: "hello" }], "a"); // error?!
// ---------------> ~~~~~~~~~~
//  Object literal may only specify known properties,
//  and 'b' does not exist in type 'Record<"a", number>'

You don't want this behavior because it really isn't indicative of an error that your object has more keys than "a". This can be worked around or avoided by not calling resample() with object literal arguments, by initializing a variable with the object literal and then calling resample() with that variable:

const differentVariable = { a: 123, b: "hello" };
resample([differentVariable], "a"); // okay

But one way to turn off such checking is to make the elements of obj of a generic type T extends Record<K, number> instead of the specific type Record<K, number>. Which is what I suggest above.

Playground link to code

Drag13 · Accepted Answer · 2021-09-23 07:20:08Z

0

The issue is that you are missing constraints on the type T, that's why TS has no idea what type will be given after: queuedItem[sortKey]

To fix this, simply add constraint like this:

Pay attention to the extends:

export function resample<T extends {[key in keyof T] : number}>(originalArray: T[], sortKey: keyof T,   samplingInterval: number): Array<T> {

    const array = [...originalArray];

    const result: Array<T> = [];

    let queuedItem = array.shift();
    let t0:number = queuedItem![sortKey]; // <-------- no problem here

  // ... more code

    return result;

}

answered Sep 23, 2021 at 7:20

Drag13

6,0281 gold badge22 silver badges44 bronze badges

3 Comments

edo.n Over a year ago

This should force ALL properties on T to be of type number?

Roberto Zvjerković Over a year ago

In the original question not every key has a number value, I believe.

Seth Lutske Over a year ago

Yes exactly, I don't want every property to have to be a number, just at least one of them

Collectives™ on Stack Overflow

TypeScript generics - Type 'T[string]' is not assignable to type 'number'

TypeScript playground demonstrating the issue

2 Answers 2

1 Comment

3 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

3 Comments

Your Answer

Sign up or log in

Post as a guest

Related