I think this would be nicely expressed in a with clause since you are subject to errors at each stage of the pipeline and therefore would want to exit the pipeline if an error is detected. So as an example:

def search_books(query = %Query{} \\ %Query{title: "Elixir"}) do
  with {:ok, url} <- build_url(query),
       {:ok, response} <- execute_request(url),
       {:ok, response} <- validate_response(response) do
    extract_books(response)
  end
end

Noting that if at any stage the patterns do not match, the with clause will exit with the non-matching return.

With this approach I would likely delegate validate_response/1 to be called within execute_request/1 since with is best used to describe the happy path. So this time with explicit error management:

def search_books(query = %Query{} \\ %Query{title: "Elixir"}) do
  with {:ok, url} <- build_url(query),
       {:ok, response} <- execute_request(url) do
    extract_books(response)
  else
    {:error, reason} -> raise "whoops, we got error #{inspect reason}"
    other -> raise "unexpected error return #{inspect other}"
  end
end

Then for execute_request/1:

def execute_request(url) do
  with {:ok, response} -> http_call(url),
       {:ok, valid_response} -> validate_response(response) do
    {:ok, valid_response}
  end
end

At some point your expressive pipeline will have to deal with errors since you have functions with side affects (like external requests) so I’m not sure its the right measure of success.

However perhaps the OK library by @Crowdhailer would reflect your tastes more?

FYI: exceptional

• GitHub
• Article