Working with tagged unions

[OliverJAsh]

Related pelotom/unionize#41

For working with tagged unions, I'm a fan of unionize. Below I outline the pros and cons of working with tagged unions in both io-ts and unionize.

However, for all of unionize's benefits over io-ts, the one big thing missing is validation, which of course io-ts aims to provide.

By outlining the pros/cons of both approaches, my hope is that we can find a way to improve io-ts so that we can have the best of both worlds: concise syntax and validation.

Do you have any thoughts on this?

io-ts

// Pros:
// - `switch` can match multiple cases at once
// Cons:
// - Definition is verbose
// - Tag is required during construction
// - Renaming tags will not update all usages and the type definition

import * as t from 'io-ts';

// Definition

const FooRT = t.type({ tag: t.literal('Foo'), foo: t.number });
type Foo = t.TypeOf<typeof FooRT>;

const BarRT = t.type({ tag: t.literal('Bar') });
type Bar = t.TypeOf<typeof BarRT>;

const BazRT = t.type({ tag: t.literal('Baz') });
type Baz = t.TypeOf<typeof BazRT>;

const ModalRT = t.taggedUnion('tag', [FooRT, BarRT, BazRT]);
type Modal = t.TypeOf<typeof ModalRT>;

// Construction

ModalRT.encode({ tag: 'Foo', foo: 2 });
ModalRT.encode({ tag: 'Foo', foo: 'foo' });

// Matching

const matchModal = (modal: Modal) => {
    switch (modal.tag) {
        case 'Foo':
            return modal.foo;
        case 'Bar':
        case 'Baz':
            return 2;
    }
};

unionize

// Pros:
// - Renaming tags will update all usages and the type definition
// - Tag can be omitted during construction
// - Definition is concise
// Cons:
// - Unlike `switch`, can't match multiple cases at once

import { unionize, ofType } from 'unionize';

// Definition

const Modal = unionize({
    Foo: ofType<{ foo: number }>(),
    Bar: ofType<{}>(),
    Baz: ofType<{}>(),
});
type Modal = typeof Modal._Union;

// Construction

Modal.Foo({ foo: 2 });
Modal.Foo({ foo: 'foo' });

// Matching

const matchModal = Modal.match({
    Foo: ({ foo }) => foo,
    Bar: () => 2,
    Baz: () => 2,
});

[gcanti]

Do you have any thoughts on this?

Yes I do

[OliverJAsh]

Brilliant, I knew you would 😉

This would be the perfect solution for us.