Algebraic data types in TypeScript

Question

Worded an other way:

How would you type the windowState DOM property in TypeScript?

SOLVED (in TypeScript 2):

declare var windowState: WindowState
const enum WindowState {
  STATE_MAXIMIZED = 1,
  STATE_MINIMIZED = 2,
  STATE_NORMAL = 3,
  STATE_FULLSCREEN = 4
}
...
var windowState = 5 // Type Error, as expected!

Original question:

How do I declare a type in TypeScript so that it describes an algebraic data type? The purpose of this is describing an existing API.

When I try the following, TypeScript obviously complains that a type is expected:

type Weather = 'sunny' | 'bad'

One idea I had is using a JavaScript 2015 Symbol, however TypeScript doesn't seem to know about these.

An other idea was using an enum, however TypeScript complains that a member initializer must be constant expression:

const enum Weather {
  sunny = 'sunny',
  bad = 'bad',
  windy = Symbol('windy')
}

I would have thought that a string constant is a constant expression.

For this particular example, you could probably use an `enum` (need to convert to/from String in places, though) — Thilo, Nov 25 '15 at 11:38
Yes, I'll add that to the question as well, as an `enum` was not really satisfactory — P Varga, Nov 25 '15 at 11:39
TypeScript does understand Symbols. If your runtime environment supports it, you can either load the `lib.es6.d.ts` or you can replicate the Symbol interface. — Kitson, Nov 25 '15 at 11:46
@Kitson Does it regard them as a constant expression, though? — P Varga, Nov 25 '15 at 11:47
TypeScript 1.8 will introduce "String Literal Types": https://github.com/Microsoft/TypeScript/pull/5185 — CoderPi, Dec 07 '15 at 14:05
Awesome, that's not full algebraic data type support, but exactly what I need for my purpose. Thank you. Why not turn your comment into an answer? — P Varga, Dec 07 '15 at 18:37
You haskell snippet is incorrect. The rhs of a data declaration should contain *value constructors* not values. — pedrofurla, Dec 15 '16 at 05:07
@pedrofurla Ok sorry, what would be the correct way to express this type in Haskell? — P Varga, Dec 15 '16 at 23:10
has it become more natural to work with algebraic data types since years ago? — Alex Gordon, Nov 02 '20 at 20:42

Daniel Rosenwasser · Accepted Answer · 2017-02-14T02:00:44.640

TypeScript 2.0 has support for discriminated unions/algebraic data types. The documentation is here.

You can combine string literal types, union types, type guards, and type aliases to build an advanced pattern called discriminated unions, also known as tagged unions or algebraic data types. Discriminated unions are useful in functional programming. Some languages automatically discriminate unions for you; TypeScript instead builds on JavaScript patterns as they exist today. There are three ingredients:

Types that have a common literal (or enum) property — the discriminant.

A type alias that takes the union of those types — the union.

Type guards on the common property.

Let's start:

interface Square {
    kind: "square";
    size: number;
}
interface Rectangle {
    kind: "rectangle";
    width: number;
    height: number;
}
interface Circle {
    kind: "circle";
    radius: number;
}

First we declare the interfaces we will union. Each interface has a kind property with a different string literal type. The kind property is called the discriminant or tag. The other properties are specific to each interface. Notice that the interfaces are currently unrelated. Let's put them into a union:

type Shape = Square | Rectangle | Circle;

Now let's use the discriminated union:

function area(s: Shape) {
    switch (s.kind) {
        case "square": return s.size * s.size;
        case "rectangle": return s.height * s.width;
        case "circle": return Math.PI * s.radius ** 2;
    }
}

In each of those branches, TypeScript will narrow down the type. If you try to use a case clause with a value that isn't present as any kind property, then TypeScript will error.

Can you give an example how to call such a function with a literal argument of that type? I guess I'm confused by false analogies to the Haskell syntax. — klos, Nov 11 '18 at 11:29

Kitson · Answer 2 · 2015-12-07T17:15:55.173

4

To use enum's you would write it something like this:

enum Weather {
    Sunny,
    Windy
};

let currently = Weather.Sunny;

String Literals

The other way the OP is asking for this to be solved are arriving in TypeScript 1.8.

They would allow you to do something like this:

type Weather = 'Sunny' | 'Windy';

edited Dec 07 '15 at 17:15

answered Nov 25 '15 at 11:50

Kitson

1,650
1
18
36

But I need a `type` that can describe being one of several `string` constants. – P Varga Nov 25 '15 at 11:54
why do you need string constants? – CoderPi Nov 25 '15 at 11:57
There is an existing API and this would be a typing for it, – P Varga Nov 25 '15 at 11:58
What you are asking for is coming in TypeScript 1.8 (which is currently available for testing via `npm install typescript@next` – Kitson Dec 07 '15 at 17:16

Algebraic data types in TypeScript

2 Answers2

String Literals