Lambda the Ultimate

Interesting is this slide from Guido's "Python Regret's" talk:

Lambda and functional stuff

I've never liked lambda

• crippled (only one expression)
• confusing (no argument list parentheses)
• can use a local function instead

map(), filter()

• using a python function here is slow
• list comprehensions do the same thing better

reduce()

• nobody uses it, few understand it
• a for loop is clearer & (usually faster)

The slides don't give much context but it appears Guido is more in favour of removing functional features than improving them (his gripes about lambda are 2/3 syntactical - who controls the syntax Guido?) Is Python really multi-paradigm? The same attitude is expressed in the this ll1-discuss thread. I don't like this attitude that I should be told what style to program in.

python has roots in abc, an educational language and TOOWTDI (there's only one way to do it) is a recognised acronym on the dev list, so this prescriptive approach isn't new.

afaik python does "expensive" tail recursion (question - if a language supports first class continuations then can it still optimize away the previous environment on tail recursion?). also, reduce is foldr, not foldl (which seems odd - foldl is the tail recursive one and so, i guess, more popular). and, of course, python lists aren't lists, but arrays (interesting paper on implementing lists: http://ic2.epfl.ch/publications/documents/IC_TECH_REPORT_200244.pdf (from pragprog email list)).

[apologies if i'm confused about foldr/foldl - some of this comes from some old notes, which i'm now starting to doubt]

so no, python isn't a functional language. but count your lucky stars you're not using (generic) java. this is my declaration for foldl (and writing functions is even more verbose, requiring nests of inner classes).

public class Foldl<A,B>
implements Fn<Fn<Fn<A,List<B>>,A>,Fn<Fn<A,B>,A>>

<Any A> A foldLeft1(Sequence seq, (A, A)->A func)

And to follow-up on Michael Vanier's comment: I think multimethods are one of the most underrated language features; the latest version of Nice allows multiple dispatch for methods declared in Java.

You can see the same thing in the Perl community when Larry Wall writes "it allows the S&M folks to inflict strongly typed compile-time semantics on each other. (Which is fine, as long as they don't inflict those semantics on the rest of us.)" The key word here being "us". Doses the Perl community value static typing?

Ok, enough amateur lit-crit from me.