F# - Quick Guide

F# - Overview

F# is a functional programming language. To understand F# constructs, you need to read a couple of lines about the programming paradigm named Functional Programming.

Functional programming treats computer programs as mathematical functions. In functional programming, the focus would be on constants and functions, instead of variables and states. Because functions and constants are things that don’t change.

In functional programming, you will write modular programs, i.e., the programs would consist of functions that will take other functions as input.

Programs written in functional programming language tend to be concise.

About F#

Following are the basic information about F# −

It was developed in 2005 at Microsoft Research.
It is a part of Microsoft’s family of .Net language.
It is a functional programming language.
It is based on the functional programming language OCaml.

Features of F#

It is .Net implementation of OCaml.
It compiles .Net CLI (Common Language Interface) byte code or MSIL (Microsoft Intermediate Language) that runs on CLR (Common Language Runtime).
It provides type inference.
It provides rich pattern matching constructs.
It has interactive scripting and debugging capabilities.
It allows writing higher order functions.
It provides well developed object model.

Use of F#

F# is normally used in the following areas −

Making scientific model
Mathematical problem solving
Artificial intelligence research work
Financial modelling
Graphic design
CPU design
Compiler programming
Telecommunications

It is also used in CRUD apps, web pages, GUI games and other general purpose programs.

F# - Environment Setup

The tools required for F# programming are discussed in this chapter.

Integrated Development Environment(IDE) for F#

Microsoft provides Visual Studio 2013 for F# programming.

The free Visual Studio 2013 Community Edition is available from Microsoft’s official website. Visual Studio 2013 Community and above comes with the Visual F# Tools. Installation details available at Asp.net Tutorial .The Visual F# Tools include the command-line compiler (fsc.exe) and F# Interactive (fsi.exe).

Using these tools, you can write all kinds of F# programs from simple command-line applications to more complex applications. You can also write F# source code files using a basic text editor, like Notepad, and compile the code into assemblies using the command-line compiler.

You can download it from Microsoft Visual Studio. It gets automatically installed in your machine.

Writing F# Programs On Links

Please visit the F# official website for the latest instructions on getting the tools as a Debian package or compiling them directly from the source − https://fsharp.org/use/linux/.

F# - Program Structure

F# is a Functional Programming language.

In F#, functions work like data types. You can declare and use a function in the same way like any other variable.

In general, an F# application does not have any specific entry point. The compiler executes all top-level statements in the file from top to bottom.

However, to follow procedural programming style, many applications keep a single top level statement that calls the main loop.

The following code shows a simple F# program −

Keyword	Description
abstract	Indicates a method that either has no implementation in the type in which it is declared or that is virtual and has a default implementation.
and	Used in mutually recursive bindings, in property declarations, and with multiple constraints on generic parameters.
as	Used to give the current class object an object name. Also used to give a name to a whole pattern within a pattern match.
assert	Used to verify code during debugging.
base	Used as the name of the base class object.
begin	In verbose syntax, indicates the start of a code block.
class	In verbose syntax, indicates the start of a class definition.
default	Indicates an implementation of an abstract method; used together with an abstract method declaration to create a virtual method.
delegate	Used to declare a delegate.
do	Used in looping constructs or to execute imperative code.
done	In verbose syntax, indicates the end of a block of code in a looping expression.
downcast	Used to convert to a type that is lower in the inheritance chain.
downto	In a for expression, used when counting in reverse.
elif	Used in conditional branching. A short form of else if.
else	Used in conditional branching.
end	In type definitions and type extensions, indicates the end of a section of member definitions. In verbose syntax, used to specify the end of a code block that starts with the begin keyword.
exception	Used to declare an exception type.
extern	Indicates that a declared program element is defined in another binary or assembly.
false	Used as a Boolean literal.
finally	Used together with try to introduce a block of code that executes regardless of whether an exception occurs.
for	Used in looping constructs.
fun	Used in lambda expressions, also known as anonymous functions.
function	Used as a shorter alternative to the fun keyword and a match expression in a lambda expression that has pattern matching on a single argument.
global	Used to reference the top-level .NET namespace.
if	Used in conditional branching constructs.
in	Used for sequence expressions and, in verbose syntax, to separate expressions from bindings.
inherit	Used to specify a base class or base interface.
inline	Used to indicate a function that should be integrated directly into the caller's code.
interface	Used to declare and implement interfaces.
internal	Used to specify that a member is visible inside an assembly but not outside it.
lazy	Used to specify a computation that is to be performed only when a result is needed.
let	Used to associate, or bind, a name to a value or function.
let!	Used in asynchronous workflows to bind a name to the result of an asynchronous computation, or, in other computation expressions, used to bind a name to a result, which is of the computation type.
match	Used to branch by comparing a value to a pattern.
member	Used to declare a property or method in an object type.
module	Used to associate a name with a group of related types, values, and functions, to logically separate it from other code.
mutable	Used to declare a variable, that is, a value that can be changed.
namespace	Used to associate a name with a group of related types and modules, to logically separate it from other code.
new	Used to declare, define, or invoke a constructor that creates or that can create an object. Also used in generic parameter constraints to indicate that a type must have a certain constructor.
not	Not actually a keyword. However, not struct in combination is used as a generic parameter constraint.
null	Indicates the absence of an object. Also used in generic parameter constraints.
of	Used in discriminated unions to indicate the type of categories of values, and in delegate and exception declarations.
open	Used to make the contents of a namespace or module available without qualification.
or	Used with Boolean conditions as a Boolean or operator. Equivalent to \|\|. Also used in member constraints.
override	Used to implement a version of an abstract or virtual method that differs from the base version.
private	Restricts access to a member to code in the same type or module.
public	Allows access to a member from outside the type.
rec	Used to indicate that a function is recursive.
return	Used to indicate a value to provide as the result of a computation expression.
return!	Used to indicate a computation expression that, when evaluated, provides the result of the containing computation expression.
select	Used in query expressions to specify what fields or columns to extract. Note that this is a contextual keyword, which means that it is not actually a reserved word and it only acts like a keyword in appropriate context.
static	Used to indicate a method or property that can be called without an instance of a type, or a value member that is shared among all instances of a type.
struct	Used to declare a structure type. Also used in generic parameter constraints. Used for OCaml compatibility in module definitions.
then	Used in conditional expressions. Also used to perform side effects after object construction.
to	Used in for loops to indicate a range.
true	Used as a Boolean literal.
try	Used to introduce a block of code that might generate an exception. Used together with with or finally.
type	Used to declare a class, record, structure, discriminated union, enumeration type, unit of measure, or type abbreviation.
upcast	Used to convert to a type that is higher in the inheritance chain.
use	Used instead of let for values that require Dispose to be called to free resources.
use!	Used instead of let! in asynchronous workflows and other computation expressions for values that require Dispose to be called to free resources.
val	Used in a signature to indicate a value, or in a type to declare a member, in limited situations.
void	Indicates the .NET void type. Used when interoperating with other .NET languages.
when	Used for Boolean conditions (when guards) on pattern matches and to introduce a constraint clause for a generic type parameter.
while	Introduces a looping construct.
with	Used together with the match keyword in pattern matching expressions. Also used in object expressions, record copying expressions, and type extensions to introduce member definitions, and to introduce exception handlers.
yield	Used in a sequence expression to produce a value for a sequence.
yield!	Used in a computation expression to append the result of a given computation expression to a collection of results for the containing computation expression.

atomic	break	checked	component	const	constraint	constructor
continue	eager	event	external	fixed	functor	include
method	mixin	object	parallel	process	protected	pure
sealed	tailcall	trait	virtual	volatile

F# Type	Size	Range	Example	Remarks
sbyte	1 byte	-128 to 127	42y -11y	8-bit signed integer
byte	1 byte	0 to 255	42uy 200uy	8-bit unsigned integer
int16	2 bytes	-32768 to 32767	42s -11s	16-bit signed integer
uint16	2 bytes	0 to 65,535	42us 200us	16-bit unsigned integer
int/int32	4 bytes	-2,147,483,648 to 2,147,483,647	42 -11	32-bit signed integer
uint32	4 bytes	0 to 4,294,967,295	42u 200u	32-bit unsigned integer
int64	8 bytes	-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807	42L -11L	64-bit signed integer
uint64	8 bytes	0 to 18,446,744,073,709,551,615	42UL 200UL	64-bit unsigned integer
bigint	At least 4 bytes	any integer	42I 1499999 9999999 9999999 9999999 9999I	arbitrary precision integer

F# Type	Size	Range	Example	Remarks
float32	4 bytes	±1.5e-45 to ±3.4e38	42.0F -11.0F	32-bit signed floating point number (7 significant digits)
float	8 bytes	±5.0e-324 to ±1.7e308	42.0 -11.0	64-bit signed floating point number (15-16 significant digits)
decimal	16 bytes	±1.0e-28 to ±7.9e28	42.0M -11.0M	128-bit signed floating point number (28-29 significant digits)
BigRational	At least 4 bytes	Any rational number.	42N -11N	Arbitrary precision rational number. Using this type requires a reference to FSharp.PowerPack.dll.

Operator	Description	Example
+	Adds two operands	A + B will give 30
-	Subtracts second operand from the first	A - B will give -10
*	Multiplies both operands	A * B will give 200
/	Divides numerator by de-numerator	B / A will give 2
%	Modulus Operator and remainder of after an integer division	B % A will give 0
**	Exponentiation Operator, raises an operand to the power of another	B**A will give 20¹⁰

Operator	Description	Example
=	Checks if the values of two operands are equal or not, if yes then condition becomes true.	(A == B) is not true.
<>	Checks if the values of two operands are equal or not, if values are not equal then condition becomes true.	(A <> B) is true.
>	Checks if the value of left operand is greater than the value of right operand, if yes then condition becomes true.	(A > B) is not true.
<	Checks if the value of left operand is less than the value of right operand, if yes then condition becomes true.	(A < B) is true.
>=	Checks if the value of left operand is greater than or equal to the value of right operand, if yes then condition becomes true.	(A >= B) is not true.
<=	Checks if the value of left operand is less than or equal to the value of right operand, if yes then condition becomes true.	(A <= B) is true.

Operator	Description	Example
&&	Called Boolean AND operator. If both the operands are non-zero, then condition becomes true.	(A && B) is false.
\|\|	Called Boolean OR Operator. If any of the two operands is non-zero, then condition becomes true.	(A \|\| B) is true.
not	Called Boolean NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false.	not (A && B) is true.

Operator	Description	Example
&&&	Binary AND Operator copies a bit to the result if it exists in both operands.	(A &&& B) will give 12, which is 0000 1100
\|\|\|	Binary OR Operator copies a bit if it exists in either operand.	(A \|\|\| B) will give 61, which is 0011 1101
^^^	Binary XOR Operator copies the bit if it is set in one operand but not both.	(A ^^^ B) will give 49, which is 0011 0001
~~~	Binary Ones Complement Operator is unary and has the effect of 'flipping' bits.	(~~~A) will give -61, which is 1100 0011 in 2's complement form.
<<<	Binary Left Shift Operator. The left operands value is moved left by the number of bits specified by the right operand.	A <<< 2 will give 240 which is 1111 0000
>>>	Binary Right Shift Operator. The left operands value is moved right by the number of bits specified by the right operand.	A >>> 2 will give 15 which is 0000 1111

Operator	Associativity
as	Right
when	Right
\| (pipe)	Left
;	Right
let	Non associative
function, fun, match, try	Non associative
if	Non associative
→	Right
:=	Right
,	Non associative
or, \|\|	Left
&, &&	Left
< op, >op, =, \|op, &op	Left
&&& , \|\|\|, ^^^, ~~~, <<<, >>>	Left
^ op	Right
::	Right
:?>, :?	Non associative
- op, +op, (binary)	Left
* op, /op, %op	Left
** op	Right
f x (function application)	Left
\| (pattern match)	Right
prefix operators (+op, -op, %, %%, &, &&, !op, ~op)	Left
.	Left
f(x)	Left
f<types>	Left

Statement	Description
if /then statement	An if/then statement consists of a Boolean expression followed by one or more statements.
if/then/ else statement	An if/then statement can be followed by an optional else statement, which executes when the Boolean expression is false.
if/then/elif/else statement	An if/then/elif/else statement allows you to have multiple else branches.
nested if statements	You can use one if or else if statement inside another if or else if statement(s).

Notation	Meaning
float → float → float	The function takes two float inputs, returns another float.
int → string → float	The function takes an int and a string input, returns a float.

Character	Escape sequence
Backspace	\b
Newline	\n
Carriage return	\r
Tab	\t
Backslash	\\
Quotation mark	\"
Apostrophe	\'
Unicode character	\uXXXX or \UXXXXXXXX (where X indicates a hexadecimal digit)

Value	Description
collect : (char → string) → string → string	Creates a new string whose characters are the results of applying a specified function to each of the characters of the input string and concatenating the resulting strings.
concat : string → seq<string> → string	Returns a new string made by concatenating the given strings with a separator.
exists : (char → bool) → string → bool	Tests if any character of the string satisfies the given predicate.
forall : (char → bool) → string → bool	Tests if all characters in the string satisfy the given predicate.
init : int → (int → string) → string	Creates a new string whose characters are the results of applying a specified function to each index and concatenating the resulting strings.
iter : (char → unit) → string → unit	Applies a specified function to each character in the string.
iteri : (int → char → unit) → string → unit	Applies a specified function to the index of each character in the string and the character itself.
length : string → int	Returns the length of the string.
map : (char → char) → string → string	Creates a new string whose characters are the results of applying a specified function to each of the characters of the input string.
mapi : (int → char → char) → string → string	Creates a new string whose characters are the results of applying a specified function to each character and index of the input string.
replicate : int → string → string	Returns a string by concatenating a specified number of instances of a string.

Property	Type	Description
Head	'T	The first element.
Empty	'T list	A static property that returns an empty list of the appropriate type.
IsEmpty	bool	true if the list has no elements.
Item	'T	The element at the specified index (zero-based).
Length	int	The number of elements.
Tail	'T list	The list without the first element.

Loop Type	Description
for… to and for… downto expressions	The for...to expression is used to iterate in a loop over a range of values of a loop variable. The for… downto expression reduces the value of loop variable.
for … in expression	This form of for loop is used to iterate over collections of items i.e., loops over collections and sequences
While…do loop	Repeats a statement or group of statements while a given condition is true. It tests the condition before executing the loop body.
nested loops	You can use one or more loop inside any other for or while loop.

Property or method	Type	Description
None	'T option	A static property that enables you to create an option value that has the None value.
IsNone	bool	Returns true if the option has the None value.
IsSome	bool	Returns true if the option has a value that is not None.
Some	'T option	A static member that creates an option that has a value that is not None.
Value	'T	Returns the underlying value, or throws a NullReferenceException if the value is None.

Value	Description
append : 'T list → 'T list → 'T list	Returns a new list that contains the elements of the first list followed by elements of the second.
average : 'T list → ^T	Returns the average of the elements in the list.
averageBy : ('T → ^U) → 'T list → ^U	Returns the average of the elements generated by applying the function to each element of the list.
choose : ('T → 'U option) → 'T list → 'U list	Applies the given function to each element of the list. Returns the list comprised of the results for each element where the function returns Some.
collect : ('T → 'U list) → 'T list → 'U list	For each element of the list, applies the given function. Concatenates all the results and return the combined list.
concat : seq<'T list> → 'T list	Returns a new list that contains the elements of each the lists in order.
empty : 'T list	Returns an empty list of the given type.
exists : ('T → bool) → 'T list → bool	Tests if any element of the list satisfies the given predicate.
exists2 : ('T1 → 'T2 → bool) → 'T1 list → 'T2 list → bool	Tests if any pair of corresponding elements of the lists satisfies the given predicate.
filter : ('T → bool) → 'T list → 'T list	Returns a new collection containing only the elements of the collection for which the given predicate returns true.
find : ('T → bool) → 'T list → 'T	Returns the first element for which the given function returns true.
findIndex : ('T → bool) → 'T list → int	Returns the index of the first element in the list that satisfies the given predicate.
fold : ('State → 'T → 'State) → 'State → 'T list → 'State	Applies a function to each element of the collection, threading an accumulator argument through the computation. This function takes the second argument, and applies the function to it and the first element of the list. Then, it passes this result into the function along with the second element, and so on. Finally, it returns the final result. If the input function is f and the elements are i0...iN, then this function computes f (... (f s i0) i1 ...) iN.
fold2 : ('State → 'T1 → 'T2 → 'State) → 'State → 'T1 list → 'T2 list → 'State	Applies a function to corresponding elements of two collections, threading an accumulator argument through the computation. The collections must have identical sizes. If the input function is f and the elements are i0...iN and j0...jN, then this function computes f (... (f s i0 j0)...) iN jN.
foldBack : ('T → 'State → 'State) → 'T list → 'State → 'State	Applies a function to each element of the collection, threading an accumulator argument through the computation. If the input function isf and the elements are i0...iN then computes f i0 (...(f iN s)).
foldBack2 : ('T1 → 'T2 → 'State → 'State) → 'T1 list → 'T2 list → 'State → 'State	Applies a function to corresponding elements of two collections, threading an accumulator argument through the computation. The collections must have identical sizes. If the input function is f and the elements are i0...iN and j0...jN, then this function computes f i0 j0 (...(f iN jN s)).
forall : ('T → bool) → 'T list → bool	Tests if all elements of the collection satisfy the given predicate.
forall2 : ('T1 → 'T2 → bool) → 'T1 list → 'T2 list → bool	Tests if all corresponding elements of the collection satisfy the given predicate pairwise.
head : 'T list → 'T	Returns the first element of the list.
init : int → (int → 'T) → 'T list	Creates a list by calling the given generator on each index.
isEmpty : 'T list → bool	Returns true if the list contains no elements, false otherwise.
iter : ('T → unit) → 'T list → unit	Applies the given function to each element of the collection.
iter2 : ('T1 → 'T2 → unit) → 'T1 list → 'T2 list → unit	Applies the given function to two collections simultaneously. The collections must have identical size.
iteri : (int → 'T → unit) → 'T list → unit	Applies the given function to each element of the collection. The integer passed to the function indicates the index of element.
iteri2 : (int → 'T1 → 'T2 → unit) → 'T1 list → 'T2 list → unit	Applies the given function to two collections simultaneously. The collections must have identical size. The integer passed to the function indicates the index of element.
length : 'T list → int	Returns the length of the list.
map : ('T → 'U) → 'T list → 'U list	Creates a new collection whose elements are the results of applying the given function to each of the elements of the collection.
map2 : ('T1 → 'T2 → 'U) → 'T1 list → 'T2 list → 'U list	Creates a new collection whose elements are the results of applying the given function to the corresponding elements of the two collections pairwise.
map3 : ('T1 → 'T2 → 'T3 → 'U) → 'T1 list → 'T2 list → 'T3 list → 'U list	Creates a new collection whose elements are the results of applying the given function to the corresponding elements of the three collections simultaneously.
mapi : (int → 'T → 'U) → 'T list → 'U list	Creates a new collection whose elements are the results of applying the given function to each of the elements of the collection. The integer index passed to the function indicates the index (from 0) of element being transformed.
mapi2 : (int → 'T1 → 'T2 → 'U) → 'T1 list → 'T2 list → 'U list	Like List.mapi, but mapping corresponding elements from two lists of equal length.
max : 'T list → 'T	Returns the greatest of all elements of the list, compared by using Operators.max.
maxBy : ('T → 'U) → 'T list → 'T	Returns the greatest of all elements of the list, compared by using Operators.max on the function result.
min : 'T list → 'T	Returns the lowest of all elements of the list, compared by using Operators.min.
minBy : ('T → 'U) → 'T list → 'T	Returns the lowest of all elements of the list, compared by using Operators.min on the function result
nth : 'T list → int → 'T	Indexes into the list. The first element has index 0.
ofArray : 'T [] → 'T list	Creates a list from the given array.
ofSeq : seq<'T> → 'T list	Creates a new list from the given enumerable object.
partition : ('T → bool) → 'T list * 'T list	Splits the collection into two collections, containing the elements for which the given predicate returns true and false respectively.
permute : (int → int) → 'T list → 'T list	Returns a list with all elements permuted according to the specified permutation.
pick : ('T → 'U option) → 'T list → 'U	Applies the given function to successive elements, returning the first result where function returns Some for some value.
reduce : ('T → 'T → 'T) → 'T list → 'T	Applies a function to each element of the collection, threading an accumulator argument through the computation. This function applies the specified function to the first two elements of the list. It then passes this result into the function along with the third element, and so on. Finally, it returns the final result. If the input function is f and the elements are i0...iN, then this function computes f (... (f i0 i1) i2 ...) iN.
reduceBack : ('T → 'T → 'T) → 'T list → 'T	Applies a function to each element of the collection, threading an accumulator argument through the computation. If the input function isf and the elements are i0...iN, then this function computes f i0 (...(f iN-1 iN)).
replicate : (int → 'T → 'T list)	Creates a list by calling the given generator on each index.
rev : 'T list → 'T list	Returns a new list with the elements in reverse order.
scan : ('State → 'T → 'State) → 'State → 'T list → 'State list	Applies a function to each element of the collection, threading an accumulator argument through the computation. This function takes the second argument, and applies the specified function to it and the first element of the list. Then, it passes this result into the function along with the second element and so on. Finally, it returns the list of intermediate results and the final result.
scanBack : ('T → 'State → 'State) → 'T list → 'State → 'State list	Like foldBack, but returns both the intermediate and final results
sort : 'T list → 'T list	Sorts the given list using Operators.compare.
sortBy : ('T → 'Key) → 'T list → 'T list	Sorts the given list using keys given by the given projection. Keys are compared using Operators.compare.
sortWith : ('T → 'T → int) → 'T list → 'T list	Sorts the given list using the given comparison function.
sum : ^T list → ^T	Returns the sum of the elements in the list.
sumBy : ('T → ^U) → 'T list → ^U	Returns the sum of the results generated by applying the function to each element of the list.
tail : 'T list → 'T list	Returns the input list without the first element.
toArray : 'T list → 'T []	Creates an array from the given list.
toSeq : 'T list → seq<'T>	Views the given list as a sequence.
tryFind : ('T → bool) → 'T list → 'T option	Returns the first element for which the given function returns true. Return None if no such element exists.
tryFindIndex : ('T → bool) → 'T list → int option	Returns the index of the first element in the list that satisfies the given predicate. Return None if no such element exists.
tryPick : ('T → 'U option) → 'T list → 'U option	Applies the given function to successive elements, returning the first result where function returns Some for some value. If no such element exists then return None.
unzip : ('T1 * 'T2) list → 'T1 list * 'T2 list	Splits a list of pairs into two lists.
unzip3 : ('T1 * 'T2 * 'T3) list → 'T1 list * 'T2 list * 'T3 list	Splits a list of triples into three lists.
zip : 'T1 list → 'T2 list → ('T1 * 'T2) list	Combines the two lists into a list of pairs. The two lists must have equal lengths.
zip3 : 'T1 list → 'T2 list → 'T3 list → ('T1 * 'T2 * 'T3) list	Combines the three lists into a list of triples. The lists must have equal lengths.

Value	Description
append : seq<'T> → seq<'T> → seq<'T>	Wraps the two given enumerations as a single concatenated enumeration.
average : seq<^T> → ^T	Returns the average of the elements in the sequence.
averageBy : ('T → ^U) → seq<'T> → ^U	Returns the average of the results generated by applying the function to each element of the sequence.
cache : seq<'T> → seq<'T>	Returns a sequence that corresponds to a cached version of the input sequence.
cast : IEnumerable → seq<'T>	Wraps a loosely-typed System. Collections sequence as a typed sequence.
choose : ('T → 'U option) → seq<'T> → seq<'U>	Applies the given function to each element of the list. Return the list comprised of the results for each element where the function returns Some.
collect : ('T → 'Collection) → seq<'T> → seq<'U>	Applies the given function to each element of the sequence and concatenates all the results.
compareWith : ('T → 'T → int) → seq<'T> → seq<'T> → int	Compares two sequences using the given comparison function, element by element.
concat : seq<'Collection> → seq<'T>	Combines the given enumeration-of-enumerations as a single concatenated enumeration.
countBy : ('T → 'Key) → seq<'T> → seq<'Key * int>	Applies a key-generating function to each element of a sequence and return a sequence yielding unique keys and their number of occurrences in the original sequence.
delay : (unit → seq<'T>) → seq<'T>	Returns a sequence that is built from the given delayed specification of a sequence.
distinct : seq<'T> → seq<'T>	Returns a sequence that contains no duplicate entries according to generic hash and equality comparisons on the entries. If an element occurs multiple times in the sequence then the later occurrences are discarded.
distinctBy : ('T → 'Key) → seq<'T> → seq<'T>	Returns a sequence that contains no duplicate entries according to the generic hash and equality comparisons on the keys returned by the given key-generating function. If an element occurs multiple times in the sequence then the later occurrences are discarded.
empty : seq<'T>	Creates an empty sequence.
exactlyOne : seq<'T> → 'T	Returns the only element of the sequence.
exists : ('T → bool) → seq<'T> → bool	Tests if any element of the sequence satisfies the given predicate.
exists2 : ('T1 → 'T2 → bool) → seq<'T1> → seq<'T2> → bool	Tests if any pair of corresponding elements of the input sequences satisfies the given predicate.
filter : ('T → bool) → seq<'T> → seq<'T>	Returns a new collection containing only the elements of the collection for which the given predicate returns true.
find : ('T → bool) → seq<'T> → 'T	Returns the first element for which the given function returns true.
findIndex : ('T → bool) → seq<'T> → int	Returns the index of the first element for which the given function returns true.
fold : ('State → 'T → 'State) → 'State → seq<'T> → 'State	Applies a function to each element of the collection, threading an accumulator argument through the computation. If the input function is f and the elements are i0...iN, then this function computes f (... (f s i0)...) iN.
forall : ('T → bool) → seq<'T> → bool	Tests if all elements of the sequence satisfy the given predicate.
forall2 : ('T1 → 'T2 → bool) → seq<'T1> → seq<'T2> → bool	Tests the all pairs of elements drawn from the two sequences satisfy the given predicate. If one sequence is shorter than the other then the remaining elements of the longer sequence are ignored.
groupBy : ('T → 'Key) → seq<'T> → seq<'Key * seq<'T>>	Applies a key-generating function to each element of a sequence and yields a sequence of unique keys. Each unique key has also contains a sequence of all elements that match to this key.
head : seq<'T> → 'T	Returns the first element of the sequence.
init : int → (int → 'T) → seq<'T>	Generates a new sequence which, when iterated, returns successive elements by calling the given function, up to the given count. The results of calling the function are not saved, that is, the function is reapplied as necessary to regenerate the elements. The function is passed the index of the item being generated.
initInfinite : (int → 'T) → seq<'T>	Generates a new sequence which, when iterated, will return successive elements by calling the given function. The results of calling the function are not saved, that is, the function will be reapplied as necessary to regenerate the elements. The function is passed the index of the item being generated.
isEmpty : seq<'T> → bool	Tests whether a sequence has any elements.
iter : ('T → unit) → seq<'T> → unit	Applies the given function to each element of the collection.
iter2 : ('T1 → 'T2 → unit) → seq<'T1> → seq<'T2> → unit	Applies the given function to two collections simultaneously. If one sequence is shorter than the other then the remaining elements of the longer sequence are ignored.
iteri : (int → 'T → unit) → seq<'T> → unit	Applies the given function to each element of the collection. The integer passed to the function indicates the index of element.
last : seq<'T> → 'T	Returns the last element of the sequence.
length : seq<'T> → int	Returns the length of the sequence.
map : ('T → 'U) → seq<'T> → seq<'U>	Creates a new collection whose elements are the results of applying the given function to each of the elements of the collection. The given function will be applied as elements are demanded using the MoveNext method on enumerators retrieved from the object.
map2 : ('T1 → 'T2 → 'U) → seq<'T1> → seq<'T2> → seq<'U>	Creates a new collection whose elements are the results of applying the given function to the corresponding pairs of elements from the two sequences. If one input sequence is shorter than the other then the remaining elements of the longer sequence are ignored.
mapi : (int → 'T → 'U) → seq<'T> → seq<'U>	Creates a new collection whose elements are the results of applying the given function to each of the elements of the collection. The integer index passed to the function indicates the index (from 0) of element being transformed.
max : seq<'T> → 'T	Returns the greatest of all elements of the sequence, compared by using Operators.max.
maxBy : ('T → 'U) → seq<'T> → 'T	Returns the greatest of all elements of the sequence, compared by using Operators.max on the function result.
min : seq<'T> → 'T	Returns the lowest of all elements of the sequence, compared by using Operators.min.
minBy : ('T → 'U) → seq<'T> → 'T	Returns the lowest of all elements of the sequence, compared by using Operators.min on the function result.
nth : int → seq<'T> → 'T	Computes the nth element in the collection.
ofArray : 'T array → seq<'T>	Views the given array as a sequence.
ofList : 'T list → seq<'T>	Views the given list as a sequence.
pairwise : seq<'T> → seq<'T * 'T>	Returns a sequence of each element in the input sequence and its predecessor, with the exception of the first element which is only returned as the predecessor of the second element.
pick : ('T → 'U option) → seq<'T> → 'U	Applies the given function to successive elements, returning the first value where the function returns a Some value.
readonly : seq<'T> → seq<'T>	Creates a new sequence object that delegates to the given sequence object. This ensures the original sequence cannot be rediscovered and mutated by a type cast. For example, if given an array the returned sequence will return the elements of the array, but you cannot cast the returned sequence object to an array.
reduce : ('T → 'T → 'T) → seq<'T> → 'T	Applies a function to each element of the sequence, threading an accumulator argument through the computation. Begin by applying the function to the first two elements. Then feed this result into the function along with the third element and so on. Return the final result.
scan : ('State → 'T → 'State) → 'State → seq<'T> → seq<'State>	Like Seq.fold, but computes on-demand and returns the sequence of intermediary and final results.
singleton : 'T → seq<'T>	Returns a sequence that yields one item only.
skip : int → seq<'T> → seq<'T>	Returns a sequence that skips a specified number of elements of the underlying sequence and then yields the remaining elements of the sequence.
skipWhile : ('T → bool) → seq<'T> → seq<'T>	Returns a sequence that, when iterated, skips elements of the underlying sequence while the given predicate returns true, and then yields the remaining elements of the sequence.
sort : seq<'T> → seq<'T>	Yields a sequence ordered by keys.
sortBy : ('T → 'Key) → seq<'T> → seq<'T>	Applies a key-generating function to each element of a sequence and yield a sequence ordered by keys. The keys are compared using generic comparison as implemented by Operators.compare.
sum : seq<^T> → ^T	Returns the sum of the elements in the sequence.
sumBy	Returns the sum of the results generated by applying the function to each element of the sequence.
take : int → seq<'T> → seq<'T>	Returns the first elements of the sequence up to a specified count.
takeWhile : ('T → bool) → seq<'T> → seq<'T>	Returns a sequence that, when iterated, yields elements of the underlying sequence while the given predicate returns true, and then returns no further elements.
toArray : seq<'T> → 'T[]	Creates an array from the given collection.
toList : seq<'T> → 'T list	Creates a list from the given collection.
truncate : int → seq<'T> → seq<'T>	Returns a sequence that when enumerated returns no more than a specified number of elements.
tryFind : ('T → bool) → seq<'T> → 'T option	Returns the first element for which the given function returns true, or None if no such element exists.
tryFindIndex : ('T → bool) → seq<'T> → int option	Returns the index of the first element in the sequence that satisfies the given predicate, or None if no such element exists.
tryPick : ('T → 'U option) → seq<'T> → 'U option	Applies the given function to successive elements, returning the first value where the function returns a Some value.
unfold : ('State → 'T * 'State option) → 'State → seq<'T>	Returns a sequence that contains the elements generated by the given computation.
where : ('T → bool) → seq<'T> → seq<'T>	Returns a new collection containing only the elements of the collection for which the given predicate returns true. A synonym for Seq.filter.
windowed : int → seq<'T> → seq<'T []>	Returns a sequence that yields sliding windows of containing elements drawn from the input sequence. Each window is returned as a fresh array.
zip : seq<'T1> → seq<'T2> → seq<'T1 * 'T2>	Combines the two sequences into a list of pairs. The two sequences need not have equal lengths − when one sequence is exhausted any remaining elements in the other sequence are ignored.
zip3 : seq<'T1> → seq<'T2> → seq<'T3> → seq<'T1 * 'T2 * 'T3>	Combines the three sequences into a list of triples. The sequences need not have equal lengths − when one sequence is exhausted any remaining elements in the other sequences are ignored.

Value	Description
add : 'T → Set<'T> → Set<'T>	Returns a new set with an element added to the set. No exception is raised if the set already contains the given element.
contains : 'T → Set<'T> → bool	Evaluates to true if the given element is in the given set.
count : Set<'T> → int	Returns the number of elements in the set.
difference : Set<'T> → Set<'T> → Set<'T>	Returns a new set with the elements of the second set removed from the first.
empty : Set<'T>	The empty set for the specified type.
exists : ('T → bool) → Set<'T> → bool	Tests if any element of the collection satisfies the given predicate. If the input function is predicate and the elements are i0...iN, then this function computes predicate i0 or ... or predicate iN.
filter : ('T → bool) → Set<'T> → Set<'T>	Returns a new collection containing only the elements of the collection for which the given predicate returns true.
fold : ('State → 'T → 'State) → 'State → Set<'T> → 'State	Applies the given accumulating function to all the elements of the set.
foldBack : ('T → 'State → 'State) → Set<'T> → 'State → 'State	Applies the given accumulating function to all the elements of the set.
forall : ('T → bool) → Set<'T> → bool	Tests if all elements of the collection satisfy the given predicate. If the input function is p and the elements are i0...iN, then this function computes p i0 && ... && p iN.
intersect : Set<'T> → Set<'T> → Set<'T>	Computes the intersection of the two sets.
intersectMany : seq<Set<'T>> → Set<'T>	Computes the intersection of a sequence of sets. The sequence must be non-empty.
isEmpty : Set<'T> → bool	Returns true if the set is empty.
isProperSubset : Set<'T> → Set<'T> → bool	Evaluates to true if all elements of the first set are in the second, and at least one element of the second is not in the first.
isProperSuperset : Set<'T> → Set<'T> → bool	Evaluates to true if all elements of the second set are in the first, and at least one element of the first is not in the second.
isSubset : Set<'T> → Set<'T> → bool	Evaluates to true if all elements of the first set are in the second.
isSuperset : Set<'T> → Set<'T> → bool	Evaluates to true if all elements of the second set are in the first.
iter : ('T → unit) → Set<'T> → unit	Applies the given function to each element of the set, in order according to the comparison function.
map : ('T → 'U) → Set<'T> → Set<'U>	Returns a new collection containing the results of applying the given function to each element of the input set.
maxElement : Set<'T> → 'T	Returns the highest element in the set according to the ordering being used for the set.
minElement : Set<'T> → 'T	Returns the lowest element in the set according to the ordering being used for the set.
ofArray : 'T array → Set<'T>	Creates a set that contains the same elements as the given array.
ofList : 'T list → Set<'T>	Creates a set that contains the same elements as the given list.
ofSeq : seq<'T> → Set<'T>	Creates a new collection from the given enumerable object.
partition : ('T → bool) → Set<'T> → Set<'T> * Set<'T>	Splits the set into two sets containing the elements for which the given predicate returns true and false respectively.
remove : 'T → Set<'T> → Set<'T>	Returns a new set with the given element removed. No exception is raised if the set doesn't contain the given element.
singleton : 'T → Set<'T>	The set containing the given element.
toArray : Set<'T> → 'T array	Creates an array that contains the elements of the set in order.
toList : Set<'T> → 'T list	Creates a list that contains the elements of the set in order.
toSeq : Set<'T> → seq<'T>	Returns an ordered view of the collection as an enumerable object.
union : Set<'T> → Set<'T> → Set<'T>	Computes the union of the two sets.
unionMany : seq<Set<'T>> → Set<'T>	Computes the union of a sequence of sets.

Member	Description
Add	Returns a new map with the binding added to the given map.
ContainsKey	Tests if an element is in the domain of the map.
Count	The number of bindings in the map.
IsEmpty	Returns true if there are no bindings in the map.
Item	Lookup an element in the map. Raises KeyNotFoundException if no binding exists in the map.
Remove	Removes an element from the domain of the map. No exception is raised if the element is not present.
TryFind	Lookup an element in the map, returning a Some value if the element is in the domain of the map and None if not.

Value	Description
append : 'T [] → 'T [] → 'T []	Creates an array that contains the elements of one array followed by the elements of another array.
average : ^T [] → ^T	Returns the average of the elements in an array.
averageBy : ('T → ^U) → 'T [] → ^U	Returns the average of the elements generated by applying a function to each element of an array.
blit : 'T [] → int → 'T [] → int → int → unit	Reads a range of elements from one array and writes them into another.
choose : ('T → U option) → 'T [] → 'U []	Applies a supplied function to each element of an array. Returns an array that contains the results x for each element for which the function returns Some(x).
collect : ('T → 'U []) → T [] → 'U []	Applies the supplied function to each element of an array, concatenates the results, and returns the combined array.
concat : seq<'T []> → 'T []	Creates an array that contains the elements of each of the supplied sequence of arrays.
copy : 'T → 'T []	Creates an array that contains the elements of the supplied array.
create : int → 'T → 'T []	Creates an array whose elements are all initially the supplied value.
empty : 'T []	Returns an empty array of the given type.
exists : ('T → bool) → 'T [] → bool	Tests whether any element of an array satisfies the supplied predicate.
exists2 : ('T1 → 'T2 → bool) → 'T1 [] → 'T2 [] → bool	Tests whether any pair of corresponding elements of two arrays satisfy the supplied condition.
fill : 'T [] → int → int → 'T → unit	Fills a range of elements of an array with the supplied value.
filter : ('T → bool) → 'T [] → 'T []	Returns a collection that contains only the elements of the supplied array for which the supplied condition returns true.
find : ('T → bool) → 'T [] → 'T	Returns the first element for which the supplied function returns true. Raises KeyNotFoundException if no such element exists.
findIndex : ('T → bool) → 'T [] → int	Returns the index of the first element in an array that satisfies the supplied condition. Raises KeyNotFoundException if none of the elements satisfy the condition.
fold : ('State → 'T → 'State) → 'State → 'T [] → 'State	Applies a function to each element of an array, threading an accumulator argument through the computation. If the input function is f and the array elements are i0...iN, this function computes f (...(f s i0)...) iN.
fold2 : ('State → 'T1 → 'T2 → 'State) → 'State → 'T1 [] → 'T2 [] → 'State	Applies a function to pairs of elements from two supplied arrays, left-to-right, threading an accumulator argument through the computation. The two input arrays must have the same lengths; otherwise, ArgumentException is raised.
foldBack : ('T → 'State → 'State) → 'T [] → 'State → 'State	Applies a function to each element of an array, threading an accumulator argument through the computation. If the input function is f and the array elements are i0...iN, this function computes f i0 (...(f iN s)).
foldBack2 : ('T1 → 'T2 → 'State → 'State) → 'T1 [] → 'T2 [] → 'State → 'State	Applies a function to pairs of elements from two supplied arrays, right-to-left, threading an accumulator argument through the computation. The two input arrays must have the same lengths; otherwise, ArgumentException is raised.
forall : ('T → bool) → 'T [] → bool	Tests whether all elements of an array satisfy the supplied condition.
forall2 : ('T1 → 'T2 → bool) → 'T1 [] → 'T2 [] → bool	Tests whether all corresponding elements of two supplied arrays satisfy a supplied condition.
get : 'T [] → int → 'T	Gets an element from an array.
init : int → (int → 'T) → 'T []	Uses a supplied function to create an array of the supplied dimension.
isEmpty : 'T [] → bool	Tests whether an array has any elements.
iter : ('T → unit) → 'T [] → unit	Applies the supplied function to each element of an array.
iter2 : ('T1 → 'T2 → unit) → 'T1 [] → 'T2 [] → unit)	Applies the supplied function to a pair of elements from matching indexes in two arrays. The two arrays must have the same lengths; otherwise, ArgumentException is raised.
iteri : (int → 'T → unit) → 'T [] → unit	Applies the supplied function to each element of an array. The integer passed to the function indicates the index of the element.
iteri2 : (int → 'T1 → 'T2 → unit) → 'T1 [] → 'T2 [] → unit	Applies the supplied function to a pair of elements from matching indexes in two arrays, also passing the index of the elements. The two arrays must have the same lengths; otherwise, an ArgumentException is raised.
length : 'T [] → int	Returns the length of an array. The Length property does the same thing.
map : ('T → 'U) → 'T [] → 'U []	Creates an array whose elements are the results of applying the supplied function to each of the elements of a supplied array.
map2 : ('T1 → 'T2 → 'U) → 'T1 [] → 'T2 [] → 'U []	Creates an array whose elements are the results of applying the supplied function to the corresponding elements of two supplied arrays. The two input arrays must have the same lengths; otherwise, ArgumentException is raised.
mapi : (int → 'T → 'U) → 'T [] → 'U []	Creates an array whose elements are the results of applying the supplied function to each of the elements of a supplied array. An integer index passed to the function indicates the index of the element being transformed.
mapi2 : (int → 'T1 → 'T2 → 'U) → 'T1 [] → 'T2 [] → 'U []	Creates an array whose elements are the results of applying the supplied function to the corresponding elements of the two collections pairwise, also passing the index of the elements. The two input arrays must have the same lengths; otherwise, ArgumentException is raised.
max : 'T [] → 'T	Returns the largest of all elements of an array. Operators.max is used to compare the elements.
maxBy : ('T → 'U) → 'T [] → 'T	Returns the largest of all elements of an array, compared via Operators.max on the function result.
min : ('T [] → 'T	Returns the smallest of all elements of an array. Operators.min is used to compare the elements.
minBy : ('T → 'U) → 'T [] → 'T	Returns the smallest of all elements of an array. Operators.min is used to compare the elements.
ofList : 'T list → 'T []	Creates an array from the supplied list.
ofSeq : seq<'T> → 'T []	Creates an array from the supplied enumerable object.
partition : ('T → bool) → 'T [] → 'T [] * 'T []	Splits an array into two arrays, one containing the elements for which the supplied condition returns true, and the other containing those for which it returns false.
permute : (int → int) → 'T [] → 'T []	Permutes the elements of an array according to the specified permutation.
pick : ('T → 'U option) → 'T [] → 'U	Applies the supplied function to successive elements of a supplied array, returning the first result where the function returns Some(x) for some x. If the function never returns Some(x), KeyNotFoundException is raised.
reduce : ('T → 'T → 'T) → 'T [] → 'T	Applies a function to each element of an array, threading an accumulator argument through the computation. If the input function is f and the array elements are i0...iN, this function computes f (...(f i0 i1)...) iN. If the array has size zero, ArgumentException is raised.
reduceBack : ('T → 'T → 'T) → 'T [] → 'T	Applies a function to each element of an array, threading an accumulator argument through the computation. If the input function is f and the elements are i0...iN, this function computes f i0 (...(f iN-1 iN)). If the array has size zero, ArgumentException is raised.
rev : 'T [] → 'T []	Reverses the order of the elements in a supplied array.
scan : ('State → 'T → 'State) → 'State → 'T [] → 'State [])	Behaves like fold, but returns the intermediate results together with the final results.
scanBack : ('T → 'State → 'State) → 'T [] → 'State → 'State []	Behaves like foldBack, but returns the intermediary results together with the final results.
set : 'T [] → int → 'T → unit	Sets an element of an array.
sort : 'T[] → 'T []	Sorts the elements of an array and returns a new array. Operators.compare is used to compare the elements.
sortBy : ('T → 'Key) → 'T [] → 'T []	Sorts the elements of an array by using the supplied function to transform the elements to the type on which the sort operation is based, and returns a new array. Operators.compare is used to compare the elements.
sortInPlace : 'T [] → unit	Sorts the elements of an array by changing the array in place, using the supplied comparison function. Operators.compare is used to compare the elements.
sortInPlaceBy : ('T → 'Key) → 'T [] → unit	Sorts the elements of an array by changing the array in place, using the supplied projection for the keys. Operators.compare is used to compare the elements.
sortInPlaceWith : ('T → 'T → int) → 'T [] → unit	Sorts the elements of an array by using the supplied comparison function to change the array in place.
sortWith : ('T → 'T → int) → 'T [] → 'T []	Sorts the elements of an array by using the supplied comparison function, and returns a new array.
sub : 'T [] → int → int → 'T []	Creates an array that contains the supplied subrange, which is specified by starting index and length.
sum : 'T [] → ^T	Returns the sum of the elements in the array.
sumBy : ('T → ^U) → 'T [] → ^U	Returns the sum of the results generated by applying a function to each element of an array.
toList : 'T [] → 'T list	Converts the supplied array to a list.
toSeq : 'T [] → seq<'T>	Views the supplied array as a sequence.
tryFind : ('T → bool) → 'T [] → 'T option	Returns the first element in the supplied array for which the supplied function returns true. Returns None if no such element exists.
tryFindIndex : ('T → bool) → 'T [] → int option	Returns the index of the first element in an array that satisfies the supplied condition.
tryPick : ('T → 'U option) → 'T [] → 'U option	Applies the supplied function to successive elements of the supplied array, and returns the first result where the function returns Some(x) for some x. If the function never returns Some(x), None is returned.
unzip : ('T1 * 'T2) [] → 'T1 [] * 'T2 []	Splits an array of tuple pairs into a tuple of two arrays.
unzip3 : ('T1 * 'T2 * 'T3) [] → 'T1 [] * 'T2 [] * 'T3 []	Splits an array of tuples of three elements into a tuple of three arrays.
zeroCreate : int → 'T []	Creates an array whose elements are initially set to the default value Unchecked.defaultof<'T>.
zip : 'T1 [] → 'T2 [] → ('T1 * 'T2) []	Combines two arrays into an array of tuples that have two elements. The two arrays must have equal lengths; otherwise, ArgumentException is raised.
zip3 : 'T1 [] → 'T2 [] → 'T3 [] → ('T1 * 'T2 * 113 'T3) []	Combines three arrays into an array of tuples that have three elements. The three arrays must have equal lengths; otherwise, ArgumentException is raised.

Property	Description
Capacity	Gets or sets the total number of elements the internal data structure can hold without resizing.
Count	Gets the number of elements contained in the List(T).
Item	Gets or sets the element at the specified index.

Constructor	Description
List(T)()	Initializes a new instance of the List(T) class that is empty and has the default initial capacity.
List(T)(IEnumerable(T))	Initializes a new instance of the List(T) class that contains elements copied from the specified collection and has sufficient capacity to accommodate the number of elements copied.
List(T)(Int32)	Initializes a new instance of the List(T) class that is empty and has the specified initial capacity.

Methods	Description
Add	Adds an object to the end of the List(T).
AddRange	Adds the elements of the specified collection to the end of the List(T).
AsReadOnly	Returns a read-only IList(T) wrapper for the current collection.
BinarySearch(T)	Searches the entire sorted List(T) for an element using the default comparer and returns the zero-based index of the element.
BinarySearch(T, IComparer(T))	Searches the entire sorted List(T) for an element using the specified comparer and returns the zero-based index of the element.
BinarySearch(Int32, Int32, T, IComparer(T))	Searches a range of elements in the sorted List(T) for an element using the specified comparer and returns the zero-based index of the element.
Clear	Removes all elements from the List(T).
Contains	Determines whether an element is in the List(T).
ConvertAll(TOutput)	Converts the elements in the current List(T) to another type, and returns a list containing the converted elements.
CopyTo(T[])	Copies the entire List(T) to a compatible one-dimensional array, starting at the beginning of the target array.
CopyTo(T[], Int32)	Copies the entire List(T) to a compatible one-dimensional array, starting at the specified index of the target array.
CopyTo(Int32, T[], Int32, Int32)	Copies a range of elements from the List(T) to a compatible one-dimensional array, starting at the specified index of the target array.
Equals(Object)	Determines whether the specified object is equal to the current object. (Inherited from Object.)
Exists	Determines whether the List(T) contains elements that match the conditions defined by the specified predicate.
Finalize	Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection (Inherited from Object).
Find	Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire List(T).
FindAll	Retrieves all the elements that match the conditions defined by the specified predicate.
FindIndex(Predicate(T))	Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the entire List(T).
FindIndex(Int32, Predicate(T))	Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the List(T) that extends from the specified index to the last element.
FindIndex(Int32, Int32, Predicate(T))	Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the List(T) that starts at the specified index and contains the specified number of elements.
FindLast	Searches for an element that matches the conditions defined by the specified predicate, and returns the last occurrence within the entire List(T).
FindLastIndex(Predicate(T))	Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the entire List(T).
FindLastIndex(Int32, Predicate(T))	Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the List(T) that extends from the first element to the specified index.
FindLastIndex(Int32, Int32, Predicate(T))	Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the List(T) that contains the specified number of elements and ends at the specified index.
ForEach	Performs the specified action on each element of the List(T).
GetEnumerator	Returns an enumerator that iterates through the List(T).
GetHashCode	Serves as the default hash function. (Inherited from Object.)
GetRange	Creates a shallow copy of a range of elements in the source List(T).
GetType	Gets the Type of the current instance. (Inherited from Object.)
IndexOf(T)	Searches for the specified object and returns the zero-based index of the first occurrence within the entire List(T).
IndexOf(T, Int32)	Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the List(T) that extends from the specified index to the last element.
IndexOf(T, Int32, Int32)	Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the List(T) that starts at the specified index and contains the specified number of elements.
Insert	Inserts an element into the List(T) at the specified index.
InsertRange	Inserts the elements of a collection into the List(T) at the specified index.
LastIndexOf(T)	Searches for the specified object and returns the zero-based index of the last occurrence within the entire List(T).
LastIndexOf(T, Int32)	Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the List(T) that extends from the first element to the specified index.
LastIndexOf(T, Int32, Int32)	Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the List(T) that contains the specified number of elements and ends at the specified index.
MemberwiseClone	Creates a shallow copy of the current Object. (Inherited from Object.)
Remove	Removes the first occurrence of a specific object from the List(T).
RemoveAll	Removes all the elements that match the conditions defined by the specified predicate.
RemoveAt	Removes the element at the specified index of the List(T).
RemoveRange	Removes a range of elements from the List(T).
Reverse()	Reverses the order of the elements in the entire List(T).
Reverse(Int32, Int32)	Reverses the order of the elements in the specified range.
Sort()	Sorts the elements in the entire List(T) using the default comparer.
Sort(Comparison(T))	Sorts the elements in the entire List(T) using the specified System. Comparison(T).
Sort(IComparer(T))	Sorts the elements in the entire List(T) using the specified comparer.
Sort(Int32, Int32, IComparer(T))	Sorts the elements in a range of elements in List(T) using the specified comparer.
ToArray	Copies the elements of the List(T) to a new array.
ToString	Returns a string that represents the current object. (Inherited from Object.)
TrimExcess	Sets the capacity to the actual number of elements in the List(T), if that number is less than a threshold value.
TrueForAll	Determines whether every element in the List(T) matches the conditions defined by the specified predicate.

F# - Quick Guide

F# - Overview

About F#

Features of F#

Use of F#

F# - Environment Setup

Integrated Development Environment(IDE) for F#

Writing F# Programs On Links

F# - Program Structure

F# - Basic Syntax

Tokens in F#

F# Keywords

Comments in F#

A Basic Program and Application Entry Point in F#

F# - Data Types

Integral Data Type

Example

Floating Point Data Types

Example

Text Data Types

Example

Other Data Types

Example

F# - Variables

Variable Declaration in F#

Example

Example

Variable Definition With Type Declaration

Example

Mutable Variables

Example

F# - Operators

Arithmetic Operators

Comparison Operators

Boolean Operators

Bitwise Operators

Operators Precedence

F# - Decision Making

F# - Loops

F# - Functions

Defining a Function

Parameters of a Function

Calling a Function

Example 1

Example 2

Example 3

Recursive Functions

Example 1

Example 2

Arrow Notations in F#

Lambda Expressions

Function Composition and Pipelining

F# - Strings

String Literals

Ways of lgnoring the Escape Sequence

Example

Basic Operators on Strings

Example 1

Example 2

Example 3

F# - Options

Using Options

Example

Option Properties and Methods

Example 1

Example 2

Example 3

F# - Tuples

Example

Accessing Individual Tuple Members

Example

Example

F# - Records

Defining Record

Creating a Record

Example 1

Example 2

F# - Lists

Creating and Initializing a List

List Literals

Property	Description
Comparer	Gets the IEqualityComparer(T) that is used to determine equality of keys for the dictionary.
Count	Gets the number of key/value pairs contained in the Dictionary(TKey, TValue).
Item	Gets or sets the value associated with the specified key.
Keys	Gets a collection containing the keys in the Dictionary(TKey, TValue).
Values	Gets a collection containing the values in the Dictionary(TKey, TValue).

Constructors	Description
Dictionary(TKey, TValue)()	Initializes a new instance of the Dictionary(TKey, TValue) class that is empty, has the default initial capacity, and uses the default equality comparer for the key type.
Dictionary(TKey, TValue)(IDictionary(TKey, TValue))	Initializes a new instance of the Dictionary(TKey, TValue) class that contains elements copied from the specified IDictionary(TKey, TValue) and uses the default equality comparer for the key type.
Dictionary(TKey, TValue)(IEqualityComparer(TKey))	Initializes a new instance of the Dictionary(TKey, TValue) class that is empty, has the default initial capacity, and uses the specified IEqualityComparer(T).
Dictionary(TKey, TValue)(Int32)	Initializes a new instance of the Dictionary(TKey, TValue) class that is empty, has the specified initial capacity, and uses the default equality comparer for the key type.
Dictionary(TKey, TValue)(IDictionary(TKey, TValue), IEqualityComparer(TKey))	Initializes a new instance of the Dictionary(TKey, TValue) class that contains elements copied from the specified IDictionary(TKey, TValue) and uses the specified IEqualityComparer(T).
Dictionary(TKey, TValue)(Int32, IEqualityComparer(TKey))	Initializes a new instance of the Dictionary(TKey, TValue) class that is empty, has the specified initial capacity, and uses the specified IEqualityComparer(T).
Dictionary(TKey, TValue)(SerializationInfo, StreamingContext)	Initializes a new instance of the ictionary(TKey, TValue) class with serialized data.

Method	Description
Add	Adds the specified key and value to the dictionary.
Clear	Removes all keys and values from the Dictionary(TKey, TValue).
ContainsKey	Determines whether the Dictionary(TKey, TValue) contains the specified key.
ContainsValue	Determines whether the Dictionary(TKey, TValue) contains a specific value.
Equals(Object)	Determines whether the specified object is equal to the current object. (Inherited from Object.)
Finalize	Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator	Returns an enumerator that iterates through the Dictionary(TKey, TValue).
GetHashCode	Serves as the default hash function. (Inherited from Object.)
GetObjectData	Implements the System.Runtime.Serialization.ISerializable interface and returns the data needed to serialize the Dictionary(TKey, TValue)instance.
GetType	Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone	Creates a shallow copy of the current Object. (Inherited from Object.)
OnDeserialization	Implements the System.Runtime.Serialization.ISerializable interface and raises the deserialization event when the deserialization is complete.
Remove	Removes the value with the specified key from the Dictionary(TKey, TValue).
ToString	Returns a string that represents the current object. (Inherited from Object.)
TryGetValue	Gets the value associated with the specified key.

Value	Description
bprintf : StringBuilder → BuilderFormat<'T> → 'T	Prints to a StringBuilder.
eprintf : TextWriterFormat<'T> → 'T	Prints formatted output to stderr.
eprintfn : TextWriterFormat<'T> → 'T	Prints formatted output to stderr, adding a newline.
failwithf : StringFormat<'T,'Result> → 'T	Prints to a string buffer and raises an exception with the given result.
fprintf : TextWriter → TextWriterFormat<'T> → 'T	Prints to a text writer.
fprintfn : TextWriter → TextWriterFormat<'T> → 'T	Prints to a text writer, adding a newline.
kbprintf : (unit → 'Result) → StringBuilder → BuilderFormat<'T,'Result> → 'T	Like bprintf, but calls the specified function to generate the result.
kfprintf : (unit → 'Result) → TextWriter → TextWriterFormat<'T,'Result> → 'T	Like fprintf, but calls the specified function to generate the result.
kprintf : (string → 'Result) → StringFormat<'T,'Result> → 'T	Like printf, but calls the specified function to generate the result. For example, these let the printing force a flush after all output has been entered onto the channel, but not before.
ksprintf : (string → 'Result) → StringFormat<'T,'Result> → 'T	Like sprintf, but calls the specified function to generate the result.
printf : TextWriterFormat<'T> → 'T	Prints formatted output to stdout.
printfn : TextWriterFormat<'T> → 'T	Prints formatted output to stdout, adding a newline.
sprintf : StringFormat<'T> → 'T	Prints to a string by using an internal string buffer and returns the result as a string.

Type	Description
%b	Formats a bool, formatted as true or false.
%c	Formats a character.
%s	Formats a string, formatted as its contents, without interpreting any escape characters.
%d, %i	Formats any basic integer type formatted as a decimal integer, signed if the basic integer type is signed.
%u	Formats any basic integer type formatted as an unsigned decimal integer.
%x	Formats any basic integer type formatted as an unsigned hexadecimal integer, using lowercase letters a through f.
%X	Formats any basic integer type formatted as an unsigned hexadecimal integer, using uppercase letters A through F.
%o	Formats any basic integer type formatted as an unsigned octal integer.
%e, %E, %f, %F, %g, %G	Formats any basic floating point type (float, float32) formatted using a C-style floating point format specifications.
%e, %E	Formats a signed value having the form [-]d.dddde[sign]ddd where d is a single decimal digit, dddd is one or more decimal digits, ddd is exactly three decimal digits, and sign is + or -.
%f	Formats a signed value having the form [-]dddd.dddd, where dddd is one or more decimal digits. The number of digits before the decimal point depends on the magnitude of the number, and the number of digits after the decimal point depends on the requested precision.
%g, %G	Formats a signed value printed in f or e format, whichever is more compact for the given value and precision.
%M	Formats a Decimal value.
%O	Formats any value, printed by boxing the object and using its ToString method.
%A, %+A	Formats any value, printed with the default layout settings. Use %+A to print the structure of discriminated unions with internal and private representations.
%a	A general format specifier, requires two arguments. The first argument is a function which accepts two arguments: first, a context parameter of the appropriate type for the given formatting function (for example, a TextWriter), and second, a value to print and which either outputs or returns appropriate text. The second argument is the particular value to print.
%t	A general format specifier, requires one argument: a function which accepts a context parameter of the appropriate type for the given formatting function (aTextWriter) and which either outputs or returns appropriate text. Basic integer types are byte, sbyte, int16, uint16, int32, uint32, int64, uint64, nativeint, and unativeint. Basic floating point types are float and float32.

Value	Description
0	Specifies to add zeros instead of spaces to make up the required width.
-	Specifies to left-justify the result within the width specified.
+	Specifies to add a + character if the number is positive (to match a - sign for negative numbers).
' ' (space)	Specifies to add an extra space if the number is positive (to match a - sign for negative numbers).
#	Invalid.

Method	Description
Beep()	Plays the sound of a beep through the console speaker.
Beep(Int32, Int32)	Plays the sound of a beep of a specified frequency and duration through the console speaker.
Clear	Clears the console buffer and corresponding console window of display information.
MoveBufferArea(Int32, Int32, Int32, Int32, Int32, Int32)	Copies a specified source area of the screen buffer to a specified destination area.
MoveBufferArea(Int32, Int32, Int32, Int32, Int32, Int32, Char, ConsoleColor, ConsoleColor)	Copies a specified source area of the screen buffer to a specified destination area.
OpenStandardError()	Acquires the standard error stream.
OpenStandardError(Int32)	Acquires the standard error stream, which is set to a specified buffer size.
OpenStandardInput()	Acquires the standard input stream.
OpenStandardInput(Int32)	Acquires the standard input stream, which is set to a specified buffer size.
OpenStandardOutput()	Acquires the standard output stream.
OpenStandardOutput(Int32)	Acquires the standard output stream, which is set to a specified buffer size.
Read	Reads the next character from the standard input stream.
ReadKey()	Obtains the next character or function key pressed by the user. The pressed key is displayed in the console window.
ReadKey(Boolean)	Obtains the next character or function key pressed by the user. The pressed key is optionally displayed in the console window.
ReadLine	Reads the next line of characters from the standard input stream.
ResetColor	Sets the foreground and background console colors to their defaults.
SetBufferSize	Sets the height and width of the screen buffer area to the specified values.
SetCursorPosition	Sets the position of the cursor.
SetError	Sets the Error property to the specified TextWriter object.
SetIn	Sets the In property to the specified TextReader object.
SetOut	Sets the Out property to the specified TextWriter object.
SetWindowPosition	Sets the position of the console window relative to the screen buffer.
SetWindowSize	Sets the height and width of the console window to the specified values.
Write(Boolean)	Writes the text representation of the specified Boolean value to the standard output stream.
Write(Char)	Writes the specified Unicode character value to the standard output stream.
Write(Char[])	Writes the specified array of Unicode characters to the standard output stream.
Write(Decimal)	Writes the text representation of the specified Decimal value to the standard output stream.
Write(Double)	Writes the text representation of the specified double-precision floating-point value to the standard output stream.
Write(Int32)	Writes the text representation of the specified 32-bit signed integer value to the standard output stream.
Write(Int64)	Writes the text representation of the specified 64-bit signed integer value to the standard output stream.
Write(Object)	Writes the text representation of the specified object to the standard output stream.
Write(Single)	Writes the text representation of the specified single-precision floating-point value to the standard output stream.
Write(String)	Writes the specified string value to the standard output stream.
Write(UInt32)	Writes the text representation of the specified 32-bit unsigned integer value to the standard output stream.
Write(UInt64)	Writes the text representation of the specified 64-bit unsigned integer value to the standard output stream.
Write(String, Object)	Writes the text representation of the specified object to the standard output stream using the specified format information.
Write(String, Object[])	Writes the text representation of the specified array of objects to the standard output stream using the specified format information.
Write(Char[], Int32, Int32)	Writes the specified subarray of Unicode characters to the standard output stream.
Write(String, Object, Object)	Writes the text representation of the specified objects to the standard output stream using the specified format information.
Write(String, Object, Object, Object)	Writes the text representation of the specified objects to the standard output stream using the specified format information.
Write(String, Object, Object, Object, Object)	Writes the text representation of the specified objects and variable-length parameter list to the standard output stream using the specified format information.
WriteLine()	Writes the current line terminator to the standard output stream.
WriteLine(Boolean)	Writes the text representation of the specified Boolean value, followed by the current line terminator, to the standard output stream.
WriteLine(Char)	Writes the specified Unicode character, followed by the current line terminator, value to the standard output stream.
WriteLine(Char[])	Writes the specified array of Unicode characters, followed by the current line terminator, to the standard output stream.
WriteLine(Decimal)	Writes the text representation of the specified Decimal value, followed by the current line terminator, to the standard output stream.
WriteLine(Double)	Writes the text representation of the specified double-precision floating-point value, followed by the current line terminator, to the standard output stream.
WriteLine(Int32)	Writes the text representation of the specified 32-bit signed integer value, followed by the current line terminator, to the standard output stream.
WriteLine(Int64)	Writes the text representation of the specified 64-bit signed integer value, followed by the current line terminator, to the standard output stream.
WriteLine(Object)	Writes the text representation of the specified object, followed by the current line terminator, to the standard output stream.
WriteLine(Single)	Writes the text representation of the specified single-precision floating-point value, followed by the current line terminator, to the standard output stream.
WriteLine(String)	Writes the specified string value, followed by the current line terminator, to the standard output stream.
WriteLine(UInt32)	Writes the text representation of the specified 32-bit unsigned integer value, followed by the current line terminator, to the standard output stream.
WriteLine(UInt64)	Writes the text representation of the specified 64-bit unsigned integer value, followed by the current line terminator, to the standard output stream.
WriteLine(String, Object)	Writes the text representation of the specified object, followed by the current line terminator, to the standard output stream using the specified format information.
WriteLine(String, Object[])	Writes the text representation of the specified array of objects, followed by the current line terminator, to the standard output stream using the specified format information.
WriteLine(Char[], Int32, Int32)	Writes the specified subarray of Unicode characters, followed by the current line terminator, to the standard output stream.
WriteLine(String, Object, Object)	Writes the text representation of the specified objects, followed by the current line terminator, to the standard output stream using the specified format information.
WriteLine(String, Object, Object, Object)	Writes the text representation of the specified objects, followed by the current line terminator, to the standard output stream using the specified format information.
WriteLine(String, Object, Object, Object, Object)	Writes the text representation of the specified objects and variable-length parameter list, followed by the current line terminator, to the standard output stream using the specified format information.

Class	Description
BinaryReader	Reads primitive data types as binary values in a specific encoding.
BinaryWriter	Writes primitive types in binary to a stream and supports writing strings in a specific encoding.
BufferedStream	Adds a buffering layer to read and write operations on another stream.
Directory	Exposes static methods for creating, moving, and enumerating through directories and subdirectories.
DirectoryInfo	Exposes instance methods for creating, moving, and enumerating through directories and subdirectories.
DirectoryNotFoundException	The exception that is thrown when part of a file or directory cannot be found.
DriveInfo	Provides access to information on a drive.
DriveNotFoundException	The exception that is thrown when trying to access a drive or share that is not available.
EndOfStreamException	The exception that is thrown when reading is attempted past the end of a stream.
ErrorEventArgs	Provides data for the FileSystemWatcher.Error event.
File	Provides static methods for the creation, copying, deletion, moving, and opening of a single file, and aids in the creation of FileStream objects.
FileFormatException	The exception that is thrown when an input file or a data stream that is supposed to conform to a certain file format specification is malformed.
FileInfo	Provides properties and instance methods for the creation, copying, deletion, moving, and opening of files, and aids in the creation of FileStream objects.
FileLoadException	The exception that is thrown when a managed assembly is found but cannot be loaded.
FileNotFoundException	The exception that is thrown when an attempt to access a file that does not exist on disk fails.
FileStream	Exposes a Stream around a file, supporting both synchronous and asynchronous read and write operations.
FileSystemEventArgs	Provides data for the directory events − Changed, Created, Deleted.
FileSystemInfo	Provides the base class for both FileInfo and DirectoryInfo objects.
FileSystemWatcher	Listens to the file system change notifications and raises events when a directory, or file in a directory, changes.
InternalBufferOverflowException	The exception thrown when the internal buffer overflows.
InvalidDataException	The exception that is thrown when a data stream is in an invalid format.
IODescriptionAttribute	Sets the description visual designers can display when referencing an event, extender, or property.
IOException	The exception that is thrown when an I/O error occurs.
MemoryStream	Creates a stream whose backing store is memory.
Path	Performs operations on String instances that contain file or directory path information. These operations are performed in a cross-platform manner.
PathTooLongException	The exception that is thrown when a path or file name is longer than the system-defined maximum length.
PipeException	Thrown when an error occurs within a named pipe.
RenamedEventArgs	Provides data for the Renamed event.
Stream	Provides a generic view of a sequence of bytes. This is an abstract class.
StreamReader	Implements a TextReader that reads characters from a byte stream in a particular encoding.
StreamWriter	Implements a TextWriter for writing characters to a stream in a particular encoding. To browse the .NET Framework source code for this type, see the Reference Source.
StringReader	Implements a TextReader that reads from a string.
StringWriter	Implements a TextWriter for writing information to a string. The information is stored in an underlying StringBuilder.
TextReader	Represents a reader that can read a sequential series of characters.
TextWriter	Represents a writer that can write a sequential series of characters. This class is abstract.
UnmanagedMemoryAccessor	Provides random access to unmanaged blocks of memory from managed code.
UnmanagedMemoryStream	Provides access to unmanaged blocks of memory from managed code.
WindowsRuntimeStorageExtensions	Contains extension methods for the IStorageFile and IStorageFolder interfaces in the Windows Runtime when developing Windows Store apps.
WindowsRuntimeStreamExtensions	Contains extension methods for converting between streams in the Windows Runtime and managed streams in the .NET for Windows Store apps.

Construct	Description
raise expr	Raises the given exception.
failwith expr	Raises the System.Exception exception.
try expr with rules	Catches expressions matching the pattern rules.
try expr finally expr	Execution the finally expression both when the computation is successful and when an exception is raised.
\| :? ArgumentException	A rule matching the given .NET exception type.
\| :? ArgumentException as e	A rule matching the given .NET exception type, binding the name e to the exception object value.
\| Failure(msg) → expr	A rule matching the given data-carrying F# exception.
\| exn → expr	A rule matching any exception, binding the name exn to the exception object value.
\| exn when expr → expr	A rule matching the exception under the given condition, binding the name exn to the exception object value.

Member	Description
Publish	Publishes an observation as a first class value.
Trigger	Triggers an observation using the given parameters.