You are previewing The Book of F#.
O'Reilly logo
The Book of F#

Book Description

The Book of F# teaches you to unlock the many strengths of F# to create smarter, leaner code.

Table of Contents

  1.  
    1. About the Author
    2. About the Technical Reviewer
  2. Foreword
  3. Preface
  4. Acknowledgments
  5. Introduction
    1. Whom Is This Book For?
    2. How Is This Book Organized?
    3. Additional Resources
  6. 1. Meet F#
    1. F# in Visual Studio
      1. Project Templates
      2. Project Organization
    2. Significance of Whitespace
    3. Grouping Constructs
      1. Namespaces
      2. Modules
    4. Expressions Are Everywhere
    5. Application Entry Point
    6. Implicit Return Values
    7. Your First F# Program
    8. Summary
  7. 2. F# Interactive
    1. Running F# Interactive
    2. F# Interactive Output
    3. The it Identifier
    4. Playing in the Sandbox
      1. #help
      2. #quit
      3. #load
      4. #r
      5. #I
      6. #time
    5. Scripting
    6. F# Interactive Options
      1. --load
      2. --use
      3. --reference
      4. --lib
      5. --define
      6. --exec
      7. --
      8. --quiet
      9. --optimize
      10. --tailcalls
    7. Summary
  8. 3. Fundamentals
    1. Immutability and Side Effects
    2. Functional Purity
    3. Bindings
      1. let Bindings
        1. Literals
        2. Mutable Bindings
        3. Reference Cells
      2. use Bindings
        1. using Function
        2. Replicating the using Function in C#
      3. do Bindings
    4. Identifier Naming
    5. Core Data Types
      1. Boolean Values and Operators
      2. Numeric Types
        1. Numeric Operators
        2. Numeric Conversion Functions
      3. Characters
      4. Strings
        1. String Literals
        2. Verbatim Strings
        3. Triple-Quoted Strings
        4. String Concatenation
    6. Type Inference
    7. Nullability
      1. Options
      2. Unit Type
    8. Enumerations
      1. Flags Enumerations
      2. Reconstructing Enumeration Values
    9. Flow Control
      1. Looping
        1. while Loops
        2. for Loops
      2. Branching
    10. Generics
      1. Automatic Generalization
      2. Explicit Generalization
      3. Flexible Types
      4. Wildcard Pattern
      5. Statically Resolved Type Parameters
    11. When Things Go Wrong
      1. Handling Exceptions
        1. try. . .with Expressions
        2. try. . .finally Expressions
      2. Raising Exceptions
      3. Custom Exceptions
    12. String Formatting
    13. Type Abbreviations
    14. Comments
      1. End-of-Line Comments
      2. Block Comments
      3. XML Documentation
    15. Summary
  9. 4. Staying Objective
    1. Classes
      1. Constructors
        1. Primary Constructors
        2. Additional Constructors
        3. Self-Identifiers
      2. Fields
        1. let Bindings
        2. Explicit Fields
      3. Properties
        1. Explicit Properties
        2. Implicit Properties
        3. Indexed Properties
        4. Setting at Initialization
      4. Methods
        1. Instance Methods
        2. Method Accessibility
        3. Named Arguments
        4. Overloaded Methods
        5. Optional Parameters
        6. Slice Expressions
      5. Events
        1. Basic Event Handling
        2. Observing Events
        3. Custom Events
    2. Structures
    3. Inheritance
      1. Casting
        1. Upcasting
        2. Downcasting
      2. Overriding Members
      3. Abstract Classes
      4. Abstract Members
        1. Abstract Properties
        2. Abstract Methods
      5. Virtual Members
      6. Sealed Classes
    4. Static Members
      1. Static Initializers
      2. Static Fields
      3. Static Properties
      4. Static Methods
    5. Mutually Recursive Types
    6. Interfaces
      1. Implementing Interfaces
      2. Defining Interfaces
    7. Custom Operators
      1. Prefix Operators
      2. Infix Operators
      3. New Operators
      4. Global Operators
    8. Object Expressions
    9. Type Extensions
    10. Summary
  10. 5. Let’s Get Functional
    1. What Is Functional Programming?
    2. Programming with Functions
      1. Functions as Data
      2. Interoperability Considerations
    3. Currying
      1. Partial Application
      2. Pipelining
        1. Forward Pipelining
        2. Backward Pipelining
        3. Noncurried Functions
      3. Function Composition
    4. Recursive Functions
      1. Tail-Call Recursion
      2. Mutually Recursive Functions
    5. Lambda Expressions
    6. Closures
    7. Functional Types
      1. Tuples
        1. Extracting Values
        2. Equality Semantics
        3. Syntactic Tuples
        4. Out Parameters
      2. Record Types
        1. Defining Record Types
        2. Creating Records
        3. Avoiding Naming Conflicts
        4. Copying Records
        5. Mutability
        6. Additional Members
    8. Discriminated Unions
      1. Defining Discriminated Unions
        1. Simple Object Hierarchies
        2. Tree Structures
        3. Replacing Type Abbreviations
      2. Additional Members
    9. Lazy Evaluation
    10. Summary
  11. 6. Going to Collections
    1. Sequences
      1. Creating Sequences
        1. Sequence Expressions
        2. Range Expressions
        3. Empty Sequences
        4. Initializing a Sequence
      2. Working with Sequences
        1. Finding Sequence Length
        2. Iterating over Sequences
        3. Transforming Sequences
        4. Sorting Sequences
        5. Filtering Sequences
        6. Aggregating Sequences
    2. Arrays
      1. Creating Arrays
        1. Array Expressions
        2. Empty Arrays
        3. Initializing Arrays
      2. Working with Arrays
        1. Accessing Elements
        2. Copying Arrays
        3. Sorting Arrays
      3. Multidimensional Arrays
      4. Jagged Arrays
    3. Lists
      1. Creating Lists
      2. Working with Lists
        1. Accessing Elements
        2. Combining Lists
    4. Sets
      1. Creating Sets
      2. Working with Sets
        1. Unions
        2. Intersections
        3. Differences
        4. Subsets and Supersets
    5. Maps
      1. Creating Maps
      2. Working with Maps
        1. Finding Values
        2. Finding Keys
    6. Converting Between Collection Types
    7. Summary
  12. 7. Patterns, Patterns, Everywhere
    1. Match Expressions
      1. Guard Clauses
      2. Pattern-Matching Functions
    2. Exhaustive Matching
      1. Variable Patterns
      2. The Wildcard Pattern
    3. Matching Constant Values
    4. Identifier Patterns
      1. Matching Union Cases
      2. Matching Literals
    5. Matching Nulls
    6. Matching Tuples
    7. Matching Records
    8. Matching Collections
      1. Array Patterns
      2. List Patterns
      3. Cons Patterns
    9. Matching by Type
      1. Type-Annotated Patterns
      2. Dynamic Type-Test Patterns
    10. As Patterns
    11. Combining Patterns with AND
    12. Combining Patterns with OR
    13. Parentheses in Patterns
    14. Active Patterns
    15. Partial Active Patterns
    16. Parameterized Active Patterns
    17. Summary
  13. 8. Measuring Up
    1. Defining Measures
    2. Measure Formulas
    3. Applying Measures
    4. Stripping Measures
    5. Enforcing Measures
    6. Ranges
    7. Converting Between Measures
      1. Static Conversion Factors
      2. Static Conversion Functions
    8. Generic Measures
    9. Custom Measure-Aware Types
    10. Summary
  14. 9. Can I Quote You on that?
    1. Comparing Expression Trees and Quoted Expressions
    2. Composing Quoted Expressions
      1. Quoted Literals
      2. .NET Reflection
      3. Manual Composition
      4. Splicing Quoted Expressions
    3. Decomposing Quoted Expressions
      1. Parsing Quoted Expressions
      2. Substituting Reflection
    4. Summary
  15. 10. Show Me the Data
    1. Query Expressions
      1. Basic Querying
      2. Filtering Data
        1. Predicate-Based Filters
        2. Distinct-Item Filters
      3. Accessing Individual Items
        1. Getting the First or Last Item
        2. Getting an Arbitrary Item
      4. Sorting Results
        1. Sorting in Ascending Order
        2. Sorting in Descending Order
        3. Sorting by Multiple Values
      5. Grouping
      6. Paginating
      7. Aggregating Data
      8. Detecting Items
      9. Joining Multiple Data Sources
      10. Extending Query Expressions
        1. Example: ExactlyOneWhen
        2. Example: AverageByNotNull
    2. Type Providers
      1. Available Type Providers
      2. Using Type Providers
      3. Example: Accessing an OData Service
      4. Example: Parsing a String with RegexProvider
    3. Summary
  16. 11. Asynchronous and Parallel Programming
    1. Task Parallel Library
      1. Potential Parallelism
      2. Data Parallelism
        1. Locking and Lock Avoidance
        2. Short-Circuiting Parallel Loops
        3. Cancelling Parallel Loops
      3. Task Parallelism
        1. Creating and Starting Tasks
        2. Returning Values from Tasks
        3. Waiting for Task Completion
        4. Continuations
        5. Cancelling Tasks
        6. Exception Handling
    2. Asynchronous workflows
      1. Creating and Starting Asynchronous Workflows
      2. Cancelling Asynchronous Workflows
      3. Exception Handling
      4. Asynchronous Workflows and the Task Parallel Library
    3. Agent-Based Programming
      1. Getting Started
      2. Scanning for Messages
      3. Replying to Messages
      4. Example: Agent-Based Calculator
    4. Summary
  17. 12. Computation Expressions
    1. Anatomy of a Computation Expression
    2. Example: FizzBuzz
    3. Example: Building Strings
    4. Summary
  18. Index
  19. About the Author
  20. Copyright