mirror of
https://github.com/unisonweb/unison.git
synced 2024-09-11 02:25:39 +03:00
120 lines
2.5 KiB
Markdown
120 lines
2.5 KiB
Markdown
# Lambda case syntax
|
|
|
|
```ucm:hide
|
|
scratch/main> builtins.merge
|
|
```
|
|
|
|
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
|
|
scratch/main> add
|
|
```
|
|
|
|
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
|
|
scratch/main> view isEmpty
|
|
```
|
|
|
|
it shows the definition using `cases` syntax opportunistically, even though the code was originally written without that syntax.
|
|
|
|
## Multi-argument cases
|
|
|
|
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:
|
|
|
|
```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
|
|
scratch/main> add
|
|
```
|
|
|
|
And here's a version using `cases`. The patterns are separated by commas:
|
|
|
|
```unison
|
|
merge2 : [a] -> [a] -> [a]
|
|
merge2 = cases
|
|
[], ys -> ys
|
|
xs, [] -> xs
|
|
h +: t, h2 +: t2 ->
|
|
if h <= h2 then h +: merge2 t (h2 +: t2)
|
|
else h2 +: merge2 (h +: t) t2
|
|
```
|
|
|
|
Notice that Unison detects this as an alias of `merge`, and if we view `merge`
|
|
|
|
```ucm
|
|
scratch/main> view merge
|
|
```
|
|
|
|
it again shows the definition using the multi-argument `cases` syntax opportunistically, even though the code was originally written without that syntax.
|
|
|
|
Here's another example:
|
|
|
|
```unison
|
|
structural type B = T | F
|
|
|
|
blah : B -> B -> Text
|
|
blah = cases
|
|
T, x -> "hi"
|
|
x, y -> "bye"
|
|
|
|
blorf = cases
|
|
x, T -> x
|
|
x, y -> y
|
|
|
|
> blah T F
|
|
> blah F F
|
|
> blorf T F
|
|
```
|
|
|
|
## Patterns with multiple guards
|
|
|
|
```unison
|
|
merge3 : [a] -> [a] -> [a]
|
|
merge3 = cases
|
|
[], ys -> ys
|
|
xs, [] -> xs
|
|
h +: t, h2 +: t2 | h <= h2 -> h +: merge3 t (h2 +: t2)
|
|
| otherwise -> h2 +: merge3 (h +: t) t2
|
|
```
|
|
|
|
```ucm
|
|
scratch/main> add
|
|
scratch/main> view merge3
|
|
```
|
|
|
|
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
|
|
```
|
|
|
|
|