In part 21 of my Elixir journey I wanted to improve a messy `case` example with help from pattern matching.
Nested Case?
In my previous post I did a comparison of `case` and `cond` by writing a simple program that would evaluate if a number was even or odd. If the number was even it would also check to see if that number was greater than 10.
defmodule MyProgram do
def even(n), do: rem(n, 2) == 0
def gt(n, max), do: n > max
def calc([]), do: []
def calc([head | tail]) do
IO.puts "calculation for #{head}"
case even(head) do
true ->
case gt(head, 10) do
true ->
IO.puts "even and > 10"
false ->
IO.puts "even and < 10"
end
false ->
IO.puts "odd number"
end
calc(tail)
end
end
The program would take a list of numbers as input and simply print out the result using `IO.puts`
MyProgram.calc([2, 16, 3])
The first implementation seems like the wrong use of `case` altogether because of the nesting required to solve this problem. My next thought was to reach for pattern matching as a means to improve clarity for the reader.
defmodule MyProgram do
def even(n), do: rem(n, 2) == 0
def gt(n, max), do: n > max
def go(true, true), do: IO.puts "even and > 10"
def go(true, false), do: IO.puts "even and < 10"
def go(false, _), do: IO.puts "odd number"
def calc([]), do: []
def calc([head | tail]) do
IO.puts "calculation for #{head}"
go(even(head), gt(head, 10))
calc(tail)
end
end
While pattern matching did eliminate the nesting problem, having a function with 2 unlabeled boolean values didn't feel like an improvement in readability. I started searching for a trick that would allow me to pattern match with named arguments or something equivalent.
defmodule MyProgram do
def even(n), do: rem(n, 2) == 0
def gt(n, max), do: n > max
def go(%{ even: true, gt: true }), do: IO.puts "even and > 10"
def go(%{ even: true, gt: false }), do: IO.puts "even and < 10"
def go(%{ even: false, gt: _ }), do: IO.puts "odd number"
def calc([]), do: []
def calc([head | tail]) do
IO.puts "calculation for #{head}"
go(%{ even: even(head), gt: gt(head, 10) })
calc(tail)
end
end
I found that using the map data structure would allow me to pattern match against the key name. I'll continue to explore the problem space that plagues me with nested `case` as a path to learning more about control flow in the language.
