Is it feasible to deduce the generic type of a function by considering all remaining arguments?

Question

Is it feasible to deduce the generic type of a function by considering all remaining arguments?

I'm working with code that looks like this:

type Boxed<T> = { inner: T }

const box = <T>(inner: T): Boxed<T> => ({ inner });

function test<T extends Boxed<any>>(...args: T[]): T extends Boxed<infer I> ? I : never {
    return args[0].inner;
}

In this scenario, the Boxed<T> represents a complex generic type, and the function is designed to "unbox" the inputs to derive a value of the union type based on all input values. However, when we pass in specific values, the type T defaults to the type of the first argument, causing any additional arguments to be rejected:

test(box(0), box('str'));
// Argument of type 'Boxed<string>' is not assignable to parameter of type 'Boxed<number>'.

Interestingly, if we destructure a tuple when passing the arguments, it works as expected:

test(...[box(0), box('str')]);
// Successfully results in type (string | number).

Is there a way to modify the function definition so that the more user-friendly first example would also work?

Playground Link

typescript generics type-inference

Answer 1

Answer №1

When using generic rest parameters, the compiler correctly infers tuple types when the type parameter T is constrained with an array type

<T extends Boxed<any>[]>

instead of an item constraint:

type Boxed<T> = { inner: T }

const box = <T>(inner: T): Boxed<T> => ({ inner });

// using 'extends Boxed<any>[]' instead of 'extends Boxed<any>'
function test<T extends Boxed<any>[]>(...args: T): T extends Boxed<infer I>[] ? I : never {
    return args[0].inner;
}

test(box(0), box('str')); // string | number 🎉
test(...[box(0), box('str')]); // string | number 🎉

You can play around with this code snippet in the TypeScript Playground.

If you specify

T extends Boxed<any>>(...args: T[])

, TypeScript tends to infer the array type based on the first item's type, assuming all rest parameter items should be of the same type.

declare function foo<T extends string | number>(...args: T[]): void
// foo<"bar">(...args: "bar"[]): void;
foo("bar", 1) // error, '1' is not assignable to type '"bar"'

The correct notation for resolving generic rest parameters is as follows:

declare function foo2<T extends (string | number)[]>(...args: T): void
// foo2<["bar", 1]>(args_0: "bar", args_1: 1): void
foo2("bar", 1)

Answer 2

When using generic rest parameters, the compiler correctly infers tuple types when the type parameter T is constrained with an array type

<T extends Boxed<any>[]>

instead of an item constraint:

type Boxed<T> = { inner: T }

const box = <T>(inner: T): Boxed<T> => ({ inner });

// using 'extends Boxed<any>[]' instead of 'extends Boxed<any>'
function test<T extends Boxed<any>[]>(...args: T): T extends Boxed<infer I>[] ? I : never {
    return args[0].inner;
}

test(box(0), box('str')); // string | number 🎉
test(...[box(0), box('str')]); // string | number 🎉

You can play around with this code snippet in the TypeScript Playground.

If you specify

T extends Boxed<any>>(...args: T[])

, TypeScript tends to infer the array type based on the first item's type, assuming all rest parameter items should be of the same type.

declare function foo<T extends string | number>(...args: T[]): void
// foo<"bar">(...args: "bar"[]): void;
foo("bar", 1) // error, '1' is not assignable to type '"bar"'

The correct notation for resolving generic rest parameters is as follows:

declare function foo2<T extends (string | number)[]>(...args: T): void
// foo2<["bar", 1]>(args_0: "bar", args_1: 1): void
foo2("bar", 1)

Is it feasible to deduce the generic type of a function by considering all remaining arguments?

Answer №1

Similar questions

Angular fails to include the values of request headers in its requests

What is the reason for the failure of the "keyof" method on this specific generic type within a Proxy object created by a class constructor?

Is it feasible to stop closure from capturing external variables in TypeScript?

Is there a way to check if a date of birth is valid using Regular Expression (RegExp) within a react form?

Remove all spaces from input fields in angular Typescript, excluding the enter key

Describing a property of an interface as the determined form of a conditional type that is generic

Receiving an error when attempting to inject the Router in a component constructor without using the elvis operator

Creating an Angular form group that includes dynamic form controls with custom form control names

Discovering if a page can be scrolled in Angular

The term 'Pick' is typically used to identify a specific type, however, in this particular situation, it appears to be functioning as a value while attempting to expand the Pick

Experiment with Google Sign-In authentication in jest with Firebase

Tips for integrating a variety of components onto a single webpage

Exploring the seamless integration of Next.js, TypeScript, and useContext across

Unable to retrieve component name using React.Children

The error "date.isUtc is not a function" is being thrown by MomentAdapter.js

Exploring the power of combining React, styled-components, and TypeScript: Creating a functional component that encapsulates a styled component

Display a picture retrieved from a POST request using Angular and a Spring Boot backend

Error message in Ionic 2: "Property is not found on type"

Having trouble locating the module for my custom TypeScript module

What is the method in AngularJS2 for using TypeScript to inject dependencies into components?