Returning a Boolean or a pair or 2-tuple with a value and a Boolean is often a perfectly good choice. Similarly, passing a single Boolean argument — to a suitably named function — is often the right approach.
But passing a Boolean to a function that accepts two or more arguments is almost always a mistake!
This article explains why and what to do instead.
This article's examples are shown using Python syntax but the ideas are applicable to most modern languages.
Query functions that return a Boolean should normally have names
beginning is or has, e.g.,
For side-effect functions the name usually reflects their action, e.g.,
container.delete(key) might return
True if key existed
in the container and was deleted, or
For functions that return a value that may or may not be valid the
choices are usually: (1) return
None (or whatever the
NULL equivalent is), or a valid value; (2) return an
Option object which essentially encapsulates a valid value and a
Boolean; or (3) return a pair or 2-tuple of value (valid or not) and
Boolean indicating the value's validity.
In all these cases, returning a Boolean (or Boolean within an Option, pair or 2-tuple) is perfectly sensible.
For functions that accept a single argument, making that argument a
Boolean works fine — providing the function's name works well with
it. For example,
For functions that take two or more arguments, none of them should be Booleans! (There's a possible exception shown in the box at the end.)
To illustrate why, imagine trying to guess what the following call does:
Most programmers would reasonably guess that
p2 are points representing two opposite corners. But no one can
reliably know what the two Boolean arguments are. And even if there was
just one Boolean — could True mean fill; or outline (i.e., the
opposite of fill); or shadow; or something else entirely? It isn't
possible to see at the call site. And this is why for functions that
take two or more arguments using Booleans is a bad idea!
What we should do instead is create an enumeration (even if it has only two members) and use that instead:
Here, there's no question about what the arguments mean. And as a bonus, because enumerations are used it is possible to extend the range of possibilities without changing the API. For example:
So, we recommend always using enumerations rather than Booleans for the parameter types of functions that take two or more arguments.
Some languages (for example, Python), allow us to specify named arguments whose names are required at the call site. For example, given this Python function signature:
def drawRectangle(p1, p2, *, fill, shadow): ...
callers must specify the last two arguments by name, e.g.,:
drawRectangle(p1, p2, fill=True, shadow=False)
Of course, this doesn't provide the versatility of using enumerations. So we still recommend always using enumerations rather than Booleans for multi-argument functions, even when using Python.
But, what if you can't change the API — for example, because the
function you're calling is in a library that you can't change? In such
cases you can still improve call site readability by creating Boolean
enumerations or Boolean constants, and passing them rather than raw
Your Privacy • Copyright © 2006 Qtrac Ltd. All Rights Reserved.