Behavior match operator with case statement

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.

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