Pattern matching

Related to https://github.com/PistonDevelopers/dyon/issues/304

Idea taken from https://github.com/PistonDevelopers/dyon/issues/359, but might be useful in general.

The idea is to add pattern matching to Dyon, a bit similar to Rust. Since Dyon is dynamically typed there is a ?= operator instead of :=.

The ?= operator checks the run-time type at run-time and reports an error if it is wrong. The type checker checks the static types and reports an error if the code never gets called.

If pattern

The ?= operator can be used with if:

x := [1, 2]
if [a, b] ?= x {
     ...
}

Try pattern

It can also be used directly in a function that returns err:

fn foo() -> res {
    x := [1, 2]
    [a, b] ?= x
    ...
}

The following code gives an error because it is exhaustive:

a := 1
b ?= a // ERROR: Use `:=` instead

Match pattern

A match expression similar to Rust:

x := [1, 2]
match x {
    [a, b] => { ... }
    _ => { ... }
}

The match requires _ or a variable since it can not be exhaustively checked.

Type is checked on all arms like with an if-expression.

Start by reviewing the related issues 304 and 359, then trace how Dyon parses, type-checks, and evaluates the shown ?= and match constructs. Done means implementing the proposed if, try, and match patterns with the stated runtime and static type errors, including exhaustive cases.