Scala Cookbook Recipes for Object-Oriented and Functional Programming (Alvin Alexander) (Z-Library)

【One-Line Pitch】 A problem-first recipe collection for writing real Scala 3 code, from string handling and collections to concurrency and type-level design. Best for working developers who already know another language and want solutions they can adapt today, not a from-scratch tutorial. 【Book Arc】 - **Opening (~0%–10%)**: Sets the cookbook contract—250+ recipes, 1,000+ examples—and starts with command-line tasks, inspecting compiled bytecode with `javap`, and everyday string work like multiline strings and regex matching. - **Early (~10%–30%)**: Core language mechanics: numbers and dates (including `BigDecimal` precision traps), control structures, `for/yield` comprehensions, pattern matching, and functional error handling with `Option`, `Try`, and `Either`. - **Middle (~30%–50%)**: Object-oriented domain modeling: classes, constructor parameters, access modifiers, traits and enums, objects, companion objects, `apply`/`unapply`, and extractors for match expressions. - **Late (~50%–80%)**: Functional programming techniques, the collections library, and building/publishing with sbt—the excerpts do not cover these chapters in detail. - **Ending (~80%–100%)**: Concurrency with `Future` and Akka Typed, plus ecosystem libraries (Spark, Scala.js, Play, GraalVM) and advanced types such as variance, givens, intersections, and unions—again, excerpts do not cover these directly. 【Key Takeaways】 - **It is a cookbook, not a tutorial** (Opening): Each recipe is framed as Problem → Solution → Discussion, so you can jump straight to the task at hand rather than reading linearly. - **Scala 3 is the target** (Opening): The book explicitly covers Scala 3, including newer features like parameterized traits and given/union/intersection types, so older Scala 2 advice may not transfer cleanly. - **Precision matters with numbers** (Early): `Double` arithmetic produces artifacts like `0.10 + 0.20 = 0.30000000000000004`; the book recommends `BigDecimal` with string constructors for monetary work. - **Prefer values over exceptions** (Early): The "Scala way" is to return `Option`, `Try/Success/Failure`, or `Either/Right/Left` instead of throwing, because `Try` and `Either` preserve failure messages that `Option` discards. - **Comprehensions are the idiomatic loop** (Early): `for/yield` builds new collections from existing ones and is the preferred alternative to imperative loops for mapping and filtering. - **Pattern matching is a first-class design tool** (Early–Middle): It appears in control flow, exception handling, and—via `unapply`—as a way to make your own classes deconstructible in `match` expressions. - **Companion objects carry the static side** (Middle): `apply` methods act as factory constructors, and `unapply` methods turn classes into extractors; case classes generate this machinery automatically. - **Traits are the primary composition unit** (Middle): With Scala 3 allowing trait parameters, the choice between traits and abstract classes hinges on multiple inheritance versus single-extends constraints. 【Reading Tips】 - **Skim the opening chapters if you are experienced**: String and number recipes are quick reference material; deep-read the `BigDecimal`, date-parsing, and error-handling discussions where subtle bugs live. - **Deep-read the OOP and pattern-matching chapters**: The `apply`/`unapply`, companion object, and trait conflict-resolution recipes are the conceptual core that later functional and concurrency chapters build on. - **Treat it as a lookup book**: When you hit a concrete problem—splitting a CSV line, parsing a date format, resolving a trait member conflict—go to the relevant recipe rather than reading cover to cover. - **Watch for Scala 2 vs. Scala 3 differences**: The book notes that package objects are deprecated after Scala 3.0; be alert to similar migration notes when adapting older code. - **Follow the "See Also" cross-references**: Recipes deliberately point to related recipes (e.g., case class internals, factory patterns), which is where the book's coherence actually lives. 【Coverage Limits】 The excerpts sampled here concentrate on the opening through middle chapters (strings, numbers, control structures, classes, traits, objects); the functional programming, collections, sbt, concurrency, and library chapters are named in the table of contents but not covered in detail, so this guide's later-arc claims rest on the book's own summary rather than sampled content.