Typescript Generic Specialization

Question

I'm looking for something akin to specialization in Typescript generics, where implementations can be disjoint based on type criteria.

A minimal example:

const someFunction = <A>() => { return 0; }

// something like this
<A extends String>someFunction = (a: A) => { return 1; }
<A extends Number>someFunction = (a: A) => { return 2; }
.
.
.

console.log(someFunction(false)); // prints 0
console.log(someFunction('string')); // prints 1
console.log(someFunction(42)); // prints 2

This is the "jist" of what I'd like. Is this possible in Typescript?

Answer 1

What you're talking about does not exist in Typescript. The closest to this would be a function overload. Based on your example it would look something like this:

function someFunction(a: boolean): 0
function someFunction(a: string): 1
function someFunction(a: number): 2
function someFunction(a: any) {
  if(typeof a === 'boolean') {
    return 0
  } else if (typeof a === 'string') {
    return 1
  } else if (typeof a === 'number') {
    return 2
  }
}

This example works with primitives and typeof but would work the same with complex values and other type guards including User-Defined Type Guards.