Python's complicating concept of a callable
Through Planet Python I recently wound up reading this article on Python decorators. It has the commendable and generally achieved goal of a clear, easily followed explanation of decorators, starting out by talking about how functions can return other functions and then defining decorators as:
A decorator is a function (such as
foobarin the above example) that takes a function object as an argument, and returns a function object as a return value.
Some experienced Python people are now jumping up and and down to say that this definition is not complete and thus not correct. To be complete and correct, you have to change function to callable. These people are correct, but at the same time this correctness creates a hassle in this sort of explanation.
In Python, it's pretty easy to understand what a function is. We have
an intuitive view that pretty much matches reality; if you write '
foobar(...):' (in module scope), you have a function. It's not so easy
to inventory and understand all of the things in Python that can be
callables. Can you do it? I'm not sure that I can:
- functions, including lambdas
- objects if they're instances of a class with a
- bound methods of an object (eg
- methods of classes in general, especially class methods and static methods
(I don't think you can make modules callable, and in any case it would be perverse.)
Being technically correct in this sort of explanation exacts an annoying price. Rather than say 'function', you must say 'callable' and then probably try to give some sort of brief and useful explanation of just what a callable is beyond a function (which should cover at least classes and callable objects, which are the two common cases for things like decorators). This is inevitably going to complicate your writing and put at least a speed bump in the way for readers.
The generality of Python accepting callables for many things is important, but it does drag a relatively complicated concept into any number of otherwise relatively straightforward explanations of things. I don't have any particular way to square the circle here; even web specific hacks like writing function as an <ABBR> element with its own pseudo-footnote seem kind of ugly.
(You could try to separate the idea of 'many things can be callable' from the specifics of just what they are beyond functions. I'm not sure that would work well, but I'm probably too close to the issue; it's quite possible that people who don't already know about callables would be happy with that.)