Clojure Programming Language Cheat Sheet

Updated 2026-05-16

Next Topic: Compilers and Interpreters Fundamentals Cheat Sheet

🧠Study flashcards on this topic180 cards · spaced repetition→

Clojure is a modern functional Lisp dialect that runs on the Java Virtual Machine, JavaScript engines (ClojureScript), and the .NET CLR. Unlike traditional object-oriented languages, Clojure treats immutable, persistent data structures as first-class citizens and provides powerful concurrency primitives that eliminate the need for explicit locking. The language embraces a REPL-driven development workflow where code is iteratively built and tested in a live environment, dramatically shortening the feedback loop. One key mental model: in Clojure, functions compose data transformations rather than mutating state—this shift from "place-oriented programming" to "value-oriented programming" makes parallel execution safe by default and greatly simplifies reasoning about program behavior.

What This Cheat Sheet Covers

This topic spans 29 focused tables and 259 indexed concepts, 180 flashcards. Below is a complete table-by-table outline of this topic, spanning foundational concepts through advanced details.

Table 1: Core Data StructuresTable 2: Collection OperationsTable 3: Higher-Order FunctionsTable 4: Sequences and Lazy EvaluationTable 5: DestructuringTable 6: Functions and Anonymous FunctionsTable 7: Macros and MetaprogrammingTable 8: Threading MacrosTable 9: Control FlowTable 10: Recursion and LoopingTable 11: State ManagementTable 12: Concurrency with core.asyncTable 13: Multimethods and ProtocolsTable 14: Java InteroperabilityTable 15: Namespaces and DependenciesTable 16: Reduce and TransducersTable 17: Sequence OperationsTable 18: String OperationsTable 19: Testing with clojure.testTable 20: Error HandlingTable 21: Regular ExpressionsTable 22: Type Checking and PredicatesTable 23: MetadataTable 24: clojure.specTable 25: REPL and DevelopmentTable 26: Compilation and PerformanceTable 27: ZippersTable 28: ClojureScript SpecificsTable 29: Tools and Build

Quick IndexSubscribe to unlock

A jump-to index of every table row in this cheat sheet.

Mind MapSubscribe to unlock

An interactive map of every table and concept in this topic.

Table 1: Core Data Structures

These are the literal building blocks you'll reach for constantly — vectors, lists, maps, and sets each have their own reader syntax (the [ ], ' ( ), { }, #{ } notations) and a distinct performance profile. Keywords and symbols round out the set: keywords are the idiomatic map keys and enum-like values, while symbols name the vars and functions your code refers to.

Structure	Example	Description
Vector	`[1 2 3]` `(vector 1 2 3)`	• Indexed collection with fast random access at any position • conj adds to end.
List	`'(1 2 3)` `(list 1 2 3)`	• Linked list optimized for sequential access from head • conj adds to front.
Map	`{:a 1 :b 2}` `(hash-map :a 1 :b 2)`	• Key-value pairs with fast lookup • keys are typically keywords
Set	`#{1 2 3}` `(hash-set 1 2 3)`	Unordered collection of unique values with fast membership testing.
Keyword	`:name` `::local-keyword`	• Self-evaluating identifier commonly used as map keys and enums • fast equality checks
Symbol	`'my-var` `user/my-fn`	• Names that refer to vars or functions • typically require quoting to prevent evaluation

Table 2: Collection Operations

Because Clojure's collections are immutable, none of these functions mutate in place — each returns a brand-new collection sharing structure with the old one. The map-focused operations (assoc, update, merge, and their -in cousins) are the workhorses for transforming data, and the nested-path variants let you reach deep into a structure without unpacking it by hand.

Function	Example	Description
conj	`(conj [1 2] 3)` → `[1 2 3]` `(conj '(1 2) 3)` → `(3 1 2)`	Adds element to collection in most efficient position (end for vectors, front for lists).

The rest of this section is part of the full cheat sheet

Table 3: Higher-Order Functions

Functions that take or return other functions are the heart of functional Clojure, and map/filter/reduce form the core toolkit for transforming sequences without explicit loops. The rest — partial, comp, juxt, complement — let you build new functions out of existing ones, so you can describe a computation as a composition rather than a procedure.

Function	Example	Description
map	`(map inc [1 2 3])` → `(2 3 4)`	Applies function to each element and returns lazy sequence of results.

The rest of this section is part of the full cheat sheet

Table 4: Sequences and Lazy Evaluation

Laziness lets you describe sequences — even infinite ones like (range) or (cycle [1 2]) — without computing anything until a value is actually needed. The take/drop family pulls finite slices out of those potentially endless sequences, while doall and dorun are the escape hatch for forcing evaluation when you actually want the side effects to fire.

Function	Example	Description
lazy-seq	`(lazy-seq (cons 1 (lazy-seq (cons 2 nil))))`	Creates lazy sequence whose elements are computed only when accessed.

The rest of this section is part of the full cheat sheet

Table 1: Core Data Structures

Structure	Example	Description
Vector	`[1 2 3]` `(vector 1 2 3)`	• Indexed collection with fast random access at any position • conj adds to end.
List	`'(1 2 3)` `(list 1 2 3)`	• Linked list optimized for sequential access from head • conj adds to front.
Map	`{:a 1 :b 2}` `(hash-map :a 1 :b 2)`	• Key-value pairs with fast lookup • keys are typically keywords
Set	`#{1 2 3}` `(hash-set 1 2 3)`	Unordered collection of unique values with fast membership testing.
Keyword	`:name` `::local-keyword`	• Self-evaluating identifier commonly used as map keys and enums • fast equality checks
Symbol	`'my-var` `user/my-fn`	• Names that refer to vars or functions • typically require quoting to prevent evaluation

Table 2: Collection Operations

Function	Example	Description
conj	`(conj [1 2] 3)` → `[1 2 3]` `(conj '(1 2) 3)` → `(3 1 2)`	Adds element to collection in most efficient position (end for vectors, front for lists).

Table 3: Higher-Order Functions

Function	Example	Description
map	`(map inc [1 2 3])` → `(2 3 4)`	Applies function to each element and returns lazy sequence of results.

Table 4: Sequences and Lazy Evaluation

Function	Example	Description
lazy-seq	`(lazy-seq (cons 1 (lazy-seq (cons 2 nil))))`	Creates lazy sequence whose elements are computed only when accessed.