Functional Programming in C#: Classic Programming Techniques for Modern Projects

✍ Scribed by Oliver Sturm

• Publisher: Wrox
• Year: 2011
• Tongue: English
• Leaves: 290
• Edition: 1
• Category: Library

✦ Synopsis

Take advantage of the growing trend in functional programming.

C# is the number-one language used by .NET developers and one of the most popular programming languages in the world. It has many built-in functional programming features, but most are complex and little understood. With the shift to functional programming increasing at a rapid pace, you need to know how to leverage your existing skills to take advantage of this trend.

Functional Programming in C# leads you along a path that begins with the historic value of functional ideas. Inside, C# MVP and functional programming expert Oliver Sturm explains the details of relevant language features in C# and describes theory and practice of using functional techniques in C#, including currying, partial application, composition, memoization, and monads. Next, he provides practical and versatile examples, which combine approaches to solve problems in several different areas, including complex scenarios like concurrency and high-performance calculation frameworks as well as simpler use cases like Web Services and business logic implementation.

• Shows how C# developers can leverage their existing skills to take advantage of functional programming
• Uses very little math theory and instead focuses on providing solutions to real development problems with functional programming methods, unlike traditional functional programming titles
• Includes examples ranging from simple cases to more complex scenarios

Let Functional Programming in C# show you how to get in front of the shift toward functional programming.

✦ Table of Contents

Professional Functional Programming in C#: Classic Programming Techniques for Modern Projects
Contents
Introduction
Part I: Introduction to Functional Programming
Chapter 1: A Look at Functional Programming History
What Is Functional Programming?
Functional Languages
The Relationship to Object Oriented Programming
Summary
Chapter 2: Putting Functional Programming Into a Modern Context
Managing Side Effects
Agile Programming Methodologies
Declarative Programming
Functional Programming Is a Mindset
Is Functional Programming in C# a Good Idea?
Summary
Part II: C# Foundations of Functional Programming
Chapter 3: Functions, Delegates, and Lambda Expressions
Functions and Methods
Reusing Functions
Anonymous Functions and Lambda Expressions
Extension Methods
Referential Transparency
Summary
Chapter 4: Flexible Typing With Generics
Generic Functions
Generic Classes
Constraining Types
Other Generic Types
Covariance and Contravariance
Summary
Chapter 5: Lazy Listing With Iterators
The Meaning of Laziness
Enumerating Things with .NET
Implementing Iterator Functions
Returning IEnumerator
Chaining Iterators
Summary
Chapter 6: Encapsulating Data in Closures
Constructing Functions Dynamically
The Problem with Scope
How Closures Work
Summary
Chapter 7: Code is Data
Expression Trees in .NET
Analyzing Expressions
Generating Expressions
.NET 4.0 Specifics
Summary
Part III: Implementing Well-Known Functional Techniques in C#
Chapter 8: Currying and Partial Application
Decoupling Parameters
Manual Currying
Automatic Currying
Calling Curried Functions
The Class Context
What FCSlib Contains
Calling Parts of Functions
Why Parameter Order Matters
Summary
Chapter 9: Lazy Evaluation
What's Good about Being Lazy?
Passing Functions
Explicit Lazy Evaluation
Comparing the Lazy Evaluation Techniques
Usability
Efficiency
How Lazy Can You Be?
Summary
Chapter 10: Caching Techniques
The Need to Remember
Precomputation
Memoization
Deep Memoization
Considerations on Memoization
Summary
Chapter 11: Calling Yourself
Recursion in C#
Tail Recursion
Accumulator Passing Style
Continuation Passing Style
Indirect Recursion
Summary
Chapter 12: Standard Higher Order Functions
Applying Operations: Map
Using Criteria: Filter
Accumulating: Fold
Map, Filter, and Fold in LINQ
Standard Higher Order Functions
Summary
Chapter 13: Sequences
Understanding List Comprehensions
A Functional Approach to Iterators
Ranges
Restrictions
Summary
Chapter 14: Constructing Functions From Functions
Composing Functions
Advanced Partial Application
Combining Approaches
Summary
Chapter 15: Optional Values
The Meaning of Nothing
Implementing Option(al) Values
Summary
Chapter 16: Keeping Data From Changing
Change Is Good — Not!
False Assumptions
Being Static Is Good
A Matter of Depth
Cloning
Automatic Cloning
Implementing Immutable Container Data Structures
Linked List
Queue
Unbalanced Binary Tree
Red/Black Tree
Alternatives to Persistent Data Types
Summary
Chapter 17: Monads
What's in a Typeclass?
What's in a Monad?
Why Do a Whole Abstraction?
A Second Monad: Logging
Syntactic Sugar
Binding with SelectMany?
Summary
Part IV: Putting Functional Programming Into Action
Chapter 18: Integrating Functional Programming Approaches
Refactoring
List Filtering with a Windows Forms UI
Calculating Mandelbrot Fractals
Writing New Code
Use Static Methods
Prefer Anonymous Methods Over Named Ones
Prefer Higher Order Functions over Manual Algorithm Implementation
Prefer Immutable Data
Watch Behavior Implementation in Classes
Finding Likely Candidates for Functional Programming
Shades of Grey
Using What's There
Summary
Chapter 19: The Mapreduce Pattern
Implementing MapReduce
Abstracting the Problem
Summary
Chapter 20: Applied Functional Modularization
Executing SQL Code from an Application
Rewriting the Function with Partial Application and Precomputation in Mind
Summary
Chapter 21: Existing Projects Using Functional Techniques
The .NET Framework
LINQ
LINQ to Objects
LINQ to a Query Backend
Parallelization
Google MapReduce and Its Implementations
NUnit
Summary
Index