Can TypeScript automatically deduce object keys from function argument values?

Question

Can TypeScript automatically deduce object keys from function argument values?

Consider this function for parsing strings.

  
  const { a, b } = parseString({
    string, 
    mapping: [{
      param: 'a',
      ...
    },{
      param: 'b',
      ...
    }]

Is there a way to restrict TypeScript to accept only 'a' and 'b' keys?

This is the current type definition I am using.

interface ParseStringArgs {
    string: string;
    mapping: {
        start: string | null;
        end: string | null
        param: string;
    }[];
}

I tried to define the key value for param.

export function parseString({ string, mapping }) {

...

    type ParamKey = typeof mapping[number]['param'];
    const result: Record<ParamKey, string> = {};

    ... some logic to populate result

    return result

The output of parseString currently is Record<string, string>

Can the return type be changed to Record<'a' | 'b', string>?

typescript typescript-generics

Answer 1

Answer №1

If you desire a function's return type to be determined by the types of its parameters in a flexible manner, then you must make the function generic. This requires explicitly declaring type parameters on the call signature as they are not automatically inferred for you (although there is an open feature request at microsoft/TypeScript#17428 for such functionality).

One approach to achieve this is:

function parseString<const P extends ParseStringArgs>({ string, mapping }: P) {
  type ParamKey = P["mapping"][number]['param'];
  const result = {} as Record<ParamKey, string>;
  return result
}

In this code snippet, a type parameter P is constrained to ParseStringArgs, and the function parameter is set to type P. Note that it's defined as a const type parameter to encourage the compiler to infer literal types for inputs, ensuring specificity when defining object properties.

The ParamKey type is derived from P through repeated indexed access. Avoid using typeof on mapping to prevent generic widening by the compiler.

Additionally, assert the result initializer as Record<ParamKey, string> since {} does not inherently match this type.

Let's now test the function:

const { a, b, z } = parseString({
  // -------> ~ error on z as expected
  string: "xyz",
  mapping: [{
    param: 'a',
  }, {
    param: 'b',
  }]
});

The test confirms that the return type of the function corresponds to {a: string, b: string}, prompting an error when attempting to destructure assign z, as intended.

Playground link to code

Answer 2

If you desire a function's return type to be determined by the types of its parameters in a flexible manner, then you must make the function generic. This requires explicitly declaring type parameters on the call signature as they are not automatically inferred for you (although there is an open feature request at microsoft/TypeScript#17428 for such functionality).

One approach to achieve this is:

function parseString<const P extends ParseStringArgs>({ string, mapping }: P) {
  type ParamKey = P["mapping"][number]['param'];
  const result = {} as Record<ParamKey, string>;
  return result
}

In this code snippet, a type parameter P is constrained to ParseStringArgs, and the function parameter is set to type P. Note that it's defined as a const type parameter to encourage the compiler to infer literal types for inputs, ensuring specificity when defining object properties.

The ParamKey type is derived from P through repeated indexed access. Avoid using typeof on mapping to prevent generic widening by the compiler.

Additionally, assert the result initializer as Record<ParamKey, string> since {} does not inherently match this type.

Let's now test the function:

const { a, b, z } = parseString({
  // -------> ~ error on z as expected
  string: "xyz",
  mapping: [{
    param: 'a',
  }, {
    param: 'b',
  }]
});

The test confirms that the return type of the function corresponds to {a: string, b: string}, prompting an error when attempting to destructure assign z, as intended.

Playground link to code

Can TypeScript automatically deduce object keys from function argument values?

Answer №1

Similar questions

The attribute 'y' is not found within the data type 'number'

Unable to stop at breakpoints using Visual Studio Code while starting with nodemon

Automatically select a value in MUI AutoComplete and retrieve the corresponding object

Prisma allows for establishing one-to-many relationships with itself, enabling complex data connections

Show a table row based on a specific condition in Angular

Angular - Issue with deleting data using HTTPClientModule

What is the process of molding items?

Using Material-UI with TypeScript

Guide to assigning object values according to properties/keys

The utilization of `ngSwitch` in Angular for managing and displaying

Retrieve the attribute from a TypeScript union data type

Encountering an error in Angular 4: 'Cannot find property on specified component type'

Indicate the location of tsconfig.json file when setting up Cypress

Determine the time difference between the beginning and ending times using TypeScript

Using ng-if to evaluate multiple numerical values

Executing multiple service calls in Angular2

Transforming jQuery library functions into TypeScript syntax

What is the best approach to enhance a class definition that lacks types from DefinitelyTyped?

Utilizing the String Enum for mapping an interface with an index

Troubleshooting issue of data-binding failure with dynamic component loader in Angular2-universal-started