Attempting to grasp the boundaries of 'T extending infer U'

Question

Attempting to grasp the boundaries of 'T extending infer U'

I've come to understand that something like:

type CustomExample<K> = K extends (infer V) ? V : 'foo';

is actually equivalent to:

type CustomExample<K> = K extends K ? K : 'foo';

However, when the complexity increases, TypeScript throws an error:

type Options = 'text' | 'date' | 'articles' | 'parameters';

type MyCustomType<Option extends Options> =  { opt : Option };

type MyCustomUnion = Options extends (infer V) ? MyCustomType<V> : never;
// Type 'V' does not meet the requirement of 'Options'.
// Type 'V' cannot be assigned to type '"params"'.

So I'm wondering why this is incorrect: in such cases involving union distribution, the inferred V should take values like text, then date, and so forth. Therefore, what exactly does K extends (infer V) signify, and when is it appropriate to utilize it?

typescript conditional-types

Answer 1

Answer №1

The utilization of `infer` seems to be misguided in your current approach - typically, infer is employed for "inferring" (or perhaps more aptly, resolving) types, often from generics.

In the manner you are employing it, you are crafting a type devoid of any "dynamic" elements (essentially lacking generality), signifying that it remains constant. Hence, inferring from something perennially static becomes illogical. Given that at compile time, it's already evident that Types only extends Types & '...anything else', and as you cannot specify that additional portion within your MyExperimentsUnion type, the utility of infer diminishes.

Illustrative Example

interface Action<T> {
    payload: T
}

type ExtractGeneric<T> = T extends Action<infer X> ? X : never

function retrievePayload<T extends Action<any>>(action: T): ExtractGeneric<T> {
    return action.payload;
}

const myAction = { payload: 'Test' };
const resolvedPayloadType = retrievePayload(myAction);

In the scenario mentioned above, resolvedPayloadType would yield string as the resolved type. Without using infer, you would likely need to pass that return type as a second parameter like this:

function retrieveUnextractedPayload<T extends Action<U>, U>(action: T): U {
    return action.payload;
}

Here is the playground link provided for reference.

Cheers.

Answer 2

The utilization of `infer` seems to be misguided in your current approach - typically, infer is employed for "inferring" (or perhaps more aptly, resolving) types, often from generics.

In the manner you are employing it, you are crafting a type devoid of any "dynamic" elements (essentially lacking generality), signifying that it remains constant. Hence, inferring from something perennially static becomes illogical. Given that at compile time, it's already evident that Types only extends Types & '...anything else', and as you cannot specify that additional portion within your MyExperimentsUnion type, the utility of infer diminishes.

Illustrative Example

interface Action<T> {
    payload: T
}

type ExtractGeneric<T> = T extends Action<infer X> ? X : never

function retrievePayload<T extends Action<any>>(action: T): ExtractGeneric<T> {
    return action.payload;
}

const myAction = { payload: 'Test' };
const resolvedPayloadType = retrievePayload(myAction);

In the scenario mentioned above, resolvedPayloadType would yield string as the resolved type. Without using infer, you would likely need to pass that return type as a second parameter like this:

function retrieveUnextractedPayload<T extends Action<U>, U>(action: T): U {
    return action.payload;
}

Here is the playground link provided for reference.

Cheers.

Answer 3

Answer №2

Although this question was posted a year ago, for those who are just joining us now, here is the information you need.

I'm not sure how I overlooked this in the documentation, but since we're all in the same boat here, let's explore what's happening (starting from your code).

type Types = 'text' | 'date' | 'articles' | 'params';

type MyExperiment<Type extends Types> =  { t : Type };

// The parentheses around "infer U" can be removed as they serve no purpose here
type MyExperimentsUnion = Types extends infer U ? MyExperiment<U> : never;
// Type 'U' does not satisfy the constraint 'Types'.

In your code, you're only using the infer keyword to capture Types, but that doesn't provide TypeScript with any information about U. This might lead you to wonder why:

type foo = Types extends infer U ? U : never;
// foo will display 'text' | 'date' | 'articles' | 'params'

You might ask yourself, "Isn't U then of type

'text' | 'date' | 'articles' | 'params'

? Why can't it be assigned to MyExperiment<>?". In my opinion, the union type is resolved only at the end of the conditional statement, so it isn't technically available when assigning it as a type parameter to MyExperiment<>.

If you wish to use infer and distribute the type properly, you'll need an additional condition to constrain U at that point to ensure it's used correctly as a type parameter in MyExperiment<>.

type MyExperimentsUnion =
    Types extends infer U ?
        U extends Types ?
            MyExperiment<U>
        : never
    : never;
// MyExperiment<"text"> | MyExperiment<"date"> | MyExperiment<"articles"> | MyExperiment<"params">

Alternatively, your example could also be achieved like this

type MyExperimentsUnion<T extends Types = Types> = T extends any ? MyExperiment<T> : never;
// Using MyExperimentsUnion without a type parameter will result in
// MyExperiment<"text"> | MyExperiment<"date"> | MyExperiment<"articles"> | MyExperiment<"params">

* This is purely speculative on my part, as I haven't delved deeply into how TypeScript evaluates these scenarios.

Answer 4

Although this question was posted a year ago, for those who are just joining us now, here is the information you need.

I'm not sure how I overlooked this in the documentation, but since we're all in the same boat here, let's explore what's happening (starting from your code).

type Types = 'text' | 'date' | 'articles' | 'params';

type MyExperiment<Type extends Types> =  { t : Type };

// The parentheses around "infer U" can be removed as they serve no purpose here
type MyExperimentsUnion = Types extends infer U ? MyExperiment<U> : never;
// Type 'U' does not satisfy the constraint 'Types'.

In your code, you're only using the infer keyword to capture Types, but that doesn't provide TypeScript with any information about U. This might lead you to wonder why:

type foo = Types extends infer U ? U : never;
// foo will display 'text' | 'date' | 'articles' | 'params'

You might ask yourself, "Isn't U then of type

'text' | 'date' | 'articles' | 'params'

? Why can't it be assigned to MyExperiment<>?". In my opinion, the union type is resolved only at the end of the conditional statement, so it isn't technically available when assigning it as a type parameter to MyExperiment<>.

If you wish to use infer and distribute the type properly, you'll need an additional condition to constrain U at that point to ensure it's used correctly as a type parameter in MyExperiment<>.

type MyExperimentsUnion =
    Types extends infer U ?
        U extends Types ?
            MyExperiment<U>
        : never
    : never;
// MyExperiment<"text"> | MyExperiment<"date"> | MyExperiment<"articles"> | MyExperiment<"params">

Alternatively, your example could also be achieved like this

type MyExperimentsUnion<T extends Types = Types> = T extends any ? MyExperiment<T> : never;
// Using MyExperimentsUnion without a type parameter will result in
// MyExperiment<"text"> | MyExperiment<"date"> | MyExperiment<"articles"> | MyExperiment<"params">

* This is purely speculative on my part, as I haven't delved deeply into how TypeScript evaluates these scenarios.

Answer 5

Answer №3

Perhaps only valued at two cents, yet here are my thoughts:

type Types = 'text' | 'date' | 'articles' | 'params';
type MyExperiment<Type extends Types> =  { t : Type };

type MyExperimentsGenericUnion<T extends Types> = T extends (infer U) ? MyExperiment<U> : never;
// encountering the same issue

type MyExperimentsUnionConstraint = any extends MyExperiment<infer U> ? MyExperiment<U> : never;
// no errors detected

I can see why MyExperimentsUnionConstraint functions while MyExperimentsUnion does not, though articulating it may require a deeper understanding of the language.

To illustrate by example:

In the case of MyExperimentsUnion, inferring U as Types | 'bla' from Types extends U results in MyExperiment<Type | 'bla'> which is problematic.
With MyExperimentsUnionConstraint, U is limited to values compatible with MyExperiment.

Answer 6

Perhaps only valued at two cents, yet here are my thoughts:

type Types = 'text' | 'date' | 'articles' | 'params';
type MyExperiment<Type extends Types> =  { t : Type };

type MyExperimentsGenericUnion<T extends Types> = T extends (infer U) ? MyExperiment<U> : never;
// encountering the same issue

type MyExperimentsUnionConstraint = any extends MyExperiment<infer U> ? MyExperiment<U> : never;
// no errors detected

I can see why MyExperimentsUnionConstraint functions while MyExperimentsUnion does not, though articulating it may require a deeper understanding of the language.

To illustrate by example:

In the case of MyExperimentsUnion, inferring U as Types | 'bla' from Types extends U results in MyExperiment<Type | 'bla'> which is problematic.
With MyExperimentsUnionConstraint, U is limited to values compatible with MyExperiment.

Attempting to grasp the boundaries of 'T extending infer U'

Answer №1

Answer №2

Answer №3

Similar questions

Testing React-Redux Containers with JestIs this okay or would

What is the recommended approach for returning two different types in a TypeScript function?

Experiencing TypeScript error in VSCode while trying to run in Nodejs? Here's how to troubleshoot and resolve

Troubleshooting: Ionic Cordova's Post Functionality Fails to

Encountered an error while trying to access a property that is undefined - attempting to call

Utilizing Angular and Typescript for Enhanced Modal Functionality: Implementing Bootstrap Modals in Various Components

Utilizing both Typescript and javascript in a unified project

There were no visible outputs displayed within the table's tbody section

Menu item currently unavailable

Using private members to create getter and setter in TypeScript

Using TypeScript with Watermelondb

Encountering difficulty in reaching the /login endpoint with TypeScript in Express framework

Converting a dynamic JSON object into a generic type in TypeScript

Utilizing AMD Modules and TypeScript to Load Bootstrap

What is the best way to incorporate tailored validation into reactive forms in Angular?

Achieving a similar functionality to Spring Security ACL in a Node.js AWS Lambda serverless environment

Tips for dynamically incorporating filtered selections into a Mat-Select dropdown

What is the purpose of having a tsconfig.json file in every subdirectory, even if it just extends the main configuration file?

Creating an interface that accurately infers the correct type based on the context

I am currently struggling with adding an HTML form to my Angular project