Functional Programming in Python
ibm.com
ibm.com
http://www.artima.com/weblogs/viewpost.jsp?thread=98196
What's interesting is the reasons he gives:
"Why drop lambda? Most Python users are unfamiliar with Lisp or Scheme, so the name is confusing; also, there is a widespread misunderstanding that lambda can do things that a nested function can't -- I still recall Laura Creighton's Aha!-erlebnis after I showed her there was no difference! Even with a better name, I think having the two choices side-by-side just requires programmers to think about making a choice that's irrelevant for their program; not having the choice streamlines the thought process."
Basically he wants to dumb down the language to make it more appealing to the mainstream programmer crowd. He wants another java. In the end, I think that mentality is a death sentence for the language.
And the reason he wanted to remove them is not because he wants to 'dumb down' the language, but rather because list comprehensions do what filter/map/reduce can do 9 times out of 10 but end up a lot more legible. He says as much in that post. But again, if you really want those functions, they still exist in Python and will exist in the future.
Another feature is the nested defines - that is quite nice (considering that you can put very little into a lambda).
From what I can tell, Python has always had this mentality. I think lambdas are a rather minor issue anyway. If you're going to slam Python for 'dumbing things down' to appeal to a 'mainstream programmer crowd' you can probably find better ammunition.
Fortunately, there exist solutions to this problem. The Haskell solution is to make your code so damn concise that you don't need to add any structure to it. The Lisp approach is to allow you to program the representation of your code in arbitrary ways.
Both are, I think, superior to the Python solution, which is simply to revert back to the imperative style.
I disagree with you there. If you understand that Map, Reduce and Filter (for example) are essentially loops, using them greatly increases code readability. Instead of having to read loop code, you're just reading code that describes what you're doing to the data.
EDIT: I know this is going to sound weird, but I recently implemented Map, Reduce and Filter in VB.NET. Aside from the fact that using .NET delegates is clumsy, the code portions that use those methods are much more concise (and readable).
By "dumbing down" I assume you mean "looks less like lisp". You can do the same as map and filter in a more elegant and pythonic way using generator expressions.
Btw. he was just thinking aloud. In the end he just moved map and filter out of the core language and into a library, and lambda stayed.
also: article is from 2001, talks about new features in Python 2!