Understanding TypeScript's Type Checks: Handling Type 'XXX' is not assignable to type 'XXX|YYY'

Learn how to effectively manage TypeScript's type assignments when creating higher-order functions, like `opposite(fn)`, that need to return a type based on input.
---

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: TypeScript: type "XXX" is not assignable to type "XXX|YYY"

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding TypeScript's Type Checks: Handling Type 'XXX' is not assignable to type 'XXX|YYY'

Creating complex functions in TypeScript can sometimes lead to tricky issues, especially when dealing with types. If you've encountered the error message "Type 'number' is not assignable to type 'ReturnType T '", you're not alone. This issue often arises when trying to implement higher-order functions that expect their return types to be consistent with their input types. In this guide, we'll explore a solution to demonstrate how to correctly type a higher-order function that can handle both boolean and numeric input functions.

The Problem

In our scenario, we're writing a higher-order function called opposite(fn), which should take an input function fn and return a new function that inverses the output of fn. Here's the specific behavior we want:

If fn returns a boolean, the returned function should return the opposite boolean value.

If fn returns a number, the returned function should return 1 if the result was non-zero, and 0 if the result was zero.

The core issue, however, arises from TypeScript type checking. When we try to return 1 or 0 from our function, we get an error indicating that a number cannot be assigned to a type that is derived from ReturnType<T>, which is ambiguous (boolean | number).

Understanding TypeScript's Type System

Before diving into the solution, let's break down the relevant concepts in TypeScript's type system that are causing the confusion:

ReturnType T : This utility type extracts the return type of a function type.

Type Inference: TypeScript infers types based on how functions are used, meaning it cannot always predict what types to expect if they're not clearly defined upfront.

Key Challenges

When constructing the opposite function, several things can go wrong:

ReturnType T is Undetermined: TypeScript cannot infer whether ReturnType<T> is boolean | number, leading to type conflicts.

Type Overloads: By specifying overloads, we introduce complexities since they're treated as intersections, where combining boolean & number results in an impossible never type.

Generic Return Type: If a caller provides an unexpected value, it can throw off TypeScript's ability to do accurate type checking, complicating the management of return types.

The Solution

To correctly implement the opposite function, we need to use a utility type called Widen that can handle our specific return types effectively. Here’s how we can structure this solution:

Step 1: Create a Widen Utility Type

This utility type will help us define the return type based on the actual input type, whether it's a boolean or number.

[[See Video to Reveal this Text or Code Snippet]]

Step 2: Write the Opposite Function

Now we can define the opposite function to utilize our Widen utility while also ensuring that it captures the expected parameter types.

[[See Video to Reveal this Text or Code Snippet]]

Step 3: Define Function Overloads (Optional)

To make the typings clearer and enforce the correct return types, we can also define function overloads.

[[See Video to Reveal this Text or Code Snippet]]

Step 4: Handling Generic Return Types

In order to parameterize the return type, we have to ensure that our function signature captures the generic nature accurately.

[[See Video to Reveal this Text or Code Snippet]]

Conclusion

Creating a robust higher-order function in TypeScript that works seamlessly across varying return types can be a challenge due to strict type checks. The key takeaway here is to utilize TypeScript’s type utilities like ReturnType and custom utility types like Widen to define clear and consistent return types for your funct