Preface

Introduction

1. Who This Book Is For
2. How to Use This Book
3. What This Book Is Not
4. A Note on Versions
5. About the Author

Chapter 1: Getting Started

1. Installing Clojure
2. The REPL
3. Creating a New Project
4. The -main Function
5. println — Clojure’s puts
6. String Formatting with str and format
7. Functions
8. Chapter Exercises
9. Summary

Chapter 2: Syntax and Data Literals

1. S-Expressions
2. Numbers
3. Strings and Characters
4. Keywords
5. Symbols
6. Lists
7. Vectors
8. Maps
9. Sets
10. Homoiconicity: Code Is Data
11. Try It Yourself
12. Chapter Exercises
13. Summary

Chapter 3: Immutability and Persistent Data Structures

1. Persistent Data Structures
2. Core Operations
3. Why Immutability Matters
4. Transients: Escape Hatch for Performance
5. Let Bindings
6. Threading Macros
7. Try It Yourself
8. Chapter Exercises
9. Summary

Chapter 4: Functions

1. defn — Named Functions
2. Multi-Arity Functions
3. Variadic Functions
4. Anonymous Functions
5. Higher-Order Functions
6. Closures
7. juxt — Apply Multiple Functions
8. some-fn and every-pred
9. Try It Yourself
10. Chapter Exercises
11. Summary

Chapter 5: Control Flow

1. if and when
2. Truthiness
3. cond — Multi-Way Branching
4. do — Grouping Expressions
5. loop / recur — Iteration Without Mutation
6. for — List Comprehension
7. doseq and dotimes — Side Effects Only
8. some and every? — Existential Checks
9. Try It Yourself
10. Chapter Exercises
11. Summary

Chapter 6: Namespaces and Code Organization

1. ns — The Namespace Declaration
2. :require — Loading Clojure Namespaces
3. Creating a Namespace
4. :import — Java Classes
5. The Classpath
6. require vs use vs refer
7. Reloading Code
8. project.clj vs deps.edn
9. Try It Yourself
10. Chapter Exercises
11. Summary

Chapter 7: Sequences and Laziness

1. The Seq Abstraction
2. map, filter, reduce — The Big Three
3. The Rest of the Toolkit
4. Sequences on Maps
5. Sequences on Strings
6. Lazy Sequences
7. The Threading Macros Revisited
8. Try It Yourself
9. Chapter Exercises
10. Summary

Chapter 8: Destructuring

1. Vector Destructuring
2. Map Destructuring
3. Destructuring in Function Parameters
4. Destructuring in let and loop
5. Destructuring in for
6. Real-World Example: Parsing API Responses
7. Try It Yourself
8. Chapter Exercises
9. Summary

Chapter 9: Java Interop

1. Why Java Interop Matters
2. Calling Methods
3. Creating Objects
4. doto — Mutating a Java Object
5. Static Fields and Enums
6. Type Hints for Performance
7. Arrays
8. Importing Java Classes
9. Real Examples
10. Try It Yourself
11. Chapter Exercises
12. Summary

Chapter 10: Concurrency and State

1. The Identity/Value Separation
2. Atoms — Independent, Synchronous State
3. Refs and Software Transactional Memory (STM)
4. Agents — Asynchronous Updates
5. Vars and Dynamic Binding
6. Futures and Promises
7. core.async — Channels and Go Blocks
8. Choosing the Right Reference Type
9. Try It Yourself
10. Chapter Exercises
11. Summary

Chapter 11: Macros and Metaprogramming

1. Why Macros?
2. Syntax Quoting, Unquote, and Unquote-Splicing
3. Writing Your First Macro
4. Debugging Macros
5. Auto-Gensym for Hygiene
6. Common Macro Patterns
7. When NOT to Use Macros
8. Macros vs Ruby Metaprogramming
9. Try It Yourself
10. Chapter Exercises
11. Summary

Chapter 12: Building a Project

1. The Project: bkmrk
2. Project Setup
3. The Data Model
4. Persistence
5. Command Handling
6. CLI Entry Point
7. Testing
8. Building and Running
9. The REPL-Driven Workflow in Practice
10. Project Structure Recap
11. Try It Yourself
12. Chapter Exercises
13. Summary

Appendix A: Resources

1. Official Documentation
2. Books
3. Online Learning
4. Editor Support
5. Libraries Worth Knowing
6. Community
7. Staying in Touch with Ruby

Appendix B: Exercise Answers

1. Chapter 1: Getting Started
2. Chapter 2: Syntax and Data Literals
3. Chapter 3: Immutability and Persistent Data Structures
4. Chapter 4: Functions
5. Chapter 5: Control Flow
6. Chapter 6: Namespaces and Code Organization
7. Chapter 7: Sequences and Laziness
8. Chapter 8: Destructuring
9. Chapter 9: Java Interop
10. Chapter 10: Concurrency and State
11. Chapter 11: Macros and Metaprogramming
12. Chapter 12: Building a Project

Glossary

Acknowledgements

Credits