Update: The solution in this post is effectively obsoleted by the
guard statement available since Swift 2.
Swift 1.2 introduces a feature that allows us to condense nested
if statements into a single one, eliminating the so-called “pyramid of doom”. However, there are still a few edge cases not covered by such an improvement, one of which appears in the Tiny Networking library by Chris Eidhof:
What prevents us from using a single
if statement is the fact that there is a corresponding
else after each
if. In fact, this is a very common pattern in data serialisation and error handling, so we need a more elegant way to represent it.
We start out by defining an operator:
rhs parameter of this operator is a closure that acts exactly like an
else block—it will only be executed if
nil. Here is an example:
The operator we defined, having higher precedence than the assignment operator, will be evaluated before assignment takes place. The implementation first checks
lhs to decide whether the closure should be called or not. In the above example, the first string is unwrapped successfully, so its corresponding closure is not called. However, the second string is
nil, which triggers the execution of its accompanying closure and causes the entire condition to fail.
Similarly, we can overload this operator to handle Boolean values:
We can even add the
@autoclosure attribute to the
rhs parameter so that you can pass in an expression without explicit curly braces around it:
Equipped with the new operator, we can now rewrite the code at the beginning of this article as follows. Note that you can chain expressions together with the operator to avoid using any curly braces, as shown in the
where clause below:
As you can see, by defining a simple operator, we can completely flatten the “pyramid of doom” and make our code much more readable.
All code above is available in this gist.