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

Using Tailwind classes as a prop functions correctly, however, it does not work when directly applied

Retrieving the output from a nested scope within a function

Avoiding an event from spreading in Angular

Testing Playwright - accessing variables from the .env file

Properly implement Angular/Typescript to populate an array with chosen objects

Running multiple instances of Chrome to execute all scenarios sequentially within a single feature file in Protractor

Encountering issues with importing a module from a .ts file

Tips for Invoking an Overloaded Function within a Generic Environment

Can you explain how to invoke a class with express().use function?

Storing TypeScript functions as object properties within Angular 6

Generating GraphQL Apollo types in React Native

What is the best way to define a union type that encompasses all values within a field of an array?

I am looking to generate an array with key-value pairs from an object that will be seen in the examination

Keep an eye out for any instances of new files being created in nodemon js or npm

Is it possible to verify type property names using a union type?

Mastering Inter-Composable Communication in Vue 3: A Guide

Arrange a JavaScript map based on its values and ensure that a specific field index remains at the top position

Efficiently loading data in a table with a universal filter feature using Angular with PrimeNG

Discovering a specific string within an array of nested objects

retrieve data types from an array of object values