Back

@screwtape I only know of one: the dotted conses make for a natural representation of a pair on an association list.

But even so, it doesn't have to be a dotted cons. It can be a two-element list.

IIRC, somebody who invented Lisp has been heard saying that if he had known, he would have required all lists to be proper lists, ending in NIL, and neither dotted nor circular.

@riley @dougmerritt
Yeah,
(let ((alist '((:foo . bar) (:baz buz))))
(cdr (assoc :foo alist)) ; -> bar
(cadr (assoc :baz alist))) ; -> buz
There isn't a lot of cost (well, one cons to nil) of using cadr or second instead of cdr. And then you could store other stuff in later positions of the list as well. When I only knew the definitions of assoc and pairlis, I mostly used cdr, but then in lisp code I've read, like you said, the cadr one seems more common in lots of places.

@screwtape @riley
As a historical note:

> There isn't a lot of cost (well, one cons to nil)

Back in the days when RAM was measured in kilobytes / kilowords, some implementations did in fact have space-optimized representations for short lists represented as small arrays.

See cdr-coding
https://en.wikipedia.org/wiki/CDR_coding

That might still be in some implementations today, since its savings might be significant in large structures or in aiding cache locality.
 
The first paper may well have been L. Peter Deutsch: A LISP Machine with Very Compact Programs. IJCAI 1973, Pages 697 - 703

This is covered in 7.13 in the classic "Anatomy of Lisp", John Allen (1937-2022), 1978 (long out of print, and the author once replied to my query saying he didn't think it was worthwhile updating it for more modern times).

Has a lot on implemention, but tends to talk about abstractions in terms of M-Expressions, which is no longer in style.

ACM has it online:
https://dl.acm.org/doi/pdf/10.5555/542865

Glowing review of "Anatomy" on goodreads: https://www.goodreads.com/book/show/1537412.Anatomy_of_LISP

"John Allen (1937-2022) and Anatomy of LISP" by Paul McJones
https://mcjones.org/dustydecks/archives/2024/04/11/1249/

@dougmerritt CDR coding was only really used on the Lisp Machine, which did not have kb of memory .. but rather megabytes. It also didn't save much, while lists are useful, for large sets of data there are better representations.

@screwtape @riley@toot.cat

@amszmidt
Doug linked John Allen's book which spends about 50 pages asking people to please not use car and cdr as though they were intended as general list manipulation tools, even though they might be literally implemented as first and rest, since it's a failure of abstraction or something.

@dougmerritt ok, instead of being a jerk .. where else was it used? @screwtape @ksaj

@dougmerritt CDR was one of those things which the LispM hackers wanted to flush on the LispM cause it was just a pain in the ass .. slow, the benefits of it was nil.

@screwtape @ksaj

@ksaj @screwtape @amszmidt @riley
A little. The Accumulator register dates all the way back to the 4004; over time the 8008 then the 8080/8085 then the x86 registers became increasingly general purpose.

The A & D register meaning is retained somewhat more closely. Lisp was originally developed for the IBM 704, which had 15 bit "address fields" and 15 bit "decrement fields" in 36 bit words (plus 6 tag bits).

Something like that, anyway.

Extracting the "address field of register" and extracting the "decrement field of register" had pretty much the same meaning back then that CAR and CDR do today.

@dougmerritt Your timeline is so broken that I was hoping for a joke.

@ksaj @screwtape @amszmidt

@riley
Which part? The 4004 did have an accumulator. Lisp was originally designed for the 704.

https://en.wikipedia.org/wiki/Intel_4004
https://en.wikipedia.org/wiki/Lisp_(programming_language)

I don't need two people to simultaneously give me shit.

@ksaj @screwtape @amszmidt

@dougmerritt 4004 is far, far newer than the IBM 704. The concept of accumulators predates computers entirely — they flow naturally from the original Hollerith process for automatic card-counting. (And even so, some early computer theorists were un-fond of them, so there were attempts to make machines with instruction sets that wouldn't imply a user-visible accumulator register.)

Before registers got names in their own, the single letters that eventually become some registers' names were single letters in the mnemonic codes of instructions, something on the order of lai for Load Accumulator Indirect.

@infosec.exchange @screwtape @amszmidt

@riley
That's all true -- NOR DID I SAY ANY DIFFERENT.

@screwtape @amszmidt

@riley
You assumed bad faith and that I was saying that the concept of an accumulator was invented for the 4004.

But I didn't say that.

The context was someone else bringing up accumulators in the x86 family.

That's a very very large reading comprehension failure.

@screwtape @amszmidt

@riley
I've got an idea. Fuck you. Blocked.

@screwtape @amszmidt