What You Need
Book Source Code & Forums
Dedications
About the Team
About the Author
About the Editors
Introduction
How to read this book
Chapter 1: Why Functional Programming
Using a declarative approach
Higher-order functions
Composition
Pure functions and testability
Exception handling
Key points
Where to go from here?
Chapter 2: Function Fundamentals
What is a function?
Introduction to category theory
Category and logic
Initial and terminal objects
Category of types and functions
Do types and functions define a category?
Initial and terminal objects
Types and sets
Function types
Challenges
Key points
Where to go from here?
Chapter 3: Functional Programming Concepts
Pure functions
Why are pure functions important?
Referential transparency and the substitution model
Side effects
Challenges
Key points
Where to go from here?
Chapter 4: Expression Evaluation, Laziness & More About Functions
Expression evaluation order
Understanding lambda expressions
Lazy evaluation
Memoization
Create a lazy stream with Kotlin
Normal-order evaluation
Challenges
Key points
Where to go from here?
Chapter 5: Higher-Order Functions
Imperative vs. declarative approach
Higher-order functions
Functional interfaces
Using lambda expressions as input and output
Challenges
Key points
Where to go from here?
Chapter 6: Immutability & Recursion
Immutability
Immutability advantages
The price of immutability
Immutability and functional programming
Immutability and recursion
Challenges
Key points
Where to go from here?
Chapter 7: Functional Data Structures
Immutable data structure
Mutators
Why FList is a persistent data structure
Challenges
Key points
Where to go from here?
Chapter 8: Composition
Composition in Kotlin
Partial application
Compose functions with side effects
Compose mutation
Challenges
Key points
Where to go from here?
Chapter 9: Data Types
What is a data type?
The Optional data type
The List data type
What about FList?
The Either data type
Challenges
Key points
Where to go from here?
Chapter 10: Algebraic Data Types
What is algebra?
Data types and multiplication
Data types and addition
Putting algebra to work
Other algebraic properties
Fun with exponents
Using algebra with the List type
Key points
Where to go from here?
Chapter 11: Functors
What is a functor?
Functors in programming
Functor laws
The FList and List functors
Bifunctors
Typeclasses
Key points
Where to go from here?
Chapter 12: Monoids & Semigroups
What is a monoid?
Property-based testing
Monoids and foldable types
Monoids and category theory
The semigroup typeclass
Key points
Where to go from here?
Chapter 13: Understanding Monads
The road to monads!
A pragmatic definition of monad
Why monads?
Key points
Where to go from here?
Chapter 14: Error Handling With Functional Programming
Exception handling
Handling exception strategies
Applicative functor
The Kotlin Result data type
Meet the RayTV app
Key points
Where to go from here?
Chapter 15: Managing State
The problem
A practical example
Key points
Where to go from here?
Chapter 16: Handling Side Effects
From State to IO
The IO monad
The meaning of IO
Key points
Where to go from here?
Chapter 17: Sequence & Flow
The Sequence data type
The Flow data type
The SharedFlow & StateFlow data types
Key points
Where to go from here?
Chapter 18: Mobius β A Functional Reactive Framework
Mobius principles and concepts
The Mobius workflow
Build your app
Mobius loop in Android
Key points
Where to go from here?
Chapter 19: Arrow
Exceptions as side effects
Arrow optics
Arrow lenses
Key points
Where to go from here?
Conclusion
Appendix A: Chapter 1 Exercise Solutions
Exercise 1.1
Exercise 1.2
Appendix B: Chapter 2 Exercise & Challenge Solutions
Exercise 2.1
Exercise 2.2
Exercise 2.3
Exercise 2.4
Exercise 2.5
Challenge 1: Functions and sets
Challenge 2: Functions and set again
Challenge 3: The right domain
Appendix C: Chapter 3 Exercise & Challenge Solutions
Exercise 3.1
Exercise 3.2
Exercise 3.3
Exercise 3.4
Exercise 3.5
Challenge 1: Pure or impure?
Challenge 2: Pure or impure?
Challenge 3: Pure or impure?
Appendix D: Chapter 4 Exercise & Challenge Solutions
Exercise 4.1
Exercise 4.2
Exercise 4.3
Exercise 4.4
Exercise 4.5
Exercise 4.6
Challenge 4.1
Challenge 4.2
Appendix E: Chapter 5 Exercise & Challenge Solutions
Exercise 5.1
Exercise 5.2
Exercise 5.3
Exercise 5.4
Exercise 5.5
Challenge 5.1: Mapping is important
Challenge 5.2: Prime number filtering
Appendix F: Chapter 6 Exercise & Challenge Solutions
Exercise 6.1
Exercise 6.2
Exercise 6.3
Exercise 6.4
Challenge 6.1: Immutability and recursion
Challenge 6.2: Tail-recursive Fibonacci
Appendix G: Chapter 7 Exercise & Challenge Solutions
Exercise 7.1
Exercise 7.2
Exercise 7.3
Exercise 7.4
Exercise 7.5
Exercise 7.6
Exercise 7.7
Challenge 7.1
Challenge 7.2
Challenge 7.3
Appendix H: Chapter 8 Exercise & Challenge Solutions
Exercise 8.1
Exercise 8.2
Exercise 8.3
Exercise 8.4
Challenge 1: Callable stuff
Challenge 2: Parameters or not parameters?
Appendix I: Chapter 9 Exercise & Challenge Solutions
Exercise 9.1
Exercise 9.2
Exercise 9.3
Exercise 9.4
Exercise 9.5
Challenge 9.1: Filtering
Challenge 9.2
Challenge 9.3: Average
Challenge 9.4: Last
Appendix J: Chapter 10 Exercise Solutions
Exercise 10.1
Exercise 10.2
Exercise 10.3
Appendix K: Chapter 12 Exercise Solutions
Exercise 12.1
Exercise 12.2
Exercise 12.3
Exercise 12.4
Exercise 12.5
Appendix L: Chapter 13 Exercise Solutions
Exercise 13.1
Exercise 13.2
Appendix M: Chapter 14 Exercise Solutions
Exercise 14.1
Exercise 14.2