jonathan-scholbach
Avoiding long `with` blocks
I find myself using a lot of very long with-statements. The functions in the with pipeline return {:ok, result} or some {:error, :error_type, additional_error_information} It could look somewhat like this:
with \
{:ok, result_a} <- function_a(input),
{:ok, result_b} <- function_b(result_a),
{:ok, result_c} <- function_c(result_b),
:ok <- some_validation_function_d(result_c)
do
{:ok, result_c}
else
{:error, :error_in_a} -> {:error, :internal_error}
{:error, :another_error_in_a} -> {:error, :some_other_error}
{:error, :error_in_b} -> {:error, :strange_error}
{:error, :error_in_b, msg} -> {:error, :strange_error, msg}
{:error, :error_in_c, msg} -> {:error, :internal_error}
{:error, :validation_error, _msg} -> {:error, :validation_error, input, msg}
end
But sometimes I have blocks that are way longer even.
This looks like a legacy of thinking like an imperative programmer to me, using a a (not so) nicely nested catch-try tree.
I would like to find a way to make my pipeline functions perform an “early return”, so I would like to “break” the pipeline.
It should look something like this instead (not working pseudocode following):
input
|> {function_a(), error_handler_a}
|> {function_b(), error_handler_b}
|> {function_c(), error_handler_c}
|> {function_d(), error_handler_d}
Where each error_handler maps the error from the function to the correct error return I am using in this context. How do I do this best? I would be willing to write a macro (although I have no experience with this.) Another constraint: I do not want to use an external dependency for this, but be in full control of the code myself.
I am new to Elixir, and I can imagine that my idea of a solution does not make too much sense. If this is the case, what are other best practices to avoid the problem in the first place?
Most Liked
stefanchrobot
One way to approach this is to avoid the else clause in with. This means that you need to introduce a somewhat generic error struct - it can be app-wide, or specific to some context. All the smaller functions will need to return the error struct on error or you’ll need to write local wrappers around them. So it would be something like this:
# Generic error.
defmodule MyApp.Error do
defexception [:code, :message, :meta]
@impl Exception
def message(%__MODULE__{code: code, message: message, meta: meta}) do
"Error (#{code}): #{message}, meta: #{inspect(meta)}"
end
def new(code, message, opts \\ []) do
%__MODULE__{
code: code,
message: message,
meta: opts[:meta] || %{}
}
end
def auth_error() do
new(:auth_error, "authorization error")
end
def validation_error(changeset) do
new(:validation_error, "validation error", meta: changeset)
end
end
# App logic.
defmodule MyApp.Foo do
def bar(input) do
with {:ok, result_a} <- function_a(input),
{:ok, result_b} <- function_b(result_a),
{:ok, result_c} <- function_c(result_b),
:ok <- some_validation_function_d(result_c) do
{:ok, result_c}
end
end
# Example of wrapping.
defp some_validation_function_d(result_c) do
case run_validation(result_c) do
:ok -> :ok
{:error, changeset} -> {:error, MyApp.Error.validation_error(changeset)}
end
end
end
# Top-level code that runs the logic (e.g. controller, background job, etc.)
defmodule MyAppWeb.FooController do
def create(conn, _params) do
case MyApp.Foo.bar(params) do
{:ok, result} -> #...
{:error, %MyApp.Error{code: :validation_error}} -> # ...
end
end
end
See also Good and Bad Elixir.
As an added bonus, all the functions that return {:error, %MyApp.Error{}} now became nicely composable.
Popular in Questions
Other popular topics
Categories:
Sub Categories:
Forums
Popular Tags
- #ecto
- #liveview
- #troubleshooting
- #learning-elixir
- #deployment
- #library
- #erlang
- #testing
- #genserver
- #mix
- #absinthe
- #remote-other
- #otp
- #plug
- #how-to-question
- #macros
- #postgres
- #channels
- #elixirconf
- #exunit
- #discussion
- #code-sync
- #javascript
- #podcasts
- #onsite
- #dialyzer
- #docker
- #authentication
- #umbrella
- #full-time-contract
- #podcasts-by-brainlid
- #ecto-query
- #elixir-ls
- #phoenix_html
- #iex
- #blog-post
- #graphql
- #genstage
- #ai
- #websockets
- #supervisor
- #advent-of-code
- #elixirconf-us
- #distillery
- #processes
- #forms
- #api
- #metaprogramming
- #security
- #performance









