Functional Programming in C {with categories} (Dimitris Papadimitriou) (Z-Library)

# Functional Programming in C# {with categories} ## 【One-Line Pitch】 A rigorous, math-forward guide that teaches functional programming in C# through the lens of category theory, monads, and type-level abstractions—ideal for experienced .NET developers who want to understand the *why* behind functional patterns, not just the *how*. ## 【Book Arc】 - **Opening (~0%–10%)**: Sets the stage by introducing C# functional syntax—lambda expressions, local functions, and the shift from imperative to expression-based thinking. Establishes the book's core premise: functional programming is about reducing side effects and chaining computations. - **Early (~10%–23%)**: Dives into typed lambda calculus (λ→), Church encoding, and higher-order functions. Explains how C# lambdas map to formal mathematical systems, including the Curry–Howard correspondence—where writing functions is equivalent to constructing logical proofs. - **Early–Middle (~23%–39%)**: Covers currying, continuation-passing style, and category theory fundamentals (objects, morphisms, categories of types). Introduces monoids and folding as universal patterns, showing how `Aggregate` in LINQ is really a monoidal operation. - **Middle (~39%–48%)**: Bridges OOP design patterns (Strategy, Decorator) with functional equivalents. Shows how predicate composition, monoid homomorphisms, and product types (tuples) map to logical AND, and how pattern matching on products becomes a practical tool. - **Late (~48%–end, partially covered)**: Moves into advanced territory—functors, applicative functors, and monads (Maybe/Option, Either, Validation, Task). Demonstrates how to combine these abstractions (e.g., `Task<Option<T>>`, `EitherAsync<>`) using language-ext and LINQ syntax. ## 【Key Takeaways】 - **Functional style in C# starts with syntax discipline** (Opening): lambdas, local functions, and expression-bodied members let you write composable, side-effect-free code—but the real value comes from chaining computations rather than writing statement blocks. - **Lambda calculus is the theoretical backbone** (Early): understanding λ→ (simply typed lambda calculus) clarifies why C# lambdas behave as they do—abstractions map to `Func<A, B>` and applications map to function calls. Church encoding shows you can build numbers from pure functions alone. - **Higher-order functions are the bridge from OOP to FP** (Early): the Strategy pattern is "passing functions as objects" in disguise. Once you see this, you can replace entire class hierarchies with single delegate signatures. - **Currying transforms multi-argument functions into chains** (Early): `Func<A, B, C>` becomes `Func<A, Func<B, C>>`—a mechanical transformation that enables partial application and reveals the underlying type algebra `((A × B) → C) → (A → (B → C))`. - **Continuation-passing style (CPS) is everywhere in modern C#** (Early): callbacks, `Task<T>`, and Rx.NET Observables are all CPS transformations. Recognizing this pattern helps you understand async/await as syntactic sugar over continuations. - **Monoids unify seemingly different operations** (Middle): addition, multiplication, and max all share the same shape—an associative binary operation with an identity element. The `Fold`/`Aggregate` function abstracts over all of them, and this insight powers everything from LINQ to decorator patterns. - **Category theory reframes types as objects and functions as arrows** (Middle): instead of focusing on what values *are* (set theory), category theory focuses on how they *relate*—a perspective that functional programmers use to design reusable abstractions. - **The Curry–Howard correspondence makes programming feel like proving theorems** (Middle): implementing a function like `Compose` is literally constructing a deductive proof. Product types correspond to logical AND; function types correspond to implications. ## 【Reading Tips】 - **Skim the first 10%** if you already write lambdas daily—the syntax review is basic. But don't skip the section on local functions; it's a C# 7+ feature many developers underuse. - **Deep-read the lambda calculus and Curry–Howard sections** (Early, ~13%–23%). These are the most conceptually dense parts. If the proof trees feel overwhelming, focus on the *intuition*: function application = implication elimination, function creation = implication introduction. - **Treat the category theory chapters as conceptual glue** (Early–Middle, ~29%–39%). You don't need to master category theory to write functional C#, but understanding monoids and morphisms will make the later functor/monad chapters click. - **Pay special attention to the monoid homomorphism section** (~42%)—it's a "thing of beauty" that explains why mapping between structures preserves behavior. This is the key to understanding why `Select` (map) works the way it does. - **The final third of the book (functors, applicatives, monads) is where theory meets practice**. If you're short on time, jump to the language-ext examples and the sections on combining `Task` with `Option`/`Either`—these are directly applicable to real-world async error handling. ## 【Coverage Limits】 The excerpts cover roughly the first half of the book (through ~48%), with partial visibility into the functor/monad chapters via the table of contents. Detailed content on applicative functors, monad laws, and the `Validation` monad is referenced but not fully excerpted—readers should expect those sections to require careful study. ##