Avoiding the restriction of narrowing generic types when employing literals with currying in TypeScript

Question

Avoiding the restriction of narrowing generic types when employing literals with currying in TypeScript

Trying to design types for Sanctuary (js library focused on functional programming) has posed a challenge. The goal is to define an Ord type that represents any value with a natural order. In essence, an Ord can be:

A built-in primitive type: number, string, Date, boolean
A user-defined type that implements the necessary interface (compareTo method)
An array containing other Ord instances

To articulate this concept, I opted for a union type (with a workaround to handle recurring types), as shown below:

type Ord = boolean | Date | number | string | Comparable<any> | OrderedArray

interface OrderedArray extends Array<Ord> {}

(The code referenced above can be accessed via this typescript playground).

In creating type definitions for functions like compare, I used generic types with constraints. Here's an example of how it's done in a curried form:

function compare<T extends Ord>(a: T): (b: T) => number

However, when trying to use such a function with literal arguments (e.g., compare(2)(3)), TypeScript raises an error stating, '3' is not assignable to '2'. It appears that TypeScript narrows down the type parameter to a literal value ('2') instead of just narrowing it down to number after the first argument is provided. Is there a way to prevent this from happening or adopt a different approach that would work effectively?

typescript type-inference

Answer 1

Answer №1

To achieve literal widening manually in TypeScript, you can utilize the type system directly. This is useful when the compiler doesn't perform the widening automatically. For example, if you have a contextual type including string, number, and boolean for T:

type Widen<T> = 
  T extends string ? string : 
  T extends number ? number : 
  T extends boolean ? boolean : 
  T;

const compare = <T extends Ord>(x: T) => (y: Widen<T>) => 0;

In this scenario, x will remain narrow while y will be widened. You can make a function call like this:

compare(1)(3);  // <1>(x: 1) => (y: number) => number

This technique provides the necessary widening behavior for your specific case. Hope this solution works well for you!

If you need the option to either keep T narrow or widen it, here's a complex approach:

type OptionallyWiden<X, T> = 
   [X] extends [never] ? 
     T extends string ? string : 
     T extends number ? number : 
     T extends boolean ? boolean : 
     T
  : T;

const compare = <X extends Ord = never, T extends Ord = X>(x: T) => (
  y: OptionallyWiden<X, T>
) => 0;

The above method allows for optional narrowing or widening based on the value of X. If X is never specified, T will be widened. Otherwise, the specified value of X will determine whether T remains narrow. Here's how it behaves:

compare(1)(3); // Works fine
// const compare: <never, 1>(x: 1) => (y: number) => number

compare<1 | 2>(1)(3); // Error now
//  ------------> ~
// 3 is not assignable to 1 | 2
// const compare: <1 | 2, 1 | 2>(x: 1 | 2) => (y: 1 | 2) => number

This approach involves using two parameters, X and T, with X defaulting to never unless otherwise stated. It offers flexibility in maintaining both narrow and wide values for T. However, consider whether the complexity of this type juggling is worth the added flexibility.

Feel free to explore these options further and decide what suits your requirements best. Let me know if you need more assistance!

Answer 2

To achieve literal widening manually in TypeScript, you can utilize the type system directly. This is useful when the compiler doesn't perform the widening automatically. For example, if you have a contextual type including string, number, and boolean for T:

type Widen<T> = 
  T extends string ? string : 
  T extends number ? number : 
  T extends boolean ? boolean : 
  T;

const compare = <T extends Ord>(x: T) => (y: Widen<T>) => 0;

In this scenario, x will remain narrow while y will be widened. You can make a function call like this:

compare(1)(3);  // <1>(x: 1) => (y: number) => number

This technique provides the necessary widening behavior for your specific case. Hope this solution works well for you!

If you need the option to either keep T narrow or widen it, here's a complex approach:

type OptionallyWiden<X, T> = 
   [X] extends [never] ? 
     T extends string ? string : 
     T extends number ? number : 
     T extends boolean ? boolean : 
     T
  : T;

const compare = <X extends Ord = never, T extends Ord = X>(x: T) => (
  y: OptionallyWiden<X, T>
) => 0;

The above method allows for optional narrowing or widening based on the value of X. If X is never specified, T will be widened. Otherwise, the specified value of X will determine whether T remains narrow. Here's how it behaves:

compare(1)(3); // Works fine
// const compare: <never, 1>(x: 1) => (y: number) => number

compare<1 | 2>(1)(3); // Error now
//  ------------> ~
// 3 is not assignable to 1 | 2
// const compare: <1 | 2, 1 | 2>(x: 1 | 2) => (y: 1 | 2) => number

This approach involves using two parameters, X and T, with X defaulting to never unless otherwise stated. It offers flexibility in maintaining both narrow and wide values for T. However, consider whether the complexity of this type juggling is worth the added flexibility.

Feel free to explore these options further and decide what suits your requirements best. Let me know if you need more assistance!

Answer 3

Answer №2

After some trial and error, I managed to come up with a solution (although it may not be the most optimal one). It required adding explicit overloads for all types with literal representation that could potentially be narrowed down. Here is how I did it:

function compare(x: number): (y: number) => number;
function compare(y: string): (y: string) => number;
function compare(x: boolean): (y: boolean) => number;

// generic overload
function compare<T extends Ord>(x: T): (y: T) => number;
function compare<T extends Ord>(x: T): (y: T) => number {
  ...
};

I believe that these explicit overloads now take precedence in signature resolution, effectively solving my initial issue:

compare(2)(3) // now resolves to compare(x: number)(y: number)

You can test out this solution on the typescript playground.

Answer 4

After some trial and error, I managed to come up with a solution (although it may not be the most optimal one). It required adding explicit overloads for all types with literal representation that could potentially be narrowed down. Here is how I did it:

function compare(x: number): (y: number) => number;
function compare(y: string): (y: string) => number;
function compare(x: boolean): (y: boolean) => number;

// generic overload
function compare<T extends Ord>(x: T): (y: T) => number;
function compare<T extends Ord>(x: T): (y: T) => number {
  ...
};

I believe that these explicit overloads now take precedence in signature resolution, effectively solving my initial issue:

compare(2)(3) // now resolves to compare(x: number)(y: number)

You can test out this solution on the typescript playground.

Answer 5

Answer №3

When you simplify the definition of Ord, all tests are successful.

interface Comparable<T> {
  compareTo(other: T): number
}

type Ord<T> = T | Comparable<T> | Array<T>

const compare = <T extends Ord<any>>(x: T) => (y: T) => 0;

TypeScript Playground here.

Although, I am uncertain if this meets all the other requirements for the library.

Answer 6

When you simplify the definition of Ord, all tests are successful.

interface Comparable<T> {
  compareTo(other: T): number
}

type Ord<T> = T | Comparable<T> | Array<T>

const compare = <T extends Ord<any>>(x: T) => (y: T) => 0;

TypeScript Playground here.

Although, I am uncertain if this meets all the other requirements for the library.

Avoiding the restriction of narrowing generic types when employing literals with currying in TypeScript

Answer №1

Answer №2

Answer №3

Similar questions

Strategies for enhancing performance in an Angular 4 project

Encountering a 404 error when utilizing ngx-monaco-editor within an Angular application

A guide to merging two JSON objects into a single array

Exploring how enums can be utilized to store categories in Angular applications

Is it possible to utilize an enum for typing an array variable?

Deciphering the .vimrc setup for tooltips and symbols in TypeScript

Is it possible to use Immutable named parameters with defaults in Typescript during compilation?

Multiple keyup events being triggered repeatedly

Steps to specify a prefix for declaring a string data type:

Typescript headaches: Conflicting property types with restrictions

Guide to implementing scheduled tasks in a Node.js API using Express

Learn how to alter the website's overall appearance by changing the background or text color with a simple click on a color using Angular

Is TypeScript 2.8 Making Type-Safe Reducers Easier?

Exploring Typescript: Combining types (rather than intersecting them)

What is the best method for saving console.log output to a file?

Create a mechanism in the API to ensure that only positive values greater than or equal to 0 are accepted

Transmit a form containing a downloaded file through an HTTP request

Guide to creating a Map with typescript

Error TS[2339]: Property does not exist on type '() => Promise<(Document<unknown, {}, IUser> & Omit<IUser & { _id: ObjectId; }, never>) | null>'

The function is missing a closing return statement and the return type does not specify 'undefined'