1.4. Why Clojure isn’t especially object-oriented
Chapter 2. Drinking from the Clojure fire hose
2.1. Scalars: the base data types
2.2. Putting things together: collections
2.3. Making things happen: calling functions
2.5.2. Creating named functions with def and defn
2.6. Locals, loops, and blocks
2.7. Preventing things from happening: quoting
2.8. Using host libraries via interop
2.8.1. Accessing static class members (Clojure only)
2.8.3. Accessing instance members with the . operator
2.9. Exceptional circumstances
2.10. Modularizing code with namespaces
2.10.1. Creating namespaces using ns
2.10.2. Loading other namespaces with :require
2.10.3. Loading and creating mappings with :refer
Chapter 3. Dipping your toes in the pool
3.3.1. Your assignment, should you choose to accept it
3.3.2. Destructuring with a vector
3.3.3. Destructuring with a map
3.4. Using the REPL to experiment
3.4.1. Experimenting with seqs
3.4.2. Experimenting with graphics
4.5. Regular expressions—the second problem
5.1. Persistence, sequences, and complexity
5.1.1. “You keep using that word. I do not think it means what you think it means.”
5.2. Vectors: creating and using them in all their varieties
5.3. Lists: Clojure’s code-form data structure
5.4. How to use persistent queues
5.5.1. Basic properties of Clojure sets
5.7. Putting it all together: finding the position of items in a sequence
3. Functional programming techniques
Chapter 6. Being lazy and set in your ways
6.1. On immutability: being set in your ways
6.2. Structural sharing: a persistent toy
6.3.1. Familiar laziness with logical-and
6.3.2. Understanding the lazy-seq recipe
6.4. Putting it all together: a lazy quicksort
Chapter 7. Functional programming
7.1. Functions in all their forms
7.2.1. Functions returning closures
7.2.2. Closing over parameters
7.4. Putting it all together: A* pathfinding
8.2. Defining control structures
8.2.1. Defining control structures without syntax-quote
8.2.2. Defining control structures using syntax-quote and unquoting
8.4. Using macros to change forms
8.5. Using macros to control symbolic resolution time
8.6. Using macros to manage resources
Chapter 9. Combining data and code
9.2. Exploring Clojure multimethods with the Universal Design Pattern
9.2.2. Basic use of the Universal Design Pattern
9.2.3. Multimethods to the rescue
9.2.4. Ad hoc hierarchies for inherited behaviors
9.3. Types, protocols, and records
9.4. Putting it all together: a fluent builder for chess moves
Chapter 10. Mutation and concurrency
10.1.1. Using refs for a mutable game board
10.2.1. Fixing the game board example
10.2.2. Commutative change with commute
10.3.1. In-process vs. distributed concurrency models
10.3.2. Controlling I/O with an agent
10.6. Vars and dynamic binding
11.2.1. Parallel tasks with promises
12.1. Generating objects on the fly with proxy
12.2. Clojure gen-class and GUI programming
12.2.1. Namespaces as class specifications
12.2.2. The guts of namespace compilation
12.2.3. Exploring user interface design and development with Clojure
12.3. Clojure’s relationship to Java arrays
12.3.1. Types of arrays: primitive and reference
12.3.3. Arrays’ unfortunate naming convention
12.4. All Clojure functions implement ...
12.4.1. The java.util.Comparator interface
12.5. Using Clojure data structures in Java APIs
12.5.1. The java.util.List interface
12.5.2. The java.lang.Comparable interface
12.5.3. The java.util.RandomAccess interface
12.7.1. A bit of background regarding exceptions
Chapter 13. Why ClojureScript?
13.1. Implementation vs. interface
13.2. Compiler internals: analysis vs. emission
Chapter 14. Data-oriented programming
14.1. Code as code, and data as data
14.3.1. The data-programmable engine
15.1.1. Advantages of type adornment
15.2.2. Transients compare in efficiency to mutable collections
15.4.1. Reexamining memoization
15.6.1. An example reducible collection
15.6.2. Deriving your first reducing function transformer
15.6.3. More reducing function transformers
15.6.4. Reducible transformers
15.6.5. Performance of reducibles
15.6.6. Drawbacks of reducibles
16.2. Thinking data via unification
16.3. An introduction to core.logic
16.4.1. An introduction to constraint programming
Chapter 17. Clojure changes the way you think
17.3. Invisible design patterns
17.4. Error handling and debugging