Re: merits of Lisp vs Python



Jon Harrop wrote:
David Steuber wrote:
Well the editor does the matching. It certainly didn't take too long
for me to stop paying much attention to the parentheses. In fact, I
bet $1 that you are more likely to find superfluous parenthesis in a C
or C like program than in a Lisp program.

That brings me onto another criticism of Lispers: they have a different
definition of "superfluous" to me. Consider the following OCaml/F#:

let a, b = 2, 3 in a + b

and the Lisp equivalent:

(let ((a 2) (b 3)) (+ a b))

The OCaml has no parentheses. That doesn't mean the Lisp's are all
superfluous because OCaml has traded some of those parentheses (e.g.
for "let" and "in") but we need to do a token count. OCaml 12 vs Lisp 18.
So Lisp has 6 "unnecessary" or superfluous tokens. That isn't so important
because the byte count is virtually the same.

But this gets a lot worse when expressions written with conventional syntax
exploit precedence. For example, F# vs Lisp token count:


Well, lets see your F# Concentration program then. Perhaps a meaningful
comparison can then be made.

Still waiting with baited breath, though I will probably pass out soon.

Wade
.