Erlang and OTP in Action.pdf - Synrc

48
However, if the first clause doesn’t match, then if the second argument is true, the
second clause of our example will be chosen. But if that clause doesn’t match either, the
third clause is tried, and if that still doesn’t match, we’ll get a run-time exception of the type
function_clause to indicate that the arguments didn’t match any of the clauses of the
function in this call.
Now, take another look at these clauses and think about what we know at each point. If
we ever get to the second clause, we know that the first argument is not true (because
otherwise the first clause would match). Likewise, if we get as far as the third clause, we
know that neither of the arguments can be true. The only valid possibility left at that point
is that both arguments are false (if the function was called with only true or false as
argument values).
It is good programming practice to make this knowledge explicit in the code—that’s why
we don’t accept anything else than (false, false) in the last clause. It means that if
someone calls this function with some unexpected value like foo or 42, he will get a runtime
exception (function_clause), which is what we want: it means that he will fail early,
so he will get a chance to detect his mistake and fix his code as soon as possible, and so that
bad data does not propagate further throughout the system. If we had tried to be “nice” and
said (_, _) in the last clause, to just return false in all remaining cases, then a call such
as either_or_both(foo, bar) would also return false without any hint of a problem.
2.5.3 – Guards
There is still a possibility of some nonsense slipping through here, though. If someone would
call the above function as either_or_both(true, 42) or as either_or_both(foo,
true), then it would quietly return true as if all was well in the world. We can add some
extra requirements to the clauses to plug this hole, using guards:
either_or_both(true, B) when is_boolean(B) ->
true;
either_or_both(A, true) when is_boolean(A) ->
true;
either_or_both(false, false) ->
false.
A clause guard begins with the keyword when and ends at the -> arrow. It contains one
or more tests, separated by commas if there are more than one, and all of them have to be
true for the clause to be selected. As you can see, we need to use variables in the patterns
to be able to refer to them in the guard, so we used the names A and B here instead of
don’t-care patterns. The is_boolean(…) test is one of those built-in functions that you can
call without specifying the module name (they live in the erlang module). There are similar
tests for all of the primitive data types: is_atom(…), is_integer(…), etc. The
is_boolean(…) test simply checks that the value is one of the atoms true and false.
Apart from such type tests, the number of things you can do within a guard is strictly
limited. You can use most of the operators (+, -, *, /, ++, etc.), and some of the built-in
©Manning Publications Co. Please post comments or corrections to the Author Online forum:
http://www.manning-sandbox.com/forum.jspaforumID=454