With/1 design patterns

Good point, that’s a very nice end result! I guess I still need to get a bit more into the functional zen of things! I’m looking forward to checking out that video later

instead of Map.fetch(params, :shoes)

design patterns

Following Scott Wlaschin’s guidance - use functions!

def fetch_item(map, key) do
  case Map.fetch(map, key) do
    :error ->
      {:error, key}
    result ->
      result
  end
end

  ...

  with(  
    {:ok, shoes} <- fetch_item(outfit, :shoes),
    {:ok, shirt} <- fetch_item(outfit, :shirt),
    {true, _} <- {shoes_match_shirt?(shoes, shirt), :matching}
  ) do
    {:ok, "service allowed"}
  else
    {:error, :shoes} ->
      {:error, "you forgot your shoes!"}
    _ ->
      :error
  end

  ...

or

def fetch_item(map, key, msg) when is_binary(msg) do
  case Map.fetch(map, key) do
    :error ->
      {:error, msg}
    result ->
      result
  end
end

  ...

  with(  
    {:ok, shoes} <- fetch_item(outfit, :shoes, "you forgot your shoes!"),
    {:ok, shirt} <- fetch_item(outfit, :shirt, "you forgot your shirt!"),
    {true, _} <- {shoes_match_shirt?(shoes, shirt), :matching}
  ) do
    {:ok, "service allowed"}
  else
    {:error, msg} = msg_error when is_binary(msg) ->
      msg_error
    _ ->
      :error
  end

  ...

If you ever need more power, you should take a look at GitHub - Nebo15/sage: A dependency-free tool to run distributed transactions in Elixir, inspired by Sagas pattern. · GitHub (Sagas pattern)

with also lets me kind of replicate a pattern I like in imperative languages (eg. ruby):

Although not normally used for control flow, you can also throw and raise errors in elixir.

shoes = get_shoes()
is_nil(shoes) || raise(DressCodeError, "no shoes!")

# or

shirt = get_shirt()
is_nil(shirt) || throw({:error, {:dress_code, "no shirt!"}})

Hmmm…I looked in the Kernel docs here:

and there is no with/1. Edit: Ah, I see. It’s listed under Kernel.SpecialForms.

And for anyone that cares, the <- operator is discussed on p. 39 of Programming Elixir 1.6 in the section titled “with and Pattern Matching”.

with/1

The precedent for the left arrow probably comes from for/1; see Pronouncing `<-` - #4 by peerreynders.

What does the left arrow do there? And where is the documentation for with/1?

Yes, that’s a good point. One of the things I like about with/1 is that it avoids nesting, but particularly if there are only one or two errors to handle, case could be the way to go (or if!).

with also lets me kind of replicate a pattern I like in imperative languages (eg. ruby):

shoes = get_shoes()
raise DressCodeError, "no shoes!" if shoes.nil?

shirt = get_shirt()
raise DressCodeError, "no shirt!" if shirt.nil?

This pattern of returning/raising as soon as possible also helps avoid a bunch of indentation, and means the function generally stays on the “happy path”.

Lots of good ideas from people I should mention that get_shoes/get_shirt are standins for code from the std. lib, or ecto or plug or whatever. They might be code I own, or maybe not.

The idea of improving the error messages is good, and in some cases could be done by changing what functions are used, too, eg. Map.get(params, :shoes, {:error, :no_shoes}) instead of Map.fetch(params, :shoes)

The idiom is {:ok, value}, {:error, reason}

So the pattern match should focus on the contents of reason.

For example:

Process.monitor/1 will result in a general message of the format:

{:DOWN, ref, :process, object, reason}

where reason can take on values like :normal, :noproc or :noconnection, i.e. values that are highly distinct and imply their context. So it’s a good idea to follow the same practice with {:error, reason} tuples.