Functional Kotlin

Introduction

1. Who is this book for?
2. What will be covered?
3. The Kotlin for Developers series
4. Conventions
5. Code conventions
6. Exercises and solutions
7. Acknowledgments

Introduction to functional programming with Kotlin

1. Why do we need to use functions as objects?

Function types

1. Defining function types
2. Using function types
3. Named parameters
4. Type aliases
5. A function type is an interface

Anonymous functions

Lambda expressions

1. Tricky braces
2. Parameters
3. Trailing lambdas
4. Result values
5. Lambda expression examples
6. An implicit name for a single parameter
7. Closures
8. Lambda expressions vs anonymous functions
9. Exercise: Function types and literals
10. Exercise: Observable value

Function references

1. Top-level functions references
2. Method references
3. Extension function references
4. Method references and generic types
5. Bounded function references
6. Constructor references
7. Bounded object declaration references
8. Function overloading and references
9. Property references
10. Exercise: Inferred function types
11. Exercise: Function references

SAM Interface support in Kotlin

1. Support for Java SAM interfaces in Kotlin
2. Functional interfaces

Inline functions

1. Inline functions
2. Inline functions with functional parameters
3. Non-local return
4. Crossinline and noinline
5. Reified type parameters
6. Inline properties
7. Costs of the inline modifier
8. Using inline functions
9. Exercise: Inline functions

Collection processing

1. forEach and onEach
2. filter
3. map
4. mapNotNull
5. flatMap
6. Exercise: Implement map
7. Exercise: Optimize collection processing
8. fold
9. reduce
10. sum
11. withIndex and indexed variants
12. take, takeLast, drop, dropLast and subList
13. Exercise: Adding element at position
14. Getting elements at certain positions
15. Finding an element
16. Counting elements
17. any, all and none
18. Exercise: Implement shop functions
19. partition
20. groupBy
21. Associating to a map
22. distinct and distinctBy
23. Exercise: Prime access list
24. Sorting: sorted, sortedBy and sortedWith
25. Sorting mutable collections
26. Maximum and minimum
27. shuffled and random
28. Exercise: Top articles
29. Exercise: Refactor collection processing
30. zip and zipWithNext
31. Windowing
32. joinToString
33. Map, Set and String processing
34. Exercise: Passing students list
35. Exercise: Best students list
36. Exercise: Functional Quick Sort
37. Exercise: Powerset
38. Exercise: All possible partitions of a set

Sequences

1. What is a sequence?
2. Order is important
3. Sequences do the minimum number of operations
4. Sequences can be infinite
5. Sequences do not create collections at every processing step
6. When aren’t sequences faster?
7. What about Java streams?
8. Kotlin Sequence debugging
9. Summary
10. Exercise: Understanding sequences

Type Safe DSL Builders

1. A function type with a receiver
2. Simple DSL builders
3. Using apply
4. Simple DSL-like builders
5. Multi-level DSLs
6. DslMarker
7. A more complex example
8. When should we use DSLs?
9. Summary
10. Exercise: HTML table DSL
11. Exercise: Creating user table row

Scope functions

1. let
2. also
3. takeIf and takeUnless
4. apply
5. The dangers of careless receiver overloading
6. with
7. run
8. Using scope functions
9. Exercise: Using scope functions
10. Exercise: orThrow

Context parameters

1. Extension function problems
2. Introducing context parameters
3. Use cases
4. Concerns
5. Named context parameters
6. Summary
7. Exercise: Logger

A birds-eye view of Arrow

1. Functions and Arrow Core
2. Testing higher-order functions
3. Error Handling
4. Data Immutability with Arrow Optics

Final words

1. Final Project: UserService

Exercise solutions