The Best Functional Programming Books for Scala Developers
Learning functional programming in Scala can feel hard, but a surprising amount of the difficulty is self-inflicted by starting with the wrong books in the wrong order. Trying to learn Scala on an as-needed basis while also learning FP basics can compound both challenges into one prolonged frustration.
The books below are some that Scala developers consistently recommend.
Programming in Scala by Martin Odersky, Lex Spoon, Bill Venners, and Frank Sommers
Programming in Scala, co-written by the creator of Scala (Martin Odersky), gives you a complete tour of the language before being thrown into the deep end of functional programming.
This is helpful because Scala has numerous ways to accomplish the same goal. Without a solid understanding of idiomatic Scala, developers tend to pattern-match against the language they came from, which creates confusion and compounds the difficulty of learning FP. Odersky has world-class FP credentials and presents Scala as a tool with multiple valid uses, which makes this book useful whether you're moving toward pure FP or a more hybrid style.
Read it fully once for the broad picture. You'll re-read chapters later as you go deeper, and they'll hit differently the second time around.
Functional Programming, Simplified by Alvin Alexander
Once you have a general understanding of Scala, Functional Programming, Simplified is a great FP book to start with. It's written for developers new to FP and learn best by seeing code rather than reading theory. Concepts are introduced incrementally and supported with multiple examples before moving on. There's no assumption of prior FP experience or academic background.
Alexander has many tutorials on his website, Learn Scala, and the book has the same teaching style: direct explanations, incremental complexity, and an awareness that readers need to feel progress to stay engaged. There's no assumption that you've spent time in academic FP or that you're comfortable with category theory vocabulary. You're treated as a competent developer who is new to this specific paradigm, which is exactly the right framing.
Effective Haskell by Rebecca Skinner (2023)
The case for including a Haskell book in a Scala reading list is specific: Haskell is a language built entirely around pure functional programming, with no object-oriented escape hatch. Studying FP there forces a completeness of understanding that's easier to sidestep in Scala. Developers who've taken this detour describe it as the thing that made certain concepts finally click, not because of anything Haskell-specific, but because seeing it in its native environment changes how you reason about it.
The goal with Effective Haskell, in our list, isn't to become a Haskell developer. It's to come back to Scala seeing things you couldn't before.
Functional Programming in Scala (The Red Book) by Paul Chiusano and Rúnar Bjarnason
Functional Programming in Scala is the gold standard for Scala FP. Most Scala developers consider it essential reading and working through it changes how you think at a fundamental level. The Red Book doesn't explain pure functional programming; it constructs it in front of you. You don't just read about functional data structures, monads, IO, trampolining, and stream transducers; you build them from scratch, guided by exercises that are central to the experience. Skipping the exercises significantly reduces what you get out of it.
The authors walk through their own design thinking when implementing several functional libraries, which is intentionally exploratory. The consistent advice from developers who've finished the book is to skim that section on the first pass, complete the remaining chapters, then return to it. It reads completely differently once you have the surrounding context.
Functional Programming Strategies by Noel Welsh
Functional Programming Strategies is a new book releasing in 2026 that plans to cover the mental models behind functional programming rather than syntax. It focuses on the kind of thinking that scales from simple functions to complex systems, something most programming books don’t teach directly. This book will explore approaches like "types as constraints" and "following the types" that guide design decisions, not just implementation details. The examples use Scala, so the techniques can be applied immediately to production code, but the strategies themselves are language-agnostic.
The book is currently available as a draft. You can buy it now and receive updates as new versions are published, or join the mailing list to be notified when the final version is released. To check out other books by Noel Welsh, visit his website.
Essential Effects by Adam Rosien
"Effects" is one of those terms that gets thrown around constantly in FP circles but can stay frustratingly abstract until you see it applied with enough depth. Essential Effects fixes that. The book provides a focused, practical treatment of managed effects in Scala. It covers how to represent them, sequence them, and reason about them in a way that holds up in real codebases. Together with Functional Programming Strategies, these two books cover the majority of what you need to write functional Scala in practice.
Practical FP in Scala by Gabriel Volpe
Knowing Scala and knowing Cats is not the same thing as knowing how to build an application with them. This is the gap that Practical FP in Scala covers. It walks through the construction of a real application using the type-level stack, showing how the pieces fit together architecturally. For developers moving into or leading a production FP codebase, this is where theory becomes engineering.
If your work involves event-driven systems or Kafka, Volpe's follow-up Functional Event-Driven Architecture extends the same approach to that context and is worth adding to the list.
Scala for the Impatient by Cay S. Horstmann
Scala for the Impatient is a rapid introduction to Scala for developers who are already competent in another language, like Java, Python, C#, JavaScript, C++, and want to be productive without sitting through explanations of what a variable is.
The format is easily digestible with short pieces of information that work as well for quick reference as they do for a first read. Its coverage is up to date with Scala 3 and focuses on practical language coverage. This book gets Scala syntax out of the way so you can focus on the harder work of learning FP.
The Books We Recommend
Programming in Scala: learn the language from its creator
Functional Programming, Simplified: build FP vocabulary and confidence
Effective Haskell: shift your perspective
Functional Programming in Scala: go deep, do the exercises, expect multiple passes
Functional Programming Strategies: develop the mental models that make everything else click
Essential Effects: bridge theory to the real ecosystem
Practical FP in Scala: learn to architect with it
Scala for the Impatient: reference throughout
Expect the loop. Most developers revisit earlier books after gaining context from later ones and find them substantially richer the second time.
