Sometimes it's useful to bind variables against overlapping parts of a structure. For instance, suppose I'm writing a pattern that is to be matched against multivalues like `([10, 20], 'true)`. And suppose I want to end up with `ys` bound to `[10, 20]`, `x` bound to `10`, and `xs` bound to `[20]`. Using the techniques introduced so far, I have two options. First, I could bind `ys` against `[10, 20]`, and then initiate a second pattern-match to break that up into `10` and `[20]`. Like this:
- case [10, 20] of
+ case ([10, 20], 'true) of
[ys, _] then case ys of
x & xs then ...;
...
Alternatively, I could directly bind `x` against `10` and `xs` against `[20]`. But then I would have to re-cons them together again to get `ys`. Like this:
- case [10, 20] of
+ case ([10, 20], 'true) of
[x & xs, _] then let
ys match x & xs
in ...;
Both of these strategies work. But they are a bit inefficient. I said you didn't really need to worry about efficiency in this seminar. But these are also a bit cumbersome to write. There's a special syntax that enables us to bind all three of `ys`, `x`, and `xs` in the desired way, despite the fact that they will be matching against overlapping, rather than discrete, parts of the value `[10, 20]`. The special syntax looks like this:
- case [10, 20] of
+ case ([10, 20], 'true) of
[(x & xs) as ys, _] then ...
...
end
We've already come across the `id` function, namely λ `x. x`.
-Other common functions are `fst`, which takes two arguments and returns the first of them; `snd`, which takes two arguments and returns the second of them; and `swap`, which takes two arguments and returns them both but with their positions swapped. These functions can be defined like this:
+Other common functions are `fst`, which takes two arguments and returns the first of them; `snd`, which takes two arguments and returns the second of them; and `swap`, which takes two arguments and returns them both but with their positions swapped. A fourth function is `dup`, which takes one argument and returns it twice.
+These functions can be defined like this:
let
fst (x, y) = x;
snd (x, y) = y;
- swap (x, y) = (y, x)
- in (fst, snd, swap)
+ swap (x, y) = (y, x);
+ dup x = (x, x)
+ in (fst, snd, swap, dup)