Is there a way to write a do_not match guard for map match?

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

It just works without it - as long as you put everything in the right order.

defmodule ElixirFun do
  def hello(%{a: _a, b: _b} = m),
    do: IO.puts("1: #{inspect(m)}")

  def hello(%{a: _a} = m),
    do: IO.puts("2: #{inspect(m)}")

  def hello(%{b: _b} = m),
    do: IO.puts("3: #{inspect(m)}")

  def hello(%{} = m),
    do: IO.puts("4: #{inspect(m)}")
end

ElixirFun.hello(%{a: 1, b: 2, c: 3})
ElixirFun.hello(%{a: 4, c: 5})
ElixirFun.hello(%{b: 6, c: 7})
ElixirFun.hello(%{c: 8})
ElixirFun.hello(%{a: nil, b: nil, c: 9})
ElixirFun.hello(%{a: nil, c: 10})
ElixirFun.hello(%{b: nil, c: 11})

 elixir elixir_fun.exs
1: %{a: 1, b: 2, c: 3}
2: %{a: 4, c: 5}
3: %{b: 6, c: 7}
4: %{c: 8}
1: %{a: nil, b: nil, c: 9}
2: %{a: nil, c: 10}
3: %{b: nil, c: 11}

… 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

Thank you both.

Hello,

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

I think it is more a question of personal taste, If the logic is complex, I’ll choose the first way, and if simple, I’ll choose the second.

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