Variable type guard with Typescript

Question

I'm trying to create a higher order function that allows me to create a function which confirms a type via a type guard.

type Shape = Circle | Triangle | Rectangle
enum Type { Circle, Triangle, Rectangle }

interface Circle {
  type: Type.Circle;
  diameter: number;
}

interface Triangle {
  type: Type.Triangle;
  width: number;
}

interface Rectangle {
  type: Type.Rectangle;
  width: number;
  height: number;
}

const isShape = (condition: Type) => (shape: Shape): shape is ? => shape.type == condition;

const isCircle = isShape(Type.Circle);

In the above example, I want the isCircle function to return whether the type is Circle. The ? is a placeholder since I can't get it to work.

Related [Mapping from discriminated union property to object type](https://stackoverflow.com/questions/47932908/mapping-from-discriminated-union-property-to-object-type). *In short, without restructuring your types, it won't be possible to give a signature to `isShape` that does what you want.* — CRice, Oct 16 '18 at 22:58
@CRice, how would the types have to be structured in order to achieve this? — Lennard Schutter, Oct 17 '18 at 01:27

Akshar Patel · Accepted Answer · 2018-10-17T01:34:14.170

2

To achieve your objective, here is what your isShape function should look like:

const isShape = <T extends Shape>(condition: Type) => {
  return function(shape: T): shape is T {
    return shape.type == condition;
  };
};

const isCircle = isShape<Circle>(Type.Circle);

edited Oct 17 '18 at 01:34

answered Oct 16 '18 at 22:41

Akshar Patel

5,377
4
20
25

This is wrong: it does not establish a relationship between `condition` and `T`. – Matt McCutchen Oct 16 '18 at 23:54
@Akshar Patel, unfortunately when this function is implemented Typescript will only tell that the type is `Shape`. – Lennard Schutter Oct 17 '18 at 01:28
@LennardSchutter: How about now? – Akshar Patel Oct 17 '18 at 01:34
1

@Akshar Patel, this works, amazing! I didn't realise I could pass the `` to the function caller. – Lennard Schutter Oct 17 '18 at 01:48
1

@Akshar Patel, I ended up making it a little more generic. `const isType = () => (condition: E) => (obj: U): obj is T => obj.type == condition;` – Lennard Schutter Oct 17 '18 at 06:19

score 2 · Answer 2 · answered Oct 17 '18 at 01:42

You need to provide a direct way for TypeScript to figure out what Shape is associated with a given Type. One way to do that is to explicitly provide a mapping between the two, which can then be used to replace your definition for Shape. So, for example:

// Instead of this:
// type Shape = Circle | Triangle | Rectangle

// Use this:
type TypeToShape = {
  [Type.Circle]: Circle,
  [Type.Triangle]: Triangle,
  [Type.Rectangle]: Rectangle,
}

// Circle | Triangle | Rectangle
type Shape = TypeToShape[keyof TypeToShape];

Then, given a specific Type, it's easy to map that to the Shape associated with it:

// Use the type map to tell typescript what shape goes with the Type K:
const isShape = <K extends Type>(condition: K) => (shape: Shape): shape is TypeToShapeMap[K] => shape.type == condition;

const isCircle = isShape(Type.Circle); // return type: shape is Circle
const isTriangle = isShape(Type.Triangle) // return type: shape is Triangle

Thanks for your effort, @CRice. Although this works also, I find the other answer to be easier to implement and would not require a change to my current code. — Lennard Schutter, Oct 17 '18 at 01:53

Variable type guard with Typescript

2 Answers2