Beginning F#

Title Page

Copyright Page

Contents at a Glance

Table of Contents

Foreword

About the Author

About the Technical Reviewer

Acknowledgments

Preface

Chapter 1 Introduction

What Is Functional Programming?

Why Is Functional Programming Important?

What Is F#?

Who Is Using F#?

Who Is This Book For?

What’s Next?

Chapter 2 How to, Obtain, Install, and Use F#

Obtaining F#

Installing F# on Windows with Visual Studio 2008

Installing F# on Linux

Using F# in Different Ways

Visual Studio

SharpDevelop

F# Interactive Command-Line

The Examples in this Book

Summary

Chapter 3 Functional Programming

Literals

Functions

Identifiers and let Bindings

Identifier Names

Scope

Capturing Identifiers

The use Binding

Recursion

Operators

Function Application

Partial Application of Functions

Pattern Matching

Control Flow

Lists

Pattern Matching Against Lists

List Comprehensions

Types and Type Inference

Defining Types

Tuple and Record Types

Union or Sum Types

Type Definitions with Type Parameters

Recursive Type Definitions

Active Patterns

Complete Active Patterns

Incomplete Active Patterns

Units of Measure

Exceptions and Exception Handling

Lazy Evaluation

Summary

Chapter 4 Imperative Programming

The unit Type

The mutable Keyword

Defining Mutable Record Types

The ref Type

Arrays

Array Comprehensions

Control Flow

Calling Static Methods and Properties from .NET Libraries

Using Objects and Instance Members from .NET Libraries

Using Indexers from .NET Libraries

Working with Events from .NET Libraries

Pattern Matching over .NET Types

The |> Operator

Summary

Chapter 5 Object-Oriented Programming

Records As Objects

F# Types with Members

Object Expressions

Defining Classes

Optional Parameters

Defining Interfaces

Implementing Interfaces

Classes and Inheritance

Methods and Inheritance

Accessing the Base Class

Properties and Indexers

Overriding Methods from Non-F# Libraries

Abstract Classes

Classes and Static Methods

Classes with Explicit Fields and Constructors

Casting

Type Tests

Type Annotations for Subtyping

Defining Delegates

Structs

Enums

Summary

Chapter 6 Organizing, Annotating, and Quoting Code

Modules

Namespaces

Opening Namespaces and Modules

Giving Modules Aliases

Signature Files

Private and Internal let Bindings and Members

Module Scope

Module Execution

Optional Compilation

Comments

Doc Comments

Comments for Cross Compilation

Custom Attributes

Quoted Code

Summary

Chapter 7 The F# Libraries

The Native F# Library FSharp.Core.dll

The Microsoft.FSharp.Core.Operators Module

Arithmetic Operators

Floating-Point Arithmetic Functions

Tuple Functions

The Conversion Functions

The Logical Or and And Operators

The Microsoft.FSharp.Reflection Module

Reflection Over Types

Reflection Over Values

The Microsoft.FSharp.Collections.Seq Module

The map and iter Functions

The concat Function

The fold Function

The exists and forall Functions

The filter, find, and tryFind Functions

The choose Function

The init and initInfinite Functions

The unfold Function

The generate Function

The cast Function

The Microsoft.FSharp.Text.Printf Module

The Microsoft.FSharp.Control.Event Module

Creating and Handling Events

The filter Function

The partition Function

The map Function

The Power Pack Library FSharp.PowerPack.dll

The Microsoft.FSharp.Math Namespace

Summary

Chapter 8 User Interfaces

Introducing WinForms

Drawing WinForms

Working with Controls in WinForms

Using the Visual Studio Form Designer’s Forms in F#

Working with WinForms Events and the Event Module

Creating New Forms Classes

Introducing Windows Presentation Foundation

Introducing Windows Presentation Foundation 3D

Introducing GTK#

Introducing ASP.NET

Creating an IHttpHandler

Working with ASP.NET Web Forms

Summary

Chapter 9 Data Access

The System.Configuration Namespace

The System.IO Namespace

Using Sequences with System.IO

The System.Xml Namespace

ADO.NET

Data Binding

Data Binding and the DataGridView Control

ADO.NET Extensions

Introducing LINQ

Using LINQ to XML

Summary

Chapter 10 Parallel Programming

Threads, Memory, Locking and Blocking

Reactive Programming

Data Parallelism

Asynchronous Programming

Message Passing

Summary

Chapter 11 Distributed Applications

Networking Overview

Using TCP/IP Sockets

Using HTTP

Using HTTP with Google Spreadsheets

Using HTTP Posts

Using HTTP Asynchronously

Creating Web Services

Windows Communication Foundation

Hosting WCF Services

Summary

Chapter 12 Language-Oriented Programming

What Is Language-Oriented Programming?

Data Structures as Little Languages

A Data Structure–Based Language Implementation

Metaprogramming with Quotations

Implementing a Compiler and an Interpreter for an Arithmetic-Language

The Abstract Syntax Tree

Interpreting the AST

Compiling the AST

Compilation vs. Interpretation

Summary

Chapter 13 Parsing Text

Parsing CSV Format

Language Definition for the Other Examples

Using fslex.exe and fsyacc.exe

Tokenizing the Text: Fslex

Generating a Parser: Fsyacc

Using the Parser

FParsec Library

Summary

Chapter 14 Compatibility and Advanced Interoperation

Calling F# Libraries from C#

Returning Tuples

Exposing Functions That Take Functions As Parameters

Using Union Types

Using F# Lists

Defining Types in a Namespace

Defining Classes and Interfaces

Calling Using COM Objects

Using COM Style APIs

Using P/Invoke

Using Inline IL

Using F# from Native Code via COM

Hosting the CLR

Summary

Index