List Manipulation Functions

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.

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).

(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.

(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.

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.