book

Functional Programming in C#, Second Edition

Name: Functional Programming in C#, Second Edition
Author: Enrico Buonanno
ISBN: 9781617299827

by Enrico Buonanno

January 2022

Intermediate to advanced

448 pages

12h 27m

English

Manning Publications

Read now

Unlock full access

inside front cover
Praise for the first edition
Functional Programming in C#
Copyright
contents
front matter
prefaceacknowledgmentsabout this bookWho should read this book?How this book is organized: A road mapCoding for real-world applicationsLeveraging functional librariesAbout the codeliveBook discussion forumabout the author
Part 1. Getting started
1 Introducing functional programming
1.1 What is this thing called functional programming?1.1.1 Functions as first-class values1.1.2 Avoiding state mutation1.1.3 Writing programs with strong guarantees1.2 How functional a language is C#?1.2.1 The functional nature of LINQ1.2.2 Shorthand syntax for coding functionally1.2.3 Language support for tuples1.2.4 Pattern matching and record types1.3 What you will learn in this bookSummary
2 Thinking in functions
2.1 What’s a function, anyway?2.1.1 Functions as maps2.1.2 Representing functions in C#2.2 Higher-order functions (HOFs)2.2.1 Functions that depend on other functions2.2.2 Adapter functions2.2.3 Functions that create other functions2.3 Using HOFs to avoid duplicationExercisesSummary
3 Why function purity matters
3.1 What is function purity?3.1.1 Purity and side effects3.1.2 Strategies for managing side effects3.1.3 Avoid mutating arguments3.2 Enabling parallelization by avoiding state mutation3.2.1 Pure functions parallelize well3.2.2 Parallelizing impure functions3.2.3 Avoiding state mutation3.3 Purity and testability3.3.1 Isolating I/O effects3.3.2 A business validation scenario3.3.3 Why testing impure functions is hard3.4 Testing code that performs I/O3.4.1 Object-oriented dependency injection3.4.2 Testability without so much boilerplate3.5 Purity and the evolution of computingExercisesSummary

Part 2. Core techniques
4 Designing function signatures and types
4.1 Designing function signatures4.1.1 Writing functions signatures with arrow notation4.1.2 How informative is a signature?4.2 Capturing data with data objects4.2.1 Primitive types are often not specific enough4.2.2 Constraining inputs with custom types4.2.3 Writing honest functions4.2.4 Composing values into complex data objects4.3 Modeling the absence of data with Unit4.3.1 Why void isn’t ideal4.3.2 Bridging the gap between Action and FuncSummary
5 Modeling the possible absence of data
5.1 The bad APIs you use every day5.2 An introduction to the Option type5.3 Implementing Option5.3.1 An idealized implementation of Option5.3.2 Consuming an Option5.3.3 Creating a None5.3.4 Creating a Some5.3.5 Optimizing the Option implementation5.4 Option as the natural result type of partial functions5.4.1 Parsing strings5.4.2 Looking up data in a collection5.4.3 The smart constructor pattern5.5 Dealing with null5.5.1 Why null is such a terrible idea5.5.2 Gaining robustness by using Option instead of null5.5.3 Non-nullable reference types?5.5.4 Bulletproof against NullReferenceExceptionExercisesSummary
6 Patterns in functional programming
6.1 Applying a function to a structure’s inner values6.1.1 Mapping a function onto a sequence6.1.2 Mapping a function onto an Option6.1.3 How Option raises the level of abstraction6.1.4 Introducing functors6.2 Performing side effects with ForEach6.3 Chaining functions with Bind6.3.1 Combining Option-returning functions6.3.2 Flattening nested lists with Bind6.3.3 Actually, it’s called a monad6.3.4 The Return function6.3.5 Relationship between functors and monads6.4 Filtering values with Where6.5 Combining Option and IEnumerable with Bind6.6 Coding at different levels of abstraction6.6.1 Regular vs. elevated values6.6.2 Crossing levels of abstraction6.6.3 Map vs. Bind, revisited6.6.4 Working at the right level of abstractionExercisesSummary
7 Designing programs with function composition
7.1 Function composition7.1.1 Brushing up on function composition7.1.2 Method chaining7.1.3 Composition in the elevated world7.2 Thinking in terms of data flow7.2.1 Using LINQ’s composable API7.2.2 Writing functions that compose well7.3 Programming workflows7.3.1 A simple workflow for validation7.3.2 Refactoring with data flow in mind7.3.3 Composition leads to greater flexibility7.4 An introduction to functional domain modeling7.5 An end-to-end server-side workflow7.5.1 Expressions vs. statements7.5.2 Declarative vs. imperative7.5.3 The functional take on layeringExercisesSummary
Part 3. Functional designs
8 Functional error handling
8.1 A safer way to represent outcomes8.1.1 Capturing error details with Either8.1.2 Core functions for working with Either8.1.3 Comparing Option and Either8.2 Chaining operations that may fail8.3 Validation: A perfect use case for Either8.3.1 Choosing a suitable representation for errors8.3.2 Defining an Either-based API8.3.3 Adding validation logic8.4 Representing outcomes to client applications8.4.1 Exposing an Option-like interface8.4.2 Exposing an Either-like interface8.4.3 Returning a result DTO8.5 Variations on the Either theme8.5.1 Changing between different error representations8.5.2 Specialized versions of Either8.5.3 Refactoring to Validation and Exceptional8.5.4 Leaving exceptions behind?ExercisesSummary
9 Structuring an application with functions
9.1 Partial application: Supplying arguments piecemeal9.1.1 Manually enabling partial application9.1.2 Generalizing partial application9.1.3 Order of arguments matters9.2 Overcoming the quirks of method resolution9.3 Curried functions: Optimized for partial application9.4 Creating a partial-application-friendly API9.4.1 Types as documentation9.4.2 Particularizing the data access function9.5 Modularizing and composing an application9.5.1 Modularity in OOP9.5.2 Modularity in FP9.5.3 Mapping functions to API endpoints9.5.4 Comparing the two approaches9.6 Reducing a list to a single value9.6.1 LINQ’s Aggregate method9.6.2 Aggregating validation results9.6.3 Harvesting validation errorsExercisesSummary
10 Working effectively with multi-argument functions
10.1 Function application in the elevated world10.1.1 Understanding applicatives10.1.2 Lifting functions10.1.3 An introduction to property-based testing10.2 Functors, applicatives, and monads10.3 The monad laws10.3.1 Right identity10.3.2 Left identity10.3.3 Associativity10.3.4 Using Bind with multi-argument functions10.4 Improving readability by using LINQ with any monad10.4.1 Using LINQ with arbitrary functors10.4.2 Using LINQ with arbitrary monads10.4.3 The LINQ clauses let, where, and others10.5 When to use Bind vs. Apply10.5.1 Validation with smart constructors10.5.2 Harvesting errors with the applicative flow10.5.3 Failing fast with the monadic flowExercisesSummary
11 Representing state and change
11.1 The pitfalls of state mutation11.2 Understanding state, identity, and change11.2.1 Some things never change11.2.2 Representing change without mutation11.3 Using records to capture the state of domain entities11.3.1 Fine-grained control on record initialization11.3.2 Immutable all the way down11.4 Separating data and logicSummary
12 A short introduction to functional data structures
12.1 The classic functional linked list12.1.1 Common list operations12.1.2 Modifying an immutable list12.1.3 Destructuring any IEnumerable12.2 Binary trees12.2.1 Common tree operations12.2.2 Structure sharing12.3 In conclusionExercisesSummary
13 Event sourcing: A functional approach to persistence
13.1 Thinking functionally about data storage13.1.1 Why data storage should be append-only13.1.2 Relax and forget about storing state13.2 Event sourcing basics13.2.1 Representing events13.2.2 Persisting events13.2.3 Representing state13.2.4 Representing state transitions13.2.5 Reconstructing the current state from past events13.3 Architecture of an event-sourced system13.3.1 Handling commands13.3.2 Handling events13.3.3 Adding validation13.3.4 Creating views of the data from events13.4 Comparing different approaches to immutable storage13.4.1 Datomic vs. Event Store13.4.2 How event-driven is your domain?Summary
Part 4. Advanced techniques
14 Lazy computations, continuations, and the beauty of monadic composition
14.1 The virtue of laziness14.1.1 Lazy APIs for working with Option14.1.2 Composing lazy computations14.2 Exception handling with Try14.2.1 Representing computations that may fail14.2.2 Safely extracting information from a JSON object14.2.3 Composing computations that may fail14.2.4 Monadic composition: What does it mean?14.3 Creating a middleware pipeline for DB access14.3.1 Composing functions that perform setup/teardown14.3.2 A recipe against the pyramid of doom14.3.3 Capturing the essence of a middleware function14.3.4 Implementing the query pattern for middleware14.3.5 Adding middleware that times the operation14.3.6 Adding middleware that manages a DB transactionSummary
15 Stateful programs and stateful computations
15.1 Programs that manage state15.1.1 Caching data in memory15.1.2 Refactoring for testability and error handling15.1.3 Stateful computations15.2 A language for generating random data15.2.1 Generating random integers15.2.2 Generating other primitives15.2.3 Generating complex structures15.3 A general pattern for stateful computationsSummary
16 Working with asynchronous computations
16.1 Asynchronous computations16.1.1 The need for asynchrony16.1.2 Representing asynchronous operations with Task16.1.3 Task as a container for a future value16.1.4 Handling failure16.1.5 An HTTP API for currency conversion16.1.6 If it fails, try a few more times16.1.7 Running asynchronous operations in parallel16.2 Async streams16.2.1 Reading from a file as an async stream16.2.2 Consuming async streams functionally16.2.3 Consuming data from several streams16.2.4 Aggregation and sorting with async streamsSummary
17 Traversable and stacked monads
17.1 Traversables: Working with lists of elevated values17.1.1 Validating a list of values with monadic Traverse17.1.2 Harvesting validation errors with applicative Traverse17.1.3 Applying multiple validators to a single value17.1.4 Using Traverse with Task to await multiple results17.1.5 Defining Traverse for single-value structures17.2 Combining asynchrony and validation (or any other two monadic effects)17.2.1 The problem of stacked monads17.2.2 Reducing the number of effects17.2.3 LINQ expressions with a monad stackSummary
18 Data streams and the Reactive Extensions
18.1 Representing data streams with IObservable18.1.1 A sequence of values in time18.1.2 Subscribing to an IObservable18.2 Creating IObservables18.2.1 Creating a timer18.2.2 Using Subject to tell an IObservable when it should signal18.2.3 Creating IObservables from callback-based subscriptions18.2.4 Creating IObservables from simpler structures18.3 Transforming and combining data streams18.3.1 Stream transformations18.3.2 Combining and partitioning streams18.3.3 Error handling with IObservable18.3.4 Putting it all together18.4 Implementing logic that spans multiple events18.4.1 Detecting sequences of pressed keys18.4.2 Reacting to multiple event sources18.4.3 Notifying when an account becomes overdrawn18.5 When should you use IObservable?Summary
19 An introduction to message-passing concurrency
19.1 The need for shared mutable state19.2 Understanding message-passing concurrency19.2.1 Implementing agents in C#19.2.2 Getting started with agents19.2.3 Using agents to handle concurrent requests19.2.4 Agents vs. actors19.3 Functional APIs, agent-based implementations19.3.1 Agents as implementation details19.3.2 Hiding agents behind a conventional API19.4 Message-passing concurrency in LOB applications19.4.1 Using an agent to synchronize access to account data19.4.2 Keeping a registry of accounts19.4.3 An agent is not an object19.4.4 Putting it all togetherSummary
Appendix A. Working with previous version of C#
A.1 Immutable data objects before C# 9A.1.1 Immutability by conventionA.1.2 Defining copy methodsA.1.3 Enforcing immutabilityA.1.4 Immutable all the way downA.1.5 Copy methods without boilerplate?A.1.6 Comparing strategies for immutabilityA.2 Pattern matching before C# 8A.2.1 C#'s incremental support for pattern matchingA.2.2 A custom solution for pattern matching expressionsA.3 Revisiting the event sourcing exampleA.4 In conclusion
Epilogue. What next?
index

Overview

Real world examples and practical techniques for functional programming in C# without the jargon and theory.

In Functional Programming in C#, Second Edition you will learn how to:

Use higher-order functions to reduce duplication and do more with less code
Use pure functions to write code that is easy to test and optimize
Write pleasant APIs that accurately describe your program's behavior
Use dedicated types to handle nullability, system errors, and validation rules predictably and elegantly
Write composable code without the overhead of an IoC container

Functional Programming in C# has helped thousands of developers apply functional thinking to C# code. Its practical examples and spot-on treatment of FP concepts makes it the perfect guide for proficient C# programmers. This second edition is fully revised to cover new functional-inspired features in the most recent releases of C#, including tuples, async streams, pattern matching, and records. Each chapter is packed with awesome perspectives and epiphany moments on how functional programming can change the way you code.

About the Technology
Turbocharge your C# code. Good functional techniques will improve concurrency, state management, event handling, and maintainability of your software. This book gives you practical answers to why, how, and where to add functional programing into your C# coding practice.

About the Book
Functional Programming in C#, Second Edition teaches functional thinking for real-world problems. It reviews the C# language features that allow you to program functionally and through many practical examples shows the power of function composition, data-driven programming, and immutable data structures. All code examples work with .NET 6 and C# 10.

What's Inside

Higher-order functions reduce duplication and do more with less code
Code based on pure functions is easy to test and optimize
Write pleasant APIs that accurately describe your program’s behavior
Write a Web API in a functional style
Monadic composition with LINQ

About the Reader
For intermediate C# programmers.

About the Author
Enrico Buonanno studied Computer Science at Columbia University and has over 15 years of experience as a developer, architect, and trainer.

Quotes
An excellent practical book for using functional programming concepts in your C# applications.
- Foster Haines, J2 Interactive

If this is your first venture into functional programming, then this is the book you want. A great mixture of the new with the familiar.
- Mark Elston, Advantest

A must-read for all .NET developers.
- Jedidja Bourgeois, Freshly Coded Software

An extremely good presentation of functional concepts for C# developers.
- David Paccoud, Bioclinica

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781617299827Publisher Support Publisher Website Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills