The value of 'number' can be assigned to the constraint 'T[keyof T]', however, there is a possibility that 'T[keyof T]' may be initialized with a different subtype of the constraint 'number'

Question

The value of 'number' can be assigned to the constraint 'T[keyof T]', however, there is a possibility that 'T[keyof T]' may be initialized with a different subtype of the constraint 'number'

The code below shows how I am attempting to sum each property of an array of T and return it as T:

export function sumProperties<T extends { [k: string]: number }>(values: T[]): T {
  return values.reduce((acc, cur) => {
    (Object.keys(cur) as Array<keyof T>).forEach((k) => {
      acc[k] = (acc[k] || 0) + cur[k];
    })
    return acc;
  }, {} as T);
}

The line acc[k] = (acc[k] || 0) + cur[k]; is causing issues in the code.

Currently, I have a workaround using

Object.assign(acc, { [k]: (acc[k] || 0) + cur[k] });

but I would prefer not to use it. Can anyone explain the reason for this error and suggest a TypeScript safe solution?

typescript

Answer 1

Answer №1

The issue arises from the fact that T extends {[k: string]: number} does not guarantee that the values of T are strictly numbers; they could also be literal numbers like {type: 1}:

// true
type Case1 = 1 extends number ? true : false

// false
type Case2 = number extends 1 ? true : false

const a: {type: 1} = {type: 1}

const a.type = 2; // error

In essence, T can include some sub-types of number as values that cannot be altered, leading to uncertainty for the compiler in terms of modification.

A possible solution would be to eliminate generics altogether, but if you still require them, one approach could be something like this, although it only provides generic functionality for keys and not values:

export function sumProperties<T extends { [k: string]: number }>(
  values: Record<keyof T, number>[],
): Record<keyof T, number> {
  return values.reduce((acc, cur) => {
    (Object.keys(cur) as Array<keyof T>).forEach((k) => {
      acc[k] = (acc[k] || 0) + cur[k];
    });
    return acc;
  }, {} as T);
}

While we still utilize T as a generic parameter, we define values as Record<keyof T, number>, enabling modifications.

playground

Answer 2

The issue arises from the fact that T extends {[k: string]: number} does not guarantee that the values of T are strictly numbers; they could also be literal numbers like {type: 1}:

// true
type Case1 = 1 extends number ? true : false

// false
type Case2 = number extends 1 ? true : false

const a: {type: 1} = {type: 1}

const a.type = 2; // error

In essence, T can include some sub-types of number as values that cannot be altered, leading to uncertainty for the compiler in terms of modification.

A possible solution would be to eliminate generics altogether, but if you still require them, one approach could be something like this, although it only provides generic functionality for keys and not values:

export function sumProperties<T extends { [k: string]: number }>(
  values: Record<keyof T, number>[],
): Record<keyof T, number> {
  return values.reduce((acc, cur) => {
    (Object.keys(cur) as Array<keyof T>).forEach((k) => {
      acc[k] = (acc[k] || 0) + cur[k];
    });
    return acc;
  }, {} as T);
}

While we still utilize T as a generic parameter, we define values as Record<keyof T, number>, enabling modifications.

playground

The value of 'number' can be assigned to the constraint 'T[keyof T]', however, there is a possibility that 'T[keyof T]' may be initialized with a different subtype of the constraint 'number'

Answer №1

Similar questions

Converting a string to a number is not functioning as expected

Ways to create a method that can be overridden

Issue: The function (0, react__WEBPACK_IMPORTED_MODULE_1__.useActionState) is not recognized as a valid function or its output is not iterable

Using TypeScript to interpret JSON - insert a 'data' label

Using TypeScript to send state through history.push({...})

What is the reason that specifying the type of function parameters does not result in conversion being

Value in Hook not updating after memoization of parent component

Error arises when attempting to pass interface props to a component in a React Typescript application

The conversion of an array to Ljava/lang/Object is not possible

I continue to encounter the same error while attempting to deliver data to this form

Using Typescript for Asynchronous Https Requests

unable to retrieve access-token and uid from the response headers

Implementing method overrides in TypeScript class objects inherited from JavaScript function-based classes

There is no index signature in the type 'string | number | EnvType' that accepts a parameter of type 'string'

What is the process for including a selected-by option in a VIS network graph?

Configure Typescript to skip errors for a specific file

What is the official name of the key type for the Built-in Object?

Utilizing the power of HTML5 drag and drop functionality in conjunction with Angular Material 2's md

Discover the steps to declare and sign up for queryParams within Angular

What is the best way to forward all URLs to one central page?