1. Multiparadigm Programming

   1. Chapter 1 Introduction to F#

      1. Getting to Know F#
      2. Visual Studio 2010
      3. F# Interactive
      4. Managing F# Source Files

   2. Chapter 2 Fundamentals

      1. Primitive Types
      2. Comparison and Equality
      3. Functions
      4. Core Types
      5. Anatomy of an F# Program

   3. Chapter 3 Functional Programming

      1. Programming with Functions
      2. Pattern Matching
      3. Discriminated Unions
      4. Records
      5. Lazy Evaluation
      6. Sequences

   4. Chapter 4 Imperative Programming

      1. Understanding Memory in .NET
      2. Changing Values
      3. Arrays
      4. Mutable Collection Types
      5. Looping Constructs
      6. Exceptions

   5. Chapter 5 Object-Oriented Programming

      1. Programming with Objects
      2. Understanding System.Object
      3. Understanding Classes
      4. Methods and Properties
      5. Inheritance

   6. Chapter 6 .NET Programming

      1. The .NET Platform
      2. Interfaces
      3. Object Expressions
      4. Extension Methods
      5. Extending Modules
      6. Enumerations
      7. Structs

   7. Chapter 7 Applied Functional Programming

      1. Units of Measure
      2. Active Patterns
      3. Using Modules
      4. Mastering Lists
      5. Tail Recursion
      6. Programming with Functions
      7. Functional Patterns

   8. Chapter 8 Applied Object-Oriented Programming

      1. Operators
      2. Generic Type Constraints
      3. Delegates and Events
      4. Events

2. Programming F#

   1. Chapter 9 Scripting

      1. F# Script Files
      2. Directives
      3. F# Script Recipes

   2. Chapter 10 Computation Expressions

      1. Toward Computation Expressions
      2. Computation Expression Builders
      3. Custom Computation Expression Builders

   3. Chapter 11 Asynchronous and Parallel Programming

      1. Working with Threads
      2. Asynchronous Programming
      3. Asynchronous Workflows
      4. Parallel Programming
      5. Parallel Extensions for .NET

   4. Chapter 12 Reflection

      1. Attributes
      2. Type Reflection
      3. Dynamic Instantiation
      4. Using Reflection

   5. Chapter 13 Quotations

      1. Quotation Basics
      2. Generating Quotation Expressions

1. Appendix Overview of .NET Libraries

   1. Visualization

   2. Data Processing

   3. Storing Data

   4. The F# Libraries

2. Appendix F# Interop

   1. .NET Interop

   2. Unmanaged Interop

3. Colophon

The image on the cover of Programming F# is a bullfinch (Pyrrhula pyrrhula). Members of the Fringillidae family, bullfinches are small passerine birds that can be found throughout central and northern Europe, from the Atlantic coast of western Europe and Morocco to the Pacific coasts of Russia and Japan. They primarily inhabit woodland areas, orchards, and farmlands, and are somewhat notorious for the damage they do by eating the buds of fruit trees and flowering shrubs in spring. Bullfinches are skittish, wary birds and are rarely seen on the ground. The common bullfinch grows to about six inches long. It has a thick neck and a short, stubby bill. Both sexes are primarily black and white, though males have rose-colored undersides while females have duller, brownish breasts. The females make nests from small twigs, moss, and roots, and lay four or five eggs twice a year. Both parents share feeding responsibilities once the young have hatched.Between 1968 and 1991, there was a significant decline in the bullfinch population. While the specific cause is not known, one theory is that the trend of deforestation and overtrimming hedges on agricultural land compromised many nesting sites and removed the birds' primary food sources. Increased use of herbicides is also a probable culprit, as well as the fact that trapping and killing bullfinches was not regulated until relatively recently. However, bullfinch numbers are now abundant over most of their range and, with the exception of some local populations and subspecies, the birds are not considered threatened.