unison/unison-src/transcripts/lambdacase.md

Lambda case syntax

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:

isEmpty x = match x with
  [] -> true
  _ -> false

scratch/main> add

Here's the same function written using cases syntax:

isEmpty2 = cases
  [] -> true
  _ -> false

Notice that Unison detects this as an alias of isEmpty, and if we view isEmpty

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:

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

scratch/main> add

And here's a version using cases. The patterns are separated by commas:

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

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:

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

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

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.

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