List Manipulation Functions

Analogy categoryAnalogies

Once you understand that a list is a chain of cons cells, the large library of built-in list functions stops looking like an arbitrary grab bag and starts looking like a coherent toolkit for walking, searching, and rebuilding that chain. Functions like append, reverse, member, and assoc all reduce, at some level, to repeated car/cdr traversal, but they package common patterns so you rarely need to write raw recursive cdr-walks yourself.

🏏

Cricket analogy: Just as a scoring app doesn't make you manually tally every run from raw ball-by-ball data — it gives you built-in views like 'strike rate' and 'partnership total' — Lisp's list functions package common traversal patterns so you don't hand-write car/cdr walks every time.

Accessing Elements: first, nth, and the c...r Family

Beyond raw car and cdr, Common Lisp provides first through tenth as readable synonyms for positional access, plus the compact 'c...r' family — cadr, caddr, cddr, and so on — which compose up to four car/cdr calls in one name (cadr is (car (cdr x)), i.e. the second element). For arbitrary positions, (nth n list) returns the nth element (zero-indexed) and (nthcdr n list) returns the list starting from that position, both implemented as repeated cdr-walks under the hood, so accessing element 10,000 of a 10,000-element list is O(n), not O(1).

🏏

Cricket analogy: Asking for 'the third ball of the fourth over' from a scorecard requires walking forward over by over, ball by ball — exactly like (nth n list) walking the chain step by step rather than jumping straight there.

lisp

(first '(a b c d))      ; => A
(second '(a b c d))     ; => B
(nth 2 '(a b c d))      ; => C   (zero-indexed)
(nthcdr 2 '(a b c d))   ; => (C D)
(cadr '(a b c d))       ; => B, same as (car (cdr '(a b c d)))

Combining and Reordering: append, reverse, length

(append list1 list2) builds a new list by copying all of list1 and then setting its final cdr to point at list2 itself (not a copy), so the result shares structure with list2 but not with list1. (reverse list) builds an entirely new list with elements in the opposite order, and (length list) walks the whole chain counting cons cells, which means length on a circular list will hang exactly like the naive traversal we saw with dotted pairs. All three are non-destructive: none of them mutates the cons cells of the lists you passed in.

🏏

Cricket analogy: Combining two innings' ball-by-ball logs into one full-match log — copying the first innings' records but just attaching a reference to the second innings' existing log — mirrors append copying list1 but pointing at list2 directly.

Searching: member, assoc, find, and remove

(member item list) walks the list looking for item (using eql by default) and returns the sublist starting at the first match, or nil if not found — note it returns a tail of the list, not just a boolean, so (member 3 '(1 2 3 4)) gives (3 4). (assoc key alist) is the association-list lookup workhorse: given a list of dotted pairs like ((:a . 1) (:b . 2)), (assoc :b alist) returns (:b . 2). (find item sequence) is more general, working on both lists and vectors and accepting a :test keyword, while (remove item list) returns a new list with matching elements removed, leaving the original untouched.

🏏

Cricket analogy: Scanning a wagon-wheel log for 'the first six hit' and getting back not just yes/no but the remaining deliveries from that point onward mirrors member returning the sublist from the match point, not a bare boolean.

Destructive vs Non-Destructive Operations

Many list functions have a destructive counterpart whose name typically starts with n — nreverse, nconc, and delete correspond to reverse, append, and remove. The destructive versions mutate the existing cons cells in place instead of allocating new ones, which is faster and uses less memory, but means any other variable still pointing at the original list structure will observe the mutation too. The classic beginner mistake is (setf mylist (reverse mylist)) done carelessly with nreverse on a list you still hold another reference to elsewhere.

🏏

Cricket analogy: Editing the official printed scorecard in-place to correct a scoring error is faster than reprinting the whole card, but if another official is still reading from that same physical card, they instantly see the edit too — like nreverse mutating shared structure.

nreverse, nconc, and delete offer real performance benefits, but only use them when you are certain no other variable holds a reference to the original list you're mutating — otherwise those other references silently become inconsistent or invalid. When in doubt, prefer the non-destructive version (reverse, append, remove) and accept the small extra allocation cost; correctness bugs from unexpected aliasing are far more expensive to track down.

first/second/... and the cadr/caddr family give readable shortcuts over raw car/cdr chains.
nth and nthcdr provide positional access but are O(n), since lists lack random access.
append copies its earlier list arguments but shares structure with its last argument.
member returns the matching sublist (not a boolean); assoc looks up key-value pairs in an alist.
reverse, append, and remove are non-destructive; nreverse, nconc, and delete mutate in place.
Destructive functions are faster but dangerous if another variable still references the original structure.
length walks the entire cons chain, so it hangs on a genuinely circular list.