The `with` statement seems similar to Haskell's `do` notation for monads, where the monad(ish) here is pattern matching.
I'm new to Elixir but I've definitely run into the "byzantine case-clause" issue and it can be very annoying. My case was very similar to the example: pulling something from a form, validating the format, validating it in the database, and returning something. All failable, single-purpose functions in sequence to narrow down the result.
I grappled between using a monad macro library[0] to simplify `{:ok, _}`/`{:error, _}` signatures versus just raising exceptions. I ended up doing the latter for the additional benefit of stack traces. Exceptions seem culturally discouraged in Elixir, though I don't quite grok why yet.
Out of curiosity, would you be willing to show how you might refactor the post's "create_organization" example?
Exceptions are not discouraged, using them for flow control is.
There are I think a few reasons why exceptions are a being a little frowned upon.
The first one is that usually we do not want to rescue them,
the let it crash philosophy.
If an error happens, the the process will crash, it will be restarted,
the error will be logged, and everyone will be happy.
In the case we really do want to handle an error,
we can usually just use `case` or `with`, which are simpler, avoids to
rescuing something we did not expect, as well as some pitfalls,
for example the fact that recursive calls inside a `try` cannot be
optimized to be tail-recursive, which can be an issue depending on the case.
However, I think it is fine to use exceptions if it can avoid
deeply nested code, which was probably your case.
I'm new to Elixir but I've definitely run into the "byzantine case-clause" issue and it can be very annoying. My case was very similar to the example: pulling something from a form, validating the format, validating it in the database, and returning something. All failable, single-purpose functions in sequence to narrow down the result.
I grappled between using a monad macro library[0] to simplify `{:ok, _}`/`{:error, _}` signatures versus just raising exceptions. I ended up doing the latter for the additional benefit of stack traces. Exceptions seem culturally discouraged in Elixir, though I don't quite grok why yet.
Out of curiosity, would you be willing to show how you might refactor the post's "create_organization" example?
[0] https://github.com/rmies/monad