Functional Programming Fundamentals in Kotlin with Arrow
In this intensive course, we’ll cover Functional Programming essentials in Kotlin over four days / 16-hrs. By the end of this course, you will have a solid grasp on the Fundamentals of the language.
Lesson 1: Functional Programming
Functional programming essentials.
- Fundamentals of FP. What is it, what is it good for.
- Purity, referential transparency, substitution model.
- Side effects.
- Higher order functions.
Lesson 2: Domain Modeling and ADTs
Modeling your program’s data through the concept of Algebraic Data Types.
- Kotlin type system and its impact on how compiler understands code.
- Algebraic Data Types.
- Modeling program choices by ADTs.
- The Nothing bottom type and inference.
- Kotlin standard library product types.
- Arrow product and sum types.
- Arrow Coproducts.
- Arrow Union types (powered by Arrow Meta).
- Refined types (powered by Arrow Meta).
Lesson 3: Immutable Data and Optics
How to optimize reusability and composition for immutable data structures using Optics.
- Understanding optics as a path for reading / modification.
- How optics improve Kotlin standard library copy syntax.
- Going over all the available types of optics.
- Optics composition and reusability.
Lesson 4: Error-Handling and Data Validation
Learning how to handle errors in our programs.
- Option datatype.
- Either datatype.
- Computational bias: Having a happy path in our types.
- Fail fast vs error accumulation strategies.
- ValidatedNel as a mean to accumulate errors.
- How to handle errors on concurrent contexts? 👇
Lesson 5: Diving into Suspend
suspendfrom Kotlin stdlib, what it represents, how it works.
- What does
suspendtranslate to at compile time (CPS).
- How we leverage that with Arrow Fx Coroutines.
- The power of delimited continuations, “the mother of all monads”.
- Equivalence between wrapped approaches and Kotlin suspend.
- Removing the need for IO wrappers.
suspendas a mean to track side effects at compile time.
Lesson 6: Arrow Fx Coroutines
- A pure functional implementation of Kotlin
- Handling errors in concurrent contexts by leveraging
- Concurrency solved by Arrow Fx Coroutines operators.
- Collaborative cancellation checked by all operators.
- Cancellable effects.
- Evaluating effects on arbitrary contexts.
- Fibers as lightweight threads: ForkAndForget / ForkConnected / ForkScoped.
- Concurrent resource safety.
- Handling concurrent mutable state.
- parallelization operators.
- Traversing effects.
- Racing effects.
- Reusable and highly composable retry & repeat strategies.
Lesson 7: Resource Safety
Lesson 8: Functional Streams
- Lightweight streams.
- Pull based - key differences vs other known streaming libraries.
- Built-in backpressure.
- Chunk based streams.
- Embedded effects.
- Stream interruption.
- Lightweight stream apis.
- Safely streaming resources with automatic scoping.