LISP Quick Reference
This reference condenses the Common Lisp operations you reach for most often: list construction and access, conditionals, variable binding, function definition, and iteration. It's meant as a lookup companion while coding, not a substitute for understanding why each form works the way it does, so each entry below is grouped by purpose rather than alphabetically, matching how you'd actually think through building a piece of code.
Cricket analogy: A quick reference is like a fielding-position cheat sheet a young captain keeps in their pocket during a match—not a substitute for understanding field strategy, but a fast lookup when setting a field under pressure.
Data Structures: Lists, Conses, and Vectors
The list is LISP's fundamental data structure, built from cons cells where each cell holds a car (first value) and a cdr (rest of the list); '(1 2 3) is syntactic sugar for (cons 1 (cons 2 (cons 3 nil))). Beyond lists, Common Lisp provides vectors for O(1) indexed access via aref, hash tables via make-hash-table and gethash for key-value lookup, and association lists (alists)—plain lists of (key . value) pairs searched with assoc—as a lightweight alternative to hash tables for small datasets.
Cricket analogy: A cons cell holding a car and cdr is like a single delivery record pairing 'runs scored on this ball' with 'a link to the next ball's record'—chain enough of these together and you've reconstructed the entire over.
;; Lists
(list 1 2 3) ;; => (1 2 3)
(first '(1 2 3)) ;; => 1
(rest '(1 2 3)) ;; => (2 3)
(append '(1 2) '(3 4)) ;; => (1 2 3 4)
(length '(1 2 3)) ;; => 3
(reverse '(1 2 3)) ;; => (3 2 1)
(member 2 '(1 2 3)) ;; => (2 3)
;; Vectors and hash tables
(let ((v (make-array 3 :initial-contents '(10 20 30))))
(aref v 1)) ;; => 20
(let ((h (make-hash-table)))
(setf (gethash :name h) "Ada")
(gethash :name h)) ;; => "Ada"
;; Association list
(assoc 'b '((a . 1) (b . 2) (c . 3))) ;; => (B . 2)Control Flow and Variable Binding
Conditionals in Common Lisp range from if (a single true/false branch) to cond (a chain of test/result clauses evaluated in order, similar to a switch statement) to case (dispatch on a value matching literal keys). Variable binding uses let for parallel bindings that can't reference each other, let* for sequential bindings where each can reference the ones before it, and setf as the generalized assignment operator that can mutate not just variables but any accessible place, including list elements ((setf (car lst) 5)) or hash table entries.
Cricket analogy: The let vs let* distinction is like naming two new batters walking in together at the same time (parallel, neither knows the other's name yet) versus introducing them one after another so the second can reference the first (sequential).
setf is the generalized place-mutation macro in Common Lisp: it works with any 'place' that has a defined setf-expander, including (car lst), (gethash key table), (aref vec i), and even user-defined accessor functions via defsetf or (setf slot-value)—this is why you rarely see separate mutator functions like set-car! in idiomatic Common Lisp the way you do in Scheme.
Function Definition and Iteration
Functions are defined with defun, which takes a name, a lambda list of parameters (supporting &optional, &rest, and &key for flexible argument handling), and a body; anonymous functions use lambda directly, often passed to higher-order functions like mapcar. For iteration, dolist and dotimes cover the common cases of iterating over a list or a numeric range respectively, while the general-purpose loop macro offers a mini-language for more complex iteration with accumulation, filtering, and early termination, at the cost of being syntactically distinct from the rest of Common Lisp.
Cricket analogy: The &optional and &key parameter markers are like a team sheet that lists mandatory starting eleven names first, then optional 12th-man and reserve names afterward, clearly separating what's required from what's situational.
dolist and dotimes cannot easily accumulate a transformed result the way mapcar can — they're built for side effects like printing. If you need to build a new list from a loop, prefer mapcar, loop ... collect, or an explicit accumulator with push followed by nreverse, rather than trying to force dolist into a role it isn't designed for.
- Lists are chains of cons cells; use
first/rest(orcar/cdr),append,length,reverse, andmemberfor common list operations. - Vectors give O(1) indexed access via
aref; hash tables give key-value lookup viagethash; alists are lightweight key-value pairs searched withassoc. ifhandles single true/false branches,condchains multiple test/result clauses, andcasedispatches on literal value matches.letbinds variables in parallel;let*binds them sequentially so later bindings can reference earlier ones.setfis the generalized assignment operator, working on variables, list cells, hash entries, and array elements alike.defundefines named functions with flexible lambda lists (&optional,&rest,&key);lambdacreates anonymous functions.dolist/dotimessuit side-effecting iteration; usemapcarorloop ... collectwhen you need to build a new list from the iteration.
Practice what you learned
1. What are the two components of a single cons cell?
2. Which data structure gives O(1) indexed access via `aref`?
3. What is the difference between `let` and `let*`?
4. Which operator is the generalized assignment/mutation form in Common Lisp?
5. Which iteration construct is best suited for building a new list of transformed values?
Was this page helpful?
You May Also Like
LISP vs Modern Languages
A comparison of LISP's core design choices—homoiconicity, macros, and minimal syntax—against mainstream languages like Python, JavaScript, and Java.
LISP Best Practices
Practical conventions for writing clean, maintainable LISP code, covering naming, recursion style, macro hygiene, and error handling.
Building a Simple Calculator in LISP
A hands-on walkthrough of building a working arithmetic expression calculator in Common Lisp, from tokenizing input to evaluating nested expressions.
LISP Interview Questions
Common LISP interview topics—from car/cdr fundamentals to macros and tail recursion—explained with the reasoning an interviewer expects.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics