Add pattern matching

[Gozala]

Currently used patten in most code is something along these lines:

const Model = Record({value: Number})

const Increment = Record({label: '+'});
const Decrement = Record({label: '-'});
const Action = Union(Increment, Decrement);

const update = (model, action) =>
  action instanceof Increment ? model.update('value', x => x + 1) :
  action instanceof Decrement ? model.update('value', x => x - 1) :
  model;

With a pattern matching it should be possible to turn it to something like this:

const update = Match(Match._, Match.pattern)
  .case(Increment, (model, _) => model.update('value', x => x + 1))
  .case(Decrement, (model, _) => model.update('value', x => x + 1))
  .default((model, _) => model)

[Gozala]

Here is a very basic implementation:

function Match(...params) {
  if (this instanceof Match) {
    this.fallback = null
    this.rules = []
    this.index = Match.max(0, params.indexOf(Match.pattern))
  } else {
    return new Match(...params)
  }
}
Match.prototype.case = function(type, clause) {
  if (this.fallback) {
    throw TypeError('Match already has a default clause')
  }
  this.rules.push({type, clause})
  return this
}
Match.prototype.default = function(clause) {
  if (this.fallback) {
    throw TypeError('Match already has a default clause')
  }

  this.fallback = clause
  return this.compile()
}
Match.prototype.compile = function() {
  if (!this.fallback) {
    throw TypeError('Can not compile matcher that has no default case')
  }

  const {rules, index, fallback} = this
  return (...params) => {
    const pattern = params[index]
    for (let {type, clause} of rules) {
      if (type.isTypeOf(pattern)) {
        return clause(...params)
      }
    }
    return fallback(...params)
  }
}
Match.pattern = new String('Match.pattern')
Match._ = new String('Match._')