Have you tried the with/1 special form?

It is pretty useful to unwrap nested case-expressions.

The biggest use of that I see is that it replicates the clean code you get from using the Maybe monad in Haskell-likes. As long as your functions fail by returning something emulating a Maybe - so basically {:ok, result} and {:error, result} and you use when to compute all the expensive parts, then you can basically reap the benefits of Maybe without implementing a new construct for it.

with {:ok, phase1} <- expensive_computation(),
     {:ok, phase2} <- read_something_from_db(phase1),
     {:ok, phase3} <- do_a_file_operation(phase2) do
  phase3
else
  :error -> :error
end

[EDIT: Fixed the operator as suggested by @Qqwy]

I like that.

The purpose of a Maybe is to “fall through” a computation when any step fails, without forcing the user to riddle the code with error-handling after every step. I don’t know how efficient with/1 is in regard to going to the else branch but it sure matches the elegance of such code without much effort.

You even get to define your own pattern what constitutes a Maybe. It just needs to be conveniently match-able. The Erlang convention of using :ok and :error tuples is hard to beat in this regard.

So, I’ll definitely take with-do-else into how I write code in the future. Thanks!

Be warned that with {:ok, result} = something() and with {:ok, result} <- something() mean something different!

With <-, the else will be called when it is not matched (or, if there is no else, the non-matching result is passed on to the outside scope).

With =, a MatchError is raised instead.