Please ensure that the function chain has appropriate parameter and return types by specifying the tuple type

Question

Please ensure that the function chain has appropriate parameter and return types by specifying the tuple type

Can a new type be created for the given tuple/array that has certain validation constraints?

The following array is considered valid:

const funcs = [(a: string) => 1, (a: number) => 'A', (a: string) => 2]

However, this one is invalid due to a change in return types:

const funcs = [(a: string) => 1, (a: number) => 2, (a: string) => 3]

The key difference is the return type of the middle function being modified from string to number.

Is there a way to achieve this through TypeScript?

type SubtractOne<T extends number> = [-1, 0, 1, 2, ...][T];
type AddOne<T extends number> = [1, 2, 3, 4, ...][T];

const funcs = [(a: string) => 1, (a: number) => 'A', (a: string) => 2]

type CheckFuncs<T extends any[]> = { [(K extends number) in keyof T]: T[AddOne<K>] }

type funcsType = typeof funcs
type funcsType2 = CheckFuncs<funcsType>

A potential solution involves indexing with mapping. Could this method be applied to perform addition or subtraction using AddOne on K? This would enable access to the ReturnType of T[K] and the Parameter<T[k+1]>[0].

Playground

arrays typescript tuples

Answer 1

Answer №1

To access the next or previous value of a tuple using an index type K, you can utilize the power of variadic tuple types. You can define a type called Tail<T> that takes a tuple type T and returns a new tuple with the first element removed:

// Tail<[1,2,3]> is [2,3]
type Tail<T extends readonly any[]> = T extends [any, ...infer R] ? R : never;

With this definition in place, you can express "T[K+1]" as Tail<T>[K].

This answers your initial question, but let me continue to demonstrate how you can use it:

Here's a starting point for defining your CheckFuncs type:

type CheckFuncs<T extends readonly ((x: any) => any)[]> = { [K in keyof T]:
    K extends keyof Tail<T> ? (
        [T[K], Tail<T>[K]] extends [(x: infer A) => infer R, (x: infer S) => any] ? (
            [R] extends [S] ? T[K] : (x: A) => S
        ) : never
    ) : T[K]
}

This code walks through the tuples in T, compares T[K] with Tail<T>[K], and adjusts T[K] so that it works correctly. You can then create instances like these (ensure to use const assertions to preserve the tuple type):

const pass = [(a: string) => 1, (a: number) => 'A', (a: string) => 2] as const
const fail = [(a: string) => 1, (a: number) => 3, (a: string) => 2] as const

These produce the following types:

type passType = CheckFuncs<typeof pass>
// readonly [(a: string) => number, (a: number) => string, (a: string) => number]

type failType = CheckFuncs<typeof fail>
// readonly [(a: string) => number, (x: number) => string, (a: string) => number]

You can also create a function that works with CheckFuncs as demonstrated below:

function useFuncs<T extends readonly ((x: any) => any)[]>(...t: CheckFuncs<T>) { }

useFuncs((a: string) => 1, (a: number) => 'A', (a: string) => 2); // success
useFuncs((a: string) => 1, (a: number) => 3, (a: string) => 2); // error!
// ----------------------> ~~~~~~~~~~~~~~~~
// Argument of type '(a: number) => number' is not assignable to 
// parameter of type '(x: number) => string'.

Your implementation of CheckFuncs may vary based on your requirements. This serves as an example to guide you. Best of luck!

Link to code

Answer 2

To access the next or previous value of a tuple using an index type K, you can utilize the power of variadic tuple types. You can define a type called Tail<T> that takes a tuple type T and returns a new tuple with the first element removed:

// Tail<[1,2,3]> is [2,3]
type Tail<T extends readonly any[]> = T extends [any, ...infer R] ? R : never;

With this definition in place, you can express "T[K+1]" as Tail<T>[K].

This answers your initial question, but let me continue to demonstrate how you can use it:

Here's a starting point for defining your CheckFuncs type:

type CheckFuncs<T extends readonly ((x: any) => any)[]> = { [K in keyof T]:
    K extends keyof Tail<T> ? (
        [T[K], Tail<T>[K]] extends [(x: infer A) => infer R, (x: infer S) => any] ? (
            [R] extends [S] ? T[K] : (x: A) => S
        ) : never
    ) : T[K]
}

This code walks through the tuples in T, compares T[K] with Tail<T>[K], and adjusts T[K] so that it works correctly. You can then create instances like these (ensure to use const assertions to preserve the tuple type):

const pass = [(a: string) => 1, (a: number) => 'A', (a: string) => 2] as const
const fail = [(a: string) => 1, (a: number) => 3, (a: string) => 2] as const

These produce the following types:

type passType = CheckFuncs<typeof pass>
// readonly [(a: string) => number, (a: number) => string, (a: string) => number]

type failType = CheckFuncs<typeof fail>
// readonly [(a: string) => number, (x: number) => string, (a: string) => number]

You can also create a function that works with CheckFuncs as demonstrated below:

function useFuncs<T extends readonly ((x: any) => any)[]>(...t: CheckFuncs<T>) { }

useFuncs((a: string) => 1, (a: number) => 'A', (a: string) => 2); // success
useFuncs((a: string) => 1, (a: number) => 3, (a: string) => 2); // error!
// ----------------------> ~~~~~~~~~~~~~~~~
// Argument of type '(a: number) => number' is not assignable to 
// parameter of type '(x: number) => string'.

Your implementation of CheckFuncs may vary based on your requirements. This serves as an example to guide you. Best of luck!

Link to code

Please ensure that the function chain has appropriate parameter and return types by specifying the tuple type

Answer №1

Similar questions

What is the most effective way to code and define a MatSelect's MatSelectTrigger using programming techniques?

Error encountered when running protractor cucumber test: SyntaxError due to an unexpected token {

Tips for creating a versatile function in TypeScript that accepts either a single value or an array of values for two parameters

Is scanf capable of handling massive char arrays without breaking?

Enhance the appearance of data in Angular using a pipe or alternative method

What is preventing me from assigning to a class variable within a $http success handler?

Typescript's interface for key-value pairing with generic types

Issue with useEffect() not receiving prop

Establishing the initial state in React

Using Row-Major Ordering in C with Command Line Parameters

What is the best way to calculate the total of a set of strings that represent

Developing a word-building game inspired by Scrabble using C programming. Implementing a method to determine specific characters in a string, followed by assigning each character a score based on an array

What is the best method to find a matching property in one array from another?

Utilizing Selenium TestNG: Implementing DataProvider with 1D Array to Enhance Yahoo Search Feature

TS2322 error: What does it mean when the type is both not assignable and assignable?

The input '{ data: InvitedUser[]; "": any; }' does not match the expected type 'Element'

The WebSocket connection in the browser, when accessed through a remote server, typically shows a CLOSED state in the readyState property during the on

Manipulating nested arrays using index values in JavaScript

Issue: The system encountered a critical error: attempting to use a string offset as an

The dropdown navigation bar fails to close upon being clicked