Tagged union types

TypeScript 2.0 implements support for tagged (or discriminated) union types.Specifically, the TS compiler now support type guards that narrow union types based on tests of a discriminant property and furthermore extend that capability to switch statements.

Example

  1. interface Square {
  2.     kind: "square";
  3.     size: number;
  4. }
  6. interface Rectangle {
  7.     kind: "rectangle";
  8.     width: number;
  9.     height: number;
  10. }
  12. interface Circle {
  13.     kind: "circle";
  14.     radius: number;
  15. }
  17. type Shape = Square | Rectangle | Circle;
  19. function area(s: Shape) {
  20.     // In the following switch statement, the type of s is narrowed in each case clause
  21.     // according to the value of the discriminant property, thus allowing the other properties
  22.     // of that variant to be accessed without a type assertion.
  23.     switch (s.kind) {
  24.         case "square": return s.size * s.size;
  25.         case "rectangle": return s.width * s.height;
  26.         case "circle": return Math.PI * s.radius * s.radius;
  27.     }
  28. }
  30. function test1(s: Shape) {
  31.     if (s.kind === "square") {
  32.         s;  // Square
  33.     }
  34.     else {
  35.         s;  // Rectangle | Circle
  36.     }
  37. }
  39. function test2(s: Shape) {
  40.     if (s.kind === "square" || s.kind === "rectangle") {
  41.         return;
  42.     }
  43.     s;  // Circle
  44. }

A discriminant property type guard is an expression of the form x.p == v, x.p === v, x.p != v, or x.p !== v, where p and v are a property and an expression of a string literal type or a union of string literal types.The discriminant property type guard narrows the type of x to those constituent types of x that have a discriminant property p with one of the possible values of v.

Note that we currently only support discriminant properties of string literal types.We intend to later add support for boolean and numeric literal types.