Functional programming is getting another on-ramp for Kotlin developers. A new tutorial book from raywenderlich.com walks readers through functional programming fundamentals in Kotlin, from pure functions and immutability to monads and the Arrow library. If you've wanted a structured, chapter-by-chapter path into this programming style, this release targets exactly that audience.
Below, we break down what the book covers, how it connects to tools you already use, and what the Kotlin community's continued interest in functional ideas means for your practice.
Key facts
- The book is organized into three numbered sections plus an appendix of exercise solutions.
- Section I covers functional programming fundamentals, including pure functions, lazy evaluation, higher-order functions, immutability, persistent data structures, and composition.
- Section II dives into data types and typeclasses such as functors, monoids, semigroups, monads, and concepts like currying.
- Section III moves into error handling, state management, IO, Kotlin collections, Mobius, and the Arrow library.
- The appendix provides solutions to the exercises and challenges sprinkled throughout the chapters.
What this book covers
The first seven chapters establish foundational concepts. You get introduced to category theory and how the category of types and functions relates to Kotlin fundamentals, then explore pure functions, referential transparency, the substitution model, side effects, lazy evaluation with lambda expressions, immutability, recursion, and persistent data structures like singly linked lists. Composition closes the section.
The next five chapters focus on data types and typeclasses. Familiar containers like List and Optional get recast through a functional lens, alongside practical chapters on functors, monoids, semigroups, and monads. The book also covers currying and property-based testing of monoid laws.
The third section puts theory into practice. It walks through exception handling with functional patterns, the State data type for managing side effects, the IO monad for effect control, and how Kotlin's lists, sequences, and flows already follow functional principles. There's also a look at Mobius as a unidirectional flow architecture, plus an introductory chapter on Arrow. An appendix wraps up with exercise solutions.
Who should care
| Your situation | Verdict |
|---|---|
| You write Kotlin daily and ship features | Best fit—you'll connect theory to your codebase |
| You use Flow and coroutines in production | High value, especially the collections chapter |
| You're new to Kotlin or functional programming | Usable, but expect a slow ramp on category theory chapters |
| You primarily write lifecycle screens with simple logic | Low ROI—concepts may feel abstract without anchoring examples |
Our analysis
For Kotlin developers, the timing of structured functional programming resources reflects a broader shift. Kotlin's functional features have matured alongside AI-assisted code generation, making understanding *why* you choose a pattern more valuable, not less. Knowing when to reach for a monad instead of a try-catch block is the kind of judgment that helps you evaluate suggestions rather than accept them blindly.
The core trade-off is upfront investment versus downstream clarity. Category theory adds cognitive load early, but developers already using Flow are already operating in functional territory—the book just formalizes the vocabulary. Arrow and Mobius both have production use cases, so this isn't purely abstract theory.
Who benefits most:** Intermediate Kotlin developers who already ship features. Beginners may find the theory chapters heavy without a production codebase to anchor examples.
Who might skip it:** Developers working primarily on simple lifecycle screens with minimal side effects, where the time investment may not pay off.
What to watch:** Community study groups forming around the book, Arrow and Mobius adoption trends in real Android apps, and whether benchmark comparisons between functional and imperative approaches surface in practice.
What to watch next
Functional programming in Kotlin is now structured enough to fill nineteen chapters and an appendix, and a major tutorial publisher is betting readers will show up. Beyond the book itself, watch for study-group threads on community forums, updated tutorials building on the final chapters, and conference talks translating the typeclass material into Android-specific design patterns.
Bottom line: this is the most structured entry point into functional programming in Kotlin we've seen from a major tutorial publisher. Start with chapter one, work through the substitutions, and let the concepts compound.
Key takeaways
- The book covers nineteen chapters across three numbered sections plus an appendix with exercise solutions.
- It balances theory (category theory, typeclasses, monads) with practical chapters on Arrow, Mobius, and Kotlin's lists, sequences, and flows.
- Beginners should plan for a slow ramp; intermediate Kotlin developers will get the most out of it.
- Even skimmers benefit from the chapter on Kotlin collections and the introductory chapters on Arrow and Mobius.
Frequently asked questions
What is the book about?
It's a tutorial book that teaches functional programming in Kotlin, starting from pure functions and category theory and working up to monads, Arrow, and Mobius.
Do I need to know functional programming already?
No. The first chapters introduce foundational ideas with appropriate sequencing so you can build up from the basics.
Will it help me write better Android apps?
The book ties functional concepts to Android-relevant libraries (Arrow, Mobius) and to Kotlin features you already use, like lists, sequences, and flows, so it can sharpen how you model state and side effects.
How long is the book?
The book has nineteen chapters grouped into three numbered sections plus an appendix that contains solutions to the exercises and challenges.
Is Arrow or Mobius covered?
Yes. Arrow gets an introductory chapter, and Mobius is covered as an implementation of a unidirectional flow architecture.