编写通用联合体类型的吸气剂

Question

From a union of two generic types I want to return the left value (or a default value if the union has the right type). I tried but generics and typeof / instanceof seems to not work so great together.

This is how I would write it in Haskell:

data Either a b = Left a | Right b

getLeftOrDefault :: a -> Either a b -> a
getLeftOrDefault _ (Left a) = a
getLeftOrDefault a (Right b) = a

and how would this translate to Typescript? This was my try:

function getLeftOrDefault<A, B>(either: A | B, backup: A) {
  if (either instanceof A) {
     return either;
  }
  return backup;
}

But this does not work. Any other way or workaround?

Answer 1

TypeScript types exist only at compile-time (since Javascript has no notion of types).

Therefore, you can't use type parameters at runtime.

Instead, you can check if (either instanceof backup.constructor) , which is an easy way to get the A constructor at runtime.

Note that this will not work for primitives.

Answer 2

As https://stackoverflow.com/a/51329983/6656422 states there are no TypeScript types at run time. You have to test the "type". To make something generic you could pass in a tester.

function getLeftOrDefault<A, B>(either: A | B, backup: A, isA: (obj: any) => obj is A): A {
  if (isA(either)) {
    return either;
  }
  return backup;
}

Usage:

Many times interfaces are used for strongly typing object literals, you can test the property(ies).

interface Car {
  engine: string;
}

interface Tree {
  branches: any[];
}

function isCar(obj: any): obj is Car {
  return !!obj.engine;
}

const myCar: Car = { engine: '350' };
const myTree: Tree = { branches: [] };
const myBackup: Car = { engine: '396' };

getLeftOrDefault(myCar, myBackup, isCar); // -> { engine: '350' }
getLeftOrDefault(myTree, myBackup, isCar); // -> { engine: '396' }

If your types are classes they have constructors at run time.

class Car {
  constructor(public engine: string) {}
}

class Tree {
  constructor(public branches: any[]) {}
}

function isCar(obj: any): obj is Car {
  return obj instanceof Car;
}

const myCar: Car = new Car('350');
const myTree: Tree = new Tree([]);
const myBackup: Car = new Car('396');

getLeftOrDefault(myCar, myBackup, isCar); // -> { engine: '350' }
getLeftOrDefault(myTree, myBackup, isCar); // -> { engine: '396' }

However constructor checking is not fool proof because of casting

const myCar: Car = { engine: '350' };
const myTree: Tree = { branches: [] };
const myBackup: Car = { engine: '396' };

getLeftOrDefault(myCar, myBackup, isCar); // -> { engine: '396' }
getLeftOrDefault(myTree, myBackup, isCar); // -> { engine: '396' }