Behavior match operator with case statement

Questions / Help
,
1

Hello everyone !

How to reproduce

case Repo.one(Client) do
  %Client{} = client -> client
  nil -> {:error, "some error message"}
end

When Repo.one(Client) returns to me a %Client{...} struct it matches, no problem with that.

Now if I reverse this match operation.

case Repo.one(Client) do
  client = %Client{} -> client
  nil -> {:error, "some error message"}
end

When Repo.one(Client) returns to me a %Client{...} struct, I expect it matches and returns new empty %Client{} struct. But this returns same result as the first example.

Troubleshooting

I don’t understand how Elixir resolve this match. I have tried to reproduce this in a IEx outside a case context, without any success.

Anybody know if this behavior is valid ? And how Elixir resolve this context and condition ?

Thanks,
Bryan!

2

The reason this works is because how %Struct{} (and, more generally, any kind of map: %{}) matches.

The idea is that, for structs and maps, you often are only interested in one or a few of the fields. Therefore, matching %{foo: _} will match any map that has a key :foo. Likewise, %{} will match any map at all.

When not matching but constructing a value, then, yes, %{} means ‘empty map’ and %Client{} means ‘empty client (whose struct fields are set to their defaults)’.

The order in which = is used (i.e. which side contains the structure to match, and which side contains the name to bind the matched part to) inside a match does not matter. Some people prefer to do it in front, (client = %Client{}), some in the back (%Client{} = client). Both mean the same.

To change your code so it returns a new client, write this:

case Repo.one(Client) do
  %Client{} -> %Client{} # Note that the RHS is an empty client, while the LHS matches _any_ client.
  nil -> {:error, "some error message"}
end
2 Likes
3

You aren’t reversing the match operation, because matches do not have an order. WITHIN a match foo = bar is exactly the same as bar = foo. Specifically,

case operation(some_var) do
  x = 1 -> x
end

is in no way whatsoever different than

case operation(some_var) do
  1 = x -> x
end

This is true of every match. So for example:

(1 = x) = y
is the same as
(x = 1) = y

The right hand most = is necessary in order to establish that the left hand side is a match, but once you’re within a match order does not matter.

2 Likes