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

! operator (reference cell dereferencing), Reference Cells
"..." (quoted identifier delimiter), Replicating the using Function in C#
#light directive, Significance of Whitespace
% operator (modulus), Numeric Types
&& operator (Boolean AND), Core Data Types
&&& operator (bitwise AND), Numeric Types
() (unit value), Options
(*...*) (block comments), End-of-Line Comments
(|...|) (active patterns), Parentheses in Patterns
* (asterisk)
multiplication operator, Numeric Types
tuple delimiter, Functional Types
** operator (exponent), Numeric Types
+ (plus)
addition operator, Numeric Types
set union operator, Creating Sets
string concatenation operator, Verbatim Strings
unary positive operator, Numeric Types
- (dash)
set difference operator, Intersections
subtraction operator, Numeric Types
unary negative operator, Numeric Types
- (set difference operator), Intersections
-> (right arrow)
function value, Functions as Data, Lambda Expressions
sequence expressions, Sequence Expressions
.. operator (range expression), Sequence Expressions
.fs files, #time
.fsx files, #time
/ operator (division), Numeric Types
// (end-of-line comments), End-of-Line Comments
/// (XML comment), End-of-Line Comments
:: operator (cons), Accessing Elements
:= operator (reference cell assignment), Reference Cells
:> operator (static cast), Inheritance
:?> operator (dynamic cast), Upcasting
;; (FSI expression terminator), Running F# Interactive
< operator (less than), Numeric Types
<- operator (assignment), Mutable Bindings, Implicit Properties, Avoiding Naming Conflicts
<< operator (backward function composition), Forward Pipelining, Function Composition
<<< operator (bitwise left shift), Numeric Types
<= operator (less than or equal to), Numeric Types
<> operator (inequality), Numeric Types
<@...@> (strongly typed quoted literal), Comparing Expression Trees and Quoted Expressions, Splicing Quoted Expressions
<@@...@@> (weakly typed quoted literal), Comparing Expression Trees and Quoted Expressions, Manual Composition, Splicing Quoted Expressions
<| operator (backward pipelining), Forward Pipelining
= operator (equality), Numeric Types, Numeric Operators
> operator (greater than), Numeric Types
>= operator (greater than or equal to), Numeric Types
>> operator (forward function composition), Forward Pipelining, Function Composition
>>> operator (bitwise right shift), Numeric Types
? (optional parameter prefix), Nullability, Overloaded Methods
?? operator (null coalescing, C#), Options
@ (at)
list concatenation operator, Accessing Elements
verbatim string prefix, Verbatim Strings
[...] (square brackets)
indexed properties, Implicit Properties
list expressions, Jagged Arrays
[|...|] (array expressions), Aggregating Sequences
^ (statically resolved type parameters), Generics, Explicit Generalization
^ operator (string concatenation, ML style), Verbatim Strings
^^^ operator (bitwise exclusive OR), Numeric Types
_ (Wildcard patterns), Extracting Values
| (vertical bar)
pattern matching delimiter, Your First F# Program, Match Expressions
union case delimiter, Tree Structures
|> operator (forward pipelining), Options, Observing Events, Partial Application, Forward Pipelining
|| operator (Boolean OR), Core Data Types
||| operator (bitwise OR), Numeric Types
~ (prefix operator), Defining Interfaces
~~~ operator (bitwise negation), Numeric Types

A

abstract
classes, Overriding Members
keyword, Abstract Classes
members
methods, Abstract Properties
properties, Abstract Classes
AbstractClassAttribute, Abstract Classes
access modifiers, Primary Constructors
internal, Primary Constructors, Explicit Properties
private, Primary Constructors, Explicit Fields, Explicit Properties
protected, Primary Constructors
public, Primary Constructors, Explicit Properties
accessor (property), Explicit Fields
Action (delegate), Functions as Data
active patterns ((|...|))
defined, Parentheses in Patterns
parameterized, Parameterized Active Patterns
partial, Active Patterns
active recognizer functions, Parentheses in Patterns
add function (Event module), Basic Event Handling
addition operator (+), Numeric Types
additional constructors, Primary Constructors
agent-based programming, Asynchronous Workflows and the Task Parallel Library
counting queued messages, Scanning for Messages
receiving messages, Getting Started
replying to messages, Scanning for Messages
scanning messages, Getting Started
sending messages, Getting Started
starting agents, Getting Started
Agent<'T> type alias (see MailboxProcessor<'T> class)
AggregateException class, Cancelling Tasks, Exception Handling
Flatten method, Exception Handling
Handle method, Cancelling Tasks, Exception Handling
InnerExceptions property, Cancelling Tasks, Exception Handling
all operator (query expressions), Detecting Items
AllowNullLiteralAttribute, Nullability
and keyword, Mutually Recursive Functions
mutual recursion, Static Methods
mutually recursive functions, Mutually Recursive Functions
property accessors, Explicit Properties
AND patterns, As Patterns
antecedents, defined, Waiting for Task Completion
Apache 2.0 license, Meet F#
ArgumentException, Raising Exceptions
arguments, named, Method Accessibility
array
expressions, Aggregating Sequences
keyword, Array Expressions
Array module
copy function, Accessing Elements
empty function, Array Expressions
get function, Accessing Elements
init function, Initializing Arrays
set function, Accessing Elements
sortInPlace function, Accessing Elements
sortInPlaceBy function, Sorting Arrays
sortInPlaceWith function, Sorting Arrays
zeroCreate function, Initializing Arrays
Array patterns, Matching Records
Array2D module, Sorting Arrays
array2D operator, Sorting Arrays
Array3D module, Sorting Arrays
ArrayList class, Generics, Going to Collections
arrays, Going to Collections, Aggregating Sequences
accessing elements, Initializing Arrays
copying, Accessing Elements
defined, Aggregating Sequences
empty, Array Expressions
initializing, Initializing Arrays
jagged, Multidimensional Arrays
multidimensional, Sorting Arrays
slicing, Accessing Elements, Jagged Arrays
sorting, Accessing Elements
as keyword (self-identifiers), Additional Constructors
As patterns, As Patterns
assignment operator (<-), Mutable Bindings, Implicit Properties, Avoiding Naming Conflicts
Async class
AwaitTask method, Exception Handling
CancelDefaultToken method, Creating and Starting Asynchronous Workflows
Catch method, Cancelling Asynchronous Workflows
Parallel method, Creating and Starting Asynchronous Workflows
RunSynchronously method, Creating and Starting Asynchronous Workflows, Exception Handling
Start method, Creating and Starting Asynchronous Workflows, Cancelling Asynchronous Workflows, Asynchronous Workflows and the Task Parallel Library
StartAsTask method, Exception Handling
StartImmediate method, Creating and Starting Asynchronous Workflows
StartWithContinuations method, Creating and Starting Asynchronous Workflows, Creating and Starting Asynchronous Workflows
TryCancelled method, Cancelling Asynchronous Workflows
async modifier (C#), Asynchronous Workflows and the Task Parallel Library
Async<'T> class, Asynchronous workflows
asynchronous programming model, Asynchronous and Parallel Programming
asynchronous workflows, Exception Handling
cancelling, Creating and Starting Asynchronous Workflows
defined, Exception Handling
exception handling, Cancelling Asynchronous Workflows
let! keyword, Asynchronous workflows, Asynchronous Workflows and the Task Parallel Library, Asynchronous Workflows and the Task Parallel Library
return! keyword, Asynchronous workflows, Asynchronous Workflows and the Task Parallel Library
use! keyword, Asynchronous workflows
with TPL, Exception Handling
AsyncReplyChannel<'T> class, Scanning for Messages
automatic generalization, generics, Generics
automatic properties, Explicit Properties
AutoOpenAttribute (modules), Modules
averageBy operator (query expressions), Paginating
averageByNullable operator (query expressions), Aggregating Data
await operator (C#), Asynchronous Workflows and the Task Parallel Library

B

backward function composition operator (<<), Forward Pipelining, Function Composition
backward pipelining
defined, Forward Pipelining
operator (<|), Forward Pipelining
banana clips, Parentheses in Patterns
base implementations, calling, Overriding Members
base keyword (inheritance), Overriding Members
bigint data type, Numeric Types
Bind method (computation expressions), Anatomy of a Computation Expression
bindings
do, Replicating the using Function in C#
let, Functional Purity
use, Reference Cells
bitwise operators
AND (&&&), Numeric Types
left shift (<<<), Numeric Types
negation (~~~), Numeric Types
OR, exclusive (^^^), Numeric Types
OR, non-exclusive (|||), Numeric Types
right shift (>>>), Numeric Types
block comments ((*...*)), End-of-Line Comments
Boolean
data type, Core Data Types
operators
AND (&&), Core Data Types
OR (||), Core Data Types
values, Core Data Types
branching, for Loops
building strings example (computationexpressions), Example: FizzBuzz
byte data type, Core Data Types

C

Call active pattern, Parsing Quoted Expressions
callbacks, defined, Waiting for Task Completion
CancellationTokenSource class, Cancelling Parallel Loops, Continuations, Cancelling Asynchronous Workflows
casting, Inheritance
char data type, Characters
Choice union type, Exception Handling
classes, Staying Objective
CLIEventAttribute, Slice Expressions, Custom Events, Comparing Expression Trees and Quoted Expressions
CLIMutableAttribute, Mutability
closures, Mutable Bindings, Lambda Expressions
code quotation (see quoted expressions)
collection types, converting between, Finding Values
collections, enumerable, Sequences
Combine method (computation expressions), Anatomy of a Computation Expression, Example: FizzBuzz, Example: FizzBuzz, Example: Building Strings
CommandLineArgs property, --exec
comments, String Formatting
block, End-of-Line Comments
end-of-line, End-of-Line Comments
XML, End-of-Line Comments
computation expressions
anatomy of, Computation Expressions
builder classes, Computation Expressions
computation type, Computation Expressions
defined, Computation Expressions
desugaring, Anatomy of a Computation Expression
concat function (string extension), Verbatim Strings
conditional compilation, --load, --exec
cons operator (::), Accessing Elements
Cons patterns, List Patterns
Console class
Write method, Custom Exceptions
WriteLine method, Custom Exceptions
Constant patterns, Matching Constant Values
constraints, generics, Explicit Generalization
constructors, Staying Objective
additional, Primary Constructors
default, Staying Objective
primary, Constructors
self-identifiers in, Additional Constructors
contains operator (query expressions), Aggregating Data
continuations, defined, Waiting for Task Completion
conversions, numeric, Numeric Operators
count operator (query expressions), Paginating
currying, Interoperability Considerations
custom exceptions, Raising Exceptions

D

data parallelism, Asynchronous and Parallel Programming, Task Parallel Library
data types, built-in bigint, Numeric Types
Boolean, Core Data Types
byte, Core Data Types
double, Core Data Types
float, Core Data Types
float32, Numeric Types
int, Core Data Types
int16, Core Data Types
int32, Core Data Types
int64, Core Data Types
int8, Core Data Types
nativeint, Numeric Types
sbyte, Core Data Types
single, Numeric Types
string, Characters
uint, Core Data Types
uint16, Core Data Types
uint32, Core Data Types
uint64, Core Data Types
unativeint, Numeric Types
unit, Options, What Is Functional Programming?
decimal data type, Core Data Types
default constructor, Staying Objective
default indexed property, Implicit Properties
default keyword (inheritance), Virtual Members
defaultArg function, Nullability, Overloaded Methods
DefaultValueAttribute, Additional Constructors
Delay method (computation expressions), Anatomy of a Computation Expression, Example: FizzBuzz, Example: FizzBuzz, Example: Building Strings
DerivedPatterns module (quoted expressions), Splicing Quoted Expressions
discriminated unions, Nullability, for Loops, Additional Members
additional members, Replacing Type Abbreviations
as object hierarchies, Defining Discriminated Unions
as tree structures, Simple Object Hierarchies
as type abbreviations, Tree Structures
defined, Additional Members
self-referencing, Simple Object Hierarchies
single case, Tree Structures
distinct operator (query expressions), Predicate-Based Filters
division operator (/), Numeric Types
do bindings, Replicating the using Function in C#
do! keyword (computation expressions), Anatomy of a Computation Expression
double data type, Core Data Types
downcasting, Upcasting
downto keyword (simple for loops), while Loops
dynamic cast operator (:?>), Upcasting
Dynamic Type-Test patterns, Type-Annotated Patterns

E

eager evaluation, Additional Members
elif keyword, for Loops
end-of-line comments (//), End-of-Line Comments
entry point, Expressions Are Everywhere
EntryPointAttribute, Expressions Are Everywhere
enumerable collections, Sequences
Enumerable.Range method, Range Expressions
enumerations, Enumerations
changing base type, Enumerations
defined, Enumerations
FlagsAttribute, Enumerations
reconstructing
enum function, Reconstructing Enumeration Values
EnumOfValue function, Reconstructing Enumeration Values
equality operator (=), Numeric Types, Numeric Operators
escape sequences, Characters
Event module, Basic Event Handling, Custom Events
add function, Basic Event Handling
filter function, Basic Event Handling
map function, Custom Events
pairwise function, Basic Event Handling
partition function, Basic Event Handling
Event<'T> class, Slice Expressions
Publish property, Observing Events
Trigger function, Observing Events
events, Slice Expressions
custom, Observing Events
observing, Basic Event Handling
exactlyOne operator (query expressions), Getting an Arbitrary Item
exactlyOneOrDefault operator (query expressions), Getting an Arbitrary Item
Exception class, Statically Resolved Type Parameters, Raising Exceptions
exception keyword, Raising Exceptions
exceptions, Statically Resolved Type Parameters
custom, Raising Exceptions
handling, Statically Resolved Type Parameters
raising, try. . .with Expressions
reraising, try. . .with Expressions
try...finally, try. . .with Expressions
exists operator (query expressions), Paginating, Detecting Items
exn type abbreviation, Statically Resolved Type Parameters
explicit properties, Explicit Fields
exponent operator (**), Numeric Types
Expr type, Comparing Expression Trees and Quoted Expressions, Quoted Literals, .NET Reflection, Splicing Quoted Expressions
Expr<'T> type, Comparing Expression Trees and Quoted Expressions
expression trees, Can I Quote You on that?, Comparing Expression Trees and Quoted Expressions
expressions, Modules
ExtCore project, Example: Building Strings
extension methods (C# and Visual Basic), Object Expressions
ExtensionAttribute, Type Extensions, Functions as Data

F

F# for Fun and Profit, Example: Building Strings
F# Interactive
defined, F# Interactive
directives
#help, Playing in the Sandbox
#I, #load, --load
#load, Playing in the Sandbox, --load
#quit, Playing in the Sandbox
#r, #load, --load
#time, #load
expression terminator (;;), Running F# Interactive
fsi.exe, F# Interactive
it identifier, F# Interactive Output
options
--, --exec
--define, --load
--exec, --exec
--lib, --load
--load, F# Interactive Options
--optimize, --quiet
--quiet, --exec
--reference, --load
--tailcalls, --quiet
--use, --load
-I, --load
-r, --load
in Visual Studio, F# Interactive Options
reset interactive session, Playing in the Sandbox
timing, #load
val (output), F# Interactive Output
Visual Studio window, F# Interactive
F# Software Foundation, Meet F#
Factory pattern, Static Properties
FailureException, Raising Exceptions
failwith function, Raising Exceptions
failwithf function, Raising Exceptions
fields, Self-Identifiers
explicit, Self-Identifiers
let bindings, Self-Identifiers
file extensions
.fs, #time
.fsx, #time
FileNotFoundException, try. . .with Expressions
filter function (Event module), Basic Event Handling
find operator (query expressions), Getting an Arbitrary Item
FizzBuzz example
active patterns, Parentheses in Patterns
computation expressions, Example: FizzBuzz
partial active patterns, Active Patterns
FlagAttribute enumerations, Enumerations
flexible types, Explicit Generalization
float data type, Core Data Types
float32 data type, Numeric Types
flow control, Reconstructing Enumeration Values
for loops, while Loops
if...then expressions, for Loops
while loops, while Loops
for loops, while Loops
For method (computation expressions), Anatomy of a Computation Expression, Example: FizzBuzz
foreach loop (C#), while Loops
forward function composition operator (>>), Forward Pipelining, Function Composition
forward pipelining, Partial Application
forward pipelining operator (|>), Options, Observing Events, Partial Application, Forward Pipelining
FSharpFunc (delegate), Functions as Data, Lambda Expressions
FSharpFuncUtil class, Functions as Data
FSharpList<'T> class, Jagged Arrays
FSI (see F# Interactive)
fsi.exe, F# Interactive
fst function, Tuples
Func (delegate), Functions as Data
function
composition, Forward Pipelining
expressions, Basic Event Handling, Lambda Expressions
keyword, Guard Clauses
values, Functions as Data
functional purity, Immutability and Side Effects
functions, higher-order, Functions as Data

G

generic measures, Generic Measures
generics
constraints, Explicit Generalization
comparison, Explicit Generalization
default constructor, Explicit Generalization
defined, Explicit Generalization
delegate, Explicit Generalization
enumeration, Explicit Generalization
equality, Explicit Generalization
member, Explicit Generalization
nullness, Explicit Generalization
reference type, Explicit Generalization
subtype, Explicit Generalization
unmanaged, Explicit Generalization
value type, Explicit Generalization
defined, Branching
generalization
automatic, Generics
explicit, Explicit Generalization
type parameters, statically resolved, Generics, Explicit Generalization
Wildcard pattern, Explicit Generalization
GetCommandLineArgs method, --exec
GetEnumerator method, Sequences
GetSlice method, Slice Expressions
global keyword (namespaces), Namespaces
greater than operator (>), Numeric Types
greater than or equal to operator (>=), Numeric Types
groupBy operator (query expressions), Sorting by Multiple Values
groupJoin operator (query expressions), Joining Multiple Data Sources
groupValBy operator (query expressions), Grouping

H

handling exceptions, Statically Resolved Type Parameters
HasFlag method (System.Enum), Flags Enumerations
Hashtable class, Sequences
head operator (query expressions), Accessing Individual Items
headOrDefault operator (query expressions), Accessing Individual Items
higher-order functions, Functions as Data

I

IComparable<'T> interface, Finding Sequence Length
Identifier patterns, Replacing Type Abbreviations, Replacing Type Abbreviations, Exhaustive Matching, Matching Constant Values
identifiers, quoted, Replicating the using Function in C#
IDisposable interface, Reference Cells, Interfaces, Implementing Interfaces
IEnumerable interface, Sequences
IEnumerable<'T> interface, while Loops, Sequences, Jagged Arrays
if...then expressions, for Loops
ignore function, Options
immutability, Immutability and Side Effects
implicit properties, Explicit Properties
indexed properties
multidimensional, Indexed Properties
one-dimensional, Implicit Properties
inequality operator (<>), Numeric Types
inherit keyword, Inheritance, Defining Interfaces
inheritance, Structures
initializing properties, Indexed Properties
instance methods, Setting at Initialization
int data type, Core Data Types
int16 data type, Core Data Types
Int32 active pattern, Parsing Quoted Expressions
int32 data type, Core Data Types
int64 data type, Core Data Types
int8 data type, Core Data Types
interface keyword, Implementing Interfaces
interfaces, Static Methods
defining, Implementing Interfaces
implementing, Interfaces
inheritance, Defining Interfaces
marker, Implementing Interfaces
internal access modifier, Primary Constructors, Explicit Properties
International System of Units, Measuring Up
invalidArg function, Raising Exceptions
InvalidCastException, Upcasting
IStructuralEquatable interface, Extracting Values
it identifier (F# Interactive), F# Interactive Output
Item property (indexed properties), Implicit Properties

J

join operator (query expressions), Joining Multiple Data Sources

L

lambda expressions, Basic Event Handling, Lambda Expressions
LanguagePrimitives module, Applying Measures
last operator (query expressions), Accessing Individual Items
lastOrDefaultOperator (query expressions), Accessing Individual Items
lazy evaluation, Additional Members
lazy keyword, Additional Members
Lazy<'T> class, Additional Members
less than operator (<), Numeric Types
less than or equal to operator (<=), Numeric Types
let keyword, Functional Purity
let! keyword
asynchronous workflows, Asynchronous workflows
computation expressions, Anatomy of a Computation Expression
license, Apache 2.0, Meet F#
lightweight syntax, Significance of Whitespace
LINQ, Generics, Slice Expressions, Object Expressions, What Is Functional Programming?, Can I Quote You on that?, Show Me the Data
list comprehensions (see sequence expressions)
list concatenation operator (@), Accessing Elements
List module
append function, Combining Lists
concat function, Combining Lists
contains function, Accessing Elements
empty function, Creating Lists
exists function, Accessing Elements
head function, Creating Lists
nth function, Creating Lists
tail function, Creating Lists
List patterns, Matching Records
List<'T> class, Generics, Sequences, Jagged Arrays
lists, Jagged Arrays
accessing elements, Creating Lists
combining, Accessing Elements
creating, Jagged Arrays
defined, Jagged Arrays
head, Creating Lists
tail, Creating Lists
Literal patterns, Matching Union Cases
LiteralAttribute, Functional Purity, Matching Constant Values, Matching Union Cases
literals, Functional Purity
locking, Data Parallelism
loops, Reconstructing Enumeration Values
for, enumerable, while Loops
for, simple, while Loops
while, while Loops

M

MailboxProcessor<'T> class, Asynchronous Workflows and the Task Parallel Library
CurrentQueueLength property, Scanning for Messages
Post method, Getting Started, Scanning for Messages
PostAndReply method, Replying to Messages
Receive method, Getting Started, Scanning for Messages
Reply method, Replying to Messages
Scan method, Getting Started
Start method, Asynchronous Workflows and the Task Parallel Library
main method (see entry point)
map function (Event module), Custom Events
Map module
containsKey function, Creating Maps
find function, Creating Maps
findKey function, Finding Values
tryFind function, Finding Values
tryFindKey function, Finding Values
Map<'Key, 'Value> class, Subsets and Supersets
maps, Subsets and Supersets
creating, Creating Maps
defined, Subsets and Supersets
finding keys, Finding Values
finding values, Creating Maps
marker interfaces, Implementing Interfaces
Mars Climate Orbiter, Measuring Up
match expressions, Tree Structures, Patterns, Patterns, Everywhere
defined, Patterns, Patterns, Everywhere
exhaustive matching, Pattern-Matching Functions
guard clauses, Match Expressions
pattern matching functions, Guard Clauses
MatchFailureException, Pattern-Matching Functions
maxBy operator (query expressions), Paginating
maxByNullable operator (query expressions), Aggregating Data
MeasureAttribute, Measuring Up
measures, Explicit Fields (see units of measure member keyword)
member val keyword pair (implicit properties), Explicit Properties
metaprogramming, Can I Quote You on that?
method accessibility, Setting at Initialization
methods, Setting at Initialization
instance, Setting at Initialization
overloaded, Overloaded Methods
minBy operator (query expressions), Paginating
minByNullable operator (query expressions), Aggregating Data
ML programming language, Meet F#
modules, Namespaces
declaring, Namespaces
defined, Namespaces
local, Namespaces
opening, Modules
top-level, Namespaces
modulus operator (%), Numeric Types
monads, Computation Expressions
(see also computation expressions)
multiplication operator (*), Numeric Types
mutability, Mutable Bindings
mutable bindings, Mutable Bindings
mutable keyword, Mutable Bindings, Avoiding Naming Conflicts, Mutability
mutual recursion
between functions, Mutually Recursive Functions
between types, Static Methods

N

named arguments, Method Accessibility
namespace keyword, Significance of Whitespace
namespaces, Significance of Whitespace
declaring, Significance of Whitespace
global, Namespaces
nesting, Significance of Whitespace
opening, Namespaces
nativeint data type, Numeric Types
new keyword
additional constructors, Primary Constructors
instance creation, Constructors
object expressions, Object Expressions, Object Expressions
not (Boolean operator), Core Data Types
nth operator (query expressions), Accessing Individual Items
null keyword, Nullability
Null patterns, Matching Union Cases
nullability, Nullability
nullable operators, Predicate-Based Filters
numeric data types, Core Data Types

O

object expressions, Global Operators
OCaml programming language, Meet F#
of keyword (discriminated unions), Additional Members
open keyword
modules, Modules
namespaces, Namespaces
OperationCanceledException, Short-Circuiting Parallel Loops, Cancelling Tasks
operators
custom, Defining Interfaces
global, New Operators
infix, Prefix Operators
new, New Operators
overloading, Defining Interfaces
prefix, Defining Interfaces
Option Infer (Visual Basic), Type Inference
option keyword, Nullability
Option<'T> type, Nullability, Overloaded Methods, Additional Members
defined, Additional Members
introduced, Nullability
None, Nullability, Additional Members
Some<'T>, Nullability, Additional Members
optional parameter prefix (?), Nullability, Overloaded Methods
optional parameters, Nullability, Overloaded Methods, Overloaded Methods
OR patterns, Combining Patterns with AND
out parameters, Syntactic Tuples
overloading
methods, Overloaded Methods
operators, Defining Interfaces
Overridable modifier (Visual Basic), Virtual Members
override keyword (inheritance), Upcasting
overriding members, Upcasting

P

pairwise function (Event module), Basic Event Handling
Parallel class
For method, Task Parallel Library, Short-Circuiting Parallel Loops
ForEach method, Task Parallel Library
Invoke method, Cancelling Parallel Loops
Parallel LINQ, Task Parallel Library
parallel loops
cancelling, Short-Circuiting Parallel Loops
short-circuiting, Short-Circuiting Parallel Loops
parallel programming, Asynchronous and Parallel Programming
ParallelLoopState class, Short-Circuiting Parallel Loops
Break method, Short-Circuiting Parallel Loops
Stop method, Short-Circuiting Parallel Loops
ParallelOptions class, Cancelling Parallel Loops
parameters, optional, Overloaded Methods
partial active patterns, Active Patterns
partial application, Interoperability Considerations
partition function (Event module), Basic Event Handling, Observing Events
pattern matching
active patterns, Parentheses in Patterns
and exception handling, Statically Resolved Type Parameters
AND patterns, As Patterns
Array patterns, Matching Records
As patterns, As Patterns
Cons patterns, List Patterns
Constant patterns, Matching Constant Values
Dynamic Type-Test patterns, Type-Annotated Patterns
Identifier patterns, Replacing Type Abbreviations, Replacing Type Abbreviations, Exhaustive Matching, Matching Constant Values
List patterns, Matching Records
Literal patterns, Matching Union Cases
Null patterns, Matching Union Cases
OR patterns, Combining Patterns with AND
parentheses, use of, Combining Patterns with AND
partial active patterns, Active Patterns
Record patterns, Matching Tuples
Singleton pattern, Primary Constructors
Tuple patterns, Tuples, Matching Nulls
Type-Annotated patterns, List Patterns
Union Case patterns, Matching Constant Values
Variable patterns, Exhaustive Matching
Wildcard patterns, Extracting Values, Exhaustive Matching
pattern matching delimiter (|), Your First F# Program, Match Expressions
Pattern module (quoted expressions), Splicing Quoted Expressions
pattern-matching functions, Guard Clauses
pipelining, Partial Application
backward, Forward Pipelining
defined, Partial Application
forward, Partial Application
noncurried functions, Forward Pipelining
PLINQ, Task Parallel Library
potential parallelism, Task Parallel Library
prefix operator (~), Defining Interfaces
primary constructor, Constructors
printf function, Custom Exceptions
printfn function, Custom Exceptions
private access modifier, Primary Constructors, Explicit Fields, Explicit Properties
project templates, Meet F#
ProjectionParameterAttribute, Joining Multiple Data Sources
properties, Explicit Fields
automatic, Explicit Properties
explicit, Explicit Fields
implicit, Explicit Properties
indexed
multidimensional, Indexed Properties
one-dimensional, Implicit Properties
initializing, Indexed Properties
PropertyGet active pattern, Substituting Reflection
protected access modifier, Primary Constructors
public access modifier, Primary Constructors, Explicit Properties
Publish property (events), Observing Events
purity, functional, Immutability and Side Effects

Q

query expressions
aggregating data, Paginating
defined, Show Me the Data
detecting items, Aggregating Data
distinct values, Predicate-Based Filters
extending, Joining Multiple Data Sources
filtering data, Basic Querying
finding arbitrary items, Accessing Individual Items
first or last item, Accessing Individual Items
grouping, Sorting by Multiple Values
joining data sources, Detecting Items
pagination, Grouping
projecting data, Query Expressions
sorting, Sorting Results
quoted expressions
creating through reflection, Quoted Literals
decomposing, Splicing Quoted Expressions
defined, Can I Quote You on that?
manual composition, .NET Reflection
quoted literals, Comparing Expression Trees and Quoted Expressions
splicing, Splicing Quoted Expressions
strongly typed, Comparing Expression Trees and Quoted Expressions
weakly typed, Comparing Expression Trees and Quoted Expressions
quoted identifier delimiter ("..."), Replicating the using Function in C#

R

raise function, try. . .with Expressions, Raising Exceptions
raising exceptions, try. . .with Expressions
range expression operator (..), Sequence Expressions, Range Expressions
range expressions, Sequence Expressions
read-evaluate-print loop (REPL), F# Interactive
readonly keyword (C#), Functional Purity
rec keyword (recursive functions), Function Composition
record expressions
copy and update, Avoiding Naming Conflicts
defined, Record Types
new records, Record Types
Record patterns, Matching Tuples
record types, Record Types
additional members, Mutability
copying, Avoiding Naming Conflicts
creating, Record Types
defined, Record Types
mutability, Avoiding Naming Conflicts
naming conflicts, Creating Records
recursion
defined, Function Composition
tail-call, Recursive Functions
ref operator, Mutable Bindings
reference cell assignment operator (:=), Reference Cells
reference cell dereferencing operator (!), Reference Cells
reference cells, Mutable Bindings
referential transparency, What Is Functional Programming?
ReflectedDefinitionAttribute, Quoted Literals, .NET Reflection, Splicing Quoted Expressions
REPL (read-evaulate-print loop), F# Interactive
reraise function, try. . .with Expressions
ResizeArray<'T> type abbreviation, Jagged Arrays
return keyword, What Is Functional Programming?
Return method (computation expressions), Anatomy of a Computation Expression
return values, Expressions Are Everywhere
return! keyword
asynchronous workflows, Asynchronous workflows
computation expressions, Anatomy of a Computation Expression
ReturnFrom method (computation expressions), Anatomy of a Computation Expression
Run method (computation expressions), Anatomy of a Computation Expression

S

sbyte data type, Core Data Types
scripting
command-line arguments, --exec
with F# Interactive, #time
sealed classes, Virtual Members
SealedAttribute, Virtual Members, Sealed Classes
Select Case statement (Visual Basic), Tree Structures, Match Expressions
select operator (query expressions), Query Expressions
self-identifiers in constructors, Additional Constructors
Seq module
average function, Aggregating Sequences
averageBy function, Aggregating Sequences
empty function, Range Expressions
filter function, Sorting Sequences
fold function, Sorting Sequences
isEmpty function, Finding Sequence Length
iter function, Finding Sequence Length
length property, Finding Sequence Length
map function, Finding Sequence Length
reduce function, Aggregating Sequences
sort function, Finding Sequence Length
sortBy function, Sorting Sequences
sum function, Aggregating Sequences
sumBy function, Aggregating Sequences
seq<'T> type abbreviation, Sequences
sequence expressions, Sequences
defined, Sequences
yielding results, Sequence Expressions
sequences, while Loops, Sequences
aggregating, Sorting Sequences
defined, Sequences
empty, Range Expressions
filtering, Sorting Sequences
initializing, Empty Sequences
iterating over, Finding Sequence Length
length of, Finding Sequence Length
sorting, Finding Sequence Length
transforming, Finding Sequence Length
set difference operator (-), Intersections
Set module
difference function, Intersections
intersect function, Intersections
isProperSubset function, Intersections
isProperSuperset function, Intersections
isSubset function, Intersections
isSuperset function, Intersections
union function, Creating Sets
set union operator (+), Creating Sets
Set<'T> class, Creating Sets
sets, Combining Lists
creating, Combining Lists
defined, Combining Lists
differences, Intersections
intersections, Intersections
subsets and supersets, Intersections
unions, Creating Sets
ShapeCombination active pattern, Decomposing Quoted Expressions, Parsing Quoted Expressions
ShapeLambda active pattern, Decomposing Quoted Expressions, Parsing Quoted Expressions
ShapeVar active pattern, Decomposing Quoted Expressions, Parsing Quoted Expressions
SI units, Measuring Up
side effects, Immutability and Side Effects
single data type, Numeric Types
Singleton pattern, Primary Constructors
Skip extension method, Slice Expressions
skip operator (query expressions), Grouping
skipWhile operator (query expressions), Grouping
slice expressions, Slice Expressions, Accessing Elements, Sorting Arrays
snd function, Tuples
sortBy operator (query expressions), Sorting Results
sortByDescending operator (query expressions), Sorting Results
sortByNullable operator (query expressions), Sorting Results
sortByNullableDescending operator (query expressions), Sorting Results
SpecificCall active pattern, Parsing Quoted Expressions
sprintf function, Custom Exceptions
static cast operator (:>), Inheritance
static class, Sealed Classes
static keyword, Sealed Classes, Static Initializers
static members
constructors, Sealed Classes
fields, Static Initializers
initializers, Sealed Classes
methods, Static Properties
properties, Static Initializers
statically resolved type parameters (^), Generics, Explicit Generalization
String class
Concat method, Verbatim Strings
Format method, Custom Exceptions
Join method, Verbatim Strings
Split method, Implicit Properties
string concatenation operator (+), Verbatim Strings
string concatenation operator, ML style (^), Verbatim Strings
string data type, Characters
strings, Characters
concatenation, Verbatim Strings
formatting, Custom Exceptions
literal, Characters
triple-quoted, Verbatim Strings
verbatim, Verbatim Strings
StructAttribute, Custom Events
structs, Custom Events
structures, Custom Events
subtraction operator (-), Numeric Types
sumBy operator (query expressions), Paginating
sumByNullable operator (query expressions), Aggregating Data
switch statement (C#), Tree Structures, Match Expressions
symbols
COMPILED, --load
DEBUG, --load
INTERACTIVE, --load
RELEASE, --load
SyncLock statement (Visual Basic), Data Parallelism
syntactic tuples, Extracting Values

T

tail-call recursion, Recursive Functions
Take extension method, Slice Expressions
take operator (query expressions), Grouping
takeWhile operator (query expressions), Grouping
Task class
constructor, Creating and Starting Tasks
ContinueWith method, Waiting for Task Completion, Continuations
Factory property, Creating and Starting Tasks
Start method, Creating and Starting Tasks
WaitAll method, Waiting for Task Completion
WaitAny method, Waiting for Task Completion
Task Parallel Library (TPL), Asynchronous and Parallel Programming, Asynchronous Workflows and the Task Parallel Library
task parallelism, Asynchronous and Parallel Programming, Cancelling Parallel Loops
Task<'T> class, Creating and Starting Tasks, Returning Values from Tasks, Continuations
Task<'T>.Result property, Returning Values from Tasks
TaskFactory class, Creating and Starting Tasks, Returning Values from Tasks, Continuations
ContinueWhenAll method, Continuations, Continuations
ContinueWhenAny method, Continuations, Continuations
StartNew method, Creating and Starting Tasks
StartNew<'T> method, Returning Values from Tasks
Wait method, Returning Values from Tasks
tasks
cancelling, Continuations
continuations, Waiting for Task Completion
creating and starting, Cancelling Parallel Loops
exception handling, Cancelling Tasks
returning values from, Creating and Starting Tasks
waiting for completion, Returning Values from Tasks
templates, project, Meet F#
then keyword, constructors, Additional Constructors
thenBy operator (query expressions), Sorting by Multiple Values
thenByDescending operator (query expressions), Sorting by Multiple Values
thenByNullable operator (query expressions), Sorting by Multiple Values
thenByNullableDescending operator (query expressions), Sorting by Multiple Values
timing (F# Interactive), #load
to keyword (simple for loops), while Loops
ToFSharpFunc method, Functions as Data
tokens, string formatting, Custom Exceptions
TPL (Task Parallel Library), Asynchronous and Parallel Programming, Asynchronous Workflows and the Task Parallel Library
Trigger function (events), Observing Events
triple-quoted strings, Verbatim Strings
try...finally expressions, Statically Resolved Type Parameters, try. . .with Expressions
try...with expressions, Statically Resolved Type Parameters
TryFinally method (computation expressions), Anatomy of a Computation Expression
TryGetReflectedDefinition method, Quoted Literals
TryWith method (computation expressions), Anatomy of a Computation Expression
tuple delimiter (*), Functional Types
Tuple patterns, Tuples, Matching Nulls
tuples, Functional Types
for out parameters, Syntactic Tuples
syntactic, Extracting Values
type abbreviations, Replicating the using Function in C#, String Formatting
type annotations
defined, Type Inference
with units of measure, Stripping Measures
type augmentations (see type extensions)
type extensions, Object Expressions
intrinsic, Object Expressions
optional, Object Expressions
type functions, Empty Sequences
type inference, Core Data Types, Type Inference
type keyword, String Formatting, Record Types, Discriminated Unions
classes, Staying Objective
interfaces, Implementing Interfaces
type providers, Example: AverageByNotNull
available providers, Type Providers
defined, Example: AverageByNotNull
security warning, Using Type Providers
Type-Annotated patterns, List Patterns

U

uint data type, Core Data Types
uint16 data type, Core Data Types
uint32 data type, Core Data Types
uint64 data type, Core Data Types
unary negative operator (-), Numeric Types
unary positive operator (+), Numeric Types
unativeint data type, Numeric Types
Unicode, Characters
union case delimiter (|), Tree Structures
Union Case patterns, Matching Constant Values
unit data type, Options, What Is Functional Programming?
unit value (()), Options
units of measure
applying, Measure Formulas
conversions, Ranges
defined, Measuring Up
enforcing, Stripping Measures
formulas, Measuring Up
generic, Generic Measures
measure annotations, Measure Formulas
measure-aware types, Generic Measures
ranges, Ranges
stripping, Applying Measures
upcasting, Inheritance
use bindings
defined, Reference Cells
within modules, use Bindings
use keyword
computation expressions, Anatomy of a Computation Expression
defined, Reference Cells
use! keyword
asynchronous workflows, Asynchronous workflows
computation expressions, Anatomy of a Computation Expression
using directive (C#), String Formatting
using function
C# implementation, using Function
defined, use Bindings
Using method (computation expressions), Anatomy of a Computation Expression
using statement (C#), Reference Cells

V

val
F# Interactive, F# Interactive Output
keyword (explicit fields), Additional Constructors, Self-Identifiers, Structures
Value active pattern, Parsing Quoted Expressions, Substituting Reflection
value types, Structures
var keyword (C#), Type Inference
Var type, Comparing Expression Trees and Quoted Expressions
Variable patterns, Exhaustive Matching
variables, Immutability and Side Effects
verbatim string prefix (@), Verbatim Strings
verbatim strings, Verbatim Strings
verbose syntax, Significance of Whitespace
virtual members, Overriding Members, Virtual Members
virtual modifier (C#), Virtual Members
void type (C#), Options

W

where operator (query expressions), Basic Querying
while loops, while Loops
While method (computation expressions), Anatomy of a Computation Expression
whitespace, significance of, Project Organization
Wildcard patterns (_)
defined, Extracting Values, Exhaustive Matching
exception handling, Statically Resolved Type Parameters
generics, Explicit Generalization
with keyword
object expressions, Object Expressions
property accessors, Explicit Properties
type extensions, Type Extensions
workflows (see asynchronous workflows; computation expressions)

X

XML comments (///), End-of-Line Comments

Y

yield keyword
computation expressions, Anatomy of a Computation Expression
defined, Sequence Expressions
Yield method (computation expressions), Anatomy of a Computation Expression, Example: FizzBuzz, Example: FizzBuzz, Example: Building Strings
yield! keyword (computation expressions), Anatomy of a Computation Expression, Example: Building Strings
YieldFrom method (computation expressions), Anatomy of a Computation Expression, Example: Building Strings

Z

Zero method (computation expressions), Anatomy of a Computation Expression, Example: Building Strings
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset