Functional Programming

  1. Advanced Functional Abstractions
    1. Functors
      1. The Concept of Mapping over a Context
        1. The map Function
          1. Functor Laws
            1. Identity Law
              1. Composition Law
              2. Practical Examples
                1. List Functor
                  1. Maybe Functor
                    1. Function Functor
                    2. Contravariant Functors
                      1. Bifunctors
                      2. Applicative Functors
                        1. Applying Functions within a Context
                          1. The apply Function
                            1. Applicative Laws
                              1. Identity
                                1. Homomorphism
                                  1. Interchange
                                    1. Composition
                                    2. Practical Examples
                                      1. Applicative vs. Monad
                                        1. Applicative Parsing
                                        2. Monoids
                                          1. Definition
                                            1. Associativity
                                              1. Identity Element
                                              2. Monoid Laws
                                                1. Associativity Law
                                                  1. Identity Laws
                                                  2. Combining Values
                                                    1. Practical Examples
                                                      1. String Concatenation
                                                        1. List Concatenation
                                                          1. Numeric Addition
                                                            1. Numeric Multiplication
                                                            2. Free Monoids
                                                              1. Commutative Monoids
                                                              2. Semigroups
                                                                1. Definition and Properties
                                                                  1. Relationship to Monoids
                                                                    1. Non-Empty Data Structures
                                                                    2. Monads
                                                                      1. Sequencing Computations in a Context
                                                                        1. The bind Function
                                                                          1. The return Function
                                                                            1. Monad Laws
                                                                              1. Left Identity
                                                                                1. Right Identity
                                                                                  1. Associativity
                                                                                  2. Common Monads
                                                                                    1. Maybe Monad
                                                                                      1. Handling Absence of Value
                                                                                        1. Chaining Computations
                                                                                          1. Avoiding Null Pointer Exceptions
                                                                                          2. Either Monad
                                                                                            1. Handling Errors
                                                                                              1. Error Propagation
                                                                                                1. Short-Circuiting on Failure
                                                                                                2. List Monad
                                                                                                  1. Non-deterministic Computations
                                                                                                    1. Cartesian Products
                                                                                                    2. State Monad
                                                                                                      1. Managing State
                                                                                                        1. Threading State through Computations
                                                                                                          1. Stateful Computations
                                                                                                          2. Reader Monad
                                                                                                            1. Dependency Injection
                                                                                                              1. Accessing Shared Environment
                                                                                                                1. Configuration Management
                                                                                                                2. Writer Monad
                                                                                                                  1. Logging
                                                                                                                    1. Accumulating Output
                                                                                                                      1. Audit Trails
                                                                                                                      2. IO Monad
                                                                                                                        1. Managing Side Effects
                                                                                                                          1. Sequencing IO Actions
                                                                                                                            1. Referential Transparency with Effects
                                                                                                                          2. Monad Transformers
                                                                                                                            1. Stacking Monads
                                                                                                                              1. Common Transformer Patterns
                                                                                                                                1. Practical Use Cases
                                                                                                                                  1. Lifting Operations
                                                                                                                                  2. Do Notation
                                                                                                                                    1. Monad Comprehensions
                                                                                                                                    2. Other Abstractions
                                                                                                                                      1. Foldables
                                                                                                                                        1. Folding over Structures
                                                                                                                                          1. Left vs. Right Folds
                                                                                                                                            1. Monadic Folds
                                                                                                                                            2. Traversables
                                                                                                                                              1. Traversing with Effects
                                                                                                                                                1. Sequence and Traverse
                                                                                                                                                  1. Applicative Traversals
                                                                                                                                                  2. Lenses and Optics
                                                                                                                                                    1. Accessing Nested Data
                                                                                                                                                      1. Immutable Updates
                                                                                                                                                        1. Composing Lenses
                                                                                                                                                          1. Prisms and Isos
                                                                                                                                                          2. Arrows
                                                                                                                                                            1. Generalizing Functions
                                                                                                                                                              1. Arrow Laws
                                                                                                                                                                1. Arrow Notation
                                                                                                                                                                2. Comonads
                                                                                                                                                                  1. Dual of Monads
                                                                                                                                                                    1. Extract and Extend
                                                                                                                                                                      1. Context-Dependent Computations

                                                                                                                                                                  Previous

                                                                                                                                                                  4. Type Systems in Functional Programming

                                                                                                                                                                  Go to top

                                                                                                                                                                  Next

                                                                                                                                                                  6. Functional Architecture and Design