Hacker News Reader

Comment by adamddev1 | Hacker News Reader

> Whew. This is why a twenty-first century language, like Racket, uses archaic, un-helpful fifty year old terms. While Matthew Flatt and team could have changed these terms, they were keeping with a long tradition.

To be fair, Racket and LISP do have the procedures `first` and `last` for accessing lists, but also keeps `car` and `cdr` for accessing either pairs or lists. Clojure did away with `car` and `cdr`, but it also did away with the ability to make plain pairs from `cons`.

Racket:

  > (first (cons 1 '())) # w list
  1 
  > (car (cons 1 '())) # w list 
  1
  > (first (cons 1 2) # w pair
  ERROR
  > (car (cons 1 2)) # w pair
  1

Clojure:

  > (first (cons 1 '())) # w list
  1
  > (cons 1 2) # pairs not allowed
  ERROR

https://docs.racket-lang.org/reference/pairs.html

View on HN

Common Lisp has FIRST, SECOND, ..., TENTH and REST.

http://www.lispworks.com/documentation/HyperSpec/Body/f_firs...

Thanks, I didn't know that but edited my comment accordingly.

Sure does. In my own code I prefer `NTH` for anything beyond the cadr. Or just use arrays for random access.

Note that "second" will not work as intended if you just have a pair; it access the second element of a list. I rarely find any use for anything beyond first, second, and rest; if I need to access nth elements I will likely switch to a different data structure.

Racket doesn't keep any "tradition"; the traditional, mutable conses are found under different naming here:

https://docs.racket-lang.org/reference/mpairs.html

Moreover, "a mutable pair is not a pair; they are completely separate datatypes".

So, I think, you can't make a piece of syntax out of these and pass them to the evaluator or compiler.

So, this doesn't even give a tip of the hat to the tradition of Barbara Liskov's substitution principle where you'd expec that a "mutable pair" is-a kind-of "pair", and so on.

> Clojure did away with `car` and `cdr`, but it also did away with the ability to make plain pairs from `cons`.

And it also means that more things than lists can be accessed as sequences using iterators.

The whole "Have to recurse the entire chain to figure out if something is terminated with nil/() and therefore a list" is part of the reason why everybody bangs on about tail recursion instead of just writing an imperative loop.

Reply on news.ycombinator.com