Functional Programming

  1. Functional Architecture and Design
    1. Handling Side Effects
      1. Isolating Impurity
        1. The Functional Core, Imperative Shell Pattern
          1. Encapsulating Effects with Monads
            1. Effect Systems
              1. Dependency Injection Patterns
              2. Error and Exception Handling
                1. Using Maybe Types
                  1. Using Either Types
                    1. Composing Error-Handling Functions
                      1. Recovering from Errors
                        1. Error Accumulation
                          1. Validation Patterns
                          2. Asynchronous Operations
                            1. Futures and Promises as Functional Constructs
                              1. Composing Asynchronous Computations
                                1. Error Handling in Asynchronous Contexts
                                  1. Async Monads
                                    1. Reactive Programming Patterns
                                    2. State Management
                                      1. Passing State Explicitly
                                        1. Using the State Monad
                                          1. Modeling State Transitions
                                            1. Immutable State Updates
                                              1. Event Sourcing
                                                1. CQRS Patterns
                                                2. Concurrency and Parallelism
                                                  1. Statelessness and Thread Safety
                                                    1. Data Parallelism
                                                      1. Functional Patterns for Concurrency
                                                        1. Map-Reduce
                                                          1. Pipelines
                                                            1. Actors and Message Passing
                                                              1. Software Transactional Memory
                                                              2. Lock-Free Data Structures
                                                                1. Parallel Collection Operations
                                                                2. Modularization and Code Organization
                                                                  1. Pure Functions and Module Boundaries
                                                                    1. Dependency Injection via Functions
                                                                      1. Layered Architectures
                                                                        1. Hexagonal Architecture
                                                                          1. Domain-Driven Design with Functional Programming
                                                                            1. Module Systems
                                                                            2. Domain Modeling
                                                                              1. Making Illegal States Unrepresentable
                                                                                1. Type-Driven Development
                                                                                  1. Domain-Specific Languages
                                                                                    1. Algebraic Data Types for Domain Modeling

                                                                                  Previous

                                                                                  5. Advanced Functional Abstractions

                                                                                  Go to top

                                                                                  Next

                                                                                  7. Functional Programming in Practice