Consider options for Symbol instead of strings for match keys

[uniphil]

the problem:

const U1 = Union({
  A: {},
  B: {},
});
const U2 = Union({
  A: {},
  Z: {},
});

const u1thing = U1.A(2, 3);
const u2thing = U2.A();

function takesAU1(thing) {
  return thing.match({
    A: (x, y) => x * y,
    [_]: () => 0,
  });
}

takesAU1(u1thing);  // U1's `.match` check validates, and we're good
takesAU1(u2thing);  // U1's `.match` check validates, but takesAU1 is not getting the thing it's expecting! this could be a hard bug.

The problem is that they only validation that match is doing is comparing strings. For safety, users have to find ways to try and make member names unique (like with namespacing: Union({U1A: {}, U1B: {}})) so that match can properly validate the options.

It would be better to compare based on a reference that comes from the union.

Here are some possible fixes:

1. with a Symbol() attached the the union

const U1 = Union({
  A: {},
  B: {},
});

const u1thing = U1.A(2, 4);

u1thing.match({
  [U1.A.symbol]: (x, y) => x * y,  // maybe with a better prop name than 'symbol'
  [_] => 0,
});

2. make union members classes and use an instanceof check

const U1 = Union({
  A: {},
  B: {},
});

const u1thing = U1.A(2, 4);

u1thing.match([
  [U1.A, (x, y) => x * y],
  [_, () => 0],
]);

// 2A (thanks Alexei)

u1thing.match(
  U1.A, (x, y) => x * y,
  _, () => 0
);

3. make union members match-aware

const U1 = Union({
  A: {},
  B: {},
});

const u1thing = U1.A(2, 4);

u1thing.match([
  U1.A.matchThen((x, y) => x * y),
  U1[_].matchThen(() => 0),
]);

4. Put match on the union instead of its members

const U1 = Union({
  A: {},
  B: {},
});

const u1thing = U1.A(2, 4);

U1.match(u1thing, {
  A: (x, y) => x * y,
  [_]: () => 0,
});

// or like,

U1(u1thing).match({
  A: (x, y) => x * y,
  [_]: () =. 0,
});

This last one can work because it's possible for U1 to know if any object is an instance of one of its members thanks to #31

[uniphil]

Going with

Result.match(None(), {
  Some: n => n * n,
  None: () => 0
});

implementing at #41