Lisp Lisp Q&A — Beginner to Expert

Lisp is a family of programming languages known for simple syntax, symbolic processing, and code-as-data.

Example:

(+ 1 2 3) ; => 6

Parentheses represent lists, which are the core data structure and syntax form in Lisp.

Lisp code is written as lists, and lists are regular data you can manipulate programmatically.

An s-expression (symbolic expression) is either an atom (number, symbol, string) or a list.

A symbol is an identifier, like x, my-function, or +.

Use a REPL (Read-Eval-Print Loop), such as SBCL REPL, where you type expressions and get immediate results.

An interactive environment that reads input, evaluates it, prints output, and loops.

Basic non-list values: numbers, strings, symbols, characters, etc.

An ordered sequence, written in parentheses.

Example:

'(1 2 3) ; a literal list

Quote prevents evaluation and treats expression as literal data.

Example:

'( + 1 2 ) ; list containing symbols and numbers

Lisp tries to evaluate it as code.

Example:

(+ 1 2) ; => 3

nil means false and also the empty list in Common Lisp.

t is the canonical true value.

Use let for local bindings or ~defparameter/~defvar for globals.

Example:

(let ((x 10)) (+ x 5)) ; => 15

defparameter always assigns; defvar assigns only if variable is unbound.

Use defun.

Example:

(defun square (x) (* x x))
(square 4) ; => 16

(function arg1 arg2 ...).

Yes, in Common Lisp arithmetic operators are functions.

Use if, cond, or ~when/~unless.

Example:

(if (> 5 3) "yes" "no") ; => "yes"

Multi-branch conditional with test-result clauses.

Example:

(cond ((< x 0) :negative)
      ((= x 0) :zero)
      (t :positive))

Variables are visible where they are textually defined (and nested inside).

Variable resolution based on call chain (special variables in Common Lisp).

Dynamically scoped variables, usually named with stars: *print-base*.

Assigns to an existing variable.

Example:

(let ((x 1))
  (setq x 9)
  x) ; => 9

Generalized assignment to many “places” (variables, array slots, object fields).

Example:

(setf (car my-list) 42)

car returns first element; cdr returns rest of list.

Example:

(car '(a b c)) ; => A
(cdr '(a b c)) ; => (B C)

Constructs a new cons cell from head and tail.

Example:

(cons 'a '(b c)) ; => (A B C)

A pair of pointers: first part and rest part; lists are chains of cons cells.

Use predicates like numberp, symbolp, listp, stringp.

Functions returning truth values, often ending in p.

Use loop, dolist, dotimes, recursion, or mapping functions.

Iterates over list elements.

Example:

(dolist (x '(1 2 3))
  (format t "~A " x))

Repeats a fixed number of times.

Example:

(dotimes (i 3) (print i))

Function calling itself with smaller input until a base case.

Example:

(defun fact (n)
  (if (<= n 1) 1 (* n (fact (- n 1)))))

Recursive call is final operation; can be optimized in some Lisps (not guaranteed in Common Lisp).

Use format.

Example:

(format t "Hello, ~A!~%" "Lisp")

print adds newline and escapes; prin1 readable representation; princ user-friendly display.

Use double quotes: "hello".

Use concatenate.

Example:

(concatenate 'string "Hello, " "world")

Use =, <, >, <=, >=.

Use eq, eql, equal, or equalp depending on semantics.

Increasingly deep/permissive equality checks; equalp is most lenient.

A self-evaluating symbol in KEYWORD package, written like :name.

Flat key-value list: (:name "Ana" :age 30).

Use getf.

Example:

(getf '(:name "Ana" :age 30) :age) ; => 30

List of key-value pairs, each pair typically a cons cell.

Anonymous function expression.

Example:

(funcall (lambda (x) (+ x 10)) 5) ; => 15

Calls a function object with arguments.

Calls a function with argument list where last arg is a list.

Example:

(apply #'+ '(1 2 3 4)) ; => 10

Namespace for symbols to avoid naming conflicts.

With defpackage, then in-package.

Imports external symbols from other packages (commonly :cl).

Creating a local symbol with same name as imported one.

Organize code into packages/files and load with ASDF systems.

Build/load system for Common Lisp projects.

Package manager/distribution for Common Lisp libraries.

A function can return several values, not just one.

Example:

(floor 7 3) ; => 2, 1

Use multiple-value-bind.

Example:

(multiple-value-bind (q r) (floor 7 3)
  (list q r)) ; => (2 1)

Explicitly returns multiple values.

Binding parts of structured data (lists) to variables.

Example:

(defun sum-pair ((a b)) (+ a b)) ; implementation-dependent style

(Usually use destructuring-bind explicitly.)

Binds variables to list structure.

Example:

(destructuring-bind (a b &optional c) '(1 2 3)
  (+ a b c))

&optional parameters may be omitted.

&rest gathers remaining args into a list.

&key named args like :verbose t.

Declares local auxiliary variables in parameter list.

Applies function to each list element, returns list.

Example:

(mapcar #'1+ '(1 2 3)) ; => (2 3 4)

mapcar builds result list; dolist is usually for side effects.

Combines sequence elements with binary function.

Example:

(reduce #'+ '(1 2 3 4)) ; => 10

Returns sequence removing elements matching predicate.

Returns first element satisfying predicate.

Destructively sorts sequence.

Example:

(sort (copy-list '(3 1 2)) #'<) ; => (1 2 3)

sort may mutate original sequence.

Key-value structure with fast average lookup.

Example:

(defparameter *h* (make-hash-table :test 'equal))
(setf (gethash "name" *h*) "Lisp")

Value and a boolean for presence.

Indexed sequences; vectors are 1D arrays.

Example:

(make-array 3 :initial-contents '(10 20 30))

Array that can change size with adjust-array.

Logical length for vectors supporting efficient append-like behavior.

Lightweight user-defined record type.

Example:

(defstruct person name age)
(make-person :name "Ana" :age 30)

Common Lisp Object System: classes, generic functions, methods, multimethod dispatch.

Classes are more dynamic/extensible; structures are lightweight/faster for simple records.

Defines a class.

Defines method on generic function based on parameter specializers.

Method selection based on types of multiple arguments.

Combining :before, primary, :after, :around methods.

Accesses object slot dynamically (less encapsulated than accessors).

Functions generated for slot read/write access.

Lisp error/signaling system with restarts and handlers.

Lisp allows recovery strategies (restarts), not only unwind-and-abort.

Handles signaled conditions similarly to try/catch.

Catches errors and returns nil + condition.

Named recovery action that can continue execution from error context.

Ensures cleanup code runs even on non-local exits.

Hints to compiler (types, optimization qualities).

Global declarations affecting compilation/runtime behavior.

Add type declarations, reduce consing, profile, and tune algorithms/data structures.

A compile-time code transformer from input forms to output forms.

Create new syntactic abstractions and eliminate boilerplate elegantly.

Functions evaluate arguments first; macros receive raw forms.

Example:

(defmacro when-not (test &body body)
  `(if (not ,test) (progn ,@body)))

Template syntax for building lists with selective evaluation.

, inserts value; ,@ splices list elements.

Resulting code after macro transforms input.

Example:

(macroexpand-1 '(when-not x (print "hi")))

Avoiding accidental variable capture/name collisions in macro-generated code.

Use gensym for unique temporary symbols.

Macro-introduced symbol accidentally binds/conflicts with user symbol.

Optional source transformations for function calls to optimize compiled code.

Extends read syntax (at read-time), e.g., quote shorthand.

Can improve DSL syntax but reduce readability/tool compatibility.

Evaluates Lisp form at runtime in dynamic environment contexts.

Harder reasoning, security/performance/debugging costs.

Function capturing lexical variables from defining environment.

Example:

(defun make-counter ()
  (let ((n 0))
    (lambda () (incf n))))

Bindings visible where function/macro is defined.

Runtime context for special variables, handlers, restarts.

“Rest of computation” from a point; explicit first-class continuations are not standard CL.

Control transfer out of current context (throw, return-from, errors).

Tagged non-local control transfer constructs.

Named lexical exit points.

Low-level goto-like flow constructs.

Metaobject Protocol for customizing CLOS behavior (implementation-dependent).

Runtime overhead of selecting applicable method(s); often acceptable, sometimes optimizable.

Can update behavior interactively in running image.

Long-lived Lisp process where definitions are incrementally reloaded.

Compiled Lisp binary artifacts loaded faster than source.

compile-file produces fasl; load loads source or fasl.

Compiling modules independently with clear package interfaces.

Mechanism to call C/native libraries from Lisp.

Memory ownership, ABI compatibility, struct layout, threading boundaries.

Arbitrary-precision integers built into Common Lisp numeric tower.

Hierarchy: integers, rationals, reals, complex numbers.

Exact rational arithmetic avoids floating-point rounding where possible.

Use coerce or numeric contagion rules in operations.

Reader syntax configuration tables.

Structured formatted output via printer control and pprint facilities.

Querying runtime metadata: function definitions, classes, packages, etc.

Inspecting/modifying program structure/behavior at runtime.

Inspect compiled machine code for functions (implementation-dependent detail).

Measuring time/allocation hot spots for optimization.

Frequent temporary object creation causing GC overhead.

Reuse structures, destructive ops carefully, better algorithms, declarations.

Adjust implementation-specific GC parameters for workload.

Entries can disappear when keys/values are no longer strongly referenced.

Cache function results (often hash table keyed by args).

Domain-specific language built naturally with macros and reader extensions.

Deciding what computations happen during macro expansion vs runtime.

Data-driven design, small composable functions, macros for abstractions, interactive development.

Keep macro surface minimal, expand into simple primitives, document expansion contracts, and test macroexpansions.

If a function (or higher-order function) is enough; prefer simpler runtime abstractions first.

Preserve old expansion behavior when possible; provide compatibility layers and deprecation phases.

Confusing compile-time and runtime dependencies can break builds/load order.

Avoid unless necessary; isolate with eval-when and clear module boundaries.

Controls when forms are evaluated: compile-toplevel, load-toplevel, execute.

Incorrect type/safety claims may cause undefined behavior or hard-to-debug bugs.

During development: high debug/safety; production hotspots: higher speed with validated assumptions.

Warm up, avoid measuring compilation, isolate GC effects, run multiple trials, report variance.

Track allocation rate, object lifetimes, heap sizing, and generation behavior of implementation.

Export minimal symbols, keep internals private, provide clear compatibility guarantees.

Use explicit imports, qualified symbols, and avoid overly generic exported names.

Define generic operations and behavioral contracts rather than rigid class trees.

CLOS excels in open extension; ADTs excel in closed exhaustive pattern handling.

Layered ASDF systems, strict package boundaries, integration tests, and development image scripts.

Minimize global mutable state, version migrations for object slots, and controlled restart workflows.

Existing instances require updates; slot changes may need migration logic.

Use generic functions, registries, packages, and capability-based protocols.

Preserve source locations where possible, keep expansions readable, provide macroexpand tooling.

Use sparingly; prefer plain macros unless syntax gain clearly outweighs tooling/readability costs.

Define clear service boundaries (RPC/HTTP/message bus), stable schemas, and observability hooks.

They enable interactive or programmatic recovery strategies without full failure teardown.

Create specific condition types for actionable handling; avoid overly generic error signaling.

Review declarations, type assumptions, destructive updates, and implementation-specific dependencies.

Stick to ANSI CL + portability libs; isolate implementation-specific code paths.

Test at three levels: expansion shape, runtime behavior, and integration semantics.

Document both user-facing forms and generated runtime contracts/invariants.

Profile first, optimize hottest 5%, verify with benchmarks, re-check correctness invariants.

Strong macro discipline, runtime insight, architectural clarity, and pragmatic simplicity.

Build real systems, read great Lisp code, inspect expansions, and iterate interactively with rigor.