I have some complex business logic have to verify a input map. And I don’t want to use nested control-flow. I expect a not_match guard to this things.
defmodule ElixirFun do
@moduledoc """
Documentation for ElixirFun.
"""
@doc """
Hello world.
## Examples
iex> ElixirFun.hello()
:world
"""
def hello do
:world
end
def hello(%{a: a, b: b}) do
# match a and b
IO.puts "Hello #{a}, #{b}"
end
def hello(%{a: a}) when not_match(%{b: _}) do
# match a and do not match b
IO.puts "Hello #{a}"
end
def hello{%{b: b}} when not_match(%{a: _}) do
# match b and do not match a
IO.puts "Hello #{b}"
end
def hello(%{} = params) do
# others
IO.inspect(params)
end
end
def hello(%{a: a, b: b}) do
def hello(%{a: a}) do ...
def hello(%{b: b} do ...
def hello(%{} = params) do
Unless there’s something I’m missing? Don’t forget that function clauses are checked top to bottom (eliding some compiler optimizations)
Edit: thought if you wanted to ensure not nil then I would add a when not is_nil(a) and when not is_nil(b) to each clause (based on the binding it is using).
… keeping in mind that those four clauses all belong to one and the same hello/1 function.
It might as well be:
defmodule ElixirFun do
def hello(m) do
case m do
%{a: _, b: _} ->
IO.puts("1: #{inspect(m)}")
%{a: _} ->
IO.puts("2: #{inspect(m)}")
%{b: _} ->
IO.puts("3: #{inspect(m)}")
%{} ->
IO.puts("4: #{inspect(m)}")
end
end
end
A beginners question: is the first way a somehow prefered way in elixir or is it more a question of personal taste to choose that instead the second way (case).
In my view multiple function clauses are preferred because it chunks the logic into distinct, separate logical paths even if they do belong to the same function. With case do you are dealing with one monolithic piece of code which gets worse the more cases you add - apart from the temptation to put code before and after the case do expression.
But that’s not to say that case do is to be avoided - they both have their place. Coming from more traditional programming languages one would tend to gravitate towards case do because it’s reminiscent of switch while pattern matching in function heads just seems weird - but in most cases with exposure people come to prefer pattern matching in function heads because of the clean separation it brings.
For some more background:
And for completeness a multi-clause anonymous function:
defmodule ElixirFun do
def make_hello() do
fn
%{a: _, b: _} = m ->
IO.puts("1: #{inspect(m)}")
%{a: _} = m ->
IO.puts("2: #{inspect(m)}")
%{b: _} = m ->
IO.puts("3: #{inspect(m)}")
%{} = m ->
IO.puts("4: #{inspect(m)}")
end
end
end
hello = ElixirFun.make_hello()
hello.(%{a: 1, b: 2, c: 3})
hello.(%{a: 4, c: 5})
hello.(%{b: 6, c: 7})
hello.(%{c: 8})
hello.(%{a: nil, b: nil, c: 9})
hello.(%{a: nil, c: 10})
hello.(%{b: nil, c: 11})