Stop writing lambda expressions in Python

all i could think of is "stop writing python". it seems to me that a lot of these problems are fundamental problems with python. i continue to not understand why anybody likes python the language.

the fact that creating a function with lambda versus the normal way is different is bonkers. for example, in f# (and other sane languages), the following are identical:

  let test1 = fun x -> x * x

  let test2 x = x * x

both return:

  x:int -> int

are they really different in python or is it just a weird naming problem? the article isn't explicit on the actual differences other than what is reported by the REPL.

also, you can't pass operators as functions in python? in f#, you simply wrap them in parentheses.

  let test3 f x y = f x y

  > test3 (*) 2 3 ;;

  val it : int = 6

i read an interview with hal abelson where he called python's lambda broken. seems so.

edit: also, this guy's thoughts on map and filter, in my opinion, show the python community's backwoods thinking regarding functional programming. yes, it seems generator expressions are nice (they are called sequence expressions in f#), but map and filter, even for his simple examples are much more clear. they communicate better what is actually happening. the fact that he never uses map and filter at all and then goes on to basically say map and filter aren't even needed in python says a lot.

The whole article, and his reasoning, reminded me of PG's Blub programmer. Seems like a perfect example. (that being said, lambdas in Python are rather lame, though not for the reasons he wrote about)

The first two situations where he recommends avoiding lambda I would agree with. But when he assigns `colors_by_length`, that's a perfectly valid usage of lambda. It's actually an ideal example of why it exists. His `length_and_alphabetical` is not an improvement. The tuple unpacking is something that destructuring in lambda syntax would improve, as it did with JavaScript. In ES6 it would be:

    const points = [[[1, 2], 'red'], [[3, 4], 'green']]
    const points_by_color = points
      .sort(([point, color]) => color)

I know it's kind of futile to argue against a point using what-ifs, but personally I wish Python embraced this style of functional programming a little bit more and adapted its syntax to it, rather than coming across articles where people recommend against this style just because the language isn't (currently) as suitable to it.

In F#, can you ask a function object what its original name was? If so, what is the original name of "test1" and "test2" in your example?

That's what python is doing and why the two are different.

(I don't think a language should track that sort of thing, but that's a different story).