What is the proper way to implement the coalesce function in my code?

Question

What is the proper way to implement the coalesce function in my code?

I'm still learning about TypeScripts and other typed languages beyond just standard types. My goal is to find a more precise way to type this function, removing the any type for both parameters and the return type.

The function is designed to return the first value that is not null, undefined, or NaN.

/** Fetches the first non-null value excluding NaN */
const coalesce = (...args: any): any => {
  for (let i = 0; i < args.length; i++) {
    // args[i] === args[i] is used to exclude NaN, as NaN !== NaN
    if (args[i] != null && args[i] === args[i]) {
      return args[i];
    }
  }
  return null;
};

This is an example of how the function is used:

test('coalesce returns the first value that is not null, undefined, NaN', () => {
  expect(coalesce(null, undefined, NaN, 'maybe')).toBe('maybe');
}); // -> returns 'maybe'

typescript

Answer 1

Answer №1

To simplify the process, we can define a function that captures the types of the parameters we pass and returns a union of all parameter types.

By using tuples for rest parameters to gather all parameter types as a tuple type, and utilizing type queries to create a union of all types in the tuple:

const coalesce = <T extends any[]>(...args: T): T[number] => {
    for (let i = 0; i < args.length; i++) {
        // args[i] === args[i] is used to avoid NaN comparison, as NaN !== NaN
        if (args[i] != null && args[i] === args[i]) {
            return args[i];
        }
    }
    return null;
};

// o will be string | number | null | undefined under strict null checks
// T is [null, undefined, number, string], so T[number] results in string | number | null | undefined
let o = coalesce(null, undefined, NaN, 'maybe')

The main purpose of the function is to eliminate nulls and undefined values (including NaN, which are not denoted in the type system and hence cannot be handled). The current signature retains null and undefined types. To address this, mapped types and conditional types can be incorporated to eliminate null and undefined if any parameter cannot be null or undefined (as any non-null/non-undefined parameter will be returned).

type ExcludeNullIfAnyNotNullHelper<T> = {
    [P in keyof T]-?: (null extends T[P] ? never : null) |
        (undefined extends T[P] ? never : undefined) 
}[keyof T]

type ExcludeNullIfAnyNotNull<T extends any[]> = Exclude<T[number], ExcludeNullIfAnyNotNullHelper<T>>

// Examples of removing null and undefined types based on conditions
type t1 = ExcludeNullIfAnyNotNull<[null, undefined, number, string]> // number | string
type t2 = ExcludeNullIfAnyNotNull<[null | string, string]> // string
type t4 = ExcludeNullIfAnyNotNull<[null | undefined | string, string | null]> // string | null

function coalesce<T extends any[]>(...args: T): ExcludeNullIfAnyNotNull<T>
function coalesce<T extends any[]>(...args: T): T[number] {
    for (let i = 0; i < args.length; i++) {
        // args[i] === args[i] is to avoid NaN, because NaN !== NaN
        if (args[i] != null && args[i] === args[i]) {
            return args[i];
        }
    }
    return null;
};

// o will be string | number 
let o = coalesce(null, undefined, NaN, 'maybe')

Answer 2

To simplify the process, we can define a function that captures the types of the parameters we pass and returns a union of all parameter types.

By using tuples for rest parameters to gather all parameter types as a tuple type, and utilizing type queries to create a union of all types in the tuple:

const coalesce = <T extends any[]>(...args: T): T[number] => {
    for (let i = 0; i < args.length; i++) {
        // args[i] === args[i] is used to avoid NaN comparison, as NaN !== NaN
        if (args[i] != null && args[i] === args[i]) {
            return args[i];
        }
    }
    return null;
};

// o will be string | number | null | undefined under strict null checks
// T is [null, undefined, number, string], so T[number] results in string | number | null | undefined
let o = coalesce(null, undefined, NaN, 'maybe')

The main purpose of the function is to eliminate nulls and undefined values (including NaN, which are not denoted in the type system and hence cannot be handled). The current signature retains null and undefined types. To address this, mapped types and conditional types can be incorporated to eliminate null and undefined if any parameter cannot be null or undefined (as any non-null/non-undefined parameter will be returned).

type ExcludeNullIfAnyNotNullHelper<T> = {
    [P in keyof T]-?: (null extends T[P] ? never : null) |
        (undefined extends T[P] ? never : undefined) 
}[keyof T]

type ExcludeNullIfAnyNotNull<T extends any[]> = Exclude<T[number], ExcludeNullIfAnyNotNullHelper<T>>

// Examples of removing null and undefined types based on conditions
type t1 = ExcludeNullIfAnyNotNull<[null, undefined, number, string]> // number | string
type t2 = ExcludeNullIfAnyNotNull<[null | string, string]> // string
type t4 = ExcludeNullIfAnyNotNull<[null | undefined | string, string | null]> // string | null

function coalesce<T extends any[]>(...args: T): ExcludeNullIfAnyNotNull<T>
function coalesce<T extends any[]>(...args: T): T[number] {
    for (let i = 0; i < args.length; i++) {
        // args[i] === args[i] is to avoid NaN, because NaN !== NaN
        if (args[i] != null && args[i] === args[i]) {
            return args[i];
        }
    }
    return null;
};

// o will be string | number 
let o = coalesce(null, undefined, NaN, 'maybe')

Answer 3

Answer №2

Describing the type function you're attempting is quite complex.

NaN poses an issue as TypeScript lacks a representation for NaN as a literal type. The value NaN falls under the type number, making it challenging for the compiler to distinguish if a value of type number is potentially NaN. Therefore, when encountering a number argument, it must be treated as number | null for the coalesce() function. For instance:

function hmm(n: number) { return coalesce(n, "oops"); }

should yield a value of type number | "oops", rather than just number. A slight improvement can be made by explicitly recognizing that a numeric literal cannot be NaN, such as in this case:

coalesce(123, "oops");

where the result should be 123 and not 123 | "oops", as 123 is a confirmed non-NaN number.

By treating arguments to coalesce() as a tuple, the goal is to iterate through the tuple from left to right, aggregating a union of the types while removing any potential null or undefined types. If a type that is unquestionably not null, undefined, or

number</code is encountered, the process stops. Otherwise, if it reaches the end without such certainty, <code>null

is added to the union, and the process concludes.

This recursive type function is not currently supported by TypeScript, necessitating approaches like unrolling the recursive type to a fixed depth before terminating.

Types can be defined as follows:

// Definitions...

The design leads to a fixed depth with orderly progression to handle longer argument lists. The above arrangement is suitable for tuples up to a certain length before transitioning to a union for longer lists.

To include literal type arguments such as 123 without automatic widening, a hint must be given to the compiler using a type like Narrowable.

type Narrowable = string | number | boolean | symbol | object |
  null | undefined | void | ((...args: any[]) => any) | {};

Finally, typing coalesce() unveils an accurate assessment based on the defined logic:

const coalesce = <T extends Narrowable[]>(...args: T): FirstNonNull<T> => {
  // Implementation...
};

Adapting this pattern, the results demonstrate the robustness of the function:

// Examples...

The outcomes are in alignment with the expected behavior of coalesce().

Addressing this multidimensional concept in type definitions is intricate yet impactful. The provided insights and structures may prove beneficial in your endeavors. Best of luck!

Answer 4

Describing the type function you're attempting is quite complex.

NaN poses an issue as TypeScript lacks a representation for NaN as a literal type. The value NaN falls under the type number, making it challenging for the compiler to distinguish if a value of type number is potentially NaN. Therefore, when encountering a number argument, it must be treated as number | null for the coalesce() function. For instance:

function hmm(n: number) { return coalesce(n, "oops"); }

should yield a value of type number | "oops", rather than just number. A slight improvement can be made by explicitly recognizing that a numeric literal cannot be NaN, such as in this case:

coalesce(123, "oops");

where the result should be 123 and not 123 | "oops", as 123 is a confirmed non-NaN number.

By treating arguments to coalesce() as a tuple, the goal is to iterate through the tuple from left to right, aggregating a union of the types while removing any potential null or undefined types. If a type that is unquestionably not null, undefined, or

number</code is encountered, the process stops. Otherwise, if it reaches the end without such certainty, <code>null

is added to the union, and the process concludes.

This recursive type function is not currently supported by TypeScript, necessitating approaches like unrolling the recursive type to a fixed depth before terminating.

Types can be defined as follows:

// Definitions...

The design leads to a fixed depth with orderly progression to handle longer argument lists. The above arrangement is suitable for tuples up to a certain length before transitioning to a union for longer lists.

To include literal type arguments such as 123 without automatic widening, a hint must be given to the compiler using a type like Narrowable.

type Narrowable = string | number | boolean | symbol | object |
  null | undefined | void | ((...args: any[]) => any) | {};

Finally, typing coalesce() unveils an accurate assessment based on the defined logic:

const coalesce = <T extends Narrowable[]>(...args: T): FirstNonNull<T> => {
  // Implementation...
};

Adapting this pattern, the results demonstrate the robustness of the function:

// Examples...

The outcomes are in alignment with the expected behavior of coalesce().

Addressing this multidimensional concept in type definitions is intricate yet impactful. The provided insights and structures may prove beneficial in your endeavors. Best of luck!

What is the proper way to implement the coalesce function in my code?

Answer №1

Answer №2

Similar questions

Include a class in ul > li elements upon page load in Angular4

What is the best way to call an Angular component function from a global function, ensuring compatibility with IE11?

Issues with Angular2 causing function to not run as expected

Functional programming: Retrieve the initial truthy output from executing an array of diverse functions using a particular parameter

Ensure all promises are resolved inside of for loops before moving on to the next

Creating callback functions that vary based on input variables

When the next() function of bcrypt.hash() is called, it does not activate the save method in mongoose

Generate a new array, specifying its type, and populate it by utilizing Angular

Are there any comparable features in Angular 8 to Angular 1's $filter('orderBy') function?

Issue with displaying Typescript sourcemaps on Android device in Ionic 2

What is the method for comparing a value in TypeScript that does not match a given value?

Guide on converting a JSON object into a TypeScript Object

To ensure the next line only runs after the line above has finished executing, remember that the function is invoked in HTML

Bring in all Functions and Interfaces from the Types Definition

I'm struggling to get a specific tutorial to work for my application. Can anyone advise me on how to map a general URL to the HTTP methods of an API endpoint that is written in C

Sorting in the TypeScript/Angular table is functioning properly on every column except for the initial one

Is There a Comparable Feature to *ngIf in DevExtreme?

Both undefined and null are sometimes allowed as values in conditional types, even when they should not be

Tips for utilizing intellisense from monaco.d.ts

What is the best way to declare and initialize a global variable in a TypeScript Node application?