2020-10-10 01:10:16 +03:00
# Lambda case syntax
```ucm:hide
2024-06-12 01:22:09 +03:00
scratch/main> builtins.merge
2020-10-10 01:10:16 +03:00
```
This function takes a single argument and immediately pattern matches on it. As we'll see below, it can be written using `cases` syntax:
```unison
isEmpty x = match x with
[] -> true
_ -> false
```
```ucm:hide
2024-06-12 01:22:09 +03:00
scratch/main> add
2020-10-10 01:10:16 +03:00
```
Here's the same function written using `cases` syntax:
```unison
isEmpty2 = cases
[] -> true
_ -> false
```
Notice that Unison detects this as an alias of `isEmpty` , and if we view `isEmpty`
```ucm
2024-06-12 01:22:09 +03:00
scratch/main> view isEmpty
2020-10-10 01:10:16 +03:00
```
2020-10-10 01:22:15 +03:00
it shows the definition using `cases` syntax opportunistically, even though the code was originally written without that syntax.
2020-10-10 01:10:16 +03:00
## Multi-argument cases
2020-10-28 00:21:37 +03:00
Functions that take multiple arguments and immediately match on a tuple of arguments can also be rewritten to use `cases` . Here's a version using regular `match` syntax on a tuple:
2020-10-10 01:10:16 +03:00
```unison:hide
merge : [a] -> [a] -> [a]
merge xs ys = match (xs, ys) with
([], ys) -> ys
(xs, []) -> xs
(h +: t, h2 +: t2) ->
if h < = h2 then h +: merge t (h2 +: t2)
else h2 +: merge (h +: t) t2
```
```ucm
2024-06-12 01:22:09 +03:00
scratch/main> add
2020-10-10 01:10:16 +03:00
```
2020-10-28 00:21:37 +03:00
And here's a version using `cases` . The patterns are separated by commas:
2020-10-10 01:10:16 +03:00
```unison
merge2 : [a] -> [a] -> [a]
merge2 = cases
2020-10-28 00:21:37 +03:00
[], ys -> ys
xs, [] -> xs
h +: t, h2 +: t2 ->
2020-10-10 01:10:16 +03:00
if h < = h2 then h +: merge2 t (h2 +: t2)
else h2 +: merge2 (h +: t) t2
```
2020-10-10 01:22:15 +03:00
Notice that Unison detects this as an alias of `merge` , and if we view `merge`
2020-10-10 01:10:16 +03:00
```ucm
2024-06-12 01:22:09 +03:00
scratch/main> view merge
2020-10-10 01:10:16 +03:00
```
it again shows the definition using the multi-argument `cases` syntax opportunistically, even though the code was originally written without that syntax.
2020-10-28 00:21:37 +03:00
Here's another example:
```unison
2021-08-24 00:05:37 +03:00
structural type B = T | F
2020-10-28 00:21:37 +03:00
2023-03-02 17:11:13 +03:00
blah : B -> B -> Text
2020-10-28 00:21:37 +03:00
blah = cases
T, x -> "hi"
2023-01-17 17:55:24 +03:00
x, y -> "bye"
2020-10-28 00:21:37 +03:00
2021-05-12 18:35:33 +03:00
blorf = cases
x, T -> x
2023-01-17 17:55:24 +03:00
x, y -> y
2021-05-12 18:35:33 +03:00
2020-10-28 00:21:37 +03:00
> blah T F
> blah F F
2021-05-12 18:35:33 +03:00
> blorf T F
2020-10-28 00:21:37 +03:00
```
2021-07-20 07:45:03 +03:00
## Patterns with multiple guards
```unison
merge3 : [a] -> [a] -> [a]
merge3 = cases
[], ys -> ys
xs, [] -> xs
2021-07-20 07:50:16 +03:00
h +: t, h2 +: t2 | h < = h2 -> h +: merge3 t (h2 +: t2)
| otherwise -> h2 +: merge3 (h +: t) t2
2021-07-20 07:45:03 +03:00
```
```ucm
2024-06-12 01:22:09 +03:00
scratch/main> add
scratch/main> view merge3
2021-07-20 07:45:03 +03:00
```
2021-07-20 07:50:16 +03:00
This is the same definition written with multiple patterns and not using the `cases` syntax; notice it is considered an alias of `merge3` above.
```unison
merge4 : [a] -> [a] -> [a]
merge4 a b = match (a,b) with
[], ys -> ys
xs, [] -> xs
h +: t, h2 +: t2 | h < = h2 -> h +: merge4 t (h2 +: t2)
h +: t, h2 +: t2 | otherwise -> h2 +: merge4 (h +: t) t2
```