I recently began using a new(ish) feature of Elixir that completely transformed the way I build programs. I'm talking about the special form `with`

. It can feel unfamiliar at first, but it is extremely powerful and flexible. This article will explain how `with`

works and how it can be used to make your code more robust to errors. First, though, let's look at the problem `with`

is trying to solve.

#### Tagged Tuples

The Elixir community has borrowed an idiom from the Erlang community called tagged tuples. Using this approach, our functions will return a tuple where the first value is an atom describing the "type" of the result. A common pattern is returning `{:ok, value}`

for a successful response and `{:error, some_error}`

for an error response.

```
defmodule Math do
def divide(_, b) when b == 0, do: {:error, "divide by zero"}
def divide(a, b), do: {:ok, a / b}
end
case Math.divide(1, 2) do
{:ok, result} -> "success: #{result}"
{:error, error} -> "error: #{error}"
end
# => "success: 0.5"
```

This is nice for a few reasons. First, it allows us to treat errors as values. We know that our function will always return even when provided semantically invalid data. Second, we can use pattern matching to act explicitly on both the success and failure case.

This patterns starts to break down when we want to perform multiple, dependent actions that can all fail. Suppose, for example, that we'd like to divide two numbers and, if successful, divide the result by a third number.

```
case Math.divide(1, 2) do
{:ok, result} ->
case Math.divide(result, 4) do
{:ok, result} -> "success: #{result}"
{:error, error} -> "error: #{error}"
end
{:error, error} -> "error: #{error}"
end
# => "success: 0.125"
```

This works, sure, but it's becoming challenging to read. You can easily imagine the mess this becomes with an arbitrarily long list of dependent operations.

What should we do? We want to continue using this pattern because it is safe and explicit but it feels ugly and unreadable with real-world examples. The answer, of course, is to use `with`

.

#### Using `with`

The `with`

special form allows you to define a set of operations to perform and associated patterns to match their results against. Each operation can use bindings from the pattern match of the previous operations. If any of the matches fail, the entire `with`

form stops and that non-matching result is returned. Let's explore by rewriting the above example using `with`

.

```
with {:ok, a} <- Math.divide(1, 2),
{:ok, b} <- Math.divide(a, 4) do
"success: #{b}"
end
# => "success: 0.125"
```

Let's walk through the execution. First, we call `Math.divide(1, 2)`

. The result is `{:ok, 0.5}`

. The `with`

form checks to see if this matches the pattern on the lefthand side of `<-`

. It does, so the variable `a`

is bound to `0.5`

and execution continues. On the second line, we run `Math.divide(0.5, 4)`

(because `a`

is now bound to `0.5`

). This returns `{:ok, 0.125}`

. We check if it matches the pattern on the lefthand side of its `<-`

. It does, so `b`

is bound to `0.125`

. There are no more operations to perform, so the body of the `do`

block is executed. This `do`

block can use any of the bindings from the `with`

operations above. It uses `b`

to return the string `"success: 0.125"`

.

Now, let's try walking through an error case.

```
with {:ok, a} <- Math.divide(1, 0),
{:ok, b} <- Math.divide(a, 4) do
"success: #{b}"
end
# => {:error, "divide by zero"}
```

First, we call `Math.divide(1, 0)`

. The result is `{:error, "divide by zero"}`

. We check to see if this matches the patter on the left of `<-`

. It doesn't! As soon as this mismatch occurs, the `with`

form immediately stops executing further operations and returns the result that did not match. Therefore, the return value of the form is `{:error, "divide by zero"}`

.

#### Better Error Handling

We're already in a better spot by using `with`

but we can go even further. The `with`

form allows us to describe an `else`

clause that handles any non-matching values rather than simply returning them. Let's add one.

```
with {:ok, a} <- Math.divide(1, 0),
{:ok, b} <- Math.divide(a, 4) do
"success: #{b}"
else
{:error, error} -> "error: #{error}"
end
# => "error: divide by zero"
```

Now, when the first operation returns `{:error, "divide by zero"}`

and it doesn't match the pattern, the value is passed to the `else`

block. Next, we check each clause of the `else`

block in order (in this example there is only one clause). The first clause matches `{:error, "divide by zero"}`

, so the string `"divide by zero"`

is bound to `error`

. Finally, the body of that clause is executed with the bindings from the match. It returns the string `"error: divide by zero"`

.

#### More

The `with`

form allows even more flexibility, including guard clauses in each of the operations. For more examples see the docs.