Index

Search in book...
Toggle Font Controls
Create new playlist

Name your new playlist

Playlist description (optional)
Sign In

Email address

Password

Forgot Password?

or

Continue with Facebook

Continue with Google
Sign Up

Full Name

Email address

Confirm Email Address

Password

or

Continue with Facebook

Continue with Google

Index

A note on the digital index

A link in an index entry is displayed as the section title in which that entry appears. Because some sections have multiple index markers, it is not unusual for an entry to have several links to the same section. Clicking on any link will take you directly to the place in the text in which the marker appears.

Symbols

! (bang) operator, Working with the Command Pattern, Other Unique Features
% quotation splicing operator, Using the Regular-Expression Type Provider
%% quotation splicing operator, Using the Regular-Expression Type Provider
& (ampersand) operator, Interop and Function Parameters
** (double star) operator, Defining a Method, Working with Units of Measure
:: (con) operator, Lists, Using the List and Array Patterns
:= operator, Working with the Command Pattern, Other Unique Features
:> operator, Converting Numbers and Using enum
:? operator, Using Variable Patterns and the when Guard
:?> operator, Upcasting and Downcasting
< function, Using Asynchronous Workflows
<@@ and @@> operators, Setting Up the Development Environment, Checking F# Types
<| (backward pipe operator), Pipe/Composite Operators
= (equal sign), exists and exists2, Module, Namespace, and Program Entry Points
=? operator, Using the join Operator
> (angle bracket), exists and exists2
?< operator, Using the take and skip Operators
?= operator, Using the join Operator
@ (at) operator, Lists, Using a quick-sort algorithm
_ (underscore), Tuples, Using Pattern Matching
|> (pipe-forward operator), Arrays
|||>, ||>, <|||, and <|| operators, Other F# Operators

A

‘a type, exists and exists2

A* algorithm, Find all paths in a graph

abs function, Other F# Operators

abstract classes, Using Inheritance

attributes, Using Abstract and Sealed Classes

abstract keyword, Using Inheritance

AbstractClass attribute, Using Inheritance, Using Abstract and Sealed Classes

accessibility modifiers, Using Classes, Using Constructors

acos function, Other F# Operators

Activator.CreateInstance method, Using a Wrapper Type Provider, Using the Multi-Inheritance Type Provider

active patterns, Working with the Chain of Responsibility Pattern, Working with the Chain of Responsibility Pattern, Using the Choice Helper Type

generating new, Reservoir sampling
multicase-case, Using Single-Case Active Patterns
parameterized, Using Multicase Active Patterns
partial-case, Using Single-Case Active Patterns
single-case, Using Single-Case Active Patterns

adapter pattern, Working with F# and Design Patterns, Working with the Adapter Pattern

add reference add-in, Some Useful Add-ins

Add Reference dialog box, Using Delegates and Events

ADO.NET Entity Framework, SQL Entity Type Provider

agents, Debugging Multithreaded Applications

events in, Using Agents
exception handling, Using Agents

algebra

CUDA Basic Linear Algebra Subroutines library, cuBLAS Library
resources for, Using the Monte Carlo Simulation to Compute the π Value on a GPU

The Algorithmist website, Exploring the Portable Library Samples

algorithms, Finding a sum from an array

(see also portable library)
implementing, Developing the WinRT Application
selecting and using, Working with the Proxy Pattern

aliases, type, Unit Types

all operator, Using the contains, exists, and find Operators

AllowIntoPattern property, Using Computation Expression Attributes

AllowNullLiteral attribute, Working with Options

ampersand (&) operator, Interop and Function Parameters

and keyword, Defining an Interface, Using F# Generic Types and Constraints, Working with Discriminated Unions

AND pattern, Using Parameterized Active Patterns

And/Or pattern, Working with the And/Or Pattern and Pattern Grouping

angle bracket (>), exists and exists2

animations, Creating an HTML5 Page

anonymous object types, Working with Reference Cells

APM (Asynchronous Programming Model), Using Asynchronous Workflows

append function, collect

architectural patterns, Creating an F# Portable Library

Array module, Pipe-Forward Operator

array pattern, Using the Tuple Pattern

Array.ofList function, Convert from Seq/List/Array

Array.ofSeq function, Convert from Seq/List/Array

Array.toList function, Convert to Seq/List/Array

Array.toSeq function, Convert to Seq/List/Array

arrays, Lists

categorizing elements, Dealing with the Dutch national flag problem
comparing, Arrays
defined, Lists
defining, Arrays
indexing, Arrays
length of, Pipe-Forward Operator
longest increasing sequence, Finding the longest increasing sequence
median of, Finding the maximum sum of an array
merging, Finding a sum from an array
processing with GPU, Maximum Values in Subarrays
slicing, Arrays
summing, Finding a sum from an array

as keyword, Creating an Indexer

as pattern, Using Variable Patterns and the when Guard

ASCII string representations, Basic Data Types

AsEnumerable(),, Using the select Operator

asin function, Other F# Operators

ASP.NET website

creating, Working with HTML5 and WebSharper
generated JavaScript code, Creating an ASP.NET Website with WebSharper

AssemblyInfo,, Using AssemblyInfo

assert keyword, Exploring the HelloWorld Type Provider

async expression, Using Agents

async keyword, Handling Exceptions

Async.Catch function, Handling Exceptions

Async.FromBeginEnd function, Using Cancellation

Async.StartChild function, Using Cancellation

Async.StartWithContinuation function, Handling Exceptions

Asynchronous Programming Model (APM), Using Asynchronous Workflows

asynchronous workflows, Using Threads

back-end processes, Using Cancellation
callback processes, Using Cancellation
canceling, Handling Exceptions
debugging, Debugging Multithreaded Applications
exception handling, Handling Exceptions
function interface, Using Asynchronous Workflows
let! and do! operators, Working with the Asynchronous Programming Model
primitives, building, Using Cancellation

at (@) operator, Using a quick-sort algorithm

atan function, Other F# Operators

attributes, Using Abstract and Sealed Classes

constant values, defining with, What Changed
defining, Using Reflection
properties, adding to, Generated Type Provider
restrictions on, Defining Attributes

auto-implemented properties, Defining a Property, Using Constructors

AutoOpen attribute, Module, Namespace, and Program Entry Points

average function, Math Operations, Using the min/max, average, and sum Operators

Azure Service Bus Queue code snippets, Azure SQL Database

Azurey (see Windows Azure)

B

B suffix, Basic Data Types

backward composite operator, Pipe/Composite Operators

backward pipe operator (<|), Pipe/Composite Operators

bang (!) operator, Working with the Command Pattern

base classes

abstract, Working with Discriminated Unions
casting to, Converting Numbers and Using enum
extending, Working with Object Expressions
for multi-inheritance type provider, Using the Multi-Inheritance Type Provider

base keyword, Using Inheritance

base types, IntelliSense and, Using the Regular-Expression Type Provider

binaries, building, Compiler Directives

binary operators, Using Operator Overloading

binary search trees (BSTs), F# binary tree and in-order traversal

(see also tree structures)
building, Build a tree from pre-order and in-order sequences
children, checking, Build a BST from a pre-order iteration list
common elements, finding, Find the common elements from two BSTs

binary trees, F# tree representation and traversal

(see also tree structures)
binary search trees, F# binary tree and in-order traversal, Build a tree from pre-order and in-order sequences
building, Delete a tree
children, checking, Build a BST from a pre-order iteration list
common ancestors, finding, Find the tree diameter
common elements, finding, Find the common elements from two BSTs
deleting, Delete a tree
diameter, finding, Find the tree diameter
traversing, Working with Discriminated Unions, Delete a tree

binomial options pricing model (BOPM), Pascal Triangle

binomial trees, and binomial options pricing model, Pascal Triangle

bitwise operations, Enumerations

bitwise operators, Enumerations

blob storage service, Azure, Azure Blob Storage

blob operations, Azure Blob Storage
cloud queue and, Azure Blob Storage
code snippets, Azure SQL Database
worker role code, Azure Blob Storage

BOPM (binomial options pricing model), Pascal Triangle

boxing, Upcasting and Downcasting

breadth-first search (BFS) algorithm, Depth-first search

bridge pattern, Working with F# and Design Patterns, Working with the Adapter Pattern

brokered messaging, Azure Communication

BSTs (binary search trees), F# binary tree and in-order traversal, Build a tree from pre-order and in-order sequences

builder pattern, Working with F# and Design Patterns, Working with the Private Data Class Pattern

byref keyword, Interop and Function Parameters

C

C#

auto-implemented property, Defining a Property
constraints, Using F# Generic Types and Constraints
converting to F#, Some Useful Add-ins, Convert from Seq/List/Array
data types, Basic Data Types
imperative implementation, C# and F# Data Structures
imperative programming support, C# and F# Data Structures
interoperating with, Using Delegates and Events
methods, invoking, Defining a Method
object-oriented programming support, C# and F# Data Structures
passing code to, Working with Object Expressions
Point2D class definition, Using F# for Object-Oriented Programming
switch statement, if Expressions

C, converting to .NET types, F# Quotation and Transform

caching

intermediate results, Using Lazy Evaluation, Partial Functions, and Memoization
values, Using Lazy Evaluation, Partial Functions, and Memoization

canContinue function, Working with the Chain of Responsibility Pattern

casting, type, Creating an Instance

ceil function, Other F# Operators

chain of responsibility pattern, Using Object-Oriented Programming and Design Patterns, Working with the Chain of Responsibility Pattern

chainOfResponsibility function, Working with the Chain of Responsibility Pattern

chainTemplate function, Working with the Chain of Responsibility Pattern

characters, from number inputs, Combination

checkWithFunction function, Working with the Factory Pattern

checkWithMatch function, Working with the Factory Pattern

Choice helper type, Using the Choice Helper Type

class equality, Comparing a Record with Other Data Structures

class keyword, Using Classes

class properties, encapsulating, Working with the Private Data Class Pattern

classes, Using Classes

abstract, Using Inheritance
accessibility modifiers, Using Classes
attributes, Using Abstract and Sealed Classes, Defining Attributes
casting, Converting Numbers and Using enum
constructors, Using Constructors
defining, Using Classes
eliminating, Writing Design Patterns: Additional Notes
extension methods, Using Extension Methods
fields, adding, Using Classes
implicit and explicit class construction, Using Inheritance
indexers, creating, Using Constructors
initialization code, Using Constructors
instances, creating, Using Abstract and Sealed Classes
methods, defining, Defining a Method
nullable, Working with Options
partial, Using Classes
properties, defining, Defining a Property
protected keyword, Using Classes
proxy, Connecting To and Consuming Data
public keyword, Using Classes
sealed, Using Inheritance
self-identifiers, Creating an Indexer
singletons, Working with the Factory Pattern
special/reserved member names, Using a Self-Identifier
static methods, defining, Defining a Method
vs. records, Comparing a Record with Other Data Structures

CLIMutable attribute, Working with Records

Close method, Using the Excel-File Type Provider, Using the Excel-File Type Provider

Closure, C# and F# Data Structures

cloud computing, Cloud and Service Programming with F#

Genetic Algorithms, MapReduce Design Patterns
MapReduce, Code Snippet for Azure Development
Windows Azure, Cloud and Service Programming with F#

cloud data

Excel files, writing to, Performing Serialization
Word documents, writing to, Exporting to Microsoft Excel

cloud queue, Developing a Windows Azure Application

blob service and, Azure Blob Storage
code snippet, Azure SQL Database
consumer role code, Azure Cloud Queue
deployment settings, Azure Cloud Queue
emulator, Azure Cloud Queue
for chromosome storage, Client-Side Code
GA communication, Genetic Algorithms in the Cloud
GAs, setting up for, Genetic Algorithms in the Cloud
instance number, setting, Azure Cloud Queue
operations, Azure Cloud Queue
size, controlling, Genetic Algorithms in the Cloud
sleep time, changing, Azure Cloud Queue
worker role projects, Developing a Windows Azure Application, Azure Cloud Queue

Cloud Service projects, Developing a Windows Azure Application

code

converting from F# to CUDA, F# Quotation and Transform
errors, catching, Working with Units of Measure
executing, Using F# Interactive
execution time, Using F# Interactive
grouping, Using Classes
initialization, Using Constructors
modules, Module, Namespace, and Program Entry Points
namespaces, Module, Namespace, and Program Entry Points
passing to C#, Working with Object Expressions
reusing, Writing Design Patterns: Additional Notes
segmenting into scopes, Variable Names

code quotations, Setting Up the Development Environment, Using the Multi-Inheritance Type Provider, Checking F# Types

(see also quotations)

code snippets, Exploring the HelloWorld Type Provider, Generated Type Provider

Azure blob storage service, Azure SQL Database
Azure Service Bus Queue code snippets, Azure SQL Database
cloud queue, Azure SQL Database
constructors, Using Type-Provider Snippets
F# add-in, Some Useful Add-ins
GA communication with cloud queue, Genetic Algorithms in the Cloud
measure builders, Using Type-Provider Snippets
parameters, Using Type-Provider Snippets
provided methods, Using Type-Provider Snippets
provided parameters, Using Type-Provider Snippets
provided properties, Using Type-Provider Snippets
Service Bus service interface definition, Service-Side Code
static parameters, Using Type-Provider Snippets
type provider skeleton, Using Type-Provider Snippets
type providers, Exploring the HelloWorld Type Provider, Generated Type Provider
Windows Azure, Azure SQL Database
XML comments, Using Type-Provider Snippets

Coding Faster: Getting More Productive with Microsoft Visual Studio (Microsoft Press, 2011), C# and F# Data Structures

collect function, collect

collections

aggregating, find
appending one to one, collect
combinations, Dijkstra algorithm
converting types, Convert to Seq/List/Array
filtering, find
iterating, Variable Names
length, find
mapping, find
mathematical operations on, Math Operations
of functions, Convert from Seq/List/Array
processing, Developing the WinRT Application

command objects, Working with the Chain of Responsibility Pattern

command pattern, Working with F# and Design Patterns, Working with the Adapter Pattern

comparison operations, Working with Comparison Operations for a Record, Tuple, and DU

compile symbols, Compiler Directives

COMPILED compile symbol, Compiler Directives

CompiledName attribute, Creating an F# Portable Library

compiler directives, Compiler Directives

composite operators, Pipe/Composite Operators

composite pattern, Working with F# and Design Patterns, Working with the Factory Pattern

CompositeNode structure, Working with the Composite Pattern

computation expressions, Using Agents

attributes, Working with Computation Expressions
for rounding, Working with Computation Expressions
methods, Working with Computation Expressions
restrictions, Working with Computation Expressions
sample, Using Computation Expression Attributes

con operator (::), Using the List and Array Patterns

conditional compilation symbols, Using the LINQ-to-SQL Type Provider

connect function, Working with the Composite Pattern

connection strings, specifying, Using the LINQ-to-SQL Type Provider

console applications, creating, Run Your Program, Module, Namespace, and Program Entry Points

console output, Console Output

Console.WriteLine method, Console Output

constant pattern, Using Pattern Matching

constants, defining, What Changed

constraints, Using the IDisposable Interface

chaining, Using F# Generic Types and Constraints
functions, Working with the Adapter Pattern
NULL, Using F# Generic Types and Constraints

constructors, Using Constructors

accessibility modifiers, Using Constructors
code snippet, Using Type-Provider Snippets
do bindings, Using Constructors, Using Constructors
implicit and explicit class construction, Using Inheritance
in records, Working with Records
in type providers, Setting Up the Development Environment, Exploring the HelloWorld Type Provider
invoking, Using Inheritance
let bindings, Using Constructors, Using Constructors
multiple, Using Constructors
new keyword, Using Constructors
optional, Using Constructors
primary, Using Constructors
static, Using Constructors
then keyword, Using Constructors
XML documents and, Using Constructors

consumer role code, Azure Cloud Queue

contains operator, Using the count and distinct Operators

continuation passing style (CPS), Using the Continuation Passing Style

Fibonacci function, converting, Using the Continuation Passing Style
recursive functions, converting, Using the Continuation Passing Style
tree traversal, converting, Using the Continuation Passing Style
vs. recursion vs. tail calls, Using the Continuation Passing Style

conversion, Setting Up the Development Environment

(see also quotations)
data, Real-World Samples
implicit and explicit, Converting Numbers and Using enum

CoreComputation class, Working with the Decorator Pattern

cos function, Other F# Operators

cosh function, Other F# Operators

count operator, Using the head, last, and nth Operators

CPS (continuation passing style), Using the Continuation Passing Style

CPUs

filtering functions, moving to GPU, Using the Monte Carlo Simulation to Compute the π Value on a GPU
host memory, CUDA
Pascal Triangle, Pascal Triangle

CSV type provider, Using the CSV Type Provider

cuBLAS (CUDA Basic Linear Algebra Subroutines) library, cuBLAS Library

data structures, cuBLAS Library
dumpbin.exe, cuBLAS Library
F# wrapper code, cuBLAS Library
invoking, cuBLAS Library
overloaded functions, cuBLAS Library

CUDA, Introducing GPU and GPGPU, CUDA

converting to F# code, F# Quotation and Transform
CUDA Basic Linear Algebra Subroutines library, cuBLAS Library
CUDA Random Number Generation library, CUDA, Using the Monte Carlo Simulation to Compute the π Value on a GPU
CUDA Toolkit, CUDA
cudaLimit enumeration, CUDA
data, transferring between device and host memory, CUDA
defined, CUDA
device flag definitions, CUDA
device management functions, CUDA
device memory-management function, CUDA
device property execution result, CUDA
driver and runtime APIs, CUDA, CUDA
driver information, CUDA
F# code, translating, F# Quotation on GPGPU
graphics card limitations, CUDA
graphics card properties, CUDA
installation, CUDA
interop code, CUDA

CUDA Zone, Using the Monte Carlo Simulation to Compute the π Value on a GPU

CUDADeviceProp structure, CUDA

cudaError structure, CUDA, CUDA

CUDALibrary.h file, F# Quotation and Transform, F# Quotation on GPGPU

CUDAMemcpyKind type, CUDA

CUDAPointer,, F# Quotation and Transform

CUDAPointer2,, F# Quotation and Transform

CUDARuntime class, F# Quotation on GPGPU

cuError structure, CUDA

cuRAND (CUDA Random Number Generation) library, CUDA, Using the Monte Carlo Simulation to Compute the π Value on a GPU

accept-reject algorithm, cuRAND Library
CUDAPointer struct, cuRAND Library
CUDARandom class definition, cuRAND Library
CUDARandom class, invoking, cuRAND Library
RanGenerator structure, cuRAND Library
x86 and x64 versions, cuRAND Library

CustomOperation attribute, Using Computation Expression Attributes

D

data binding, enabling, Developing the WinRT Application

Data property, Using the CSV Type Provider, Using the CSV Type Provider

data sets, processing, Code Snippet for Azure Development

(see also MapReduce)

data structures

attributes, applying, Defining Attributes
defined, C# and F# Data Structures

data types, Using the Regular-Expression Type Provider

(see also types)
basic, Basic Data Types
sorting, Developing the WinRT Application
triple-quoted strings, Basic Data Types
variable names, Triple-Quoted Strings

data-rich environments, Type Providers

databases, Other Type Providers

(see also query syntax; SQL databases, Azure)
counting data elements, Using the head, last, and nth Operators
external access, Using the LINQ-to-SQL Type Provider
filtering data, Using the select Operator, Connecting To and Consuming Data
grouping data, Using the group Operator
joining data, Using the join Operator
records, adding and removing, SQL Entity Type Provider
skipping data, Using the take and skip Operators
sorting data, Using the join Operator
updating, Using the LINQ-to-SQL Type Provider
Word documents, passing data to, Exporting to Microsoft Excel

db variable, Using the LINQ-to-SQL Type Provider, Using the LINQ-to-SQL Type Provider

debugging multithreaded operations, Debugging Multithreaded Applications

decorator pattern, Working with F# and Design Patterns, Working with the Observer Pattern

decr function, Working with the Command Pattern, Other Unique Features

default keyword, Using Inheritance

defaultArg function, Defining a Method

DefaultValue attribute, Adding Fields

define first and reference later principle, Using Constructors

delegates, Using Operator Overloading

combining, Using Delegates and Events
defined, Using Operator Overloading
defining, Using Operator Overloading
invoking, Using Delegates and Events

depth-first search (DFS) algorithm, Using the Graph Library

derived classes, casting to, Upcasting and Downcasting

design patterns, F# and Design Patterns

active patterns, Working with the Chain of Responsibility Pattern, Working with the Chain of Responsibility Pattern
adapter pattern, Working with F# and Design Patterns, Working with the Adapter Pattern
behavior patterns, Writing Design Patterns: Additional Notes
bridge pattern, Working with F# and Design Patterns, Working with the Adapter Pattern
builder pattern, Working with F# and Design Patterns, Working with the Private Data Class Pattern
chain of responsibility pattern, Using Object-Oriented Programming and Design Patterns, Working with the Chain of Responsibility Pattern
command pattern, Working with F# and Design Patterns, Working with the Adapter Pattern
composite pattern, Working with F# and Design Patterns, Working with the Factory Pattern
decorator pattern, Working with F# and Design Patterns, Working with the Observer Pattern
defined, F# and Design Patterns
facade pattern, Working with F# and Design Patterns, Working with the Façade Pattern
factory pattern, Working with F# and Design Patterns, Working with the State Pattern
for MapReduce, MapReduce Design Patterns
memento pattern, Working with F# and Design Patterns, Working with the Façade Pattern
object-oriented programming and, F# and Design Patterns
observer pattern, Working with F# and Design Patterns, Working with the Command Pattern
private data class pattern, Working with F# and Design Patterns, Working with the Private Data Class Pattern
proxy pattern, Working with F# and Design Patterns, Working with the Decorator Pattern
singleton pattern, Working with F# and Design Patterns, Working with the Factory Pattern
state pattern, Working with F# and Design Patterns, Working with the Strategy Pattern
strategy pattern, Working with F# and Design Patterns, Working with the Proxy Pattern
structural patterns, Writing Design Patterns: Additional Notes
template pattern, Working with F# and Design Patterns, Working with the Composite Pattern
writing, Writing Design Patterns: Additional Notes

design principles, SOLID, Working with Reference Cells

design-time DLLs, Using the DGML-File Type Provider

device memory, CUDA

(see also GPUs (graphics processing units))
CUDA management function, CUDA
transferring from host memory, CUDA

__device__ keyword, F# Quotation on GPGPU

DFS (depth-first search) algorithm, Using the Graph Library

DGML files, graph deserialization from, Using the Graph Library

DGML-file type provider, Using the XML Type Provider

DGMLClass type, Using the DGML-File Type Provider

DGMLReader, invoking, Using the Graph Library

Dijkstra algorithm, Dijkstra algorithm

Directed Graph Markup Language (DGML), Using the XML Type Provider

disconnect function, Working with the Composite Pattern

discriminated unions (DUs), Working with the Command Pattern, Working with Discriminated Unions

binary tree structures, Working with Discriminated Unions
comparing, Working with Comparison Operations for a Record, Tuple, and DU
decomposing, Using the List and Array Patterns, Find the tree diameter
interfaces, Working with Discriminated Unions
members and properties, Working with Discriminated Unions
recursive feature, Working with Discriminated Unions
reflection on, Using Tuples
Shape type, Working with Discriminated Unions

Dispose method, Using the IDisposable Interface

distinct operator, Using the head, last, and nth Operators

do bindings, Using Constructors, Using Constructors

self-identifiers in, Creating an Indexer

do! (do-bang), Working with the Asynchronous Programming Model

Do/Undo functionality, Working with the Command Pattern

dot notation, Lists

double star (**) operator, Defining a Method

double-backticks, Triple-Quoted Strings

downcast keyword, Upcasting and Downcasting

dual-choice structures, Using the Choice Helper Type

dumpbin.exe, cuBLAS Library

DUs (see discriminated unions (DUs))

E

echo services, Setting Up the Service from Azure Management Portal

elements

all, checking, exists and exists2
existence, checking, Pipe-Forward Operator
index lookups, find

elif expressions, while Loops

else compiler directive, Compiler Directives

Emit method, MapReduce Design Patterns

Empty function, Lists

emptyList element, Lists

emptyList2 element, Lists

encapsulation, Using Object-Oriented Programming and Design Patterns, Writing Design Patterns: Additional Notes

class properties, Working with the Private Data Class Pattern

endif compiler directive, Compiler Directives

Entity type provider for Azure SQL databases, Azure SQL Database

EntryPoint attribute, Module, Namespace, and Program Entry Points

enum conversion, Creating an Instance

enumerations, Variable Names

defining, Enumerations

equal function definitions, exists and exists2

equal sign (=), exists and exists2, Module, Namespace, and Program Entry Points

equality comparisons, Lists

erased type providers, Write Your Own Type Provider

vs. generated type providers, Separating Run Time and Design Time

errors

indentation problems, Some Useful Add-ins
type conversion, Basic Data Types
type information and, Type Inferences

escape characters, Triple-Quoted Strings

Event type, Using Delegates and Events

events, Using Operator Overloading, Working with the Observable Module

converting, Working with the Observable Module
defined, Using Delegates and Events
defining, Using Delegates and Events
filtering, Working with the Observable Module
invoking, Using Delegates and Events
merging, Working with the Observable Module
partitioning data, Working with the Observable Module

evolutionary process (see GAs (Genetic Algorithms))

exactlyOne operator, Using the contains, exists, and find Operators

Excel, retrieving cloud data into, Performing Serialization

Excel-file type provider, Using the CSV Type Provider

exception handling

in agents, Using Agents
in asynchronous workflows, Handling Exceptions

exceptions, Working with Exceptions

catching, Working with Exceptions
defining, Throwing Exceptions
exn abbreviation, Working with Exceptions
reflection on, Using Exceptions with F#
throwing, Throwing Exceptions

exclamation point (!), Other Unique Features

Execute In Interactive command, Using F# Interactive

Execute Line In Interactive command, Using F# Interactive

ExecuteStoreQuery method, SQL Entity Type Provider

executeStrategy function, Working with the Strategy Pattern

executing code, Using F# Interactive

branching, Variable Names
execution time, Using F# Interactive

exists function, Pipe-Forward Operator, Using the count and distinct Operators

exists2 function, Pipe-Forward Operator

exn abbreviation, Working with Exceptions

explicit class construction, Using Inheritance

extension methods, Using Extension Methods

extern function, Interop and Function Parameters

F

F#

code snippet add-in, Some Useful Add-ins
converting to CUDA code, F# Quotation and Transform, F# Quotation on GPGPU
data types, Basic Data Types
define first and reference later approach, Using Constructors
depth colorizer, Some Useful Add-ins, Working with Records
functional programming support, C# and F# Data Structures, In Closing
imperative programming support, C# and F# Data Structures
interoperating with C# projects, Using Delegates and Events
NULL value support, Working with Options
object-oriented programming support, C# and F# Data Structures, Using F# for Object-Oriented Programming
operators, Using Operator Overloading
snippets, Exploring the HelloWorld Type Provider, Generated Type Provider
syntax (see syntax)
T-SQL knowledge, mapping to, SQL Query and F# Query
Windows 8 verification bug, Developing the WinRT Application

F# Interactive (FSI), Using F# Interactive, Pipe-Forward Operator, Pipe-Forward Operator, Type Inferences

F# library, Finding a sum from an array

(see also portable library)
for GPU translations, GPGPU with F#

F# quotations, F# Quotation and Transform

(see also quotations)

F# types, What Changed

F1 function, Using the Excel-File Type Provider

F2 function, Using the Excel-File Type Provider

facade pattern, Working with F# and Design Patterns, Working with the Façade Pattern

factories, Working with the State Pattern

factory pattern, Working with F# and Design Patterns, Working with the State Pattern

failwith function, Throwing Exceptions

failwithf function, Throwing Exceptions

FCore numerical library (Statfactory), Using the Monte Carlo Simulation to Compute the π Value on a GPU

fields, class

default values, Adding Fields
DefaultValue attribute, Adding Fields
defining, Using Classes
explicit, Using Classes
let keyword, Using Classes
val keyword, Using Classes

File System type provider, Other Type Providers

filter function, find

find function, exists and exists2, Using the count and distinct Operators

fixed query schema file, WSDL Type Provider Parameters

fixed-query datasets, Connecting To and Consuming Data

flexible types, Using F# Generic Types and Constraints

float type, Basic Data Types, Math Operations, Working with Units of Measure

float32 type, Basic Data Types

floor function, Other F# Operators

flow control, Variable Names

console output, Console Output
for loops, Variable Names
if expressions, while Loops
match expressions, if Expressions
while loops, for Loop

fold function, find

for loops, Variable Names

for...in form, Variable Names
for...to/downto form, Variable Names

forall function, exists and exists2

forall2 function, exists and exists2

Force method, Using Lazy Evaluation, Partial Functions, and Memoization

Fork/Join pattern, Using Threads

formlets

as wizards, Using a Formlet Type to Get Input and Generate Output

forward composite operator, Pipe/Composite Operators

FSharp.Data.TypeProviders assembly, Using the LINQ-to-SQL Type Provider

FSharpX project, Other Type Providers

FSI (F# Interactive), Using F# Interactive, Using the LINQ-to-SQL Type Provider

commands, Using F# Interactive
debugging code, Pipe-Forward Operator
default folder, FSIAnyCPU
directives, FSIAnyCPU
executing code, Using F# Interactive
function definitions, checking, Pipe-Forward Operator
references, adding, Type Inferences
resetting sessions, Using F# Interactive
window, Using F# Interactive

FSIAnyCPU feature, Using F# Interactive

fst function, Tuples

FuncConvert.FuncFromTupled, Pipe/Composite Operators

function keyword, Working with the State Pattern, Using Pattern Matching

function operators, Recursive Functions, Writing Design Patterns: Additional Notes

functional programming, C# and F# Data Structures, Pipe-Forward Operator, Convert from Seq/List/Array, In Closing

design patterns and, Writing Design Patterns: Additional Notes

functions, Convert from Seq/List/Array, Tuples

active pattern, Using Multicase Active Patterns
CompiledName attribute, Creating an F# Portable Library
continuations, Using the Continuation Passing Style
defining, Tuples
definitions, checking, Pipe-Forward Operator
encapsulating, Writing Design Patterns: Additional Notes
implementing, Function
initialization, Working with Options
inline, Working with the Adapter Pattern
mutually recursive, Recursive Functions
names, special characters in, Exploring the Portable Library Samples
naming convention, Creating an F# Portable Library
nonpartial, Using Lazy Evaluation, Partial Functions, and Memoization
overriding, Using a Self-Identifier
partial, Using Lazy Evaluation, Partial Functions, and Memoization
quotations, getting, F# Quotation and Transform
referencing, Module, Namespace, and Program Entry Points
statically resolved type parameters, Working with the Adapter Pattern
tail calls, Recursive Functions
templates, Working with the Composite Pattern
wrapping, Using the CSV Type Provider

G

garbage collection, Using the IDisposable Interface

GAs (Genetic Algorithms), MapReduce Design Patterns

Azure communication, Azure Communication
chromosomes, MapReduce Design Patterns
code, Elitism
code, invoking, Azure Communication
communication with cloud queue, Genetic Algorithms in the Cloud
crossover and mutation, Selection
diversity, Elitism
elitism, Crossover and Mutation
fitness function, MapReduce Design Patterns
in the cloud, Client-Side Code
loci, Understanding Genetic Algorithms
Monitor role, Genetic Algorithms in the Cloud
population, MapReduce Design Patterns
population convergence, Elitism
population initialization, Understanding Genetic Algorithms, Elitism
query results, Genetic Algorithms in the Cloud
recombination, MapReduce Design Patterns, Selection
Run function, Genetic Algorithms in the Cloud
selection, Selection
simple GA functionality, Understanding Genetic Algorithms

General-Purpose Computation on Graphics Hardware, Using the Monte Carlo Simulation to Compute the π Value on a GPU

general-purpose GPU (see GPGPU (general-purpose GPU))

generated properties, Generated Type Provider

generated type providers, Write Your Own Type Provider, What Is a Type Provider?, Separating Run Time and Design Time

fields, Generated Type Provider
test code, Generated Type Provider

generated types, accessing, Generated Type Provider

generic constraints, Using F# Generic Types and Constraints

generic invoke (GI) function, Console Output, Writing Design Patterns: Additional Notes, Working with a Generic Invoke Function

inline function, Working with a Generic Invoke Function

generic types, Using the IDisposable Interface

new keyword and, Creating an Instance

Genetic Algorithms (GAs) (see GAs (Genetic Algorithms))

GetDataContext method, Using the LINQ-to-SQL Type Provider

GitHub, Other Type Providers

global operators, Using Operator Overloading

__global__ keyword, F# Quotation on GPGPU

GPGPU (general-purpose GPU), GPGPU with F#

defined, Introducing GPU and GPGPU
F# translations on, F# Quotation on GPGPU
for real-time math operations, GPGPU with F#

GPUAttribute attribute, F# Quotation and Transform, F# Quotation on GPGPU

GPUExecution class, F# Quotation on GPGPU

GPUs (graphics processing units), GPGPU with F#

array processing, Maximum Values in Subarrays
data, copying to and from, CUDA
defined, Introducing GPU and GPGPU
device flag definitions, CUDA
driver information, CUDA
filtering functions, Using the Monte Carlo Simulation to Compute the π Value on a GPU
functions, loading and executing, F# Quotation on GPGPU
hardware limitations, CUDA
OpenCL, Introducing GPU and GPGPU
Pascal Triangle, Pascal Triangle
performance, measuring, Using the Monte Carlo Simulation to Compute the π Value on a GPU
simulations, Maximum Values in Subarrays
supported types, checking for, F# Quotation and Transform
uses, Introducing GPU and GPGPU

Graph class, Using the Graph Library

graph library, Using the Graph Library

A* algorithm, Find all paths in a graph
breadth-first search algorithm, Depth-first search
depth-first search algorithm, Using the Graph Library
Dijkstra algorithm, Dijkstra algorithm

graphics processing units (see GPUs (graphics processing units))

graphs

defined, Using the Graph Library
deserializing, Using the Graph Library
paths, finding, Find all paths in a graph

group join operations, Using the join Operator

group operator, Using the group Operator

grouping code, Using Classes

groupValBy keyword, Using the group Operator

H

head operator, Using the head, last, and nth Operators

HelloWorld type provider, Exploring the HelloWorld Type Provider

constructor, Exploring the HelloWorld Type Provider
invoking, Exploring the HelloWorld Type Provider
ProvidedMethod type, Exploring the HelloWorld Type Provider
ProvidedProperty type, Exploring the HelloWorld Type Provider

#help directive, FSIAnyCPU

HideObjectMethods property, Using the Regular-Expression Type Provider

higher-order functions, Working with the Chain of Responsibility Pattern, Working with the Strategy Pattern, Working with the Composite Pattern, Working with the Builder Pattern, Writing Design Patterns: Additional Notes

host memory, CUDA

transferring to device memory, CUDA

HTML5 pages, creating, Creating an HTML5 Page

I

id function, collect

identifier pattern, Using the List and Array Patterns

IDisposable interface, Type Inferences, Using the IDisposable Interface

new keyword and, Using Abstract and Sealed Classes

IEchoChannel interface, Setting Up the Service from Azure Management Portal, Service-Side Code

IEchoContract interface, Setting Up the Service from Azure Management Portal, Service-Side Code

if compiler directive, Compiler Directives

if expressions, while Loops

else branch, while Loops

ignore operator, Unit Types

ILoanCalculator interface, Azure WCF Service

images, storing as blobs, Azure Blob Storage

imperative programming, C# and F# Data Structures, Convert from Seq/List/Array

implicit class construction, Using Inheritance

IMyInterface parameter, Working with Reference Cells

“Incomplete pattern matches on this expression” warnings, Using the Excel-File Type Provider

incr function, Working with the Command Pattern, Other Unique Features

indexed properties, Defining a Property

indexers

arrays and, Arrays
creating, Using Constructors
Item property, Using Constructors
lists and, Lists

inherit keyword, Using Inheritance

inheritance, Using Inheritance, Using Object-Oriented Programming and Design Patterns, Writing Design Patterns: Additional Notes

interfaces and, Defining an Interface
with type providers, Using a Wrapper Type Provider

initialization code, Using Constructors

additional, Using Constructors

inline function, Working with a Generic Invoke Function

input strings, reading, Working with Options

input, invalid, Working with Options

InstanceContextMode field, Genetic Algorithms in the Cloud

instances

creating, Using Abstract and Sealed Classes
upcasting and downcasting, Converting Numbers and Using enum

integers, converting to enumeration, Enumerations

IntelliSense, Using F# Interactive, Type Providers

base types and, Using the Regular-Expression Type Provider
column names, Using the LINQ-to-SQL Type Provider
generated types and, Write Your Own Type Provider
in F# projects, Using the LINQ-to-SQL Type Provider
type information, Type Inferences
with type providers, Using the LINQ-to-SQL Type Provider

INTERACTIVE compile symbol, Compiler Directives

interfaces

defining, Upcasting and Downcasting
IDisposable,, Using the IDisposable Interface
implementing, Defining an Interface
inheritance, Defining an Interface
with properties, Defining an Interface

interleaving, Using Threads, Using Asynchronous Workflows, Permutations of a string

internal keyword, Using Constructors

interop function, Type Inferences

interoperating with C# projects, Using Delegates and Events

invalidArg function, Throwing Exceptions

InvalidCastException function, Upcasting and Downcasting

invalidOp function, Throwing Exceptions

InvalidOperationException errors, Using Constructors

InvokeCode,, Using the Multi-Inheritance Type Provider

IsErased property, Separating Run Time and Design Time

IsLikeJoin property, Using Computation Expression Attributes

IsMatch static method, Using the Regular-Expression Type Provider

IState interface, Using the DGML-File Type Provider

Item property, Defining a Property, Using Constructors

item templates, Using F# Interactive

J

join operator, Using the join Operator

group joins, Using the join Operator
outer joins, Using the join Operator

JSON serialization, Performing Serialization

JSON type provider, Other Type Providers

K

Kadane algorithm, Finding the maximum sum of an array
KeyNotFoundException, exists and exists2
keywords, Using a Self-Identifier
Khronos Group, Using the Monte Carlo Simulation to Compute the π Value on a GPU
KMP string search algorithm, String interleaving

L

#l directive, FSIAnyCPU

lambda expressions, Using Operator Overloading

language features, Type Providers

Language Integrated Query (LINQ), C# and F# Data Structures, Some Useful Add-ins

LanguagePrimitives.Float32WithMeasure,, Working with Units of Measure

LanguagePrimitives.FloatWithMeasure,, Working with Units of Measure

large data sets, processing, Code Snippet for Azure Development

(see also MapReduce)

last operator, Using the head, last, and nth Operators

lazy evaluation, Using Lazy Evaluation, Partial Functions, and Memoization

on loops, Build a BST from a pre-order iteration list

lazy keyword, Using Lazy Evaluation, Partial Functions, and Memoization

Lazy.Create,, Using Lazy Evaluation, Partial Functions, and Memoization

legacy code, invoking, Working with the Adapter Pattern

length function, Pipe-Forward Operator

let bindings, Using Constructors

modifiers and, Using Constructors

let keyword, Basic Data Types, Using Classes

let! (let-bang) operator, Working with the Asynchronous Programming Model

libraries

CUDA Basic Linear Algebra Subroutines library, cuBLAS Library
CUDA Random Number Generation library, CUDA, Using the Monte Carlo Simulation to Compute the π Value on a GPU
F# Portable Library template, Exploring the Portable Library Samples
FCore numerical library (Statfactory), Using the Monte Carlo Simulation to Compute the π Value on a GPU
graph library, Using the Graph Library
Portable Class Library project, Portable Library and HTML/JavaScript
portable library, Developing Windows Store Applications with F#
Task Parallel Library, Using Cancellation

line compiler directive, Compiler Directives

line intersections, Reservoir sampling

linear algebra

CUDA Basic Linear Algebra Subroutines library, cuBLAS Library
resources for, Using the Monte Carlo Simulation to Compute the π Value on a GPU

LINQ (Language INtegrated Query), C# and F# Data Structures, Some Useful Add-ins

LINQ-to-SQL type provider, Using the LINQ-to-SQL Type Provider

LIS (longest increasing sequence), Finding the longest increasing sequence

List module, Pipe-Forward Operator

list pattern, Using the Tuple Pattern

List.ofArray function, Convert from Seq/List/Array

List.ofSeq function, Convert from Seq/List/Array

List.toArray function, Convert to Seq/List/Array

List.toSeq function, Convert to Seq/List/Array

lists, Lists

combinations, Dijkstra algorithm
comparing, Lists
concatenating, Lists, Using a quick-sort algorithm
defining, Lists
elements, attaching, Lists
heads and tails, Using a quick-sort algorithm
indexing, Lists
length of, Pipe-Forward Operator
merging, Performing a merge sort
operators, Lists
shuffling, Phone keyboard
sorting, zip and zip3
structural equality, Lists

ListT type, Lists

Literal attribute, What Changed, Using the LINQ-to-SQL Type Provider

#load directive, FSIAnyCPU

lock function, Using Threads, Using Threads

log function, Other F# Operators

log10 function, Other F# Operators

longest increasing sequence (LIS), Finding the longest increasing sequence

M

mailbox processor, Working with the State Pattern, Using the DGML-File Type Provider, Debugging Multithreaded Applications, Using Agents

main function, Module, Namespace, and Program Entry Points

MaintainsVariableSpace property, Using Computation Expression Attributes

MaintainsVariableSpaceUsingBind property, Using Computation Expression Attributes

Manage NuGet Packages dialog box, Other Type Providers

map combinators, Code Snippet for Azure Development

map data structure, Convert from Seq/List/Array

map function, find

MapReduce, Code Snippet for Azure Development

counting, MapReduce Design Patterns
data, passing in, MapReduce
design patterns, MapReduce Design Patterns
Emit method, MapReduce Design Patterns
graph processing, MapReduce Design Patterns
map step, MapReduce
parameter and result queues, MapReduce
reduce step, MapReduce
simulating, MapReduce
worker role projects, MapReduce

match expressions, if Expressions

missing patterns, Using the Tuple Pattern
option type, Using the List and Array Patterns

Match method, Using the Regular-Expression Type Provider

match statement, Binary search tree

active pattern and, Using Parameterized Active Patterns
shortcut for, Working with the State Pattern

mathematical operations, Math Operations

in real time, GPGPU with F#

matrices

graphs as, Find all paths in a graph
manipulation, Using the Monte Carlo Simulation to Compute the π Value on a GPU

max function, Math Operations, Other F# Operators

measure builders code snippet, Using Type-Provider Snippets

Median pattern, Finding the median of two sorted arrays

member keyword, Defining a Property, Working with Records

self-identifiers in, Creating an Indexer

member names, special/reserved, Using a Self-Identifier

members, hiding from base class, Using a Self-Identifier

memento pattern, Working with F# and Design Patterns, Working with the Façade Pattern

memoization, Using Lazy Evaluation, Partial Functions, and Memoization

code template, Using Lazy Evaluation, Partial Functions, and Memoization

merge function, Performing a merge sort

merge operations

on arrays, Finding a sum from an array
sorts, Performing a merge sort

message queues, Working with the State Pattern

messaging, Azure Communication

meta-programming, Using a Wrapper Type Provider, Using the Multi-Inheritance Type Provider

methods

accessing, Defining an Interface
defined, Defining a Method
defining, Defining a Method
extension, Using Extension Methods
invoking, Using a Wrapper Type Provider
overriding, Using Abstract and Sealed Classes
static, Defining a Method
virtual, Using Inheritance

Microsoft Excel, retrieving cloud data into, Performing Serialization

Microsoft IntelliSense (see IntelliSense)

Microsoft Translator, fixed-query datasets, Connecting To and Consuming Data

Microsoft Visual Studio 2012 (see Visual Studio)

Microsoft Web Platform Installer 4.5, Setting Up Your Environment

Microsoft Word, retrieving cloud data into, Exporting to Microsoft Excel

Microsoft.FSharp.Control namespace, Using Delegates and Events

Microsoft.FSharp.Core.dll, Lists, Defining a Method

min function, Math Operations, Other F# Operators

min/max operators, Using the min/max, average, and sum Operators

Model-View-ViewModel (MVVM) pattern, Creating an F# Portable Library

modules, Pipe-Forward Operator, Using Classes

defining, Module, Namespace, and Program Entry Points
extending, Module, Namespace, and Program Entry Points
nesting, Module, Namespace, and Program Entry Points
use keyword and, Using the IDisposable Interface

Monte Carlo simulation, Maximum Values in Subarrays

multithreaded operations

debugging, Debugging Multithreaded Applications
immutable variables and, while Loops

mutable data, defining, Other Unique Features

mutable fields, Defining Structure

mutable keyword, while Loops, Working with Records

mutable variables, Working with the Command Pattern

MyCollectionExtensions namespace, Module, Namespace, and Program Entry Points

MyException type, Throwing Exceptions

N

namespaces, Module, Namespace, and Program Entry Points

.NET 4+, Using Cancellation

.NET methods, Interop and Function Parameters

.NET serialization, Performing Serialization

.NET types, Using Type-Provider Snippets

converting to C, F# Quotation and Transform

neural networks, Find triangles

defined, Find triangles
training, Neural network

new keyword, Type Inferences, Using Constructors, Using Abstract and Sealed Classes

Norvig, Peter, Writing Design Patterns: Additional Notes

nowarning compiler directive, Compiler Directives

nth operator, Using the head, last, and nth Operators

NuGet packages, Other Type Providers

NULL constraints, Using F# Generic Types and Constraints

NULL pattern, Using the List and Array Patterns

NULL values, Using F# Generic Types and Constraints, Working with Options, CUDA

options, converting to or from, Working with Options

Nullable.float type, Using the min/max, average, and sum Operators

nullArg function, Throwing Exceptions

number conversion, Creating an Instance

numerical input, characters from, Combination

NVCC.exe, F# Quotation on GPGPU

NVIDIA CUDA, Introducing GPU and GPGPU, CUDA

O

object expressions, Working with the Factory Pattern, Writing Design Patterns: Additional Notes, Writing Design Patterns: Additional Notes, Working with Reference Cells

abstract classes, Working with Object Expressions
base classes, extending, Working with Object Expressions
code, organizing, Working with Object Expressions
multiple interfaces, implementing, Working with Object Expressions
property declarations, Working with Object Expressions
reference cells in, Working with Object Expressions
restrictions, Working with Object Expressions
WPF commands in, Working with Object Expressions

object-oriented programming (OOP), Using F# for Object-Oriented Programming

classes, Using Classes
design patterns and, F# and Design Patterns
encapsulation, Using Object-Oriented Programming and Design Patterns
inheritance, Using Inheritance, Using Object-Oriented Programming and Design Patterns, Writing Design Patterns: Additional Notes
polymorphism, Using Object-Oriented Programming and Design Patterns

objects

anonymous, Working with Reference Cells
building, Working with the Private Data Class Pattern
decorating, Working with the Observer Pattern
internal state, saving, Working with the Façade Pattern
placeholders and interfaces for, Working with the Decorator Pattern
state of, Working with the Strategy Pattern

objExpression type, Working with Reference Cells

Observable module, Working with the Observer Pattern, Working with the Observable Module

partition function, Working with the Observable Module

ObservableCollection with list features, Using ObservableCollection with List Features

ObservableList,, Using ObservableCollection with List Features

observer pattern, Working with F# and Design Patterns, Working with the Command Pattern

OData type provider, WSDL Type Provider Parameters

parameters, OData Type Provider
Windows Azure Marketplace, connecting with, Connecting To and Consuming Data

Office Open XML File format, Using the CSV Type Provider

Office OpenXML SDK, Exporting to Microsoft Excel

OnRun function, Azure Blob Storage

OnStart function, Azure Blob Storage

OOP (object-oriented programming), Using F# for Object-Oriented Programming

Open Data Protocol (OData) type provider, WSDL Type Provider Parameters

open statement, Module, Namespace, and Program Entry Points

Open XML SDK, Using the CSV Type Provider

OpenCL, Introducing GPU and GPGPU

OpenCL on NVIDIA, Using the Monte Carlo Simulation to Compute the π Value on a GPU

operator characters, names, Using Operator Overloading

operators

binary, Using Operator Overloading
generated names, Using Operator Overloading
global, Using Operator Overloading
overloading, Using Extension Methods
passing to higher-order functions, Using Asynchronous Workflows
unary, Using Operator Overloading

option data structure, Working with the Chain of Responsibility Pattern, Working with the Chain of Responsibility Pattern

optional constructors, Using Constructors

options, Working with Object Expressions

characteristics of, Working with Object Expressions
members, Working with Object Expressions
NULL values, converting to or from, Working with Options
NULL vs. None,, Working with Options

Out attribute, Interop and Function Parameters

out parameter, Interop and Function Parameters

outer joins, Using the join Operator

overloading

operators, Using Extension Methods
type inferences and, Type Inferences

override keyword, Using a Self-Identifier

overriding

functions, Using a Self-Identifier
methods, Using Abstract and Sealed Classes

P

parallel/asynchronous programming, Using Threads

parameters

code snippet, Using Type-Provider Snippets
for active pattern, Using Multicase Active Patterns
grouping, Tuples
named features, Defining a Method
optional, Defining a Method

partial functions, Using Lazy Evaluation, Partial Functions, and Memoization

Pascal Triangle, Pascal Triangle

BOPM, converting to, Using Binomial Trees and the BOPM
processing, Pascal Triangle

pascalTriangle function, F# Quotation on GPGPU

pattern grouping, Working with the And/Or Pattern and Pattern Grouping

pattern matching, Using Pattern Matching

And/Or pattern, Working with the And/Or Pattern and Pattern Grouping
array pattern, Using the Tuple Pattern
as pattern, Using Variable Patterns and the when Guard
Choice helper type, Using the Choice Helper Type
constant pattern, Using Pattern Matching
function keyword, Using Pattern Matching
identifier pattern, Using the List and Array Patterns
list pattern, Using the Tuple Pattern
missing patterns, Using the Tuple Pattern
NULL pattern, Using the List and Array Patterns
pattern grouping, Working with the And/Or Pattern and Pattern Grouping
quick sort algorithm, Using a quick-sort algorithm
record pattern, Using the List and Array Patterns
tuple pattern, Using Pattern Matching
type pattern, Using Variable Patterns and the when Guard
underscore (_), Using Pattern Matching
variable patterns, Using Variable Patterns and the when Guard
when guard, Using Variable Patterns and the when Guard

patterns, F# and Design Patterns

(see also design patterns; pattern matching)
defined, Using Pattern Matching

phone keyboard, Combination

pi, calculation, Maximum Values in Subarrays

pipe operations, hooking into, Pipe/Composite Operators

pipe operators, Pipe/Composite Operators

pipe-backward operator (<|), Pipe/Composite Operators

pipe-forward operator (|>), Arrays

pipeline operators, Writing Design Patterns: Additional Notes

placeholders, format specification indicators, Console Output

polymorphism, Using Object-Oriented Programming and Design Patterns, Writing Design Patterns: Additional Notes

Portable Class Library project, Portable Library and HTML/JavaScript

portable library

arrays, operations on, Finding a sum from an array
code change for data binding, Developing the WinRT Application
collection data structures, Developing the WinRT Application
combination, Dijkstra algorithm
continuation passing style, Using the Continuation Passing Style
creating, Developing Windows Store Applications with F#
data types, sorting, Developing the WinRT Application
data, categorizing, Dealing with the Dutch national flag problem
default content, Developing Windows Store Applications with F#
for WinRT applications, Exploring the Portable Library Samples
graph library, Using the Graph Library
line intersections, Reservoir sampling
neural networks, Find triangles
phone keyboard, Combination
project properties, Developing the WinRT Application
properties, Creating an F# Portable Library
reservoir sampling, Shuffle algorithm
Result property, Developing the WinRT Application, Developing the WinRT Application
samples, Exploring the Portable Library Samples
sequences, Finding the longest increasing sequence
shuffle algorithm, Phone keyboard
string operations, Calculate the tree boundary
tree structures, Creating a Tree Structure
triangles, Find triangles

Post method, Working with the State Pattern

primary constructors, Using Constructors

printf statements, Using Constructors

printfn function, Console Output, Using Threads

with lock, Using Asynchronous Workflows

private data class pattern, Working with F# and Design Patterns, Working with the Private Data Class Pattern

processing objects, Working with the Chain of Responsibility Pattern

programs

running, Run Your Program
scope, Variable Names

project references, Using Delegates and Events

ProjectionParameter,, Using Computation Expression Attributes

projects

AssemblyInfo,, Using AssemblyInfo
referencing, Using Delegates and Events

properties

accessibility levels, Defining a Property
attributes, adding, Generated Type Provider
auto-implemented, Defining a Property, Using Constructors
defining, Defining a Property
indexed, Defining a Property
initializing values, Defining a Property
member keyword, Defining a Property

protected keyword, Using Classes

provided methods, Setting Up the Development Environment, Setting Up the Development Environment

code snippet, Using Type-Provider Snippets
generating, Using the Multi-Inheritance Type Provider

provided parameters code snippet, Using Type-Provider Snippets

provided properties, Setting Up the Development Environment

code snippet, Using Type-Provider Snippets

provided types, Setting Up the Development Environment

base type, erasing to, Using the Excel-File Type Provider

ProvidedAssembly class, Separating Run Time and Design Time

ProvidedMeasureBuilder type, Using the CSV Type Provider

ProvidedMethod type, Exploring the HelloWorld Type Provider

ProvidedProperty type, Exploring the HelloWorld Type Provider

ProvidedTypeDefinition,, Exploring the HelloWorld Type Provider

proxy classes, Connecting To and Consuming Data

proxy pattern, Working with F# and Design Patterns, Working with the Decorator Pattern

PTX file, F# Quotation and Transform, F# Quotation on GPGPU

public keyword, Using Classes

Publish method, Using Delegates and Events

Publish Windows Azure Application Wizard, Developing a Windows Azure Application

Q

queries, fixed-query datasets, Connecting To and Consuming Data

query function, Working with the Composite Pattern, Using Agents

query syntax, Other Type Providers

all operator, Using the contains, exists, and find Operators
average operator, Using the min/max, average, and sum Operators
contains operator, Using the count and distinct Operators
count operator, Using the head, last, and nth Operators
distinct operator, Using the head, last, and nth Operators
exactlyOne operator, Using the contains, exists, and find Operators
exists operator, Using the count and distinct Operators
find operator, Using the count and distinct Operators
group operator, Using the group Operator
head operator, Using the head, last, and nth Operators
join operator, Using the join Operator
last operator, Using the head, last, and nth Operators
min/max operators, Using the min/max, average, and sum Operators
nth operator, Using the head, last, and nth Operators
nullable values, Using the sortBy Operator, Using the min/max, average, and sum Operators
select operator, Query
server-side code, Using the select Operator
skip operator, Using the take and skip Operators
sortBy operator, Using the join Operator
sum operator, Using the min/max, average, and sum Operators
take operator, Using the take and skip Operators
where operator, Using the select Operator
Word documents, generating, Exporting to Microsoft Excel

quick sorts, Using a quick-sort algorithm

#quit directive, FSIAnyCPU

quotation marks, escaping, Triple-Quoted Strings

quotation splicing operators, Using the Regular-Expression Type Provider

quotations, Setting Up the Development Environment, Using the Multi-Inheritance Type Provider, Checking F# Types, GPGPU with F#, F# Quotation and Transform

.NET types to C, F# Quotation and Transform
block and thread relationships, F# Quotation on GPGPU
BlockDim,, F# Quotation on GPGPU
code generation function, F# Quotation on GPGPU
code structure intermediate functions, F# Quotation and Transform
code translation, F# Quotation and Transform
CUDA data structures, F# Quotation on GPGPU
functions for checking supported types, F# Quotation and Transform
functions for return type and signature, F# Quotation and Transform
GPUAttribute attribute, F# Quotation and Transform, F# Quotation on GPGPU
iterating tree structure, Working with Code Quotation
on GPGPU, F# Quotation on GPGPU
Pascal Triangle, Pascal Triangle
pascalTriangle function, F# Quotation on GPGPU
PTX files, F# Quotation and Transform, F# Quotation on GPGPU
__device__ keyword, F# Quotation on GPGPU
__global__ keyword, F# Quotation on GPGPU
ReflectedDefinition attribute, F# Quotation and Transform
sample2 function, F# Quotation on GPGPU
ThreadIdx identifier, F# Quotation on GPGPU
tree traversal, F# Quotation and Transform

R

#r directive, FSIAnyCPU

raise function, Throwing Exceptions

random number generation (RNG), CUDA

random-selection algorithms, Phone keyboard

rank selection, Selection

Receive method, Working with the State Pattern

record equality, Comparing a Record with Other Data Structures

record pattern, Using the List and Array Patterns

record types, Working with the Chain of Responsibility Pattern

properties and methods, adding to, Working with the Private Data Class Pattern

record-related functions, reflection on, Using Functions Related to Discriminated Unions

records, Working with Units of Measure

CLIMutable attribute, Working with Records
comparing, Working with Comparison Operations for a Record, Tuple, and DU
comparing with data structures, Comparing a Record with Other Data Structures
copying, Working with Records
defining and creating, Working with Records
equality comparisons, Working with Records
matching, Using the List and Array Patterns
mutable fields, Working with Records
serialization and, Using the CLIMutable Attribute
static members, Working with Records
vs. classes, Comparing a Record with Other Data Structures

recursive functions, Recursive Functions

converting to CPS, Using the Continuation Passing Style
lists, summing, Using the Continuation Passing Style
on arrays, Finding the maximum sum of an array
quotations, accessing with, Working with Code Quotation
rewriting, Using the Continuation Passing Style

reduce combinators, Code Snippet for Azure Development

ref keyword, Interop and Function Parameters, Working with the Adapter Pattern, Other Unique Features

reference cells, Working with the Command Pattern, Other Unique Features

definition, Other Unique Features
in object expressions, Working with Object Expressions
sample, Working with Computation Expressions

reference equality, Comparing a Record with Other Data Structures

references

managing, Some Useful Add-ins
to C# projects, Using Delegates and Events

ReflectedDefinition attribute, Working with Code Quotation, F# Quotation and Transform

reflection, Using a Wrapper Type Provider, Using a Wrapper Type Provider, Using Reflection

attributes, defining, Using Reflection
functions, implementing, Function
on discriminated unions, Using Tuples
on exceptions, Using Exceptions with F#
on record-related functions, Using Functions Related to Discriminated Unions
on tuples, Working with Type and Member Info
type information, Defining Attributes

Registry type provider, Other Type Providers

regular-expression type provider, Using the Regular-Expression Type Provider

relayed messaging, Azure Communication

remote services and data, accessing, WSDL Type Provider

RequireQualifiedAccess attribute, Module, Namespace, and Program Entry Points

reraise function, Throwing Exceptions

reservoir sampling, Shuffle algorithm

resources, releasing, Using the IDisposable Interface

retry computation expression, Working with Computation Expressions

rev function, zip and zip3

RNG (random number generation), CUDA

roulette wheel selection, Selection

round function, Other F# Operators

Run function, Genetic Algorithms in the Cloud

run-time DLLs, Using the DGML-File Type Provider

running programs, Run Your Program

compiler directives, Compiler Directives
console applications, Run Your Program
F# Interactive, Using F# Interactive
FSI directives, FSIAnyCPU
FSIAnyCPU feature, Using F# Interactive

S

sample2 function, F# Quotation on GPGPU

Scala, C# and F# Data Structures

schema data, Using a Wrapper Type Provider

schematized data, Using the CSV Type Provider

scopes, segmenting code into, Variable Names

script files vs. source files, Using F# Interactive

Sealed attribute, Using Abstract and Sealed Classes, Defining Structure

sealed classes, Using Inheritance

attributes, Using Abstract and Sealed Classes

segmenting code, Variable Names

select operator, Query

multiple select statements, Using the select Operator

selection

rank, Selection
roulette wheel, Selection

self-identifiers, Creating an Indexer

in interface implementation code, Defining an Interface
in property names, Defining a Property
this keyword, Defining a Property

semicolons, while Loops, Using F# Interactive, Lists

seq expression, Using Agents

Seq module, Pipe-Forward Operator

Seq.fold function, Using a quick-sort algorithm

Seq.ofArray function, Convert from Seq/List/Array

Seq.ofList function, Convert from Seq/List/Array

Seq.toArray function, Convert to Seq/List/Array

Seq.toList function, Convert to Seq/List/Array

Seq.windowed function, Using Threads

sequences, Lists

binary trees, building, Delete a tree
defined, Lists
defining, Lists
in C#, Lists
length, Pipe-Forward Operator

serialization, Performing Serialization

record types in, Using the CLIMutable Attribute

Service Bus Relay service, Azure Communication

Service Bus service

client-side code, Service-Side Code
default key, Setting Up the Service from Azure Management Portal
echo service code, Setting Up the Service from Azure Management Portal
interface definition snippets, Service-Side Code
setting up, Setting Up the Service from Azure Management Portal

set data structure, Convert from Seq/List/Array

SetFunction,, Using the DGML-File Type Provider

setter function, Defining a Property

Shape type, Working with Discriminated Unions

shuffle algorithm, Phone keyboard

simulations, GPU for, Maximum Values in Subarrays

sin function, Other F# Operators

singleton pattern, Working with F# and Design Patterns, Working with the Factory Pattern

singletons, Working with the Factory Pattern

sinh function, Other F# Operators

sizeof operator, FSIAnyCPU

SizeT wrapper, CUDA

skip operator, Using the take and skip Operators, Connecting To and Consuming Data

slicing arrays, Arrays

snd function, Tuples

snippets, Exploring the HelloWorld Type Provider, Generated Type Provider

(see also code snippets)

SOLID (Single responsibility, Open-closed, Liskov substitution, Interface segregation, and Dependency inversion) design principles, Working with Reference Cells

Some()/ None syntax, Working with the Chain of Responsibility Pattern

sort function, zip and zip3

sortBy operator, Using the join Operator

sortByNullable operator, Using the sortBy Operator

sortByNullableDescending operator, Using the sortBy Operator

sorting