The pattern `{f1=x1, ..., fn=xn}` will match against a record
(assuming all the types match) `{f1=v1,...,fn=vn}`.

Note that since all tuples are really records, all matches are against records.

```
fun sum_triple (triple : int * int * int) =
case triple of
(x, y, z) => x + y + z
```

Can use patterns in val bindings as well:

```
fun full_name (r : {first:string, middle:string, last:string}) =
let val {first=x, middle=y, last=z}
in
x ^ " " ^ y ^ " " z
end
fun sum_triple triple =
let val (x, y, z) = triple
in x + y + z
end
```

`sum_triple` works due to type checking.

In general:

```
val p = e
```

where `p` is a pattern.

The best way, though, is:

```
fun full_name {first=x, middle=y, last=z} =
x ^ " " ^ y " " ^ z
fun sum_triple (x, y, z) =
x + y + z
```

In general:

```
fun f p = e
```

where `p` is a pattern.

Is `sum_triple` taking an argument of type `int*int*int` or 3
arguments of type `int`? It is the same thing! Either way you look at
it, the type is `int*int*int->int`.

*Every* function in ML takes only **one** argument! Behind the scenes,
pattern matching is going on to the tuple argument to extract the pieces.

There are also *no* zero argument functions. The argument they take is
`()`.

Since functions take only one argument, you can invoke a function without parentheses if the argument is not a tuple:

```
fun f x =
1 + x
f 3 (* instead of f(3) *)
```

As a general rule, *any* time you have a `case` statement with one
branch, you have poor style. Consider the options above.

## Multiple Cases in a Function Binding

In general, if you have:

```
fun f x =
case x of
p1 => e1
| p2 => e2
| pn => en
```

you can rewrite this as:

```
fun f p1 = e1
| f p2 = e2
| f pn = en
```

This only works if you do not need `x`. You may need parentheses to
avoid ambiguities.

Example:

```
fun append ([], ys) = ys
| append (x::xs', ys) = x :: append(xs', ys)
fun get_second (_, x) = x
```