Clojure Cookbook Recipes for Functional Programming (Luke VanderHart, Ryan Neufeld)（Z-Library）

【One-Line Pitch】 A practical recipe collection for experienced Clojure developers who want ready-to-adapt solutions for everyday JVM programming tasks, from data wrangling to web services and distributed data processing. Best suited to readers who already know Clojure basics and prefer learning by example over theory. 【Book Arc】 - **Opening (~0%–10%)**: Orients you to the book's cookbook format, the Leiningen/lein-try tooling used to run recipes, and the philosophy that Clojure is a "language of libraries" rather than a large standard library. - **Early (~10%–35%)**: Covers primitive data — strings, characters, numbers, dates, and unique IDs — establishing the low-level building blocks you'll reuse throughout. - **Middle (~35%–55%)**: Moves into composite data structures (lists, vectors, sets, maps), their creation, manipulation, comparison, and idiomatic sequence handling. - **Late (~55%–90%)**: Shifts to applied engineering: library authoring and publishing, local system interaction, networking, database access, Ring-based dynamic websites, packaging, profiling, logging, and cloud/distributed data crunching with Cascalog. - **Ending (~90%–100%)**: Closes with testing strategies — unit, Midje, randomized/property-based, browser-based, execution tracing, and core.typed for type checking and Java interop verification. 【Key Takeaways】 - **Clojure favors libraries over built-ins** (Opening): the small standard library is a deliberate design choice, so recipes lean heavily on third-party tools and the `lein-try` plugin to experiment quickly. - **Primitive data handling is more nuanced than it looks** (Early): string splitting, numeric accuracy (rationals vs. doubles), date comparison via `compare`, and UUID generation each carry subtle trade-offs worth internalizing. - **Composite structures have distinct idioms** (Middle): vectors append at the end, sets double as predicates, maps expose `MapEntry` with `key`/`val`, and `merge-with` enables powerful recursive merging. - **Comparison requires care** (Middle): `compare` returns -1/0/1 and works across compatible types, but standard operators coerce numerics — a trap when sorting dates or mixed values. - **The book spans the full application lifecycle** (Late): from authoring and publishing libraries through networking, databases, Ring web apps, packaging, profiling, and logging. - **Distributed data processing is treated as a first-class concern** (Late): Cascalog recipes cover ETL pipelines, aggregation, checkpointing, query explanation, and running jobs on Elastic MapReduce. - **Testing is layered, not monolithic** (Ending): unit tests, Midje, randomized input testing, failure-value discovery, browser tests, tracing, and core.typed each address different confidence needs. - **Type checking is optional but valuable** (Ending): core.typed helps avoid null-pointer exceptions and verify Java interop and higher-order functions without abandoning Clojure's dynamic nature. 【Reading Tips】 - **Skim the Preface and tooling setup** (Opening) once, then keep `lein-try` commands handy — they're the fastest way to run any recipe. - **Deep-read the primitive and composite data chapters** (Early–Middle) even if you think you know them; the discussions explain *why* solutions work, which is where the real learning lives. - **Jump directly to Late chapters** (web, databases, cloud, testing) based on your current project — this is a reference cookbook, not a linear narrative. - **Treat the "Discussion" and "See Also" sections as the highest-value parts** — they connect recipes and reveal adaptation patterns beyond the specific problem. - **Don't expect a tutorial on Clojure syntax** — the book assumes fluency, so pair it with a fundamentals text if you're still new. 【Coverage Limits】 This guide is synthesized from stratified excerpts covering the table of contents, preface, and selected recipes across data structures and testing; the excerpts do not cover the full text of every chapter, so specific recipe details in later chapters (e.g., exact Cascalog or Ring configurations) are summarized at the chapter level rather than recipe-by-recipe.