Table of Contents
Foreword
Preface
Introducing F#
Who This Book Is For
What You Need to Get Going
How the Book Is Organized
Part I, Multiparadigm Programming
Part II, Programming F#
Appendixes
Conventions Used in This Book
How to Contact Us
Using Code Examples
Safari® Books Online
Acknowledgments
Part I. Multiparadigm Programming
Chapter 1. Introduction to F#
Getting to Know F#
Visual Studio 2010
Your Second F# Program
Values
Whitespace Matters
.NET Interop
Comments
F# Interactive
Managing F# Source Files
Chapter 2. Fundamentals
Primitive Types
Numeric Primitives
Arithmetic
Conversion Routines
BigInt
Bitwise Operations
Characters
Strings
Boolean Values
Comparison and Equality
Functions
Type Inference
Generic Functions
Scope
Control Flow
Core Types
Unit
Tuple
Lists
List ranges
List comprehensions
List module functions
Aggregate Operators
List.map
List.fold
Folding right-to-left
List.iter
Option
Printfn
Anatomy of an F# Program
Modules
Creating modules
Nested modules
Namespaces
Program Startup
Chapter 3. Functional Programming
Programming with Functions
Immutability
Function Values
Partial function application
Functions returning functions
Recursive Functions
Mutual recursion
Symbolic Operators
Function Composition
Pipe-forward operator
Forward composition operator
Pipe-backward operator
Backward composition operator
Pattern Matching
Match Failure
Named Patterns
Matching Literals
when Guards
Grouping Patterns
Matching the Structure of Data
Tuples
Lists
Options
Outside of Match Expressions
let bindings
Anonymous functions
Wildcard patterns
Alternate Lambda Syntax
Discriminated Unions
Using Discriminated Unions for Tree Structures
Pattern Matching
Methods and Properties
Records
Cloning Records
Pattern Matching
Type Inference
Methods and Properties
Lazy Evaluation
Lazy Types
Sequences
Sequence Expressions
Seq Module Functions
Seq.take
Seq.unfold
Aggregate Operators
Seq.iter
Seq.map
Seq.fold
Chapter 4. Imperative Programming
Understanding Memory in .NET
Value Types Versus Reference Types
Default Values
Reference Type Aliasing
Changing Values
Reference Cells
Mutable Records
Arrays
Indexing an Array
Array Slices
Creating Arrays
Pattern Matching
Array Equality
Array Module Functions
partition
tryFind and tryFindIndex
Aggregate operators
Multidimensional Arrays
Rectangular arrays
Jagged arrays
Mutable Collection Types
List<'T>
Dictionary<'K,'V>
HashSet<'T>
Looping Constructs
While Loops
For Loops
Simple for loops
Enumerable for loop
Exceptions
Handling Exceptions
Reraising Exceptions
Defining Exceptions
Chapter 5. Object-Oriented Programming
Programming with Objects
The Benefits of OOP
When OOP Breaks Down
Understanding System.Object
Common Methods
ToString
GetHashCode
Equals
GetType
Object Equality
Generated Equality
Understanding Classes
Explicit Construction
Implicit Class Construction
Generic Classes
The Self-Identifier
Methods and Properties
Properties
Setting Properties in the Constructor
Methods
Static Methods, Properties, and Fields
Static fields
Method Overloading
Accessibility Modifiers
Accessibility modifiers on module values
F# signature files
Inheritance
Method Overriding
Categories of Classes
Abstract classes
Sealed classes
Casting
Static upcast
Dynamic cast
Pattern matching against types
Chapter 6. .NET Programming
The .NET Platform
The CLI
Garbage Collection
Interfaces
Using Interfaces
Defining Interfaces
Object Expressions
Object Expressions for Interfaces
Object Expressions for Derived Classes
Extension Methods
Extending Modules
Enumerations
Creating Enumerations
Conversion
When to Use an Enum Versus a Discriminated Union
Structs
Creating Structs
Restrictions
When to Use a Struct Versus a Record
Chapter 7. Applied Functional Programming
Units of Measure
Defining Units of Measure
Converting Between Units of Measure
Generic Units of Measure
Active Patterns
Single-Case Active Patterns
Partial-Case Active Patterns
Parameterized Active Patterns
Multi-Case Active Patterns
Using Active Patterns
Combining active patterns
Nesting active patterns
Using Modules
Converting Modules to Classes
Intentional Shadowing
Controlling Module Usage
Mastering Lists
List Operations
Cons
Append
Using Lists
Tail Recursion
Understanding the Stack
Introducing Tail Recursion
Tail-Recursive Patterns
Accumulator pattern
Continuations
Programming with Functions
Currying
Passing functions as parameters
Eliminating Redundant Code
Closures
Functional Patterns
Memoization
Memoizing recursive functions
Mutable Function Values
Lazy Programming
Reducing memory usage
Abstracting data access
Chapter 8. Applied Object-Oriented Programming
Operators
Operator Overloading
Indexers
Adding Slices
Generic Type Constraints
Delegates and Events
Defining Delegates
Combining Delegates
Events
Creating Events
Delegates for events
Creating and raising the event
Subscribing to events
The Event<_,_> Class
The Observable Module
Observable.add
Observable.merge
Observable.map
Creating .NET Events
Part II. Programming F#
Chapter 9. Scripting
F# Script Files
Directives
General Directives
__SOURCE_DIRECTORY__
__SOURCE_FILE__
F# Script-Specific Directives
#r
#I
#load
F# Script Recipes
Colorful Output
Producing Sound
Walking a Directory Structure
Starting Processes Easily
Automating Microsoft Office
Chapter 10. Computation Expressions
Toward Computation Expressions
Computation Expression Builders
Custom Computation Expression Builders
Asynchronous Workflows
The Rounding Workflow
The State Workflow
Building up the computation
Implementation
Chapter 11. Asynchronous and Parallel Programming
Working with Threads
Spawning Threads
Thread.Sleep
Thread.Abort
The .NET Thread Pool
Sharing Data
Race conditions
Deadlocks
Asynchronous Programming
Asynchronous Workflows
The Async Library
Starting async tasks
Exceptions
Cancellation
Async Operations
Custom Async Primitives
Limitations
Parallel Programming
Parallel.For
The Array.Parallel Module
Parallel Extensions for .NET
Primitives
Cancellation
Exceptions
Concurrent Data Structures
Concurrent queue
Concurrent dictionary
Concurrent bag
Chapter 12. Reflection
Attributes
Applying Attributes
Attribute targets
Applying multiple attributes
Defining New Attributes
Type Reflection
Accessing Types
Accessing generic types
Inspecting methods
Inspecting attributes
Reflecting on F# Types
Tuples
Discriminated unions
Records
Dynamic Instantiation
Instantiating Types
Instantiating F# Types
Dynamic Invocation
The Question Mark Operators
Using Reflection
Declarative Programming
Plug-in Architecture
Plug-in interfaces
Loading assemblies
Loading plug-ins
Chapter 13. Quotations
Quotation Basics
Decomposing Quotations
Literal values
Function calls
Function values
Quoting Method Bodies
Decomposing Arbitrary Code
Application: Deferring Computation to Other Platforms
Generating Quotation Expressions
Expression Holes
Evaluating Quotations
Application: Generating Derivatives
Appendix A. Overview of .NET Libraries
Visualization
Windows Forms
Windows Presentation Foundation
XAML, the eXtensible Application Markup Language
Binding
Data Processing
Regular Expressions
Metacharacters
String manipulation
Capture groups
Working with XML
Writing XML
Reading XML
Storing Data
File IO
Data Serialization
Deserialization
The F# Libraries
FSharp.Core.dll
The F# PowerPack
SI units of measure
FSLex and FSYacc
Appendix B. F# Interop
.NET Interop
C# Interoperating with F#
Discriminated unions
Function values
F# Interoperating with C#
Byref and out parameters
Dealing with null
Unmanaged Interop
Platform Invoke
COM Interop
Index