LISP Quick Reference

Analogy categoryAnalogies

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.

lisp

;; 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 (or car/cdr), append, length, reverse, and member for common list operations.
Vectors give O(1) indexed access via aref; hash tables give key-value lookup via gethash; alists are lightweight key-value pairs searched with assoc.
if handles single true/false branches, cond chains multiple test/result clauses, and case dispatches on literal value matches.
let binds variables in parallel; let* binds them sequentially so later bindings can reference earlier ones.
setf is the generalized assignment operator, working on variables, list cells, hash entries, and array elements alike.
defun defines named functions with flexible lambda lists (&optional, &rest, &key); lambda creates anonymous functions.
dolist/dotimes suit side-effecting iteration; use mapcar or loop ... collect when 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?

LISP Interview Questions

Related Study Notes in Programming

Browse all study notes

Programming

Apache Spark Study Notes

Programming · 30 topics

Programming

Apache Flink Study Notes

Programming · 30 topics

Programming

Hadoop Study Notes

Programming · 30 topics

Programming

Snowflake Study Notes

Programming · 30 topics

Programming

Apache Airflow Study Notes

Programming · 30 topics

Programming

dbt (Data Build Tool) Study Notes

Programming · 30 topics

Topics covered

#Programming#LISPStudyNotes#LISPQuickReference#LISP#Quick#Reference#Data#StudyNotes#SkillVeris#ExamPrep

LISP Quick Reference