RE: [External] : Re: Elisp threading macros

[Drew Adams <drew.adams@oracle.com>]

> emacs lisp already has `first', `rest' and
> `seq-do' or `dolist'. And `nth' to replace
> `caddr' etc.

Neither nth nor nthcdr replaces caddr, caar
cdadar, cdddar, etc.  Each of the c[..]r
functions targets a particular part of a
list (tree) in one fell swoop.

And its name is a _picture_ of where that
part is located in the tree.  Direct access,
including mentally/visually.

(Yes, it takes (a little) getting used to.)

That alone is a good reason for not only
keeping car and cdr but having them at the
back of your mind in combination, instead
of just first/rest or head/tails.

Could different chars have been used than
c, a, d, and r?  Of course.  The c and r
aren't needed, and we could have used f for
first and r for rest, or h for head and
t for tails, or | for car and . for cdr, or
- for car and @ for cdr:

 cadaar  =  frff  =  hthh  =  |.||  =  -@--
 caar    =  ff    =  hh    =  ||    =  --
 caaar   =  fff   =  hhh   =  |||   =  ---
 caddar  =  frrf  =  htth  =  |..|  =  -@@-

 cdadar  =  rfrf  =  thth  =  .|.|  =  @-@-
 cdddar  =  rrrf  =  ttth  =  ...|  =  @@@-
 caddr   =  frr   =  htt   =  |..   =  -@@

Or Morse code: .-..  ..  ...  .--.
                L    I    S    P

The point is that there are 2 basic access
functions for the 2 components of a cons,
and accessing their combinations can be
abbreviated in a pictorial way with 2 chars.
___

Of course, no one would suggest that people
should _mostly_ use the more complex c[..]r
abbreviations instead of binding intermediate
vars with meaningful names to uses of smaller
access c[..]r variations (including car/cdr).

Still, when that's not so important, if a
reader is _used_ to the c[..]r pictures, an
occasional (caddar foo) can be handier than
(first (rest (rest (first foo)))) or
(first (nthcdr 1 (first foo))).

IOW, if you're going to use such first/rest
combinations anyway (instead of intermediate
vars), then the c[..]r patterns can be handy
and healthy. ;-)

It kinda depends on what one's used to.

(setq foo  '((1 (2 3) 4 . 5)))

(caar foo)         => 1        ..        I
(caadar foo)       => 2        ..-.      F
(cadar foo)        => (2 3)    .-.       R
(cadr (cadar foo)) => 3        .- (._.)  A(R)
(cddar foo)        => (4 . 5)  --.       G
(caddar foo)       => 4        .--.      P
(cdddar foo)       => 5        ---.      Ó
                                         or O(E)
                                         or M(N)
                                         or T(G)

YMMV.