Inferencing partial types in Typescript

Question

Inferencing partial types in Typescript

I'm completely stuck on this and can't seem to figure it out without using a second function:

interface Fixed { a: number }
const fn = <A, B extends {} = {}>(b: B) => {
  return b
}

fn({ a: 1 }) // { a: number }
fn<Fixed>({ a: 1 }) // {}

const fn2 = <A>() => <B extends {} = {}>(b: B) => {
  return b
}

const result = fn2<Fixed>()({ a: 1 }) // { a: number }

Why is TypeScript not able to infer the type of B when I specify type A? Everything works again if I return a function that attempts to infer the type of B.

typescript type-inference

Answer 1

Answer №1

Type inference operates on the principle of all or nothing. In the initial scenario:

fn({ a: 1 })

where no generic type parameters are provided, it will infer:

B as { a: number } based on the function argument;
and A as unknown since it is not utilized within the function.

In the subsequent case:

fn<Fixed>({ a: 1 })

when one generic type is specified, type inference will not apply to the remaining type parameters – hence:

A is set as Fixed;

B</bode> remains unspecified and defaults to <code>{}

.

This behavior may be frustrating, but it reflects the workings of TypeScript. Using two function calls, like in your second example, is a common workaround for this limitation.

Find more information about this topic in this GitHub issue.

Answer 2

Type inference operates on the principle of all or nothing. In the initial scenario:

fn({ a: 1 })

where no generic type parameters are provided, it will infer:

B as { a: number } based on the function argument;
and A as unknown since it is not utilized within the function.

In the subsequent case:

fn<Fixed>({ a: 1 })

when one generic type is specified, type inference will not apply to the remaining type parameters – hence:

A is set as Fixed;

B</bode> remains unspecified and defaults to <code>{}

.

This behavior may be frustrating, but it reflects the workings of TypeScript. Using two function calls, like in your second example, is a common workaround for this limitation.

Find more information about this topic in this GitHub issue.

Answer 3

Answer №2

In my opinion, the concept of currying provides a comprehensive solution. Here is a brief example to illustrate:

const x = <I>(v: I) => <O>((v: I) => O) => O

// fully typed
x<number>(10)<string>((n) => `${n * 2}`);

// partial inference NO.1
x(10)<string>((n) => `${n * 2}`);

// partial inference NO.2
x<number>(10)((n) => `${n * 2}`);

// full inference
x(10)((n) => `${n * 2}`);

Answer 4

In my opinion, the concept of currying provides a comprehensive solution. Here is a brief example to illustrate:

const x = <I>(v: I) => <O>((v: I) => O) => O

// fully typed
x<number>(10)<string>((n) => `${n * 2}`);

// partial inference NO.1
x(10)<string>((n) => `${n * 2}`);

// partial inference NO.2
x<number>(10)((n) => `${n * 2}`);

// full inference
x(10)((n) => `${n * 2}`);

Answer 5

Answer №3

To work around this issue, one possible solution is to introduce a second parameter solely for the purpose of type inference. This can be achieved by explicitly casting an empty object {} to the desired type:

interface Specified { x: string }
const func = <X, Y extends {} = {}>(y: Y, _placeholder_for_type_inference: X) => {
  return y
}

func({ x: 'example' }, {} as Specified)
/*
const func: <Specified, {
    x: string;
}>(y: {
    x: string;
}, _placeholder_for_type_inference: Specified) => {
    x: string;
}
*/

Answer 6

To work around this issue, one possible solution is to introduce a second parameter solely for the purpose of type inference. This can be achieved by explicitly casting an empty object {} to the desired type:

interface Specified { x: string }
const func = <X, Y extends {} = {}>(y: Y, _placeholder_for_type_inference: X) => {
  return y
}

func({ x: 'example' }, {} as Specified)
/*
const func: <Specified, {
    x: string;
}>(y: {
    x: string;
}, _placeholder_for_type_inference: Specified) => {
    x: string;
}
*/

Inferencing partial types in Typescript

Answer №1

Answer №2

Answer №3

Similar questions

Error encountered when upgrading to Material-UI v5 rc.0 with typescript

Having trouble locating the type definition file for 'cucumber' when using the Protractor framework with Cucumber and Typescript

Match and populate objects from the array with corresponding items

Add a npm module without type definitions

The feature of "compile on save" is not functioning properly in my current Angular project

At first, Typescript generics make an inference but are ultimately specified

Tips for transmitting data from Dart to Typescript Cloud functions, encountering the UNAUTHENTICATED error code

Troubles encountered while trying to make MediaRecorder function in Angular 9

Locate and retrieve the item that appears most often in a given array

Using TypeScript controllers to inject $scope

What steps can be taken to avoid special characters in ion-input fields?

The openapi-generator with the typescript-angular language option appears to be experiencing some issues

The GIPHY API object returns no results

Problem with file organizer in Angular application - unable to see files and directories

Ways to categorize items retrieved from an HTTP request to the backend in Angular

React Hot Toast useState is unfortunately not exported from the React library

Removing a key from an index signature in Typescript - a step-by-step guide

Encountering an error when trying to access this.$store.state in a basic Vuex

Troubleshooting the error message "TypeError: Cannot read property 'name' of undefined" when working with data binding in Angular 4

Utilizing Typescript for parsing large JSON files