An interesting, to me, capacity of Lisp is to be represented uniformly - so called homoiconicity. For example, having a Lisp program, you can relatively easily add - statically - a debug statement after each statement, and then use that resulting program instead. That would be harder to do in Haskell - because the Haskell syntax is much richer.
Another doubt to "eating all languages lunches" comes from having multiple different paradigms in programming languages. I can imagine Haskell eating, say, Prolog's lunch - for example, Norvig has shown how Prolog could be implemented as embedded in Lisp. But I suspect it's going to be harder to repeat in Haskell the strong points of Forth (stack computations), Tcl (strings as universal media?) or J (composability of primitives), even though some approximations could be made.
It's fishy idea to search for a singular "perfect" language - unless that's something like English, with all its imperfections built-in.
The singular "perfect" language would have to have pluggable syntax - so that anyone can have their perfect syntax as long as it generates the same parse tree.
At the same time, its type system will be pluggable too, so that people can keep improving the type system (dependent types, dynamic types, etc.) without changing the language.
Oh yeah, and of course its code generation/execution model will be pluggable as well. Do you want to interpret it? Sure! Do you want to compile it so it performs better on your target computers? No problem! Compile it to JavaScript? Why not?
In that way everyone can be programming in the same language that's flexible enough for everyone's use, but at the same time can contain DSLs. Pluggable syntax/custom type checking means you can embed SQL code and make sure it's valid before running it. It also means SQL could be a custom SQLStatement data type with its own semantics.
In short, only a language that allows every type of programming can be the "one true language"
You'd be somewhat surprised on that point. Especially if you just take it such that everything is just trying to build up an s-expression. While the homoiconicity of the language is incredibly cool for macros and whatnot, I don't think you strictly need it. Especially not at the top level. (That is, if you made a language that "compiled" down to s-expressions, what is missing?)
At the extreme end, take a look at Dylan.
Though, I was really referring to your other points. It seemed every one of your "questions" is directly addressed.
But everybody defining their own syntax would not make a language "the perfect language". Quite the opposite, because nobody would be able to understand each other's code anymore. It would be the ultimate fragmented language.
And because of that, I don't think a perfect language is even theoretically possible. Everybody has their own syntactical preferences, and allowing all of them means fragmentation.
Funny you should mention Forth; the "concatenative" languages are very Forth-like, and if you constrain yourself to what they call "point-free" style in Haskell, it's also rather Forth-like, or at least past simple cases you have to play the sort of weird games you do in Forth to make up for not being able to name parameters.
Coincidentally, I just saw a reddit comment where someone showed a way to statically add a debug statement to every function definition. The trick is to use a "pattern guard" to evaluate the trace, and then compare the result to "undefined" (never matches), so that the program continues on to look for a pattern that matches.
foo x | trace (show x) False = undefined
| otherwise = ... x ...
? That's not comparing anything to undefined, now is it a pattern guard, it's executing the trace function which then returns False leading to the next guard being evaluated and the actual computation being performed. The undefined is just there because it always type checks, and will never execute.
Another doubt to "eating all languages lunches" comes from having multiple different paradigms in programming languages. I can imagine Haskell eating, say, Prolog's lunch - for example, Norvig has shown how Prolog could be implemented as embedded in Lisp. But I suspect it's going to be harder to repeat in Haskell the strong points of Forth (stack computations), Tcl (strings as universal media?) or J (composability of primitives), even though some approximations could be made.
It's fishy idea to search for a singular "perfect" language - unless that's something like English, with all its imperfections built-in.