https://read.engineerscodex.com/p/clever-code-is-probably-the-worst
And clear, readable code is probably the hardest code to write
Coding happens in languages. This works much the same way as natural language, sometimes you'll speak in a way that is very clear to you and people who speak that language, but not to others.
sumSquares = sum . map (^ 2)
vs
def sumSquares(numbers):
result = 0
for number in numbers:
result += number ** 2
return result
Function composition is clear to people who speak Haskell, and eliminating mutation/untracked side effects helps to keep behavior local and gives equational reasoning. You can ask your IDE what the type of sumSquares is, and immediately know without looking at the implementation that there are no side effects, and what the types are.
On the flip side, most programmers can read basic Python, the C family of languages has seen more adoption, and Python simplifies a lot of the syntax/concepts down to their most basic forms. Python tries to be the most like English, and this is both its greatest strength and weakness (English can be an abysmal language for structured data processing).
You can of course write the Haskell to look more like the Python, or the Python to look more like Haskell. But I'd say the two snippets above represent idiomatic code for those languages, and as someone who actually loves FP, I wish Python never introduced list comprehensions/generator expressions (what a lot of people would use to implement the above in Python). If you're trying to write typesafe functional code, you should just not be using Python.