Can callback argument types be contingent on certain conditions? For example, could argument 0 be null if argument 1 is a string?

Question

Can callback argument types be contingent on certain conditions? For example, could argument 0 be null if argument 1 is a string?

I am attempting to implement conditional type logic for the parameter types of a callback function.

In this scenario, the first argument represents the value while the second argument could be an error message.

type CallbackWithoutError = (value: string, error: undefined) => void
type CallbackWithError = (value: undefined, error: string) => void

declare const foo: (cb: CallbackWithError | CallbackWithoutError) => void

// Assuming CallbackWithError initially
foo((value, error) => {
   if (error) {
      // handle error
      return
   }
   // Switching to CallbackWithoutError after checking for error
   console.log(value)
})

Is it feasible for TypeScript to assume that the callback function has the parameters related to errors defined first?

The code snippet shows how the presence of the 'error' parameter determines which type of callback (with or without error) will be used in subsequent operations.

typescript

Answer 1

Answer №1

It appears that utilizing discriminating tuples could be helpful in this case:

// Define the parameters to only accept one of two tuple types:
type Callback = (...p: [string, undefined] | [undefined, string]) => void

declare const foo: (cb: Callback) => void

foo((...p) => {
    if (p[1] !== undefined) {
        // handle
        return
    } else {
        console.log(p[0]) // TypeScript recognizes it as a string at this point.
    }
})

For more details, check out this Playground Link.

Answer 2

It appears that utilizing discriminating tuples could be helpful in this case:

// Define the parameters to only accept one of two tuple types:
type Callback = (...p: [string, undefined] | [undefined, string]) => void

declare const foo: (cb: Callback) => void

foo((...p) => {
    if (p[1] !== undefined) {
        // handle
        return
    } else {
        console.log(p[0]) // TypeScript recognizes it as a string at this point.
    }
})

For more details, check out this Playground Link.

Can callback argument types be contingent on certain conditions? For example, could argument 0 be null if argument 1 is a string?

Answer №1

Similar questions

Getting just the outer edges of intricate BufferGeometry in Three.js

The assignment of Type Observable<Observable<any[]>> to Observable<any[]> is not valid

Enhancing Code Functionality with TypeScript Overload Methods

Reactive Programming: Transforming an earlier value as it moves down the pipeline

Enhance React component props for a styled component element using TypeScript

Encountering a type error with mongoose's pre-save method while using Express with TypeScript

Is it necessary for the React generic type prop to be an extension of another type

Utilize the useState() hook to add an object and display its data in a React Native

A function that retrieves an array containing each individual element from a multi-dimensional array

Having trouble installing npm package in Angular project

Is it possible for transclusion to display content from external sources using *ngIf and <ng-content>?

Utilizing Vue 3 props validation in conjunction with the power of Typescript

Steps for setting up a nested route in Angular 2

Is foreach not iterating through the elements properly?

Executing an HTTP POST request without properly encoding a specific parameter

What is the process for changing a field in a document on firestore?

Issue with NestedKeyof type arising from circularly referencing objects

Angular 4 Operator for adding elements to the front of an array and returning the updated array

Tips for incorporating nested generics in Typescript

The default value in an Ionic select dropdown remains hidden until it is clicked for the first time