Functional Programming

6.

Functional Architecture and Design

6.1.

Handling Side Effects

6.1.1.

Isolating Impurity

6.1.2.

The Functional Core, Imperative Shell Pattern

6.1.3.

Encapsulating Effects with Monads

6.1.4.

6.1.5.

Dependency Injection Patterns

6.2.

Error and Exception Handling

6.2.1.

Using Maybe Types

6.2.2.

Using Either Types

6.2.3.

Composing Error-Handling Functions

6.2.4.

Recovering from Errors

6.2.5.

Error Accumulation

6.2.6.

Validation Patterns

6.3.

Asynchronous Operations

6.3.1.

Futures and Promises as Functional Constructs

6.3.2.

Composing Asynchronous Computations

6.3.3.

Error Handling in Asynchronous Contexts

6.3.4.

6.3.5.

Reactive Programming Patterns

6.4.

State Management

6.4.1.

Passing State Explicitly

6.4.2.

Using the State Monad

6.4.3.

Modeling State Transitions

6.4.4.

Immutable State Updates

6.4.5.

6.4.6.

6.5.

Concurrency and Parallelism

6.5.1.

Statelessness and Thread Safety

6.5.2.

Data Parallelism

6.5.3.

Functional Patterns for Concurrency

6.5.3.1.

6.5.3.2.

6.5.3.3.

Actors and Message Passing

6.5.3.4.

Software Transactional Memory

6.5.4.

Lock-Free Data Structures

6.5.5.

Parallel Collection Operations

6.6.

Modularization and Code Organization

6.6.1.

Pure Functions and Module Boundaries

6.6.2.

Dependency Injection via Functions

6.6.3.

Layered Architectures

6.6.4.

Hexagonal Architecture

6.6.5.

Domain-Driven Design with Functional Programming

6.6.6.

6.7.

Domain Modeling

6.7.1.

Making Illegal States Unrepresentable

6.7.2.

Type-Driven Development

6.7.3.

Domain-Specific Languages

6.7.4.

Algebraic Data Types for Domain Modeling

Previous

5. Advanced Functional Abstractions

Go to top

Next

7. Functional Programming in Practice