On 20 Oct 2009, at 13:21 , Steven D'Aprano wrote:
You don't pass compound statements around as input to other functions, so you know the environment that they're being called in, and can more easily reason about their correctness.
But unless the language is dynamically scoped (which is getting pretty rare these days, and which Python definitely isn't) the environment in which the block is executed is not quite relevant, since the free variables are bound based on its lexical scope (the environment in which the block is created) and the rest is made of argument (as in every other function).
In my opinion, it simply isn't enough of a burden to define a function before you use it, using a "don't care" name, to deserve the amount of words written about potential multi-statement lambda syntax. If Python had different syntax, then perhaps we'd have anonymous functions like Ruby. But we don't, and frankly I don't think it is much of a restriction.
The biggest (by far) advantages I see to good anonymous functions (note: Ruby's aren't, as far as I'm concerned, because due to their nature they don't easily scale from 1/call to 2+/call) are in flexibility, freedom of experimentation and possibility to keep the core language itself small: had Python had "full-blown" anonymous functions, it wouldn't have been necessary to add the `with` statement to the language. It could just as well have been implemented through a protocol or the stdlib, and people would have been free to toy with it in their projects long before it was added to the core language. It also gives the possibility of making OO much less imperative (right now if one wants customized code paths, one usually has to rely on extracting data from objects, performing imperative operations and then feeding the result back to some other object, but objects could just as well provide "hooks" thought callables), and of creating custom control structures (see `with` above, but it applies to far more stuff). In fact, Smalltalk quite clearly demonstrated that with messages (method calls) and blocks (anonymous functions) you basically didn't need "hard-coded" control structures anymore. Now Smalltalk probably went a bit too far for most people, even 30 years later, but it does show how powerful this combination is, and how it allows the language's users to evolve the language itself, without having to change its core syntax.