Can anyone suggest a simpler method for creating function signatures with multiple conditions?

Question

Can anyone suggest a simpler method for creating function signatures with multiple conditions?

In my function, the first argument now determines if the function should receive an array or not. This function is similar to Foo

type stringF = (arr: false, type: 'str', value: string) => void
type numberF = (arr, false, type: 'num', value: number) => void
type booleanF = (arr, false, type: 'bool', value: boolean) => void
...
... 

declare const Foo: stringF & numberF & booleanF //& etc..

Initially there were 6 function types, which was manageable. But with the addition of an extra parameter determining array usage, things have become more complex.

Now the function types are:

type stringF = (arr: true, type: 'str', value: string[]) => void
type numberF = (arr, true, type: 'num', value: number[]) => void
type booleanF = (arr, true, type: 'bool', value: boolean[]) => void
...

Now there are 12 function types, and it seems challenging to properly type each function.

Is there an easier way to handle conditional function signatures?

typescript typescript2.0

Answer 1

Answer №1

To streamline different possibilities, conditional types can be utilized to create a singular signature:

type StringToType = { 
  str: string,
  num: number,
  bool: boolean
}
type MakeArrayIfTrue<TCondition, T> = TCondition extends true ? T[] : T;

type fn =  <MakeArray extends boolean, TypeKey extends keyof StringToType>(arr:  MakeArray, type: TypeKey, value: MakeArrayIfTrue<MakeArray, StringToType[TypeKey]>) => void

declare let fn : fn;
fn(true, "str", [""]);
fn(true, "bool", [""]); // error
fn(false, "str", [""]); // error

When handling union parameters, the behavior differs from multiple overloads. For instance, the following is valid:

declare let b: boolean;
declare let strOrBool: "str" | "bool";
// Last parameter can be boolean | string | boolean[] | string[]
fn(b, strOrBool, "") //ok
fn(b, strOrBool, [""]) //ok
fn(b, strOrBool, true) //ok
fn(b, strOrBool, 1) //this is still an error

To restrict this behavior, a union of all possible signatures can be created and transformed using UnionToIntersection to achieve a type resembling a function with overloads:

type StringToType = { 
  str: string,
  num: number,
  bool: boolean
}
type MakeArrayIfTrue<TCondition, T> = TCondition extends true ? T[] : T;

type UnionToIntersection<U> =  (U extends any ? (k: U)=>void : never) extends ((k: infer I)=>void) ? I : never
type FnHelper<MakeArray extends boolean = boolean, TypeKey extends keyof StringToType = keyof StringToType> = 
    MakeArray extends any ? TypeKey extends any ? (arr:  MakeArray, type: TypeKey, value: MakeArrayIfTrue<MakeArray, StringToType[TypeKey]>) => void: never: never;
type fn = UnionToIntersection<FnHelper>;

declare let fn : fn;
fn(true, "str", [""]);
fn(true, "bool", [""]); // error
fn(false, "str", [""]); // error

declare let b: boolean;
declare let strOrBool: "str" | "bool";
fn(b, strOrBool, "") //error
fn(b, strOrBool, [""]) //error
fn(b, strOrBool, true) //error

Answer 2

To streamline different possibilities, conditional types can be utilized to create a singular signature:

type StringToType = { 
  str: string,
  num: number,
  bool: boolean
}
type MakeArrayIfTrue<TCondition, T> = TCondition extends true ? T[] : T;

type fn =  <MakeArray extends boolean, TypeKey extends keyof StringToType>(arr:  MakeArray, type: TypeKey, value: MakeArrayIfTrue<MakeArray, StringToType[TypeKey]>) => void

declare let fn : fn;
fn(true, "str", [""]);
fn(true, "bool", [""]); // error
fn(false, "str", [""]); // error

When handling union parameters, the behavior differs from multiple overloads. For instance, the following is valid:

declare let b: boolean;
declare let strOrBool: "str" | "bool";
// Last parameter can be boolean | string | boolean[] | string[]
fn(b, strOrBool, "") //ok
fn(b, strOrBool, [""]) //ok
fn(b, strOrBool, true) //ok
fn(b, strOrBool, 1) //this is still an error

To restrict this behavior, a union of all possible signatures can be created and transformed using UnionToIntersection to achieve a type resembling a function with overloads:

type StringToType = { 
  str: string,
  num: number,
  bool: boolean
}
type MakeArrayIfTrue<TCondition, T> = TCondition extends true ? T[] : T;

type UnionToIntersection<U> =  (U extends any ? (k: U)=>void : never) extends ((k: infer I)=>void) ? I : never
type FnHelper<MakeArray extends boolean = boolean, TypeKey extends keyof StringToType = keyof StringToType> = 
    MakeArray extends any ? TypeKey extends any ? (arr:  MakeArray, type: TypeKey, value: MakeArrayIfTrue<MakeArray, StringToType[TypeKey]>) => void: never: never;
type fn = UnionToIntersection<FnHelper>;

declare let fn : fn;
fn(true, "str", [""]);
fn(true, "bool", [""]); // error
fn(false, "str", [""]); // error

declare let b: boolean;
declare let strOrBool: "str" | "bool";
fn(b, strOrBool, "") //error
fn(b, strOrBool, [""]) //error
fn(b, strOrBool, true) //error

Answer 3

Answer №2

When faced with this situation, it is recommended to utilize Generics. Your function signature could be structured as follows:

function myFunc<T>(value: T|T[]): void

Whether it's an array or a single value, you can simply handle the logic within your function. The type T encompasses all possible value types.

Answer 4

When faced with this situation, it is recommended to utilize Generics. Your function signature could be structured as follows:

function myFunc<T>(value: T|T[]): void

Whether it's an array or a single value, you can simply handle the logic within your function. The type T encompasses all possible value types.

Can anyone suggest a simpler method for creating function signatures with multiple conditions?

Answer №1

Answer №2

Similar questions

What is the process for obtaining the form of an item and then adjusting the characteristics of each individual leaf property?

The constructor in Angular 2 service is operational, however, other functions within the service are experiencing issues

Is there a way to assign a value to an Angular-specific variable using PHP?

What is the best way to calculate checksum and convert it to a 64-bit value using Javascript for handling extremely large files to avoid RAM overflow?

Issue: The parameter "data" is not recognized as a valid Document. The input does not match the requirements of a typical JavaScript object

Guide on showing a component exclusively for iPads with React and TypeScript

"Learn the steps to seamlessly add text at the current cursor position with the angular-editor tool

The Error message "Property 'data' is not present in Type <void> | AxiosHttpResponse<any>" is indicating that the data property is missing on

Creating a JSON file using an object to send requests in Angular

Error message: Injector Error: R3InjectorError(Standalone[_AppComponent])[_WebService -> _WebService -> _WebService] occurred

Implementing child components in React using TypeScript and passing them as props

Error: Unable to locate the type definition file for the '@babel' package

Describe a Typescript Interface Value as a collection of strings or any input provided as an argument

Assign a value to a FormControl in Angular 6

Stop the MatSort feature from activating when the space key is pressed in Angular Material

How can I select just one element to be impacted by a click event when using map in TypeScript?

Fast + Vue3 + VueRouter Lazy Load Routes According to Files

What is the process for incorporating buttons into an Angular mat-table?

"Unsuccessful API request leads to empty ngFor loop due to ngIf condition not being

Saving a user with a BLOB avatar in Angular 5: Tips and Tricks for Success