4 ms·
The Background for CAR and CDR
- adamddev1 5y ago> 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 https://docs.racket-lang.org/reference/pairs.html
- lispm 5y agoCommon Lisp has FIRST, SECOND, ..., TENTH and REST. http://www.lispworks.com/documentation/HyperSpec/Body/f_firstc.htm#first http://www.lispworks.com/documentation/HyperSpec/Body/f_firs...
- adamddev1 5y agoThanks, I didn't know that but edited my comment accordingly.
- nomorecommas 5y agoSure does. In my own code I prefer `NTH` for anything beyond the cadr. Or just use arrays for random access.
- betterunix2 5y agoNote 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.
- bsder 5y ago> 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.
- kazinator 5y agoRacket doesn't keep any "tradition"; the traditional, mutable conses are found under different naming here: https://docs.racket-lang.org/reference/mpairs.html 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.
- rgoulter 5y agoI was introduced to Scheme as part of a course in the tradition of SICP. Hmm. I'm not sure how much using "pair, first, second" instead of "cons, car, cdr" would clarify things. The nature of "a list is either nil, or a cons of an item and a list" is entirely different from e.g. how you interact with Python lists. I'm not sure "a list is either nil, or a pair of an item and a list" is that much clearer. But also, with that algebraic definition of a list, it often didn't require using car/cdr directly. During the SICP course, you find that you can solve the given exercises by either writing functions which use car/cdr, or by using the higher-order map/filter/flatten/fold. Or e.g. in Haskell, a list can be pattern-matched to x:xs.
- addaon 5y agoOne of the things I find fascinating about the use of the names 'car' and 'cdr' is the 'c' part of it. As a developer who rights a small to moderate amount of assembly, I would tend to refer to the value in, say, 'r8' as 'r8' almost always -- I recognize the difference between "the register named r8" and "the value stored in the register named r8", but it's rare that I need to draw that distinction. On the other hand, in writing (and more importantly in teaching!) C and C-style languages, I find that one of the strongest tools for ensuring understanding is to distinguish between "the variable named x", "the value of the variable named x", and "the value at the memory location named by the value of the variable named x." In C we use * for part of this distinction; it seems like the 'car'/'cdr'-era equivalent would be to distinguish between 'r8' and 'cr8'/'*r8'.
- dfox 5y agoMy understanding is that the original vacuum tube based IBM computers on which Lisp was implemented were accumulator based architectures (ie. had one register usually named "accumulator") with some instructions using parts of the accumulator in particular harwired ways. Also, for CISC architectures that can do indirect loads on the ISA level (nowadays this is the only remaining practical difference between RISC and CISC), the difference between value of register (for i386: eax or %eax) and value referenced by that register ([eax] or $(%eax)) leads to different syntax of the assembly with same mnemonic. i386 with intel assembly syntax is particularly good example of this as 'mov' refers to at least a two dozens of different opcodes depending on the syntax of its two arguments and current mode of the assembler.
- kazinator 5y agoWhat's mind boggling is that in this historic thing called FLPL (Fortran List Programming Language), these names were complicated further with X...F wrapping. So CAR was spelled XCARF, CDR spelled XCDRF and so on.
- codr7 5y agoOne of the reasons they're still around in Common Lisp is to serve as a baseline for the set of cadr functions it provides. Never use them myself, but I suspect once they're part of muscle memory they make dealing with lists very convenient. clhs.lisp.se/Body/f_car_c.htm
- Kessler83 5y agoThis isn't a very good article. First of all, this has to be the most rehashed curiosa topic about Lisp, ever. Secondly, "keeping in touch with tradition" isn't a shallow thing you do for fun---it is both about identity and about the ability to read and reuse code, even though it is decades old. And thirdly, the reason you keep car and cdr isn't only about tradition, but also about the ability to quickly reach into nested lists: (cdaddr '(1 (2 (3 4 (5) (6 7) 8) 9) (10 1 3) 3)) => (1 3) Without these oldies, you would have to write several combinations of first, second etc. and rest, or some combination of first/rest and nth n list.
- betterunix2 5y agocdaddr is an unreadable monstrosity. Keeping it around for the sake of reusing good code from decades ago is one thing, but let's not praise it for giving programmers a compact way to retrieve a nested list. It is too easy to mistake "cdaddr" for "cddadr" in a large codebase and the bugs it would introduce will probably be very hard to deal with. If your list structure is so complex that you are using cdaddr or anything like it, you did something wrong. You should use defstruct with human-readable slot names to create more readable and easier to work with code.
- Kessler83 5y agoActually, there is no need to make guesses about whether cdaddr is bad, unreadable, introduces hard to handle bugs or what the limits of list structure complexity should be. It isn't some new idea or brief historic oddity that you can pass whatever judgement on. The term is at least 40 years old, standardized, still in use, has its own established pronunciation and isn't known to cause a lot of bugs. It is also at the periphery of the car/cdr body of terms -- i.e. programming tradition shows that the level of complexity it covers is needed (or the term would have disappeared), but any further is too rare to merit a shortcut. In addition, it is easy to remember what it does: each d is a cdr, each a is a car. So it isn't any harder to read than a chain of firsts, seconds, rests and nth n's.
- betterunix2 5y ago
- aap_ 5y ago> Although the exact origins of the names for car and cdr are lost in the mists of time This is absolutely wrong. If you read AI memo 1 you will find a bunch of functions: cwr, cpr, csr, cir, cdr, ctr, car, cbr, csgr. These return various parts of an IBM 704 word (also called a register) or will set it when assigned to. As we know only car and cdr survived, but it's explained very clearly how they wanted to build list structures.