Introduction                                       xiii
Part I Introduction To Functional Programming
  Chapter 1 A Look At Functional Programming       3   (6)
  History
    What Is Functional Programming?                3   (2)
    Functional Languages                           5   (2)
    The Relationship to Object Oriented            7   (1)
    Programming
    Summary                                        8   (1)
  Chapter 2 Putting Functional Programming Into    9   (8)
  A Modern Context
    Managing Side Effects                          10  (1)
    Agile Programming Methodologies                11  (1)
    Declarative Programming                        11  (1)
    Functional Programming Is a Mindset            12  (1)
    Is Functional Programming in C# a Good Idea?   13  (1)
    Summary                                        13  (4)
Part II C# Foundations Of Functional Programming
  Chapter 3 Functions, Delegates, And Lambda       17  (14)
  Expressions
    Functions and Methods                          17  (2)
    Reusing Functions                              19  (4)
    Anonymous Functions and Lambda Expressions     23  (3)
    Extension Methods                              26  (2)
    Referential Transparency                       28  (2)
    Summary                                        30  (1)
  Chapter 4 Flexible Typing With Generics          31  (12)
    Generic Functions                              32  (2)
    Generic Classes                                34  (1)
    Constraining Types                             35  (2)
    Other Generic Types                            37  (1)
    Covariance and Contravariance                  38  (3)
    Summary                                        41  (2)
  Chapter 5 Lazy Listing With Iterators            43  (12)
    The Meaning of Laziness                        43  (1)
    Enumerating Things with .NET                   44  (3)
    Implementing Iterator Functions                47  (4)
      Returning IEnumerator                        50  (1)
    Chaining Iterators                             51  (2)
    Summary                                        53  (2)
  Chapter 6 Encapsulating Data In Closures         55  (6)
    Constructing Functions Dynamically             55  (1)
    The Problem with Scope                         56  (1)
    How Closures Work                              57  (3)
    Summary                                        60  (1)
  Chapter 7 Code Is Data                           61  (16)
    Expression Trees in .NET                       63  (1)
    Analyzing Expressions                          64  (4)
    Generating Expressions                         68  (4)
    .NET 4.0 Specifics                             72  (2)
    Summary                                        74  (3)
Part III Implementing Well-Known Functional
Techniques in C#
  Chapter 8 Currying And Partial Application       77  (14)
    Decoupling Parameters                          77  (9)
      Manual Currying                              78  (2)
      Automatic Currying                           80  (2)
      Calling Curried Functions                    82  (1)
      The Class Context                            82  (3)
      What FCSlib Contains                         85  (1)
    Calling Parts of Functions                     86  (2)
    Why Parameter Order Matters                    88  (1)
    Summary                                        89  (2)
  Chapter 9 Lazy Evaluation                        91  (10)
    What's Good about Being Lazy?                  92  (1)
    Passing Functions                              93  (2)
    Explicit Lazy Evaluation                       95  (3)
    Comparing the Lazy Evaluation Techniques       98  (1)
      Usability                                    98  (1)
      Efficiency                                   98  (1)
    How Lazy Can You Be?                           99  (1)
    Summary                                        100 (1)
  Chapter 10 Caching Techniques                    101 (16)
    The Need to Remember                           101 (1)
    Precomputation                                 102 (5)
    Memoization                                    107 (8)
      Deep Memoization                             110 (4)
      Considerations on Memoization                114 (1)
    Summary                                        115 (2)
  Chapter 11 Calling Yourself                      117 (14)
    Recursion in C#                                117 (2)
    Tail Recursion                                 119 (2)
    Accumulator Passing Style                      121 (1)
    Continuation Passing Style                     122 (4)
    Indirect Recursion                             126 (3)
    Summary                                        129 (2)
  Chapter 12 Standard Higher Order Functions       131 (10)
    Applying Operations: Map                       132 (6)
      Using Criteria: Filter                       132 (1)
      Accumulating: Fold                           133 (5)
    Map, Filter, and Fold in LINQ                  138 (2)
    Standard Higher Order Functions                140 (1)
    Summary                                        140 (1)
  Chapter 13 Sequences                             141 (8)
    Understanding List Comprehensions              141 (1)
    A Functional Approach to Iterators             142 (1)
    Ranges                                         143 (3)
    Restrictions                                   146 (1)
    Summary                                        147 (2)
  Chapter 14 Constructing Functions From           149 (10)
  Functions
    Composing Functions                            149 (3)
    Advanced Partial Application                   152 (3)
    Combining Approaches                           155 (3)
    Summary                                        158 (1)
  Chapter 15 Optional Values                       159 (8)
    The Meaning of Nothing                         159 (1)
    Implementing Option(al) Values                 160 (5)
    Summary                                        165 (2)
  Chapter 16 Keeping Data From Changing            167 (26)
    Change Is Good湧ot!                            167 (1)
    False Assumptions                              168 (9)
      Being Static Is Good                         169 (1)
      A Matter of Depth                            170 (1)
      Cloning                                      171 (2)
      Automatic Cloning                            173 (4)
    Implementing Immutable Container Data          177 (13)
    Structures
      Linked List                                  177 (6)
      Queue                                        183 (2)
      Unbalanced Binary Tree                       185 (2)
      Red/Black Tree                               187 (3)
    Alternatives to Persistent Data Types          190 (1)
    Summary                                        191 (2)
  Chapter 17 Monads                                193 (16)
    What's in a Typeclass?                         194 (3)
    What's in a Monad?                             197 (1)
    Why Do a Whole Abstraction?                    198 (3)
    A Second Monad: Logging                        201 (2)
    Syntactic Sugar                                203 (1)
    Binding with SelectMany?                       204 (1)
    Summary                                        205 (4)
Part IV Putting Functional Programming Into
Action
  Chapter 18 Integrating Functional Programming    209 (24)
  Approaches
    Refactoring                                    210 (14)
      List Filtering with a Windows Forms UI       211 (5)
      Calculating Mandelbrot Fractals              216 (8)
    Writing New Code                               224 (5)
      Use Static Methods                           224 (2)
      Prefer Anonymous Methods Over Named Ones     226 (1)
      Prefer Higher Order Functions over Manual    227 (1)
      Algorithm Implementation
      Prefer Immutable Data                        228 (1)
      Watch Behavior Implementation in Classes     229 (1)
    Finding Likely Candidates for Functional       229 (3)
    Programming
      Shades of Grey                               230 (1)
      Using What's There                           231 (1)
    Summary                                        232 (1)
  Chapter 19 The MapReduce Pattern                 233 (8)
    Implementing MapReduce                         234 (3)
    Abstracting the Problem                        237 (3)
    Summary                                        240 (1)
  Chapter 20 Applied Functional Modularization     241 (6)
    Executing SQL Code from an Application         241 (2)
    Rewriting the Function with Partial            243 (2)
    Application and Precomputation in Mind
    Summary                                        245 (2)
  Chapter 21 Existing Projects Using Functional    247 (14)
  Techniques
    The .NET Framework                             247 (2)
    LINQ                                           249 (8)
      LINQ to Objects                              249 (4)
      LINQ to a Query Backend                      253 (2)
      Parallelization                              255 (2)
    Google MapReduce and Its Implementations       257 (1)
    NUnit                                          258 (2)
    Summary                                        260 (1)
Index                                              261