Hacker News Reader

Comment by rurban | Hacker News Reader

= for defun, really? why not set?

= really is for equality in lisp, not assignment

APL, ML and Pascal too. There is a story that Ken Iverson, the inventor of APL, was passing a terminal at which a Fortran programmer had just typed:

      I = I+1

Ken paused for a moment, muttered “no it doesn’t”, and passed on.

I read (= a b) as unification and slowly pieced together that it was probably assignment. Not as equality as the results of all the expressions starting = were discarded.

Why is it so strange that someone ignored a convention?

Because it's a 50-year old convention, and there doesn't seem to be a compelling reason for ignoring it. The language then uses `is` for equality, including numbers.

It's just weird, especially given they're using old-fashioned car/cdr instead of head/tail.

This is not a Lisp, and never claimed to be one.

This kind of gatekeeping from ANSI Common Lisp purists is tiring. Who cares about convention when one just wants to build their own language, use S-exprs and car/cdr for the sake of it.

> Who cares

Potential users care. It's off-putting to use something familiar but different in strange ways.

Using head/tail versus car/cdr would be a deviation I could understand. This = mess isn't.

It's not like common lisps practices are that great anyways. It being an old lisp convention, to me, is actually a reason to not follow it.

I want to see a modern take on sexpr based languages instead of being stuck in the past forever.

> Because it's a 50-year old convention

That's a terrible reason to justify... well, anything, really.

It's not just 50 years old, it's widely conformed to for these 50 years.

Why won't you use "&" for "less" and "%" for "greater", instead of sticking to the tired "<" and ">"?

Slavery was widely confirmed for even longer. Tradition, right?

How about instead of using tradition to decide if something is beneficial or not, you just assess it on its value?

> Slavery was widely confirmed for even longer. Tradition, right?

This is an egregious use of the noncentral fallacy.[1]

Conforming to this 50-year tradition makes the language more familiar and easier to learn, so it's reasonable to question why the language chose differently.

[1]: https://www.lesswrong.com/posts/yCWPkLi8wJvewPbEp/the-noncen...

And yet, Clojure, the most used Lisp today, decided to use brackets instead of parentheses for parameter lists, breaking with 50 years of Lisp tradition. How dare they??

But I'm sure you know better than them.

When Lisp first appeared, square brackets were not even standard characters. Maybe McCarthy would use them if he could.

The word "set" is much older, and is universally supported.

But most glaringly, (= a b) has a well-understood and entirely different meaning in most lisps, also since 1950s. It's comparison, not assignment. Breaking a well-set convention is a very different thing than making a new, slightly improved convention.

My original post includes "there doesn't seem to be a compelling reason for ignoring it". I'm not arguing for tradition for tradition's sake.

I don't think using = instead of define/defun/defn has a compelling reason. Clojure's use of [], {}, #(), etc., is compelling to me. I'm not a Lisp purist who thinks everything should be parentheses. Adding that syntax is helpful for the reader.

Innovation is welcome when it's beneficial. = for assignment isn't.

Using [] to style function formal parameters is completely pointless. It literally serves no purpose. It just makes it gratuitously different from other languages (not only Lisps). In most mainstream languages, both formal parameters and actual parameters use parentheses.

There would be a sense to it if square brackets shifted into some alternative semantics: (fn (...) ...) versus (fn [...] ...) doing something usefully different.

If you must use square brackets there, they are just a syntactic quirk that doesn't enable any new semantics.

Everyone who uses Clojure, and even people who don't, but know Lisp, understand the point: since parentheses are used in Lisp to delineate everything, it makes sense to use a different pair of symbols to make parameter lists stand out more.

Maybe saying it's "completely pointless. It literally serves no purpose" is a bit overly dramatic, don't you think?

You could have limited yourself to saying you don't personally like it because it breaks with tradition.

> it makes sense to use a different pair of symbols to make parameter lists stand out more.

Quite simply, no, it doesn't.

> you don't personally like it because it breaks with tradition.

Nope! I don't impersonally like it, because it's a gratuitous inconsistency which doesn't do anything. It's not technically justified in any way.

How does it make sense to have the formal parameter stand out? Why don't we want the function body to stand out? (fn (a b) [+ a b])?

Don't the parameters already stand out by being on their own line (usually)?

   (defn (a b)  ;; <-- sticks out like sore thumb
     ...)

If you think something deserves to stand out in code, can't you teach your editor to highlight it?

Where are the numbers to back all this "sense"?

Scheme used braces at least a decade or two before clojure even existed.

March 1960, the Lisp I Programmer's Manual:

  ff[x] = [atom[x] -> x; T -> ff[car[x]]]

  DEFINE ((
    (FF (LAMBDA (X)
          (COND ((ATOM X) X)
                (T (FF (CAR X))))))
    )) ()

which one or two decades later would be in Lisp:

  (defun ff (x)
    (cond ((atom x) x)
          (t (ff (car x)))))

There is no mention of this being a Lisp anywhere in the name or README files.

You are mistaken in assuming that, since it has parens, then it must conform to being a Lisp.

Reply on news.ycombinator.com