Lisp

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.

, insrts value; ,@ splices list elements.

Resultig code after macro transforms input.

Exampl: #+beginsrc lisp (macroepand-1 '(when-not x (print "hi"))) #+end_sc

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

Use gesym for unique temporary symbols.

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

Optiona source transformations for function calls to optimize compiled code.

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

Can impove DSL syntax but reduce readability/tool compatibility.

Evaluats Lisp form at runtime in dynamic environment contexts.

Harder easoning, security/performance/debugging costs.

Functio capturing lexical variables from defining environment.

Exampl: #+beginsrc lisp (defun ake-counter () (let (n 0)) (labda () (incf n)))) #+end_sc

Binding visible where function/macro is defined.

Runtimecontext for special variables, handlers, restarts.

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

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

Tagged on-local control transfer constructs.

Named lxical exit points.

Low-levl goto-like flow constructs.

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

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

Can updte behavior interactively in running image.

Long-lived Lisp process where definitions are incrementally reloaded.

Compiled Lisp binary artifacts loaded faster than source.

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

Compilig modules independently with clear package interfaces.

Mechanim to call C/native libraries from Lisp.

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

Arbitrry-precision integers built into Common Lisp numeric tower.

Hierarhy: integers, rationals, reals, complex numbers.

Exact ational arithmetic avoids floating-point rounding where possible.

Use cerce or numeric contagion rules in operations.

Readersyntax configuration tables.

Structred formatted output via printer control and pprint facilities.

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

Inspecing/modifying program structure/behavior at runtime.

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

Measurng time/allocation hot spots for optimization.

Frequet temporary object creation causing GC overhead.

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

Adjustimplementation-specific GC parameters for workload.

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

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

Domainspecific language built naturally with macros and reader extensions.

Decidig what computations happen during macro expansion vs runtime.

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

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

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

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

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

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

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

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

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

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

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

Exportminimal symbols, keep internals private, provide clear compatibility guarantees.

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

Definegeneric operations and behavioral contracts rather than rigid class trees.

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

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

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

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

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

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

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

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

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

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

Reviewdeclarations, type assumptions, destructive updates, and implementation-specific dependencies.

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

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

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

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

Strongmacro discipline, runtime insight, architectural clarity, and pragmatic simplicity.

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