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})

These clauses seem like they’ll do what you want:

  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).

Thank you both.