What is the method for assigning the results of Array#map to a variadic tuple `[P in keyof T]: ReturnType<T[P]>`?

Question

What is the method for assigning the results of Array#map to a variadic tuple `[P in keyof T]: ReturnType<T[P]>`?

Attempting to devise a strongly-typed function for mapping over a uniform array of functions that yield arbitrary values.

I've tinkered with both approaches, and while they do produce the expected types, I encounter issues with the return value:

const executeFunctions = <T extends (() => any)[]>(
    functionsArray: [...T],
): {
    [P in keyof T]: ReturnType<T[P]>
} => {
    const result = [];
    for (let i = 0; i < functionsArray.length; i += 1) {
        result.push(functionsArray[i]());
    }
    return result;
}
// ^ Error: Type 'any[]' is not assignable to type '{ [P in keyof T]: ReturnType<T[P]>; }'.ts(2322)

const results = executeFunctions([
    () => 'hello',
    () => 123,
    () => true,
]);

// const results: [string, number, boolean]


const executeFunctions = <T extends (() => unknown)[]>(
    tasks: [...T],
): {
    [P in keyof T]: ReturnType<T[P]>;
} => tasks.map(task => task());

// ^ Error: Type 'unknown[]' is not assignable to type '{ [P in keyof T]: ReturnType<T[P]>; }'.ts(2322)


const results = executeFunctions([
    () => 'hello',
    () => 123,
    () => true,
]);
// const results: [string, number, boolean]

How can I accurately determine the return type?

arrays typescript dictionary variadic-tuple-types

Answer 1

Answer №1

To achieve this, you can explicitly convert the unknown[] array returned by .map to match the complex return type of the function runAll. Although it may seem unconventional, performing a cast in this situation is safe because you are certain about the types involved. In my adaptation based on your second example, I also addressed an additional issue related to the return type. It resulted in:

type AllResults<T> = {
    [P in keyof T]: T[P] extends (() => unknown) ? ReturnType<T[P]> : never;
};

const runAll = <T extends Array<() => unknown>>(
    actions: [...T],
): AllResults<T> => actions.map(action => action()) as AllResults<T>;

const results = runAll([
    () => 'hello',
    () => 123,
    () => true,
]);
// const results: [string, number, boolean]

Answer 2

To achieve this, you can explicitly convert the unknown[] array returned by .map to match the complex return type of the function runAll. Although it may seem unconventional, performing a cast in this situation is safe because you are certain about the types involved. In my adaptation based on your second example, I also addressed an additional issue related to the return type. It resulted in:

type AllResults<T> = {
    [P in keyof T]: T[P] extends (() => unknown) ? ReturnType<T[P]> : never;
};

const runAll = <T extends Array<() => unknown>>(
    actions: [...T],
): AllResults<T> => actions.map(action => action()) as AllResults<T>;

const results = runAll([
    () => 'hello',
    () => 123,
    () => true,
]);
// const results: [string, number, boolean]

Answer 3

Answer №2

Let's explore the following scenario:


type Fn = () => any

type MapPredicate<F> = F extends Fn ? ReturnType<F> : never

/**
 * A function that iterates through an array and retrieves the return type
 */
type Mapped<
  Arr extends Array<unknown>,
  Result extends Array<unknown> = []
  > = Arr extends []
  ? []
  : Arr extends [infer H]
  ? [...Result, MapPredicate<H>]
  : Arr extends [infer Head, ...infer Tail]
  ? Mapped<[...Tail], [...Result, MapPredicate<Head>]>
  : Readonly<Result>;

/**
 * Function overload to handle different callbacks in an array
 * check out documentation for more details: 
 * https://www.typescriptlang.org/docs/handbook/functions.html#overloads
 */
function runAll<Cb extends Fn, Cbs extends Cb[]>(
  array: [...Cbs],
): Mapped<Cbs>

function runAll<Cb extends Fn, Cbs extends Cb[]>(
  array: [...Cbs],
) {
  return array.reduce<ReadonlyArray<ReturnType<Cbs[number]>>>(
    (acc, elem) => [...acc, elem()],
    []
  )
}

const results = runAll([
  () => 'hello',
  () => 123,
  () => true,
]); // [string, number, boolean]

Playground

When working with functions that iterate through arrays, specifying a return type explicitly may not be effective. It is advisable to use overloads in such scenarios.

I have introduced a helper called Mapped, which recursively traverses the type of the array argument and returns the return type of each callback function.

This is similar to array.map(elem=>elem())

For more intriguing examples, you can visit my blog here.

Answer 4

Let's explore the following scenario:


type Fn = () => any

type MapPredicate<F> = F extends Fn ? ReturnType<F> : never

/**
 * A function that iterates through an array and retrieves the return type
 */
type Mapped<
  Arr extends Array<unknown>,
  Result extends Array<unknown> = []
  > = Arr extends []
  ? []
  : Arr extends [infer H]
  ? [...Result, MapPredicate<H>]
  : Arr extends [infer Head, ...infer Tail]
  ? Mapped<[...Tail], [...Result, MapPredicate<Head>]>
  : Readonly<Result>;

/**
 * Function overload to handle different callbacks in an array
 * check out documentation for more details: 
 * https://www.typescriptlang.org/docs/handbook/functions.html#overloads
 */
function runAll<Cb extends Fn, Cbs extends Cb[]>(
  array: [...Cbs],
): Mapped<Cbs>

function runAll<Cb extends Fn, Cbs extends Cb[]>(
  array: [...Cbs],
) {
  return array.reduce<ReadonlyArray<ReturnType<Cbs[number]>>>(
    (acc, elem) => [...acc, elem()],
    []
  )
}

const results = runAll([
  () => 'hello',
  () => 123,
  () => true,
]); // [string, number, boolean]

Playground

When working with functions that iterate through arrays, specifying a return type explicitly may not be effective. It is advisable to use overloads in such scenarios.

I have introduced a helper called Mapped, which recursively traverses the type of the array argument and returns the return type of each callback function.

This is similar to array.map(elem=>elem())

For more intriguing examples, you can visit my blog here.

What is the method for assigning the results of Array#map to a variadic tuple `[P in keyof T]: ReturnType<T[P]>`?

Answer №1

Answer №2

Similar questions

Ruby - Obtain the byte array that includes the two's complement representation of a Bignum/Fixnum

Using the foreach loop to iterate through a System.String[] and print out the values

What are the reasons behind the code not functioning properly while utilizing 'vue-property-decorator' in Vue.js with TypeScript?

Adding Components Dynamically to Angular Parent Dashboard: A Step-by-Step Guide

How can we ensure in ReactJS that one API call has been completed before making another one?

Add a consecutive number before each element in an array using Bash

What is the best way to expose the "nuxtServerInit" action for Nuxt.js when using dynamic modules exclusively?

Achieving top-tier efficiency in segmenting items within an array of objects

How to utilize Enzyme to call a React prop in TypeScript

How to Retrieve Multiple Toggle Button Values using ID in AngularJS?

What programming language is the best choice for Angular 2 development?

correct usage of getServerSideProps with Typescript in a next.js project using i18n

How can I calculate multiplication using values from dynamic text fields with Jquery/Javascript?

Include a character in a tube using Angular

How can I pass a ref to a custom component in React with TypeScript using RefForwardingComponent and forwardRef?

Initializing Arrays of Struct in C++

Using Angular to include more than two parameters in an HTTP GET request

How can I showcase array elements using checkboxes in an Ionic framework?

Recording attributes in a React component with Typescript

In Swift 1.2, the dictionary keys and values are stored in the same order based on