FSharp.Core

Gets the tail of the list, which is a list containing all the elements of the list, excluding the first element

Gets the number of items contained in the list

Get the element of the list at the given position. Note lists are represented as linked lists so this is an O(n) operation.

Gets a value indicating if the list contains no entries

Gets the first element of the list

Returns an empty list of a particular type

Returns a list with head as its first element and tail as its subsequent elements

The type of immutable singly-linked lists. Use the constructors [] and :: (infix) to create values of this type, or the notation [1;2;3]. Use the values in the List module to manipulate values of this type, or pattern match against the values directly.

An abbreviation for the type of immutable singly-linked lists.

Lookup an element in the map. Raise KeyNotFoundException if no binding exists in the map.

Return true if there are no bindings in the map.

The empty map

The number of bindings in the map

Lookup an element in the map, returning a Some value if the element is in the domain of the map and None if not.

Remove an element from the domain of the map. No exception is raised if the element is not present.

Test if an element is in the domain of the map

Return a new map with the binding added to the given map.

Build a map that contains the bindings of the given IEnumerable

Immutable maps. Keys are ordered by F# generic comparison. Maps based on generic comparison are efficient for small keys. They are not a suitable choice if keys are recursive data structures or if keys require bespoke comparison semantics.

An abbreviation for the .NET type System.Collections.Generic.List<_>

Return a new set with the elements of the second set removed from the first.

Compute the union of the two sets.

Returns the lowest element in the set according to the ordering being used for the set

Returns the highest element in the set according to the ordering being used for the set

A useful shortcut for Set.isEmpty. See the Set module for further operations on sets.

The empty set for the type 'T.

The number of elements in the set

Return a new set with the elements of the second set removed from the first.

A useful shortcut for Set.remove. Note this operation produces a new set and does not mutate the original set. The new set will share many storage nodes with the original. See the Set module for further operations on sets.

Evaluates to "true" if all elements of the first set are in the second

Evaluates to "true" if all elements of the second set are in the first

Returns the greatest element in the set that is less than the given key according to the ordering being used for the set

Returns the least element in the set that is greater than the given key according to the ordering being used for the set

A useful shortcut for Set.contains. See the Set module for further operations on sets.

A useful shortcut for Set.add. Note this operation produces a new set and does not mutate the original set. The new set will share many storage nodes with the original. See the Set module for further operations on sets.

Create a set containing elements drawn from the given sequence.

Immutable sets based on binary trees, where comparison is the F# structural comparison function, potentially using implementations of the IComparable interface on key values. See the Set module for further operations on sets. These sets can be used with elements of any type, but you should check that structural hashing and equality on the element type are correct for your type.

An abbreviation for the type of immutable singly-linked lists. Use the constructors [] and :: (infix) to create values of this type, or the notation [1;2;3]. Use the values in the List module to manipulate values of this type, or pattern match against the values directly.

An abbreviation for the .NET type System.Collections.Generic.IEnumerable<_>

Fetch the base-index for the first dimension of the array. See notes on the Array2D module re. zero-basing.

Fetch the base-index for the second dimension of the array. See notes on the Array2D module re. zero-basing.

Read a range of elements from the first array and write them into the second.

Build a new array whose elements are the same as the input array. For non-zero-based arrays the basing on an input array will be propogated to the output array.

Create an array whose elements are all initially the given value

Create a based array whose elements are all initially the given value

Fetch an element from a 2D array. You can also use the syntax 'array.[index1,index2]'

Create an array given the dimensions and a generator function to compute the elements.

Create a based array given the dimensions and a generator function to compute the elements.

Apply the given function to each element of the array.

Apply the given function to each element of the array. The integer indicies passed to the function indicates the index of element.

Return the length of an array in the first dimension

Return the length of an array in the second dimension

Build a new array whose elements are the results of applying the given function to each of the elements of the array. For non-zero-based arrays the basing on an input array will be propogated to the output array.

Build a new array whose elements are the results of applying the given function to each of the elements of the array. The integer indices passed to the function indicates the element being transformed. For non-zero-based arrays the basing on an input array will be propogated to the output array.

Build a new array whose elements are the same as the input array but where a non-zero-based input array generates a corresponding zero-based output array.

Set the value of an element in an array. You can also use the syntax 'array.[index1,index2] <- value'

Create an array where the entries are initially Unchecked.defaultof<'T>.

Create a based array where the entries are initially Unchecked.defaultof<'T>.

Basic operations on 2-dimensional arrays. F# and .NET multi-dimensional arrays are typically zero-based. However, .NET multi-dimensional arrays used in conjunction with external libraries (e.g. libraries associated with Visual Basic) be non-zero based, using a potentially different base for each dimension. The operations in this module will accept such arrays, and the basing on an input array will be propogated to a matching output array on the Array2D.map and Array2D.mapi operations. Non-zero-based arrays can also be created using Array2D.zero_create_based, Array2D.create_based and Array2D.init_based.

Create an array whose elements are all initially the given value

Fetch an element from a 3D array. You can also use the syntax 'array.[index1,index2,index3]'

Create an array given the dimensions and a generator function to compute the elements.

Apply the given function to each element of the array.

Apply the given function to each element of the array. The integer indicies passed to the function indicates the index of element.

Return the length of an array in the first dimension

Return the length of an array in the second dimension

Return the length of an array in the third dimension

Set the value of an element in an array. You can also use the syntax 'array.[index1,index2,index3] <- value'.

Create an array where the entries are initially the "default" value.

Basic operations on rank 3 arrays.

Create an array whose elements are all initially the given value

Fetch an element from a 4D array. You can also use the syntax 'array.[index1,index2,index3,index4]'

Create an array given the dimensions and a generator function to compute the elements.

Return the length of an array in the first dimension

Return the length of an array in the second dimension

Return the length of an array in the third dimension

Return the length of an array in the fourth dimension

Set the value of an element in an array. You can also use the syntax 'array.[index1,index2,index3,index4] <- value'.

Create an array where the entries are initially the "default" value.

Basic operations on rank 4 arrays.

Build a new array that contains the elements of the first array followed by the elements of the second array

Return the average of the elements in the array. If the array is empty an ArgumentException is thrown.

Return the average of the elements generated by applying the function to each element of the array. If the array is empty an ArgumentException is thrown.

Read a range of elements from the first array and write them into the second.

Apply the given function to each element of the array. Return the array comprised of the results "x" for each element where the function returns Some(x)

For each element of the array, apply the given function. Concatenate all the results and return the combined array.

Build a new array that contains the elements of each of the given sequence of arrays

Build a new array that contains the elements of the given array

Create an array whose elements are all initially the given value.

Return an empty array of the given type

Test if any element of the array satisfies the given predicate. The predicate is applied to the elements of the input array. If any application returns true then the overall result is true and no further elements are tested. Otherwise, false is returned.

Test if any pair of corresponding elements of the arrays satisfies the given predicate. The predicate is applied to matching elements in the two collections up to the lesser of the two lengths of the collections. If any application returns true then the overall result is true and no further elements are tested. Otherwise, if one collections is longer than the other then the ArgumentException exception is raised. Otherwise, false is returned.

Fill a range of elements of the array with the given value.

Return a new collection containing only the elements of the collection for which the given predicate returns "true"

Return the first element for which the given function returns 'true'. Raise KeyNotFoundException if no such element exists.

Return the index of the first element in the array that satisfies the given predicate. Raise KeyNotFoundException if none of the elements satisy the predicate.

Apply 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 computes f (... (f s i0)...) iN

Apply a function to pairs of elements drawn from the two collections, left-to-right, threading an accumulator argument through the computation. The two input arrays must have the same lengths, otherwise an ArgumentException is raised.

Apply a function to each element of the array, threading an accumulator argument through the computation. If the input function is f and the elements are i0...iN then computes f i0 (...(f iN s))

Apply a function to pairs of elements drawn from the two collections, right-to-left, threading an accumulator argument through the computation. The two input arrays must have the same lengths, otherwise an ArgumentException is raised.

Apply a function to each element of the array, threading an accumulator argument through the computation. If the input function is f and the elements are i0...iN then computes f i0 (...(f iN s))

Test if all elements of the array satisfy the given predicate. The predicate is applied to the elements of the input collection. If any application returns false then the overall result is false and no further elements are tested. Otherwise, true is returned.

Test if all corresponding elements of the array satisfy the given predicate pairwise. The predicate is applied to matching elements in the two collections up to the lesser of the two lengths of the collections. If any application returns false then the overall result is false and no further elements are tested. Otherwise, if one collection is longer than the other then the ArgumentException exception is raised. Otherwise, true is returned.

Get an element from an array

Create an array given the dimension and a generator function to compute the elements.

Return true if the given array is empty, otherwise false

Apply the given function to each element of the array.

Apply the given function to pair of elements drawn from matching indices in two arrays. The two arrays must have the same lengths, otherwise an ArgumentException is raised.

Apply the given function to each element of the array. The integer passed to the function indicates the index of element.

Apply the given function to pair of elements drawn from matching indices in two arrays, also passing the index of the elements. The two arrays must have the same lengths, otherwise an ArgumentException is raised.

Return the length of an array. You can also use property arr.Length.

Build a new array whose elements are the results of applying the given function to each of the elements of the array.

Build a new collection whose elements are the results of applying the given function to the corresponding elements of the two collections pairwise. The two input arrays must have the same lengths, otherwise an ArgumentException is raised.

Build a new array whose elements are the results of applying the given function to each of the elements of the array. The integer index passed to the function indicates the index of element being transformed.

Build a new collection whose elements are the results of applying the given 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 an ArgumentException is raised.

Return the greatest of all elements of the array, compared via Operators.max on the function result

Return the lowest of all elements of the array, compared via Operators.min

Return the lowest of all elements of the array, compared via Operators.min on the function result

Build an array from the given list

Build a new array from the given enumerable object

Split the collection into two collections, containing the elements for which the given predicate returns "true" and "false" respectively

Returns an array with all elements permuted according to the specified permutation

Apply the given function to successive elements, returning the first result where function returns Some(x) for some x. If the function never returns Some(x) then KeyNotFoundException is raised.

Apply a function to each element of the array, threading an accumulator argument through the computation. If the input function is f and the elements are i0...iN then computes f (... (f i0 i1)...) iN. Raises ArgumentException if the array has size zero.

Apply a function to each element of the array, threading an accumulator argument through the computation. If the input function is f and the elements are i0...iN then computes f i0 (...(f iN-1 iN)). Raises ArgumentException if the array has size zero.

Return a new array with the elements in reverse order

Like fold_left, but return the intermediary and final results

Like fold_right, but return both the intermediary and final results

Set an element of an array

Sort the elements of an array, returning a new array. Elements are compared using Operators.compare.

Sort the elements of an array, using the given projection for the keys and returning a new array. Elements are compared using Operators.compare.

Sort the elements of an array by mutating the array in-place, using the given comparison function. Elements are compared using Operators.compare.

Sort the elements of an array by mutating the array in-place, using the given projection for the keys. Elements are compared using Operators.compare.

Sort the elements of an array by mutating the array in-place, using the given comparison function as the order

Sort the elements of an array, using the given comparison function as the order, returning a new array

Sort the elements of an array, using the given projection for the keys. Elements are compared using Operators.compare.

Build a new array that contains the given subrange specified by starting index and length.

Return the sum of the elements in the array

Return the sum of the results generated by applying the function to each element of the array.

Build a list from the given array

View the given array as a sequence

Return the first element for which the given function returns true. Return None if no such element exists.

Return the index of the first element in the array that satisfies the given predicate.

Apply the given function to successive elements, returning the first result where function returns Some(x) for some x. If the function never returns Some(x) then None is returned.

Split an array of pairs into two arrays

Split an array of triples into three arrays

Create an array where the entries are initially the default value Unchecked.defaultof<'T>.

Combine the two arrays into an array of pairs. The two arrays must have equal lengths, otherwise an ArgumentException is raised.

Combine three arrays into an array of pairs. The three arrays must have equal lengths, otherwise an ArgumentException is raised.

Basic operations on arrays

Compare using the given comparer function

Convert an existing IComparer object into a comparison function with a fast entry point If comparer was originally built using ComparisonIdentity.FromFunction then the original function will be returned

Convert an existing IComparer object into a comparison function with a fast entry point

Structural comparison. Compare using Operators.compare.

Common notions of comparison identity used with sorted data structures.

Hash using the given hashing and equality functions

Physical hashing (hash on reference identity of objects, and the contents of value types). Hash using LanguagePrimitives.PhysicalEquality and LanguagePrimitives.PhysicalHash, That is, for value types use GetHashCode and Object.Equals (if no other optimization available), and for reference types use System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode and reference equality.

Structural hashing. Hash using Operators.(=) and Operators.hash.

Common notions of value identity used with hash tables.

Return a new list that contains the elements of the first list followed by elements of the second

Return the average of the elements in the list. If the list is empty an ArgumentException is thrown.

Return the average of the elements generated by applying the function to each element of the list. If the list is empty an ArgumentException is thrown.

Apply the given function to each element of the list. Return the list comprised of the results x for each element where the function returns Some(x)

For each element of the list, apply the given function. Concatenate all the results and return the combined list.

Return a new list that contains the elements of each the lists in order

Return an empty list of the given type

Test if any element of the list satisfies the given predicate. The predicate is applied to the elements of the input list. If any application returns true then the overall result is true and no further elements are tested. Otherwise, false is returned.

Test if any pair of corresponding elements of the lists satisfies the given predicate. The predicate is applied to matching elements in the two collections up to the lesser of the two lengths of the collections. If any application returns true then the overall result is true and no further elements are tested. Otherwise, if one collections is longer than the other then the ArgumentException exception is raised. Otherwise, false is returned.

Return a new collection containing only the elements of the collection for which the given predicate returns "true"

Return the first element for which the given function returns true. Raise KeyNotFoundException if no such element exists.

Return the index of the first element in the list that satisfies the given predicate. Raise KeyNotFoundException if no such element exists.

Apply a function to each element of the collection, threading an accumulator argument through the computation. Take the second argument, and apply the function to it and the first element of the list. Then feed this result into the function along with the second element and so on. Return the final result. If the input function is f and the elements are i0...iN then computes f (... (f s i0) i1 ...) iN

Apply 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 computes f (... (f s i0 j0)...) iN jN.

Test if all elements of the collection satisfy the given predicate. The predicate is applied to the elements of the input list. If any application returns false then the overall result is false and no further elements are tested. Otherwise, true is returned.

Test if all corresponding elements of the collection satisfy the given predicate pairwise. The predicate is applied to matching elements in the two collections up to the lesser of the two lengths of the collections. If any application returns false then the overall result is false and no further elements are tested. Otherwise, if one collection is longer than the other then the ArgumentException exception is raised. Otherwise, true is returned.

Return the first element of the list. Raise (Invalid_argument "hd") if undefined.

Create a list by calling the given generator on each index

Return true if the list contains no elements, false otherwise

Apply the given function to each element of the collection.

Apply the given function to two collections simultaneously. The collections must have identical size.

Apply the given function to each element of the collection. The integer passed to the function indicates the index of element.

Apply the given function to two collections simultaneously. The collections must have identical size. The integer passed to the function indicates the index of element.

Return the length of the list

Build a new collection whose elements are the results of applying the given function to each of the elements of the collection.

Build a new collection whose elements are the results of applying the given function to the corresponding elements of the two collections pairwise.

Build a new collection whose elements are the results of applying the given function to the corresponding elements of the three collections simultaneously.

Build 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.

Like mapi, but mapping corresponding elements from two lists of equal length.

Return the greatest of all elements of the list, compared via Operators.max

Return the greatest of all elements of the array, compared via Operators.max on the function result

Return the lowest of all elements of the list, compared via Operators.min

Return the lowest of all elements of the array, compared via Operators.min on the function result

Index into the list. The first element has index 0.

Build a collection from the given array

Build a new collection from the given enumerable object

Split the collection into two collections, containing the elements for which the given predicate returns true and false respectively

Returns a list with all elements permuted according to the specified permutation

Apply the given function to successive elements, returning the first result where function returns Some(x) for some x. If no such element exists then raise System.Collections.Generic.KeyNotFoundException

Apply a function to each element of the collection, threading an accumulator argument through the computation. Apply the function to the first two elements of the list. Then feed this result into the function along with the third element and so on. Return the final result. If the input function is f and the elements are i0...iN then computes f (... (f i0 i1) i2 ...) iN. Raises ArgumentException if the list has no elements.

Create a list by calling the given generator on each index

Return a new list with the elements in reverse order

Like foldBack, but return both the intermediary and final results

Sort the given list using the given comparison function

Sort the given list using keys given by the given projection. Keys are compared using Operators.compare.

Sort the given list using the given comparison function

Return the sum of the elements in the list

Return the sum of the results generated by applying the function to each element of the list.

Return the tail of the list. Raise (Invalid_argument "tl") if undefined.

Build an array from the given collection

Build a new collection from the given enumerable object

Return the first element for which the given function returns true. Return None if no such element exists.

Return the index of the first element in the list that satisfies the given predicate. Return None if no such element exists.

Apply the given function to successive elements, returning Some(x) the first result where function returns Some(x) for some x. If no such element exists then return None

Split a list of pairs into two lists

Split a list of triples into three lists

Combine the two lists into a list of pairs. The two lists must have equal lengths.

Combine the three lists into a list of triples. The lists must have equal lengths.

Basic operations on lists.

Return a new map with the binding added to the given map.

Test is an element is in the domain of the map

The empty map

Return true if the given predicate returns true for one of the bindings in the map.

Build a new map containing only the bindings for which the given predicate returns 'true'

Lookup an element in the map, raising KeyNotFoundException if no binding exists in the map.

Evaluates the function on each mapping in the collection. Returns the key for the first mapping where the function returns 'true'. Raise KeyNotFoundException if no such element exists.

Search the map looking for the first element where the given function returns a Some value

Fold over the bindings in the map

Return true if the given predicate returns true for all of the bindings in the map.

Is the map empty?

Apply the given function to each binding in the dictionary

Build a new collection whose elements are the results of applying the given function to each of the elements of the collection. The index passed to the function indicates the index of element being transformed.

Return a new map made from the given bindings

Build two new maps, one containing the bindings for which the given predicate returns 'true', and the other the remaining bindings.

Search the map looking for the first element where the given function returns a Some value

Remove an element from the domain of the map. No exception is raised if the element is not present.

Returns an array of all key-value pairs in the mappinng

Returns a list of all key-value pairs in the mappinng

View the collection as an enumerable sequence. This collection type is also directly compatible with 'seq<KeyValuePair<_,_> >'. Note this function returns a sequence of tuples, whereas the collection itself is compatible with the logically equivalent sequence of KeyValuePairs. Using sequences of tuples tends to be more convenient in F#, however the collection itself must enumerate KeyValuePairs to conform to the .NET design guidelines and the IDictionary interface.

Lookup an element in the map, returning a Some value if the element is in the domain of the map and None if not.

Return the key of the first mapping in the collection that satisfies the given predicate. Return 'None' if no such element exists.

Search the map looking for the first element where the given function returns a Some value

Functional programming operators related to the Map<_,_> type.

Wrap the two given enumeration-of-enumerations as a single concatenated enumeration. The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently.

Return the average of the elements in the sequence The elements are averaged using the '+' operator, 'DivideByInt' method and 'Zero' property associated with the element type.

Return the average of the results generated by applying the function to each element of the sequence. The elements are averaged using the '+' operator, 'DivideByInt' method and 'Zero' property associated with the generated type.

Return a sequence that corresponds to a cached version of the input sequence. This result sequence will have the same elements as the input sequence. The result can be enumerated multiple times. The input sequence will be enumerated at most once and only as far as is necessary. Enumeration of the result sequence is thread safe in the sense that multiple independent IEnumerator values may be used simultaneously from different threads (accesses to the internal lookaside table are thread safe). Each individual IEnumerator is not typically thread safe and should not be accessed concurrently. Note, once enumeration of the input sequence has started, it's enumerator will be kept live by this object until the enumeration has completed. At that point, the enumerator will be disposed. The enumerator may be disposed and underlying cache storage released by converting the returned sequence object to type IDisposable, and calling the Dispose method on this object. The sequence object may then be re-enumerated and a fresh enumerator will be used.

Wrap a loosely-typed System.Collections sequence as a typed sequence. The use of this function usually requires a type annotation. An incorrect type annotation may result in runtime type errors. Individual IEnumerator values generated from the returned sequence should not be accessed concurrently.

Apply the given function to each element of the list. Return the list comprised of the results "x" for each element where the function returns Some(x) The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently. Remember sequence is lazy, effects are delayed until it is enumerated.

For each element of the enumeration apply the given function and concatenate all the results. Remember sequence is lazy, effects are delayed until it is enumerated.

Compare two sequence's using generic comparison, element by element.

Compare two sequence's using the given comparison function, element by element.

Wrap the given enumeration-of-enumerations as a single concatenated enumeration. The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently.

Apply a key-generating function to each element of a sequence and return a sequence yielding unique keys and their number of occurences in the original sequence. Note that this function returns a sequence that digests the whole initial sequence as soon as that sequence is iterated. As a result this function should not be used with large or infinite sequences. The function makes no assumption on the ordering of the original sequence.

Return a sequence that is built from the given delayed specification of an Seq. The input function is evaluated each time an IEnumerator for the sequence is requested.

Return 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.

Return 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.

Create an empty sequence

Test if any element of the sequence satisfies the given predicate. The predicate is applied to the elements of the input sequence. If any application returns true then the overall result is true and no further elements are tested. Otherwise, false is returned.

Test if any pair of corresponding elements of the input sequences satisfies the given predicate. The predicate is applied to matching elements in the two sequences up to the lesser of the two lengths of the collections. If any application returns true then the overall result is true and no further elements are tested. Otherwise, false is returned. If one sequence is shorter than the other then the remaining elements of the longer sequence are ignored.

Return a new collection containing only the elements of the collection for which the given predicate returns "true" The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently. Remember sequence is lazy, effects are delayed until it is enumerated.

Return the first element for which the given function returns true. Raise KeyNotFoundException if no such element exists.

Return the index of the first element in the sequence of pairs that satisfies the given predicate. Raise KeyNotFoundException if no such element exists.

Test if all elements of the sequence satisfy the given predicate. The predicate is applied to the elements of the input sequence. If any application returns false then the overall result is false and no further elements are tested. Otherwise, true is returned.

Test the all pairs of elements drawn from the two sequences satisfies the given predicate. If one sequence is shorter than the other then the remaining elements of the longer sequence are ignored

Apply 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. Note that this function returns a sequence that digests the whole initial sequence as soon as that sequence is iterated. As a result this function should not be used with large or infinite sequences. The function makes no assumption on the ordering of the original sequence.

Return the first element of the sequence.

Generate a new sequence which, when iterated, will return successive elements by calling the given function, up to the given count. The results of calling the function will not be saved, i.e. the function will be reapplied as necessary to regenerate the elements. The function is passed the index of the item being generated. The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently.

Generate a new sequence which, when iterated, will return successive elements by calling the given function. The results of calling the function will not be saved, i.e. the function will be reapplied as necessary to regenerate the elements. The function is passed the index of the item being generated The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently.

Return true if the sequence contains no elements, false otherwise

Apply the given function to each element of the collection.

Apply 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.

Apply the given function to each element of the collection. The integer passed to the function indicates the index of element.

Return the length of the sequence

Build 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. The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently.

Build 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.

Return the greatest of all elements of the sequence, compared via Operators.max

Return the greatest of all elements of the array, compared via Operators.max on the function result

Return the lowest of all elements of the sequence, compared via Operators.min

Return the lowest of all elements of the array, compared via Operators.min on the function result

Compute the nth element in the collection.

Build a collection from the given array

Return 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.

Apply the given function to successive elements, returning the first 'x' where the function returns "Some(x)".

Build a new sequence object that delegates to the given sequence object. This ensures the original sequence can't 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 can't cast the returned sequence object to an array.

Apply 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. Raises ArgumentException if the sequence has no elements.

Like fold, but compute on-demand and return the sequence of intermediary and final results

Return a sequence that yields one item only.

Return a sequence that skips N elements of the underlying sequence and then yields the remaining elements of the sequence

Return 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

Yield a sequence ordered by keys. Note that this function returns a sequence that digests the whole initial sequence as soon as that sequence is iterated. As a result this function should not be used with large or infinite sequences. The function makes no assumption on the ordering of the original sequence.

Apply 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. Note that this function returns a sequence that digests the whole initial sequence as soon as that sequence is iterated. As a result this function should not be used with large or infinite sequences. The function makes no assumption on the ordering of the original sequence.

Return the sum of the elements in the sequence. The elements are summed using the '+' operator and 'Zero' property associated with the generated type.

Return the sum of the results generated by applying the function to each element of the sequence. The generated elements are summed using the '+' operator and 'Zero' property associated with the generated type.

Return the first N elements of the sequence.

Return a sequence that, when iterated, yields elements of the underlying sequence while the given predicate returns 'true', and returns no further elements

Build an array from the given collection

Build a list from the given collection

Return a sequence that when enumerated returns at most N elements.

Return the first element for which the given function returns true. Return None if no such element exists.

Return the index of the first element in the sequence that satisfies the given predicate. Return 'None' if no such element exists.

Apply the given function to successive elements, returning the first result where the function returns "Some(x)".

Return a sequence that contains the elements generated by the given computation. The given initial 'state' argument is passed to the element generator. For each IEnumerator elements in the stream are generated on-demand by applying the element generator, until a None value is returned by the element generator. Each call to the element generator returns a new residual 'state'. Note the stream will be recomputed each time an IEnumerator is requested and iterated for the Seq. The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently.

Return a sequence that yields 'sliding windows' of containing elements drawn from the input sequence. Each window is returned as a fresh array.

Combine 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.

Combine the three sequences into a list of triples. The two sequences need not have equal lengths: when one sequence is exhausted any remaining elements in the other sequence are ignored.

Basic operations on IEnumerables.

The F# compiler emits implementations of this method for compiled sequence expressions

The F# compiler emits implementations of this type for compiled sequence expressions

The F# compiler emits calls to this function to implement the compiler-intrinsic conversions from untyped System.Collections.IEnumerable sequences to typed sequences

The F# compiler emits calls to this function to implement the 'try/finally' operator for F# sequence expressions

The F# compiler emits calls to this function to implement the 'use' operator for F# sequence expressions

The F# compiler emits calls to this function to implement the 'while' operator for F# sequence expressions

A group of functions used as part of the compiled representation of F# sequence expressions

Return a new set with an element added to the set. No exception is raised if the set already contains the given element.

Returns the minimum element of the set

Evaluates to "true" if the given element is in the given set

Return the number of elements in the set. Same as size

Return a new set with the elements of the second set removed from the first.

The empty set for the type 'T .

Test if any element of the collection satisfies the given predicate. If the input function is f and the elements are i0...iN then computes p i0 or ... or p iN.

Return a new collection containing only the elements of the collection for which the given predicate returns true

Apply the given accumulating function to all the elements of the set

Test if all elements of the collection satisfy the given predicate. If the input function is f and the elements are i0...iN and "j0...jN" then computes p i0 && ... && p iN.

Compute the intersection of the two sets.

Compute the intersection of a sequence of sets. The sequence must be non-empty

Return "true" if the set is empty

Apply the given function to each element of the set, in order according to the comparison function

Return a new collection containing the results of applying the given function to each element of the input set

Evaluates to "true" if the given element is in the given set

Build a set that contains the same elements as the given array

Build a set that contains the same elements as the given list

Build a new collection from the given enumerable object

Split the set into two sets containing the elements for which the given predicate returns true and false respectively

Return a new set with the given element removed. No exception is raised in the set doesn't contain the given element.

The set containing the given one element.

Evaluates to "true" if all elements of the second set are in the first

Build an array that contains the elements of the set in order

Build a list that contains the elements of the set in order

Return a view of the collection as an enumerable object

Compute the union of the two sets.

Compute the union of a sequence of sets.

Functional programming operators related to the Set<_> type.

Get the default group for executing asynchronous computations

Specify an asynchronous computation that, when run, executes computation, If p is effectively cancelled before its termination then the process f exn is executed.

Specify an asynchronous computation that, when run, queues a CPU-intensive work in the thread pool item that runs its continutation.

Specify an asynchronous computation that, when run, creates a new thread and runs its continutation in that thread

Specify an asynchronous computation that, when run, runs its continuation using syncContext.Post. If syncContext is null then the asynchronous computation is equivalent to SwitchToThreadPool().

Start a child computation within an asynchronous workflow. This allows multiple asynchronous computations to be executed simultaneously. This method should normally be used as the immediate right-hand-side of a 'let!' binding in an F# asynchronous workflow, i.e., async { ... let! completor1 = childComputation1 |> Async.StartChild let! completor2 = childComputation2 |> Async.StartChild ... let! result1 = completor1 let! result2 = completor2 ... } When used in this way, each use of StartChild starts an instance of childComputation and returns a completor object representing a computation to wait for the completion of the operation. When executed, the completor awaits the completion of childComputation.

Start the asynchronous computation in the thread pool. Do not await its result. Run as part of the default AsyncGroup

Run an asynchronous computation, initially as a work item. Run as part of the default AsyncGroup

Run the asynchronous computation and await its result. If an exception occurs in the asynchronous computation then an exception is re-raised by this function. Run as part of the default AsyncGroup

Specify an asynchronous computation that, when run, executes the given callback. The callback must eventually call either the continuation, the exception continuation or the cancel exception.

Specify an asynchronous computation that, when run, executese the three asynchronous computations, starting each in the thread pool. If any raise an exception then the overall computation will raise an exception, and attempt to cancel the others. All the sub-computations belong to an AsyncGroup that is a subsidiary of the AsyncGroup of the outer computations.

Specify an asynchronous computation that, when run, executes the two asynchronous computations, starting each in the thread pool. If any raise an exception then the overall computation will raise an exception, and attempt to cancel the others. All the sub-computations belong to an AsyncGroup that is a subsidiary of the AsyncGroup of the outer computations.

Specify an asynchronous computation that, when run, executes all the given asynchronous computations, initially queueing each as work items and using a fork/join pattern. If any raise an exception then the overall computation will raise the first detected exception, and attempt to cancel the others. All the sub-computations belong to an AsyncGroup that is a subsidiary of the AsyncGroup of the outer computations.

Generate a scoped, cooperative cancellation handler for use within an asynchronous workflow. async { use! holder = Async.OnCancel f ... } generates an asynchronous computation where, if a cancellation happens any time during the execution of the asynchronous computation in the scope of 'holder', then action 'f' is executed on the thread that is performing the cancellation. You can use this to arrange for your own computation to be asynchronously notified that a cancellation has occurred, e.g. by setting a flag, or deregistering a pending I/O action.

Specify an asynchronous computation that, when run, runs 'p', ignoring the result and returning the result '()'.

Get the default group for executing asynchronous computations

Raise the cancellation condition for the most recent set of Async computations started without any specific AsyncGroup. Replace the global group with a new global group for any asynchronous computations created after this point without any specific AsyncGroup.

Specify an asynchronous computation in terms of a Begin/End pair of actions in the style used in .NET APIs where the overall operation is not qualified by any arguments. For example, Async.BuildPrimitive(ws.BeginGetWeather,ws.EndGetWeather) When the computation is run, the 'Begin' half of the operation is executed, and an asynchronous computation is returned that, when run, awaits the completion of the computation and fetches its overall result using the 'End' operation.

Specify an asynchronous computation in terms of a Begin/End pair of actions in the style used in .NET APIs where the overall operation is qualified by one argument. For example, Async.BuildPrimitive(place,ws.BeginGetWeather,ws.EndGetWeather) When the computation is run, the 'Begin' half of the operation is executed, and an asynchronous computation is returned that, when run, awaits the completion of the computation and fetches its overall result using the 'End' operation.

Specify an asynchronous computation in terms of a Begin/End pair of actions in the style used in .NET APIs where the overall operation is qualified by two arguments. For example, Async.BuildPrimitive(arg1,arg2,ws.BeginGetWeather,ws.EndGetWeather) When the computation is run, the 'Begin' half of the operation is executed, and an asynchronous computation is returned that, when run, awaits the completion of the computation and fetches its overall result using the 'End' operation.

Specify an asynchronous computation in terms of a Begin/End pair of actions in the style used in .NET APIs where the overall operation is qualified by three arguments. For example, Async.BuildPrimitive(arg1,arg2,arg3,ws.BeginGetWeather,ws.EndGetWeather) When the computation is run, the 'Begin' half of the operation is executed, and an asynchronous computation is returned that, when run, awaits the completion of the computation and fetches its overall result using the 'End' operation.

This static class holds members for creating and manipulating asynchronous computations

Specify an asynchronous computation that, when run, just returns '()'

Specify an asynchronous computation that, when run, runs 'p' repeatedly until 'gd()' becomes false.

Specify an asynchronous computation that, when run, runs 'f(resource)'. The action 'resource.Dispose()' is executed as this computation yields its result or if the asynchronous computation exits by an exception or by cancellation.

Specify an asynchronous computation that, when run, runs 'p' and returns its result. If an exception happens then 'f(exn)' is called and the resulting computation executed instead.

Specify an asynchronous computation that, when run, runs 'p'. The action 'f' is executed after 'p' completes, whether 'p' exits normally or by an exception. If 'f' raises an exception itself the original exception is discarded and the new exception becomes the overall result of the computation.

Specify an asynchronous computation that, when run, returns the result 'v'

Specify an asynchronous computation that, when run, enumerates the sequence 'seq' on demand and runs 'f' for each element.

Specify an asynchronous computation that, when run, runs 'f()'

Specify an asynchronous computation that, when run, first runs 'p1' and then runs 'p2', returning the result of 'p2'.

Specify an asynchronous computation that, when run, runs 'p', and when 'p' generates a result 'T', runs 'f res'.

Generate an object used to build asynchronous computations using F# computation expressions. The value 'async' is a pre-defined instance of this type.

The type of the 'async' operator, used to build workflows for asynchronous computations.

Wait for the completion of the operation and get its result

Raise the cancellation condition for this group of computations

Start the asynchronous computation as a work item. Do not await its result.

Start the asynchronous computation as a work item. Return a handle to the computation as an AsyncFuture.

Run the asynchronous computation and await its result. If an exception occurs in the asynchronous computation then an exception is re-raised by this function.

Generate a new asynchronous group

A handle to a capability to cancel a set of asynchronous computations.

Send a reply to a PostAndReply message

A handle to a capability to reply to a PostAndReply message

An asynchronous computation, which, when run, will eventually produce a value of the given type, or else raise an exception. The value and/or exception is not returned to the caller immediately, but is rather passed to a success continuation, exception continuation or cancellation continuation. Asynchronous computations are normally specified using the F# 'workflow' syntax for building computations. When run, asynchronous computations can normally be thought of as running run in one of two modes: 'work item mode' or 'waiting mode'. - 'work item mode' indicates that the computation is executing as a work item, e.g. in the .NET Thread Pool via ThreadPool.QueueUserWorkItem, or is running a brief event-response action on the GUI thread. - 'waiting mode' indicates the computations a waiting for asynchronous I/O completions, typically suspended as thunks using ThreadPool.RegisterWaitForSingleObject. Asynchronous computations running as 'work items' should not generally perform blocking operations, e.g. long running synchronous loops. However, some asynchronous computations may, out of necessity, need to execute blocking I/O operations: these should be run on new threads or a user-managed pool of threads specifically dedicated to resolving blocking conditions. For example, System.IO.OpenFile is, by design, a blocking operation. However frequently it is important to code as if this is asynchronous. This can be done by executing Async.SwitchToNewThread as part of the workflow. When run, asynchronous computations belong to an AsyncGroup. This can usually be specified when the async computation is started. The only action on an AsyncGroup is to raise a cancellation condition for the AsyncGroup. Async values check the cancellation condition for their AsyncGroup regularly, though synchronous computations within an asynchronous computation will not automatically check this condition. This gives a user-level cooperative cancellation protocol.

Publish the event as a first class event value

Trigger the event using the given parameters

Create an event object suitable for implementing an arbitrary type of delegate

Event implementations for an arbitrary type of delegate

Publish the event as a first class event value

Trigger the event using the given parameters

Create an event object suitable for implementing for the IEvent<_> type

Event implementations for the IEvent<_> type

Publish the event as a first class event value

Trigger the event using the given sender object and parameters. The sender object may be null.

Create an event object suitable for delegate types following the standard .NET Framework convention of a first 'sender' argument

Event implementations for a delegate types following the standard .NET Framework convention of a first 'sender' argument

A delegate type associated with the F# event type IEvent<_>

Remove a listener delegate from an event listener store

Connect a handler delegate object to the event. A handler can be later removed using RemoveHandler. The listener will be invoked when the event is fired.

F# gives special status to non-virtual instance member properties compatible with type IDelegateEvent, generating approriate .NET metadata to make the member appear to other .NET languages as a .NET event.

First-class listening points (i.e. objects that permit you to register a 'callback' activated when the event is triggered). See the module Event for functions to create events.

Connect a listener function to the event. The listener will be invoked when the event is fired.

The family of first class event values for delegate types that satisfy the F# delegate constraint.

Force the execution of this value and return its result. Same as Value. Mutual exclusion is used to prevent other threads also computing the value.

Indicates if the lazy value has been successfully computed

Indicates if the lazy value is being computed or the computation raised an exception

Indicates if the lazy value has yet to be computed

Same as Force, except no lock is taken.

Same as Force

Force the execution of this value and return its result. Same as Value. Mutual exclusion is used to prevent other threads also computing the value. If the value is re-forced during its own computation the Undefined exception is raised.

Create a lazy computation that evaluates to the given value when forced

Create a lazy computation that evaluates to the result of the given function when forced

The type of delayed computations. Use the values in the Lazy module to manipulate values of this type, and the notation 'lazy expr' to create values of this type.

Raise a timeout exception if a message not received in this amount of time. Default infinite.

Return an asynchronous computation which will look through messages in arrival order until 'scanner' returns a Some value. No thread is blocked while waiting for further messages. Return None if the timeout is exceeded.

Return an asynchronous computation which will consume the first message in arrival order. No thread is blocked while waiting for further messages. Return None if the timeout is exceeded.

Like PostAndReply, but return None if no reply within the timeout period.

Create and start an instance of a MailboxProcessor. The asynchronous computation executed by the processor is the one returned by the 'initial' function.

Start the MailboxProcessor

Return an asynchronous computation which will consume the first message in arrival order. No thread is blocked while waiting for further messages. Raise a TimeoutException if the timeout is exceeded.

Post a message to the message queue of the MailboxProcessor and await a reply on the channel synchronously. The message is produced by a single call to the first function which must build a message containing the reply channel. The receiving MailboxProcessor must process this message and invoke the Reply method on the reply channel precisly once.

Post a message to the message queue of the MailboxProcessor, asynchronously

Like AsyncPostAndReply, but return None if no reply within the timeout period.

Post a message to the message queue of the MailboxProcessor and await a reply on the channel asynchronously. The message is produced by a single call to the first function which must build a message containing the reply channel. The receiving MailboxProcessor must process this message and invoke the Reply method on the reply channel precisly once.

Create an instance of a MailboxProcessor. The asynchronous computation executed by the processor is the one returned by the 'initial' function. This function is not executed until 'Start' is called.

A MailboxProcessor is a message-processing agent defined using an asynchronous workflow. The agent encapsulates a message queue that supports multiple-writers and the single reader agent. Writers send messages to the agent by using the Post, PostAndReply or AsyncPostAndReply methods. The reader agent is specified when creating the MailboxProcessor. The agent is usually an asychronous workflow that waits for messages by using the Receive or TryReceive methods. A MailboxProcessor may also scan through all available messages by using the Scan or TryScan method. The encapsulated message queue only supports a single active reader, thus at most one concurrent call to Receive, TryReceive, Scan and/or TryScan may be active at any one time.

The type of delayed computations. Use the values in the Lazy module to manipulate values of this type, and the notation 'lazy expr' to create values of this type.

An exeption type raised when the evaluation of a lazy value recursively depend upon itself

A module of extension members that provide asynchronous operations for some basic .NET types related to concurrency and I/O.

Return a new event which fires on a selection of messages from the original event. The selection function takes an original message to an optional new message.

Create an IEvent with no initial listeners. Two items are returned: a function to invoke (trigger) the event, and the event that clients can plug listeners into.

Return a new event that listens to the original event and triggers the resulting event only when the argument to the event passes the given function

Run the given function each time the given event is triggered.

Return a new event that passes values transformed by the given function

Fire the output event when either of the input events fire

Return a new event that triggers on the second and subsequent triggerings of the input event. The Nth triggering of the input event passes the arguments from the N-1th and Nth triggering as a pair. The argument passed to the N-1th triggering is held in hidden internal state until the Nth triggering occurs. You should ensure that the contents of the values being sent down the event are not mutable. Note that many EventArgs types are mutable, e.g. MouseEventArgs, and each firing of an event using this argument type may reuse the same physical argument obejct with different values. In this case you should extract the necessary information from the argument before using this combinator.

Return a new event that listens to the original event and triggers the first resulting event if the application of the predicate to the event arguments returned true, and the second event if it returned false

Return a new event consisting of the results of applying the given accumulating function to successive values triggered on the input event. An item of internal state records the current value of the state parameter. The internal state is not locked during the execution of the accumulation function, so care should be taken that the input IEvent not triggered by multiple threads simultaneously.

Return a new event that listens to the original event and triggers the first resulting event if the application of the function to the event arguments returned a Choice1Of2, and the second event if it returns a Choice2Of2

Basic operations on first class event objects.

Create an instance of the attribute

Adding this attribute to class definition makes it abstract, which means it need not implement all its methods. Instances of abstract classes may not be constructed directly.

Indicates the namespace or module to be automatically opened when an assembly is referenced or an enclosing module opened.

Create an attribute used to mark a module as 'automatically opened' when the enclosing namespace is opened

Create an attribute used to mark a namespace or module path to be 'automatically opened' when an assembly is referenced

This attribute is used for two purposes. When applied to an assembly, it must be given a string argument, and this argument must indicate a valid module or namespace in that assembly. Source code files compiled with a reference to this assembly are processed in an environment where the given path is automatically oepned. When applied to a module within an assembly, then the attribute must not be given any arguments. When the enclosing namespace is opened in user source code, the module is also implicitly opened.

The value of the attribute, indicating whether the type is automatically marked serializable or not

Create an instance of the attribute

Adding this attribute to a type with value 'false' disables the behaviour where F# makes the type Serializable by default.

Create an instance of the attribute

Adding this attribute to a property with event type causes it to be compiled with as a .NET Common Language Infrastructure metadata event, through a syntactic translation to a pair of 'add_EventName' and 'remove_EventName' methods.

Helper types for active patterns with 2 choices.

Helper types for active patterns with 3 choices.

Helper types for active patterns with 4 choices.

Helper types for active patterns with 5 choices.

Helper types for active patterns with 6 choices.

Helper types for active patterns with 7 choices.

Create an instance of the attribute

Adding this attribute to a type causes it to be represented using a .NET class.

Indicates the variant number of the entity, if any, in a linear sequence of elements with F# source code

Indicates the relationship between the compiled entity and F# source code

Indicates the sequence number of the entity, if any, in a linear sequence of elements with F# source code

Create an instance of the attribute

This attribute is inserted automatically by the F# compiler to tag types and methods in the gneerated .NET code with flags indicating the correspondence with original source constructs. It is used by the functions in the Microsoft.FSharp.Reflection library to reverse-map compiled constructs to their original forms. It is not intended for use from use code.

Indicates one or more adjustments to the compiled representation of an F# type or member

Create an instance of the attribute

This attribute is used to adjust the runtime representation for a type. For example, it may be used to note that the null representation may be used for a type. This affects how some constructs are compiled.

Indicates one or more adjustments to the compiled representation of an F# type or member

The value of the attribute, indicating whether the type has a default augmentation or not

Create an instance of the attribute

Adding this attribute to a discriminated union with value false turns off the generation of standard helper member tester, constructor and accessor members for the generated .NET class for that type.

Indicates if a constraint is asserted that the field type supports 'null'

Create an instance of the attribute

Adding this attribute to a field declaration means that the field is not initialized. During type checking a constraint is asserted that the field type supports 'null'. If the 'check' value is false then the constraint is not asserted.

Create an instance of the attribute

Adding this attribute to a function indicates it is the entrypoint for an application. If this absent is not speficied for an EXE then the initialization implicit in the module bindings in the last file in the compilation sequence are used as the entrypoint.

Indicates the warning message to be emitted when F# source code uses this construct

Create an instance of the attribute

This attribute is used to tag values that are part of an experimental library feature

The release number of the F# version associated with the attribute

The minor version number of the F# version associated with the attribute

The major version number of the F# version associated with the attribute

Create an instance of the attribute

This attribute is added to generated assemblies to indicate the version of the data schema used to encode additional F# specific information in the resource attached to compiled F# libraries.

Convert an F# first class function value to a value of type System.Converter

Convert an value of type System.Converter to a F# first class function value

Convert an F# first class function value to a value of type System.Converter

Invoke an F# first class function value with five curried arguments. In some cases this will result in a more efficient application than applying the arguments successively.

Invoke an F# first class function value with four curried arguments. In some cases this will result in a more efficient application than applying the arguments successively.

Invoke an F# first class function value with three curried arguments. In some cases this will result in a more efficient application than applying the arguments successively.

Invoke an F# first class function value with two curried arguments. In some cases this will result in a more efficient application than applying the arguments successively.

Invoke an F# first class function value with one argument

Convert an value of type System.Converter to a F# first class function value

Construct an instance of an F# first class function value

The .NET type used to represent F# function values. This type is not typically used directly, though may be used from other .NET languages.

Convert the given Action delegate object to an F# function value

Convert the given Converter delegate object to an F# function value

A utility funcion to convert function values from tupled to curried form

Helper functions for converting F# first class function values to and from .NET representaions of functions using delegates.

Create an instance of the attribute

Adding this attribute to a non-function value with generic parameters indicates that uses of the construct can give rise to generic code through type inference.

Create an instance of the attribute

Adding this attribute to a type causes it to be represented using a .NET interface.

Create an instance of the attribute

Adding this attribute to a value causes it to be compiled as a .NET constant literal.

Create an instance of the attribute

Adding this attribute to a type causes it to be interpreted as a refined type, currently limited to measure-parameterized types. This may only be used under very limited conditions.

Create an instance of the attribute

Adding this attribute to a type causes it to be interpreted as a unit of measure. This may only be used under very limited conditions.

Create an instance of the attribute

This attribute is used to tag values that may not be dynamically invoked at runtime. This is typically added to inlined functions whose implementations include unverifiable code. It causes the method body emitted for the inlined function to raise an exception if dynamically invoked, rather than including the unverifiable code in the generated assembly.

Indicates the warning message to be emitted when F# source code uses this construct

Create an instance of the attribute

This attribute is used to tag values, modules and types that are only present in F# to permit a degree of code-compatibility and cross-compilation with other implementations of ML-familty languages, in particular OCaml. The use of the construct will give a warning unless the --ml-compatibility flag is specified.

Get the value of a 'Some' option. A NullReferenceException is raised if the option is 'None'.

Create an option value that is a 'None' value.

Return 'true' if the option is a 'Some' value.

Return 'true' if the option is a 'None' value.

Create an option value that is a 'Some' value.

The type of optional values. When used from other .NET languages the empty option is the null value. Use the constructors Some and None to create values of this type. Use the values in the Option module to manipulate values of this type, or pattern match against the values directly. None values will appear as the value null to other .NET languages. Instance methods on this type will appear as static methods to other .NET languages due to the use of null as a value representation.

Create an instance of the attribute

This attribute is added automatically for all optional arguments

A unique identifier for this overloaded member within a given overload set

Create an instance of the attribute

Adding the OverloadID attribute to a member permits it to be part of a group overloaded by the same name and arity. The string must be a unique name amongst those in the overload set. Overrides of this method, if permitted, must be given the same OverloadID, and the OverloadID must be specified in both signature and implementation files if signature files are used.

The current value of the reference cell

The type of mutable references. Use the functions [:=] and [!] to get and set values of this type.

Create an instance of the attribute

Adding this attribute to a record or union type disables the automatic generation of overrides for 'System.Object.Equals(obj)', 'System.Object.GetHashCode()' and 'System.IComparable' for the type. The type will by default use reference equality. This is identical to adding attributes StructuralEquality(false) and StructuralComparison(false).

Create an instance of the attribute

Adding this attribute to the let-binding for the definition of a top-level value makes the quotation expression that implements the value available for use at runtime.

Create an instance of the attribute

This attribute is used to indicate that references to a the elements of a module, record or union type require explicit qualified access.

Create an instance of the attribute

Adding this attribute to a type, value or member requires that uses of the construct must explicitly instantiate any generic type parameters.

The value of the attribute, indicating whether the type is sealed or not

Create an instance of the attribute

Adding this attribute to class definition makes it sealed, which means it may not be extended or implemented.

Indicates the relationship between a compiled entity in a CLI binary and an element in F# source code

Create an instance of the attribute

Adding this attribute to a type causes it to be represented using a .NET struct.

The value of the attribute, indicating whether the type uses structural comparison or not

Create an instance of the attribute

Adding this attribute to a record, union or struct type with value 'false' disables the automatic generation of implementations for 'System.IComparable' for the type.

The value of the attribute, indicating whether the type uses structural equality or not

Create an instance of the attribute

Adding this attribute to a record, union or struct type with value 'false' confirms the automatic generation of overrides for 'System.Object.Equals(obj)' and 'System.Object.GetHashCode()' for the type. This attribute is usually used in conjunction with StructuralComparison(false) to generate a type that supports structural equality but not structural comparison.

Indicates the text to display by default when objects of this type are displayed using '%A' printf formatting patterns and other two-dimensional text-based display layouts.

Create an instance of the attribute

This attribute is used to mark how a type is displayed by default when using '%A' printf formatting patterns and other two-dimensional text-based display layouts. In this version of F# the only valid values are of the form PreText {PropertyName} PostText. The property name indicates a property to evaluate and to display instead of the object itself.

Compiled versions of F# tuple types. These are not used directly, though these compiled forms are seen by other .NET languages.

Specialize the type function at a given type

Construct an instance of an F# first class type function value

The .NET type used to represent F# first-class type function values. This type is for use by compiled F# code.

The type 'unit', which has only one value "()". This value is special and always uses the representation 'null'.

Create an instance of the attribute

This attribute is used to tag values whose use will result in the generation of unverifiable code. These values are inevitably marked 'inline' to ensure that the unverifiable constructs are not present in the actual code for the F# library, but are rather copied to the source code of the caller.

Four dimensional arrays, typically zero-based. Non-zero-based arrays can be created using methods on the System.Array type. Use the values in the Array4D module to manipulate values of this type, or the notation 'arr.[x1,x2,x3,x4]' to get and set array values.

Three dimensional arrays, typically zero-based. Non-zero-based arrays can be created using methods on the System.Array type. Use the values in the Array3D module to manipulate values of this type, or the notation 'arr.[x1,x2,x3]' to get and set array values.

Two dimensional arrays, typically zero-based. Use the values in the Array2D module to manipulate values of this type, or the notation 'arr.[x,y]' to get/set array values. Non-zero-based arrays can also be created using methods on the System.Array type.

Single dimensional, zero-based arrays, written 'int[]', 'string[]' etc. Use the values in the Array module to manipulate values of this type, or the notation 'arr.[x]' to get/set array values.

An abbreviation for the type Microsoft.FSharp.Math.BigInt

An abbreviation for the .NET type System.Boolean

Represents a managed pointer in F# code.

An abbreviation for the .NET type System.Byte

An abbreviation for the .NET type System.Char

An abbreviation for the .NET type System.Decimal

The type of decimal numbers, annotated with a unit of measure. The unit of measure is erased in compiled code and when values of this type are analyzed using reflection. The type is representationally equivalent to System.Decimal.

An abbreviation for the .NET type System.Double

An abbreviation for the .NET type System.Exception

An abbreviation for the .NET type System.Double

An abbreviation for the .NET type System.Single

The type of floating point numbers, annotated with a unit of measure. The unit of measure is erased in compiled code and when values of this type are analyzed using reflection. The type is representationally equivalent to System.Single.

This type is for internal use by the F# code generator

An abbreviation for the .NET type System.Int32

An abbreviation for the .NET type System.Int16

The type of 16-bit signed integer numbers, annotated with a unit of measure. The unit of measure is erased in compiled code and when values of this type are analyzed using reflection. The type is representationally equivalent to System.Int16.

An abbreviation for the .NET type System.Int32

An abbreviation for the .NET type System.Int64

The type of 64-bit signed integer numbers, annotated with a unit of measure. The unit of measure is erased in compiled code and when values of this type are analyzed using reflection. The type is representationally equivalent to System.Int64.

An abbreviation for the .NET type System.SByte

The type of 8-bit signed integer numbers, annotated with a unit of measure. The unit of measure is erased in compiled code and when values of this type are analyzed using reflection. The type is representationally equivalent to System.SByte.

The type of 32-bit signed integer numbers, annotated with a unit of measure. The unit of measure is erased in compiled code and when values of this type are analyzed using reflection. The type is representationally equivalent to System.Int32.

An abbreviation for the .NET type System.IntPtr

Represents an unmanaged pointer in F# code. This type should only be used when writing F# code that interoperates with native code. Use of this type in F# code may result in unverifiable code being generated. Conversions to and from the nativeint type may be required. Values of this type can be generated by the functions in the NativeInterop.NativePtr module.

An abbreviation for the .NET type System.Object

The type of optional values. When used from other .NET languages the empty option is the null value. Use the constructors Some and None to create values of this type. Use the values in the Option module to manipulate values of this type, or pattern match against the values directly. 'None' values will appear as the value null to other .NET languages. Instance methods on this type will appear as static methods to other .NET languages due to the use of null as a value representation.

The type of mutable references. Use the functions [:=] and [!] to get and set values of this type.

An abbreviation for the .NET type System.SByte

An abbreviation for the .NET type System.Single

An abbreviation for the .NET type System.String

An abbreviation for the .NET type System.UInt16

An abbreviation for the .NET type System.UInt32

An abbreviation for the .NET type System.UInt64

An abbreviation for the .NET type System.Byte

An abbreviation for the .NET type System.UIntPtr

The type 'unit', which has only one value "()". This value is special and always uses the representation 'null'.

Dynamic invocations of functions marked with the NoDynamicInvocationAttribute attribute raise this exception

This exception is raised by 'failwith'

Non-exhaustive match failures will raise the MatchFailure exception

Build an aysnchronous workflow using computation expression syntax

Builds a lookup table from a sequence of key/value pairs. The key objects are indexed using generic hashing and equality.

Print to stderr using the given format

Print to stderr using the given format, and add a newline

Print to a string buffer and raise an exception with the given result. Helper printers must return strings.

Print to a file using the given format

Print to a file using the given format, and add a newline

Special prefix operator for splicing typed expressions into quotation holes

Special prefix operator for splicing untyped expressions into quotation holes

Print to stdout using the given format

Print to stdout using the given format, and add a newline

Builds a sequence using sequence expression syntax

Builds a set from a sequence of objects. The key objects are indexed using generic comparison

Print to a string using the given format

An active pattern to force the execution of values of type Lazy<_>

Pervasives: Additional bindings available at the top level

A compiler intrinsic that implements dynamic invocations to the '+' operator

A compiler intrinsic that implements dynamic invocations to the checked '+' operator

Generate a null value for reference types.

Divide a floating point value by an integer

A compiler intrinsic that implements dynamic invocations for the DivideByInt primitive

Build an enum value from an underlying value

Get the underlying value for an enum value

A static F# comparer object

Return an F# comparer object suitable for hashing and equality. This hashing behaviour of the returned comparer is not limited by an overall node count when hashing F# records, lists and union types.

Make an F# comparer object for the given type

Make an F# hash/equality object for the given type

Make an F# hash/equality object for the given type using node-limited hashing when hashing F# records, lists and union types.

Compare two values

Compare two values. May be called as a recursive case from an implementation of System.IComparable to ensure consistent NaN comparison semantics.

Compare two values for equality

Compare two values

Hash a value according to its structure. This hash is not limited by an overall node count when hashing F# records, lists and union types.

Recursively hash a part of a value according to its structure.

Compare two values

Hash a value according to its structure. Use the given limit to restrict the hash when hashing F# records, lists and union types.

Take the maximum of two values structurally according to the order given by GenericComparison

Take the minimum of two values structurally according to the order given by GenericComparison

Resolves to the one value for any primitive numeric type or any type with a static member called 'One'

Resolves to the zero value for any primitive numeric type or any type with a static member called 'Zero'

A compiler intrinsic that implements dynamic invocations to the '+' operator

Parse an int32 according to the rules used by the overloaded 'int32' conversion operator when applied to strings

Parse an int64 according to the rules used by the overloaded 'int64' conversion operator when applied to strings

Parse an uint32 according to the rules used by the overloaded 'uint32' conversion operator when applied to strings

Parse an uint64 according to the rules used by the overloaded 'uint64' conversion operator when applied to strings

Reference/physical equality. True if boxed versions of the inputs are reference-equal, OR if both are primitive numeric types and the implementation of Object.Equals for the type of the first argument returns true on the boxed versions of the inputs.

The physical hash. Hashes on the object identity, except for value types, where we hash on the contents.

A primitive entry point used by the F# compiler for optimization purposes.

The F# compiler emits calls to some of the functions in this module as part of the compiled form of some language constructs

This function implements calls to default constructors acccessed by 'new' constraints.

A compiler intrinsic for the efficeint compilation of sequence expressions

The standard overloaded associative (indexed) lookup operator

The standard overloaded associative (2-indexed) lookup operator

The standard overloaded associative (3-indexed) lookup operator

The standard overloaded associative (4-indexed) lookup operator

Primitive used by pattern match compilation

This function implements parsing of decimal constants

The standard overloaded associative (indexed) mutation operator

The standard overloaded associative (2-indexed) mutation operator

The standard overloaded associative (3-indexed) mutation operator

The standard overloaded associative (4-indexed) mutation operator

A compiler intrinsic that implements the ':?' operator

A compiler intrinsic that implements the ':?>' operator

The F# compiler emits calls to some of the functions in this module as part of the compiled form of some language constructs

Address-of. Uses of this value may result in the generation of unverifiable code.

Binary 'and'. When used as a binary operator the right hand value is evaluated only on demand

Binary 'or'. When used as a binary operator the right hand value is evaluated only on demand

Address-of. Uses of this value may result in the generation of unverifiable code.

Binary 'or'. When used as a binary operator the right hand value is evaluated only on demand

The F# compiler emits calls to some of the functions in this module as part of the compiled form of some language constructs

Language primitives associated with the F# language

Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'

Provide a default implementation of the F# numeric literal syntax 'dddN'

Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'

Absolute value of the given number

Inverse cosine of the given number

Inverse sine of the given number

Inverse tangent of the given number

Inverse tangent of x/y where x and y are specified separately

Boxes a strongly typed value.

Converts the argument to byte. This is a direct conversion for all primitive numeric types. For strings, the input is converted using Byte.Parse() on strings and otherwise requires a ToByte method on the input type

Ceiling of the given number

Converts the argument to character. Numeric inputs are converted according to the UTF-16 encoding for characters. String inputs must be exactly one character long. For other types a static member ToChar must exist on the type.

Generic comparison

Cosine of the given number

Hyperbolic cosine of the given number

Converts the argument to System.Decimal using a direct conversion for all primitive numeric types and requiring a ToDecimal method otherwise

Decrement a mutable reference cell containing an integer

Used to specify a default value for an optional argument in the implementation of a function

Converts the argument to 64-bit float. This is a direct conversion for all primitive numeric types. For strings, the input is converted using Double.Parse() with InvariantCulture settings. Otherwise the operation requires and invokes a ToDouble method on the input type

Converts the argument to a particular enum type.

Exit the current hardware isolated process, if security settings permit, otherwise raise an exception. Calls System.Environment.Exit.

Exponential of the given number

Throw a FailureException exception

Converts the argument to 32-bit float. This is a direct conversion for all primitive numeric types. For strings, the input is converted using Single.Parse() with InvariantCulture settings. Otherwise the operation requires and invokes a ToSingle method on the input type

Floor of the given number

Return the first element of a tuple, fst (a,b) = a.

A generic hash function, designed to return equal hash values for items that are equal according to the "=" operator. By default it will use structural hashing for F# union, record and tuple types, hashing the complete contents of the type. The exact behaviour of the function can be adjusted on a type-by-type basis by implementing GetHashCode for each type.

The identity function

Ignore the passed value. This is often used to throw away results of a computation.

Increment a mutable reference cell containing an integer

Equivalent to System.Double.PositiveInfinity

Equivalent to System.Single.PositiveInfinity

Converts the argument to signed 32-bit integer. This is a direct conversion for all primitive numeric types. For strings, the input is converted using Int32.Parse() with InvariantCulture settings. Otherwise the operation requires and invokes a ToInt32 method on the input type

Converts the argument to signed 16-bit integer. This is a direct conversion for all primitive numeric types. For strings, the input is converted using Int16.Parse() with InvariantCulture settings. Otherwise the operation requires and invokes a ToInt16 method on the input type

Converts the argument to signed 64-bit integer. This is a direct conversion for all primitive numeric types. For strings, the input is converted using Int64.Parse() with InvariantCulture settings. Otherwise the operation requires and invokes a ToInt64 method on the input type

Throw an ArgumentException exception

Throw an InvalidOperationException exception

A generic hash function. This function has the same behaviour as 'hash', however the default structural hashing for F# union, record and tuple types stops when the given limit of nodes is reached. The exact behaviour of the function can be adjusted on a type-by-type basis by implementing GetHashCode for each type.

Execute the function as a mutual-exlcusion region using the input value as a lock.

Natural logarithm of the given number

Logarithm to base 10 of the given number

Maximum based on generic comparison

Minimum based on generic comparison

Equivalent to System.Double.NaN

Equivalent to System.Single.NaN

Converts the argument to signed native integer. This is a direct conversion for all primitive numeric types and ToIntPtr method otherwise)

Negate a logical value. not true equals false and not false equals true

Throw an KeyNotFoundException exception

Throw an ArgumentNullException exception

Overloaded addition operator

Concatenate two lists.

Apply a function to three values, the values being a triple on the left, the function on the right

Apply a function to two values, the values being a pair on the left, the function on the right

Overloaded logical-AND operator

Overloaded logical-OR operator

Assign to a mutable reference cell

Compose two functions, the function on the right being applied first

Compose two functions, the function on the left being applied first

Concatenate two strings. The overlaoded operator '+' may also be used.

Dereference a mutable reference cell

Overloaded division operator

Structural equality

Overloaded logical-XOR operator

Overloaded power operator.

Structural greater-than

Structural greater-than-or-equal

Overloaded byte-shift left operator by a specified number of bits

Apply a function to two values, the values being a pair on the right, the function on the left

Apply a function to three values, the values being a triple on the right, the function on the left

Structural inequality

Structural less-than comparison

Structural less-than-or-equal comparison

Overloaded logical-NOT operator

Overloaded modulo operator

Overloaded multiplication operator

Apply a function to a value, the value being on the right, the function on the left

Apply a function to a value, the value being on the left, the function on the right

The standard overloaded range operator, e.g. [n..m] for lists, seq {n..m} for sequences

The standard overloaded skip range operator, e.g. [n..skip..m] for lists, seq {n..skip..m} for sequences

Overloaded byte-shift right operator by a specified number of bits

Overloaded subtraction operator

Overloaded unary negation.

Overloaded prefix=plus operator

Overloaded power operator. If n > 0 then equivalent to x*...*x for n occurrences of x.

Raises an exception

Create a mutable reference cell

Rethrows an exception. This should only be used when handling an exception

Round the given number

Converts the argument to signed byte. This is a direct conversion for all primitive numeric types. For strings, the input is converted using SByte.Parse() with InvariantCulture settings. Otherwise the operation requires and invokes a ToSByte method on the input type

Sign of the given number

Sine of the given number

Hyperbolic sine of the given number

Returns the internal size of a type in bytes. For example, sizeof<int> returns 4.

Return the second element of a tuple, snd (a,b) = b.

Square root of the given number

Reads the value of the property System.Console.Error.

Reads the value of the property System.Console.In.

Reads the value of the property System.Console.Out.

Converts the argument to a string using ToString. For standard integer and floating point values the ToString conversion uses CultureInfo.InvariantCulture. Note, native integer ToString does not support specifying CultureInfo.

Tangent of the given number

Hyperbolic tangent of the given number

Overloaded truncate operator.

Generate a System.Type representation for a type definition. If the input type is a generic type instantiation then return the generic type definition associated with all such instantiations.

Generate a System.Type runtime represenation of a static type. The static type is still maintained on the value returned.

Converts the argument to unsigned 16-bit integer. This is a direct conversion for all primitive numeric types. For strings, the input is converted using UInt16.Parse() with InvariantCulture settings. Otherwise the operation requires and invokes a ToUInt16 method on the input type

Converts the argument to unsigned 32-bit integer. This is a direct conversion for all primitive numeric types. For strings, the input is converted using UInt32.Parse() with InvariantCulture settings. Otherwise the operation requires and invokes a ToUInt32 method on the input type

Converts the argument to unsigned 64-bit integer. This is a direct conversion for all primitive numeric types. For strings, the input is converted using UInt64.Parse() with InvariantCulture settings. Otherwise the operation requires and invokes a ToUInt64 method on the input type

Converts the argument to unsigned native integer using a direct conversion for all primitive numeric types and requiring a ToUintPtr method otherwise

Unboxes a strongly typed value. This is the inverse of box, unbox<t>(box<t> a) equals a.

Clean up resources associated with the input object after the completion of the given function. Cleanup occurs even when an exception is raised by the protected code.

An active pattern to match values of type System.Collections.Generic.KeyValuePair

Converts the argument to byte. This is a direct conversion for all primitive numeric types and ToByte method otherwise)

Converts the argument to unicode character based on UTF16 encoding (a direct conversion for all primitive numeric types and ToUIntPtr method otherwise)

Converts the argument to signed 32-bit integer. This is a direct conversion for all primitive numeric types and ToInt32 method otherwise)

Converts the argument to signed 16-bit integer. This is a direct conversion for all primitive numeric types and ToInt16 method otherwise)

Converts the argument to signed 32-bit integer. This is a direct conversion for all primitive numeric types and ToInt32 method otherwise)

Converts the argument to signed 64-bit integer. This is a direct conversion for all primitive numeric types and ToInt64 method otherwise)

Converts the argument to signed native integer. This is a direct conversion for all primitive numeric types and ToIntPtr method otherwise)

Overloaded addition operator (checks for overflow)

Overloaded multiplication operator (checks for overflow)

Overloaded subtraction operator (checks for overflow)

Overloaded unary negation (checks for overflow)

Converts the argument to signed byte. This is a direct conversion for all primitive numeric types and ToSByte method otherwise)

Converts the argument to unsigned 16-bit integer. This is a direct conversion for all primitive numeric types and ToUInt16 method otherwise)

Converts the argument to unsigned 32-bit integer. This is a direct conversion for all primitive numeric types and ToUInt32 method otherwise)

Converts the argument to unsigned 64-bit integer. This is a direct conversion for all primitive numeric types and ToUInt64 method otherwise)

Converts the argument to unsigned native integer. This is a direct conversion for all primitive numeric types and ToUIntPtr method otherwise)

This module contains the basic arithmetic operations with overflow checks.

Get a slice of an array

Get a slice from a string

This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'byte'

This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'decimal'

This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'float'

This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator

This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'int16'

This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'int32'

This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'int64'

This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'nativeint'

This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'sbyte'

This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'float32'

This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'uint16'

This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'uint32'

This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'uint64'

This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'unativeint'

Generate a range of byte values

Generate a range of char values

Generate a range of float values

Generate a range of values using the given zero, add, start, step and stop values

Generate a range of int16 values

Generate a range of integers

Generate a range of int64 values

Generate a range of nativeint values

Generate a range of sbyte values

Generate a range of float32 values

Generate a range of values using the given zero, add, start, step and stop values

Generate a range of uint16 values

Generate a range of uint32 values

Generate a range of uint64 values

Generate a range of unativeint values

Set a slice of an array

A module of compiler intrinsic functions for efficient implementations of F# integer ranges and dynamic invocations of other F# operators

Generate a defult value for any type. This is null for reference types, For structs, this is struct value where all fields have the default value. This function is unsafe in the sense that some F# values do not have proper null values.

This module contains basic operations which do not apply runtime and/or static checks

Basic F# Operators. This module is automatically opened in all F# code.

Invoke the optimized function value with two curried arguments

Adapt an F# first class function value to be an optimized function value that can accept two curried arguments without intervening execution.

Construct an optimized function value that can accept two curried arguments without intervening execution.

The .NET type used to represent F# function values that accept two iterated (curried) arguments without intervening execution. This type should not typically used directly from either F# code or from other .NET languages.

Invoke an F# first class function value that accepts three curried arguments without intervening execution

Adapt an F# first class function value to be an optimized function value that can accept three curried arguments without intervening execution.

Construct an optimized function value that can accept three curried arguments without intervening execution.

The .NET type used to represent F# function values that accept three iterated (curried) arguments without intervening execution. This type should not typically used directly from either F# code or from other .NET languages.

Invoke an F# first class function value that accepts four curried arguments without intervening execution

Adapt an F# first class function value to be an optimized function value that can accept four curried arguments without intervening execution.

Construct an optimized function value that can accept four curried arguments without intervening execution.

The .NET type used to represent F# function values that accept four iterated (curried) arguments without intervening execution. This type should not typically used directly from either F# code or from other .NET languages.

Invoke an F# first class function value that accepts five curried arguments without intervening execution

Adapt an F# first class function value to be an optimized function value that can accept five curried arguments without intervening execution.

Construct an optimized function value that can accept five curried arguments without intervening execution.

The .NET type used to represent F# function values that accept five iterated (curried) arguments without intervening execution. This type should not typically used directly from either F# code or from other .NET languages.

An implementation module used to hold some private implementations of function value invocation.

bind f inp evaluates to match inp with None -> None | Some x -> f x length inp evaluates to match inp with None -> 0 | Some _ -> 1 exists p inp evaluates to match inp with None -> false | Some x -> p x filter p inp evaluates to match inp with None -> None | Some x -> if p x then inp else None fold_left f s inp evaluates to match inp with None -> s | Some x -> f s x fold_right f inp s evaluates to "match inp with None -> s | Some x -> f x s" forall p inp" evaluates to "match inp with None -> true | Some x -> p x

Gets the value associated with the option. If the option is None then raises ArgumentException

Returns true if the option is None

Returns true if the option is not None

iter f inp executes match inp with None -> () | Some x -> f x filter p inp evaluates to match inp with None -> None | Some x -> if p x then inp else None map f inp evaluates to match inp with None -> None | Some x -> Some (f x) partition p inp evaluates to match inp with None -> None,None | Some x -> if p x then inp,None else None,inp

Convert the option to an array of length 0 or 1

Convert the option to a list of length 0 or 1

Basic operations on options.

Build a new string whose characters are the results of applying the function mapping to each of the characters of the input string and concatenating the resulting strings.

Return a new string made by concatenating the given strings with separator 'sep', i.e. 'a1 + sep + ... + sep + aN'

Test if any character of the string satisfies the given predicate.

Test if all characters in the string satisfy the given predicate.

Build a new string whose characters are the results of applying the function mapping to each index from 0 to count-1 and concatenating the resulting strings.

Apply the function action to each character in the string.

Apply the function action to the index of each character in the string and the character itself.

Return the length of the string.

Build a new string whose characters are the results of applying the function mapping to each of the characters of the input string.

Build a new string whose characters are the results of applying the function mapping to each character in the string and the character itself.

Return a string by concatenating count instances of str.

Functional programming operators for string processing. Further string operations are available via the member functions on strings and other functionality in System.String and System.Text.RegularExpressions types.

Return the given big integer

Return the negation of a big integer

Return the difference of big integers

Generate a range of big integers, with a step

Generate a range of big integers

Return the product of big integers

Return the modulus of big integers

This operator is for use from other .NET languages

Return the ratio of big integers

Return the sum of two big integers

Get the big integer for zero

Return the sign of a big integer: 0, +1 or -1

Get the big integer for one

Return true if a big integer is 'zero'

Return true if a big integer is 'one'

Convert a big integer to a 64-bit signed integer

Convert a big integer to a 32-bit signed integer

Convert a big integer to a floating point number

Return n^m for two big integers

Parse a big integer from a string format

Return the greatest common divisor of two big integers

Compute the factorial function as a big integer

Compute the ratio and remainder of two big integers

Compute the absolute value of a big integer

Construct a BigInt value for the given integer

Construct a BigInt value for the given 64-bit integer

The type of arbitrary-sized integers

Abstract internal type

Return a typed native pointer by adding index * sizeof<'T> to the given input pointer

Dereference the typed native pointer computed by adding index * sizeof<'T> to the given input pointer

Get the address of an element of a pinned array

Get the address of an element of a pinned 2-dimensional array

Return a typed native pointer for a given machine address

Dereference the given typed native pointer

Assign the value into the memory location referenced by the typed native pointer computed by adding index * sizeof<'T> to the given input pointer

Return a machine address for a given typed native pointer

Assign the value into the memory location referenced by the given typed native pointer

Contains operations on native pointers. Use of these operators may result in the generation of unverifiable code.

Returns type of an expression

Returns the custom attributes of an expression

Build an expression that represents a while loop

Build an expression that represents setting a mutable variable

Build an expression that represents a variable

Build an expression that represents a constant value of a particular type

Build an expression that represents a constant value

Build an expression that represents a test of a value is of a particular union case

Build an expression that represents a type test

Build an expression that represents getting a field of a tuple

Build an expression that represents a try/with construct for exception filtering and catching

Try and find a stored reflection definition for the given method. Stored reflection definitions are added to an F# assembly through the use of the [<ReflectedDefinition>] attribute.

Build an expression that represents a try/finally construct

Substitute through the given expression using the given functions to map variables to new values. The functions must give consistent results at each application. Variable renaming may occur on the target expression if variable capture occurs.

Build an expression that represents the sequential execution of one expression followed by another

Permit interactive environments such as F# Interactive to explicitly register new pickled resources that represent persisted top level definitions. The string indicates a unique name for the resources being added. The format for the bytes is the encoding generated by the F# compiler.

Build an expression that represents a nested quotation literal

Build an expression that represents writing to a property of an object

Build an expression that represents writing to a static property

Build an expression that represents reading a property of an object

Build an expression that represents reading a static property

Build an expression that represents the creation of a union case value

Build an expression that represents the creation of an F# tuple value

Build record-construction expressions

Build an expression that represents the invocation of an object constructor

Build an expression that represents the creation of a delegate value for the given type

Build an expression that represents the creation of an array value initialized with the given elements

Build recursives expressions associated with 'let rec' constructs

Build expressions associated with 'let' constructs

Build an expression that represents the constrution of an F# function value

Build 'if ... then ... else' expressions

Fetch or create a new variable with the given name and type from a global pool of shared variables indexed by name and type. The type is given by the expicit or inferred type parameter

Get the free expression variables of an expression as a list

Build a 'for i = ... to ... do ...' expression that represent loops over integer ranges

Build an expression that represents writing to a static field

Build an expression that represents writing to a field of an object

Build an expression that represents the access of a static field

Build an expression that represents the access of a field of an object

This function is called automatically when quotation syntax (<@ @>) and related typed-expression quotations are used. The bytes are a pickled binary representation of an unlinked form of the qutoed expression, and the System.Type argument is any type in the assembly where the quoted expression occurs, i.e. it helps scope the interpretation of the cross-assembly references in the bytes.

Build an expression that represents the invocation of a default object constructor

Build an expression that represents the coercion of an expression to a type

Return a new typed expression given an underlying runtime-typed expression. A type annotation is usually required to use this function, and using an incorrect type annotation may result in a later runtime exception.

Build an expression that represents a call to an static method or module-bound function

Build an expression that represents a call to an instance method associated with an object

Build an expression that represents the application of a first class function value to multiple arguments

Build an expression that represents the application of a first class function value to a single argument

Build an expression that represents setting the value held at a particular address

Build an expression that represents getting the address of a value

Quoted expressions annotated with System.Type values.

Get the raw expression associated with this type-carrying expression

Type-carrying quoted expressions. Expressions are generated either by quotations in source text or programatically

The type associated with the variable

The declared name of the variable

Indicates if the variable represents a mutable storage location

Fetch or create a new variable with the given name and type from a global pool of shared variables indexed by name and type

Create a new variable with the given name, type and mutability

Information at the binding site of a variable

An active pattern to recognize expressions of the form a && b

An active pattern to recognize expressions that represent the application of a (possibly curried or tupled) first class function value

An active pattern to recognize constant boolean expressions

An active pattern to recognize constant byte expressions

An active pattern to recognize constant unicode character expressions

An active pattern to recognize constant 64-bit floating point number expressions

An active pattern to recognize constant int16 expressions

An active pattern to recognize constant int32 expressions

An active pattern to recognize constant int64 expressions

An active pattern to recognize expressions that represent a (possibly curried or tupled) first class function value

An active pattern to recognize methods that have an associated ReflectedDefinition

An active pattern to recognize expressions of the form a || b

An active pattern to recognize property getters or values in modules that have an associated ReflectedDefinition

An active pattern to recognize property setters that have an associated ReflectedDefinition

An active pattern to recognize constant signed byte expressions

An active pattern to recognize constant 32-bit floating point number expressions

A parameterized active pattern to recognize calls to a specified function or method

An active pattern to recognize constant string expressions

An active pattern to recognize constant unsigned int16 expressions

An active pattern to recognize constant unsigned int32 expressions

An active pattern to recognize constant unsigned int64 expressions

An active pattern to recognize () constant expressions

Contains a set of derived F# active patterns to analyze F# expression objects

Re-build combination expressions. The first parameter should be an object returned by the ShapeCombination case of the active pattern in this module.

An active pattern that performs a complete decomposition viewing the expression tree as a binding structure

Active patterns for traversing, visiting, rebuilding and tranforming expressions in a generic way

An active pattern to recognize expressions that represent getting the address of a value

An active pattern to recognize expressions that represent setting the value held at an address

An active pattern to recognize expressions that represent applications of first class function values

An active pattern to recognize expressions that represent calls to static and instance methods, and functions defined in modules

An active pattern to recognize expressions that represent coercions from one type to another

An active pattern to recognize expressions that represent invocations of a default constructor of a struct

An active pattern to recognize expressions that represent getting a static or instance field

An active pattern to recognize expressions that represent setting a static or instance field

An active pattern to recognize expressions that represent loops over integer ranges

An active pattern to recognize expressions that represent conditionals

An active pattern to recognize expressions that represent first class function values

An active pattern to recognize expressions that represent recursive let bindings of one or more variables

An active pattern to recognize expressions that represent let bindings

An active pattern to recognize expressions that represent the construction of arrays

An active pattern to recognize expressions that represent construction of delegate values

An active pattern to recognize expressions that represent invocation of object constructors

An active pattern to recognize expressions that represent construction of record values

An active pattern to recognize expressions that represent construction of tuple values

An active pattern to recognize expressions that represent construction of particular union case values

An active pattern to recognize expressions that represent the read of a static or instance property, or a non-function value declared in a module

An active pattern to recognize expressions that represent setting a static or instance property, or a non-function value declared in a module

An active pattern to recognize expressions that represent a nested quotation literal

An active pattern to recognize expressions that represent sequential exeuction of one expression followed by another

An active pattern to recognize expressions that represent a try/finally construct

An active pattern to recognize expressions that represent a try/with construct for exception filtering and catching

An active pattern to recognize expressions that represent getting a tuple field

An active pattern to recognize expressions that represent a dynamic type test

An active pattern to recognize expressions that represent a test if a value is of a particular union case

An active pattern to recognize expressions that represent a constant value

An active pattern to recognize expressions that represent setting a mutable variable

An active pattern to recognize expressions that represent a variable

An active pattern to recognize expressions that represent while loops

Contains a set of primitive F# active patterns to analyze F# expression objects

Return a System.Type representing an F# tuple type with the given element types

Return a System.Type representing the F# function type with the given domain and range

Return true if the typ is a representation of an F# union type or the runtime type of a value of that type

Return true if the typ is a representation of an F# tuple type

Return true if the typ is a representation of an F# record type

Return true if the typ is a System.Type value corresponding to the compiled form of an F# module

Return true if the typ is a representation of an F# function type or the runtime type of a closure implementing an F# function type

Return true if the typ is a representation of an F# exception declaration

Get the cases of a union type. Assumes the given type is a union type. If not, ArgumentException is raised during pre-computation.

Get the tuple elements from the representation of an F# tuple type

Read all the fields from a record value, in declaration order Assumes the given input is a record value. If not, ArgumentException is raised.

Get the domain and range types from an F# function type or from the runtime type of a closure implementing an F# type

Read all the fields from an F# exception declaration, in declaration order Assumes exceptionType is an exception representation type. If not, ArgumentException is raised.

Contains operations associated with constructing and analyzing F# types such as records, unions and tuples

Assumes the given type is a union type. If not, ArgumentException is raised during pre-computation. Using the computed function is more efficient than calling GetUnionCase because the path executed by the computed function is optimized given the knowledge that it will be used to read values of the given type.

Precompute a property or static method for reading an integer representing the case tag of a union type.

Precompute a function for reading all the fields for a particular discriminator case of a union type Using the computed function will typically be faster than executing a corresponding call to GetFields

A method that constructs objects of the given case

Precompute a function for constructing a discriminated union value for a particular union case.

Precompute a function for reading the values of a particular tuple type Assumes the given type is a TupleType. If not, ArgumentException is raised during pre-computation.

Get information that indicates how to read a field of a tuple

Get a method that constructs objects of the given tuple type. For small tuples, no additional typoe will be returned. For large tuples, an additional type is returned indicating that a nested encoding has been used for the tuple type. In this case the suffix portion of the tuple type has the given type and an object of this type must be created and passed as the last argument to the ConstructorInfo. A recursive call to PreComputeTupleConstructorInfo can be used to determine the constructor for that the suffix type.

Precompute a function for reading the values of a particular tuple type Assumes the given type is a TupleType. If not, ArgumentException is raised during pre-computation.

Precompute a function for reading all the fields from a record. The fields are returned in the same order as the fields reported by a call to Microsoft.FSharp.Reflection.Type.GetInfo for this type. Assumes the given type is a RecordType. If not, ArgumentException is raised during pre-computation. Using the computed function will typically be faster than executing a corresponding call to Value.GetInfo because the path executed by the computed function is optimized given the knowledge that it will be used to read values of the given type.

Precompute a function for reading a particular field from a record. Assumes the given type is a RecordType with a field of the given name. If not, ArgumentException is raised during pre-computation. Using the computed function will typically be faster than executing a corresponding call to Value.GetInfo because the path executed by the computed function is optimized given the knowledge that it will be used to read values of the given type.

Get a ConstructorInfo for a record type

Precompute a function for constructing a record value. Assumes the given type is a RecordType. If not, ArgumentException is raised during pre-computation.

Create a union case value

Create an instance of a tuple type Assumes at least one element is given. If not, ArgumentException is raised.

Create an instance of a record type Assumes the given input is a record type. If not, ArgumentException is raised.

Build a typed function from object from a dynamic function implementation

Identify the union case and its fields for an object Assumes the given input is a union case value. If not, ArgumentException is raised. If the type is not given, then the runtime type of the input object is used to identify the relevant union type. The type should always be given if the input object may be null. For example, option values may be represented using the 'null'.

Read all fields from a tuple Assumes the given input is a tuple value. If not, ArgumentException is raised.

Read a field from a tuple value Assumes the given input is a tuple value. If not, ArgumentException is raised.

Read all the fields from a record value Assumes the given input is a record value. If not, ArgumentException is raised.

Read a field from a record value Assumes the given input is a record value. If not, ArgumentException is raised.

Read all the fields from a value built using an instance of an F# exception declaration Assumes the given input is an F# exception value. If not, ArgumentException is raised.

Contains operations associated with constructing and analyzing values associated with F# types such as records, unions and tuples

The integer tag for the case

The name of the case

The type in which the case occurs

The fields associated with the case, represented by PropertyInfo

Return the custom attributes associated with the case

Return the custom attributes associated with the case matching the given attribute type

Represents a case of a discriminated union type

Type of a formatting expression 'Printer : function type generated by printf 'State: type argument passed to %a formatters 'Residue: value generated by the overall printf action (e.g. sprint generates a string) 'Result: value generated after post processing (e.g. failwithf generates a string internally then raises an exception)

The raw text of the format string

Construct a format string

Type of a formatting expression. 'Printer : function type generated by printf 'State: type argument passed to %a formatters 'Residue: value generated by the overall printf action (e.g. sprint generates a string) 'Result: value generated after post processing (e.g. failwithf generates a string internally then raises an exception)

Construct a format string

Represents a statically-analyzed format associated with writing to a System.Text.StringBuilder. The type parameter indicates the arguments and return type of the format operation.

Represents a statically-analyzed format associated with writing to a System.Text.StringBuilder. The first type parameter indicates the arguments of the format operation and the last the overall return type.

Represents a statically-analyzed format when formatting builds a string. The type parameter indicates the arguments and return type of the format operation.

Represents a statically-analyzed format when formatting builds a string. The first type parameter indicates the arguments of the format operation and the last the overall return type.

Represents a statically-analyzed format associated with writing to a System.IO.TextWriter. The type parameter indicates the arguments and return type of the format operation.

Represents a statically-analyzed format associated with writing to a System.IO.TextWriter. The first type parameter indicates the arguments of the format operation and the last the overall return type.

Print to a System.Text.StringBuilder

Formatted printing to stderr

Formatted printing to stderr, adding a newline

Print to a string buffer and raise an exception with the given result. Helper printers must return strings.

Print to a text writer or an OCaml-compatible channel

Print to a text writer or an OCaml-compatible channel, adding a newline

bprintf, but call the given 'final' function to generate the result. See kprintf.

fprintf, but call the given 'final' function to generate the result. See kprintf.

printf, but call the given 'final' 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.

sprintf, but call the given 'final' function to generate the result. See kprintf.

twprintf, but call the given 'final' function to generate the result. See kprintf.

Formatted printing to stdout

Formatted printing to stdout, adding a newline

Print to a string via an internal string buffer and return the result as a string. Helper printers must return strings.

Print to any subtype of the .NET type System.IO.TextWriter

Print to any subtype of the .NET type System.IO.TextWriter, and add a newline

Extensible printf-style formatting for numbers and other datatypes Format specifications are strings with "%" markers indicating format placeholders. Format placeholders consist of: %[flags][width][.precision][type] where the type is interpreted as follows: %b: bool, formatted as "true" or "false" %s: string, formatted as its unescaped contents %d, %i: any basic integer type formatted as a decimal integer, signed if the basic integer type is signed. %u: any basic integer type formatted as an unsigned decimal integer %x, %X, %o: any basic integer type formatted as an unsigned hexadecimal (a-f)/Hexadecimal (A-F)/Octal integer %e, %E, %f, %F, %g, %G: any basic floating point type (float,float32) formatted using a C-style floating point format specifications, i.e %e, %E: 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: 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: Signed value printed in f or e format, whichever is more compact for the given value and precision. %M: System.Decimal value %O: Any value, printed by boxing the object and using it's ToString method(s) %A: Any value, printed by using Microsoft.FSharp.Text.StructuredPrintfImpl.Display.any_to_string with the default layout settings %a: A general format specifier, requires two arguments: (1) a function which accepts two arguments: (a) a context parameter of the appropriate type for the given formatting function (e.g. an #System.IO.TextWriter) (b) a value to print and which either outputs or returns appropriate text. (2) the particular value to print %t: A general format specifier, requires one argument: (1) a function which accepts a context parameter of the appropriate type for the given formatting function (e.g. an System.IO.TextWriter)and which either outputs or returns appropriate text. Basic integer types are: byte,sbyte,int16,uint16,int32,uint32,int64,uint64,nativeint,unativeint Basic floating point types are: float, float32 The following format patterns are accepted but a warning is printed: %h(d|u|x|X|o) %l(d|u|x|X|o) The following format patterns are now deprecated: %Ld, %Li, %Lu, %Lx, %LX, %Lo: same, but an int64 %nd, %ni, %nu, %nx, %nX, %no: same, but a nativeint %Ud, %Ui, %Uu, %Ux, %UX, %Uo: same, but an unsigned int32 (uint32) %ULd, %ULi, %ULu, %ULx, %ULX, %ULo: same, but an unsigned int64 (uint64) %Und, %Uni, %Unu, %Unx, %UnX, %Uno: same, but an unsigned nativeint (unativeint) The optional width is an integer indicating the minimal width of the result. For instance, %6d prints an integer, prefixing it with spaces to fill at least 6 characters. If width is '*', then an extra integer argument is taken to specify the corresponding width. any number '*': Valid flags are: 0: add zeros instead of spaces to make up the required width '-': left justify the result within the width specified '+': add a '+' character if the number is positive (to match a '-' sign for negatives) ' ': add an extra space if the number is positive (to match a '-' sign for negatives) The printf '#' flag is invalid and a compile-time error will be reported if it is used.

A record of options to control structural formatting. For F# Interactive properties matching those of this value can be accessed via the 'fsi' value. Floating Point format given in the same format accepted by System.Double.ToString, e.g. f6 or g15. If ShowProperties is set the printing process will evaluate properties of the values being displayed. This may cause additional computation. The ShowIEnumerable is set the printing process will force the evalution of IEnumerable objects to a small, finite depth, as determined by the printing parameters. This may lead to additional computation being performed during printing. From F# Interactive the default settings can be adjusted using, for example,

   open Microsoft.FSharp.Compiler.Interactive.Settings;;
   setPrintWidth 120;;

Data representing structured layouts of terms.

Convert any value to a string using a standard formatter Data is typically formatted in a structured format, e.g. lists are formatted using the "[1;2]" notation. The details of the format are not specified and may change from version to version and according to the flags given to the F# compiler. The format is intended to be human-readable, not machine readable. If alternative generic formats are required you should develop your own formatter, using the code in the implementation of this file as a starting point. Data from other .NET languages is formatted using a virtual call to Object.ToString() on the boxed version of the input.

Convert any value to a layout using the given formatting options. The layout can then be processed using formatting display engines such as those in the LayoutOps module. any_to_string and output_any are built using any_to_layout with default format options.

Ouput any value to a channel using the same set of formatting rules as any_to_string

Layout two vertically.

Layout list vertically.

Wrap braces around layout.

Wrap round brackets around Layout.

Join layouts into a comma separated list.

The empty layout

Is it the empty layout?

An string which is left parenthesis (no space on the right).

Layout like an F# list.

An uninterpreted leaf, to be interpreted into a string by the layout engine. This allows leaf layouts for numbers, strings and other atoms to be customized according to culture.

Join broken with ident=0

Join broken with ident=1

Join broken with ident=2

Join, unbreakable.

Join, possible break with indent=1

Join, possible break with indent=2

Join, possible break with indent=0

Layout like an F# option.

An string which is right parenthesis (no space on it's left).

Join layouts into a semi-colon separated list.

An string which requires no spaces either side.

Join layouts into a list separated using the given Layout.

Join layouts into a space separated list.

Wrap square brackets around layout.

See tagL

Form tuple of layouts.

For limitting layout of list-like sequences (lists,arrays,etc). unfold a list of items using (project and z) making layout list via itemL. If reach maxLength (before exhausting) then truncate.

An string leaf

A layout is a sequence of strings which have been joined together. The strings are classified as words, separators and left and right parenthesis. This classification determines where spaces are inserted. A joint is either unbreakable, breakable or broken. If a joint is broken the RHS layout occurs on the next line with optional indentation. A layout can be squashed to for given width which forces breaks as required.