singrdk/base/build/fslib10.xml

<?xml version="1.0" encoding="utf-8"?>
<doc>
<assembly><name>fslib10</name></assembly>
<members>
<member name="T:Microsoft.FSharp.Collections.CHashSet`1">

</member>
<member name="T:Microsoft.FSharp.Collections.CHashTable`2">

</member>
<member name="M:Microsoft.FSharp.Collections.HashMultiMap`2.Add(System.Object,System.Object)">
<summary>
Add a binding for the element to the table
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashMultiMap`2.Clear">
<summary>
Clear all elements from the collection
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashMultiMap`2.Contains(System.Object)">
<summary>
Test if the collection contains any bindings for the given element
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashMultiMap`2.Copy">
<summary>
Make a shallow copy of the collection
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashMultiMap`2.Create">
<summary>
Create a new empty mutable hash table 
with key hash/equality based on the F# structural "hash" and (=) functions.

This function is always inlined to give compilers the opportunity to optimize the
structural hash/equality functions based on any available compile-time knowledge 
of the key type at the call site.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashMultiMap`2.Create(System.Int32)">
<summary>
Create a new empty mutable hash table with an internal bucket array of the given approximate size
and with key hash/equality based on the F# structural "hash" and (=) functions

This function is always inlined to give compilers the opportunity to optimize the
structural hash/equality functions based on any available compile-time knowledge 
of the key type at the call site.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashMultiMap`2.Create(Microsoft.FSharp.Compatibility.IEqualityComparer,System.Int32)">
<summary>
Create a new empty mutable hash table with an internal bucket array of the given approximate size
and with the given key hash/equality functions
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashMultiMap`2.Create(Microsoft.FSharp.Compatibility.IEqualityComparer,Microsoft.FSharp.Collections.HashStats,System.Int32)">
<summary>
Create a new empty mutable hash table with an internal bucket array of the given approximate size
and with the given key hash/equality functions and the given HashStats collector
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashMultiMap`2.Create(Microsoft.FSharp.Compatibility.IEnumerable)">
<summary>
 Build a map that contains the bindings of the given IEnumerable
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashMultiMap`2.Find(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.HashMultiMap`2.FindAll(System.Object)">
<summary>
Find all bindings for the given element in the table, if any
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashMultiMap`2.Fold(Microsoft.FSharp.Core.FastFunc)">
<summary>
Apply the given function to each element in the collection threading the accumulating parameter
through the sequence of function applications
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashMultiMap`2.GetLongestChain">
<summary>
Get the longest chain in the hash table as a list.  Use for debugging
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashMultiMap`2.Iterate(Microsoft.FSharp.Core.FastFunc)">
<summary>
Apply the given function to each binding in the hash table 
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashMultiMap`2.Remove(System.Object)">
<summary>
Remove the latest binding (if any) for the given element from the table
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashMultiMap`2.Replace(System.Object,System.Object)">
<summary>
Replace the latest binding (if any) for the given element.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashMultiMap`2.TryFind(System.Object)">
<summary>
Lookup the given element in the table, returning the result as an Option
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.HashMultiMap`2.Count">

</member>
<member name="P:Microsoft.FSharp.Collections.HashMultiMap`2.Item(System.Object)">
<summary>
Lookup or set the given element in the table.  Raise Not_found/IndexOutOfRangeException if the element is not found.
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.HashMultiMap`2.Item(System.Object,System.Object)">
<summary>
Lookup or set the given element in the table.  Raise Not_found/IndexOutOfRangeException if the element is not found.
</summary>
</member>
<member name="T:Microsoft.FSharp.Collections.HashMultiMap`2">
<summary>
 Hash tables, by default based on F# structural "hash" and (=) functions. 
 This is precisely the same type as that manipulated by 
 the functions in [[Microsoft.FSharp.Compatibility.OCaml.Hashtbl]].
 The table may map a single key to multiple bindings.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashSet`1.Add(System.Object)">
<summary>
Add an element to the collection
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashSet`1.Clear">
<summary>
Clear all elements from the set
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashSet`1.Contains(System.Object)">
<summary>
Test if the set contains the given element
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashSet`1.Copy">
<summary>
Make a shallow copy of the set
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashSet`1.Create">
<summary>
Create a new empty mutable hash set 
with key hash/equality based on the F# structural "hash" and (=) functions

This function is always inlined to give compilers the opportunity to optimize the
structural hash/equality functions based on any available compile-time knowledge 
of the key type at the call site.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashSet`1.Create(System.Int32)">
<summary>
Create a new empty mutable hash set with an internal bucket array of the given approximate size
and with key hash/equality based on the F# structural "hash" and (=) functions

This function is always inlined to give compilers the opportunity to optimize the
structural hash/equality functions based on any available compile-time knowledge 
of the key type at the call site.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashSet`1.Create(Microsoft.FSharp.Compatibility.IEqualityComparer,System.Int32)">
<summary>
Create a new empty mutable hash set with an internal bucket array of the given approximate size
and with the given key hash/equality functions 
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashSet`1.Create(Microsoft.FSharp.Compatibility.IEqualityComparer,Microsoft.FSharp.Collections.HashStats,System.Int32)">
<summary>
Create a new empty mutable hash set with an internal bucket array of the given approximate size
and with the given key hash/equality functions and the given HashStats collector
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashSet`1.Create(Microsoft.FSharp.Compatibility.IEnumerable)">
<summary>
Create a new mutable hash set containing elements drawn from the given sequence
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashSet`1.Fold(Microsoft.FSharp.Core.FastFunc)">
<summary>
Apply the given function to the set threading the accumulating parameter
through the sequence of function applications
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashSet`1.GetLongestChain">
<summary>
 Use to debug poorly performing hash tables
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashSet`1.Iterate(Microsoft.FSharp.Core.FastFunc)">
<summary>
Apply the given function to each binding in the hash table 
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashSet`1.Remove(System.Object)">
<summary>
Remove the given element from the set
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.HashSet`1.Count">

</member>
<member name="T:Microsoft.FSharp.Collections.HashSet`1">
<summary>
 Mutable hash sets based by default on F# structural "hash" and (=) functions. Implemented via a hash table and/or Dictionary.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashStats.Create">
<summary>
Create a new HashStats sink.
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.HashStats.LongestChainLength">
<summary>
 The longest ever chain length sampled in all tables traced by this sink.
 Chain levels are typically sampled only on resizes.
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.HashStats.NumResizes">
<summary>
The total number of resizes of all hash tables traced by this sink.
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.HashStats.NumTables">
<summary>
The total number of tables traced by this sink.
</summary>
</member>
<member name="T:Microsoft.FSharp.Collections.HashStats">
<summary>
 Sinks recording statistical properties of one or more hash tables.
</summary>
</member>
<member name="T:Microsoft.FSharp.Collections.HashTable`2">

</member>
<member name="T:Microsoft.FSharp.Collections.IHashOps`1">

</member>
<member name="T:Microsoft.FSharp.Collections.LazyList`1">
<summary>
 LazyLists are possibly-infinite, cached sequences.  See also IEnumerable/Seq for
 uncached sequences. Calling "get" on the same lazy list value you will keep 
 getting the same (cached) result.  LazyLists normally involve delayed computations
 without side-effects, and calling "get" may cause these computations to be executed.  The results 
 of these computations are cached - evaluations will be performed 
 only once for each element of the lazy list.  This is different to IEnumerable/Seq where
 recomputation happens each time an enumerator is created and the sequence traversed.

 LazyLists can represent cached potentially-infinite computations.  Because they are cached they may cause 
 memory leaks if some part of your code maintains a live reference to
 the head of an infinite or very large lazy list while iterating it, or if a reference is
 maintained after the list is no longer required.

 Although lazy lists are an abstract type you may pattern match against them using the
 LazyList.Cons and LazyList.Nil active patterns.  These may force the computation of elements
 of the list.

Possibly-infinite lazy lists. See also IEnumerable, which recomputes elements when needed.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List`1.Cons(System.Object,Microsoft.FSharp.Collections.List)">
<summary>
 The module 'List' contains additional values and functions related to this type.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List`1.Exists(Microsoft.FSharp.Core.FastFunc)">
<summary>
Test if any element of the collection satisfies the given predicate.

See also List.exists. The module 'List' contains additional values and functions 
related to this type.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List`1.Filter(Microsoft.FSharp.Core.FastFunc)">
<summary>
Return a new collection containing only the elements of the collection
for which the given predicate returns "true"

See also List.filter. The module 'List' contains additional values and functions 
related to this type.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List`1.ForAll(Microsoft.FSharp.Core.FastFunc)">
<summary>
Test if all elements of the collection satisfy the given predicate.

See also List.for_all. The module 'List' contains additional values and functions 
related to this type.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List`1.Iterate(Microsoft.FSharp.Core.FastFunc)">
<summary>
 See List.iter
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List`1.IterateIndexed(Microsoft.FSharp.Core.FastFunc)">
<summary>
Apply the given function to each element of the collection. The integer passed to the
function indicates the index of element.

See also List.iteri. The module 'List' contains additional values and functions 
related to this type.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List`1.Map(Microsoft.FSharp.Core.FastFunc)">
<summary>
Build a new list whose elements are the results of applying the given function

See also List.map. The module 'List' contains additional values and functions 
related to this type.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List`1.MapIndexed(Microsoft.FSharp.Core.FastFunc)">
<summary>
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.

See also List.map. The module 'List' contains additional values and functions 
related to this type.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List`1.Reverse">
<summary>
Return a new list with the elements in reverse order

See also List.rev. The module 'List' contains additional values and functions 
related to this type.
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.List`1.Head">
<summary>
 The module 'List' contains additional values and functions related to this type,
 e.g. List.fold_left, List.append etc.
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.List`1.IsCons">
<summary>
 The module 'List' contains additional values and functions related to this type.
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.List`1.IsNil">
<summary>
 The module 'List' contains additional values and functions related to this type.
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.List`1.Length">
<summary>
 The module 'List' contains additional values and functions related to this type.
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.List`1.Nil">
<summary>
 The module 'List' contains additional values and functions related to this type.
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.List`1.Tail">
<summary>
 The module 'List' contains additional values and functions related to this type.
</summary>
</member>
<member name="T:Microsoft.FSharp.Collections.List`1">
 <summary>
 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.
 </summary>

</member>
<member name="M:Microsoft.FSharp.Collections.Map`2.Add(System.Object,System.Object)">
<summary>
 Return a new map with the binding added to the given map.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map`2.ContainsKey(System.Object)">
<summary>
 Test is an element is in the domain of the map
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map`2.Create">

</member>
<member name="M:Microsoft.FSharp.Collections.Map`2.Create(Microsoft.FSharp.Compatibility.IEnumerable)">
<summary>
 Build a map that contains the bindings of the given IEnumerable
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map`2.Empty">
<summary>
 The empty map
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map`2.Equals(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.Map`2.Exists(Microsoft.FSharp.Core.FastFunc)">
<summary>
Return true if the given predicate returns true for one of the
bindings in the map. Always returns false if the map is empty.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map`2.Filter(Microsoft.FSharp.Core.FastFunc)">
<summary>
Build a new map containing the bindings for which the given predicate returns 'true'.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map`2.Find(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.Map`2.First(Microsoft.FSharp.Core.FastFunc)">
<summary>
 Search the map looking for the first element where the given function returns a [[Some]] value
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map`2.Fold(Microsoft.FSharp.Core.FastFunc)">
<summary>
 Fold over the bindings in the map.  
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map`2.FoldAndMap(Microsoft.FSharp.Core.FastFunc)">
<summary>
 Fold over the bindings in the map.  
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map`2.FoldSection(System.Object)">
<summary>
 Given the start and end points of a key range,
 Fold over the bindings in the map that are in the range,
 and the end points are included if present (the range is considered a closed interval).
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map`2.ForAll(Microsoft.FSharp.Core.FastFunc)">
<summary>
Return true if the given predicate returns true for all of the
bindings in the map. Always returns true if the map is empty.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map`2.FromList(Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Collections.Map`2.Iterate(Microsoft.FSharp.Core.FastFunc)">
<summary>
Apply the given function to each binding in the dictionary
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map`2.Map(Microsoft.FSharp.Core.FastFunc)">
<summary>
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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map`2.MapRange(Microsoft.FSharp.Core.FastFunc)">
<summary>
Build a new collection whose elements are the results of applying the given function
to each of the elements of the collection.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map`2.Partition(Microsoft.FSharp.Core.FastFunc)">
<summary>
Build two new maps, one containing the bindings for which the given predicate returns 'true',
and the other the remaining bindings.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map`2.Remove(System.Object)">
<summary>
 Remove an element from the domain of the map.  No exception is raised if the element is not present.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map`2.ToArray">
<summary>
The elements of the set as an array
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map`2.ToList">
<summary>
The elements of the set as a list.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map`2.TryFind(System.Object)">
<summary>
 Lookup an element in the map, returning a [[Some]] value if the element is in the domain 
 of the map and [[None]] if not.
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.Map`2.Count">
<summary>
 The number of bindings in the map
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.Map`2.IsEmpty">
<summary>
 Return true if there are no bindings in the map.
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.Map`2.Item(System.Object)">
<summary>
 Lookup an element in the map, raising [[Not_found]]/[[IndexOutOfRangeException]] if no binding
 exists in the map.
</summary>
</member>
<member name="T:Microsoft.FSharp.Collections.Map`2">
<summary>
Immutable maps.  Keys are ordered by F# structural comparison, potentially using implementations
of the IComparable interface on key values.

<performance> 
  Maps based on structural comparison are  
  efficient for small keys. They are not a suitable choice if keys are recursive data structures 
  or require non-structural comparison semantics.
</performance>
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Permutation..ctor(System.Int32[])">
<summary>
 Create a permutation by specifying the result of permuting [| 0 .. n-1 |]. For example, 
 Permutation([| 1;2;0 |])  specifies a permutation that rotates all elements left one place.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Permutation..ctor(System.Int32,Microsoft.FSharp.Compatibility.IEnumerable)">
<summary>
 Create a permutation by specifying (source,destination) index pairs. For example,
 Permutation(3,[ (0,2);(1,0); (2,1) ]) specifies a permutation that rotates 
 all elements left one place. Not all elements need be given, e.g. 
 Permutation(5,[ (1,2);(2,1) |]) specifies a permutation that swaps elements at indexes
 1 and 2.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Permutation.Compose(Microsoft.FSharp.Collections.Permutation,Microsoft.FSharp.Collections.Permutation)">
<summary>
 Return a permutation that, when applied, first applies p1 then applies p2.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Permutation.Identity(System.Int32)">
<summary>
 Return the iddentity permutation
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Permutation.Reverse(System.Int32)">
<summary>
 Return a permutation that, when applied, maps index 0 to N-1, N-1 to 0 etc.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Permutation.Rotate(System.Int32,Microsoft.FSharp.Core.Option)">
<summary>
 Return a permutation that rotates right by the given distance. If the distance
 is negative then a left rotation results.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Permutation.Swap(System.Int32,System.Int32,System.Int32)">
<summary>
 Return a swaps the given two elements.
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.Permutation.Inverse">
<summary>
 Compute the inverse of the permutation
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.Permutation.Item(System.Int32)">
<summary>
 Apply the composition to an index within the range 0..Length-1
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.Permutation.Length">

</member>
<member name="T:Microsoft.FSharp.Collections.Permutation">

</member>
<member name="T:Microsoft.FSharp.Collections.ReadonlyArray`1">
<summary>
 A type of read-only arrays
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.Add(System.Object)">
<summary>
 A useful shortcut for Set.add.  Note this operation prodcues 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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.Compare(Microsoft.FSharp.Collections.Set,Microsoft.FSharp.Collections.Set)">

</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.Contains(System.Object)">
<summary>
 A useful shortcut for Set.mem.  See the Set module for further operations on sets.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.Create">

</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.Create(Microsoft.FSharp.Compatibility.IEnumerable)">
<summary>
 Build a set that contains the same elements as the given IEnumerable
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.Difference(Microsoft.FSharp.Collections.Set,Microsoft.FSharp.Collections.Set)">
<summary>
Return a new set with the elements of the second set removed from the first.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.Empty">
<summary>
 The empty set based on the default structural comparison operator
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.Equality(Microsoft.FSharp.Collections.Set,Microsoft.FSharp.Collections.Set)">

</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.Equals(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.Exists(Microsoft.FSharp.Core.FastFunc)">
<summary>
Test if any element of the collection satisfies the given predicate.
If the elements are "i0...iN" 
then computes "p i0 or ... or p iN".
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.Filter(Microsoft.FSharp.Core.FastFunc)">
<summary>
Return a new collection containing only the elements of the collection
for which the given predicate returns "true"
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.Fold(Microsoft.FSharp.Core.FastFunc)">
<summary>
Apply the given accumulating function to all the elements of the set
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.ForAll(Microsoft.FSharp.Core.FastFunc)">
<summary>
Test if all elements of the collection satisfy the given predicate.
If the elements are "i0...iN" and "j0...jN"
then computes "p i0 &amp;&amp; ... &amp;&amp; p iN".
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.FromArray(System.Object[])">
<summary>
 Build a set that contains the same elements as the given array
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.GetNextElement(System.Object)">
<summary>
 Returns the least element in the set that is greater than the given key 
 according to the ordering being used for the set
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.GetPreviousElement(System.Object)">
<summary>
 Returns the greatest element in the set that is less than the given key 
 according to the ordering being used for the set
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.Intersection(Microsoft.FSharp.Collections.Set,Microsoft.FSharp.Collections.Set)">
<summary>
Compute the intersection of the two sets.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.Intersection(Microsoft.FSharp.Compatibility.IEnumerable)">
<summary>
Compute the intersection of N sets. At least one set must be given.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.IsSubsetOf(Microsoft.FSharp.Collections.Set)">
<summary>
Evaluates to "true" if all elements of the second set are in the first
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.IsSupersetOf(Microsoft.FSharp.Collections.Set)">
<summary>
Evaluates to "true" if all elements of the first set are in the second
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.Iterate(Microsoft.FSharp.Core.FastFunc)">
<summary>
Apply the given function to each binding in the collection
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.Map(Microsoft.FSharp.Core.FastFunc)">
<summary>
Return a new collection containing the results of applying the
given function to each element of the input set
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.Partition(Microsoft.FSharp.Core.FastFunc)">

</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.Remove(System.Object)">
<summary>
 A useful shortcut for Set.remove.  Note this operation prodcues 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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.Singleton(System.Object)">
<summary>
 A singleton set based on the default structural comparison operator
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.ToArray">

</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.ToList">
<summary>
The elements of the set as a list.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.Union(Microsoft.FSharp.Collections.Set,Microsoft.FSharp.Collections.Set)">
<summary>
Compute the union of the two sets.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.Union(Microsoft.FSharp.Compatibility.IEnumerable)">
<summary>
Compute the union of multiple sets.
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.Set`1.CheckBalanceInvariant">

</member>
<member name="P:Microsoft.FSharp.Collections.Set`1.Choose">

</member>
<member name="P:Microsoft.FSharp.Collections.Set`1.Count">
<summary>
 Return the number of elements in the set
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.Set`1.IsEmpty">
<summary>
 A useful shortcut for Set.is_empty.  See the Set module for further operations on sets.
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.Set`1.MaximumElement">
<summary>
Returns the highest element in the set according to the ordering being used for the set
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.Set`1.MinimumElement">
<summary>
Returns the lowest element in the set according to the ordering being used for the set
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.Set`1.Size">
<summary>
 A useful shortcut for Set.size.  See the Set module for further operations on sets.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.op_Addition(Microsoft.FSharp.Collections.Set,Microsoft.FSharp.Collections.Set)">
<summary>
Compute the union of the two sets.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set`1.op_Subtraction(Microsoft.FSharp.Collections.Set,Microsoft.FSharp.Collections.Set)">
<summary>
Return a new set with the elements of the second set removed from the first.
</summary>
</member>
<member name="T:Microsoft.FSharp.Collections.Set`1">
<summary>
 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.  

 Efficiency: Structural comparison is relatively efficient but is not a suitable
 choice in all circumstances, e.g. it may not compare efficiently on 
 non-reference types and deeply-structured types. 
</summary>
</member>
<member name="T:Microsoft.FSharp.Collections.list`1">

</member>
<member name="T:Microsoft.FSharp.Collections.roarray`1">

</member>
<member name="T:Microsoft.FSharp.Collections.seq`1">

</member>
<member name="M:Microsoft.FSharp.Collections.Array.append(System.Object[],System.Object[])">
<summary>
Build a new array that contains the elements of the first array followed by the elements of the second array
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.blit(System.Object[],System.Int32,System.Object[],System.Int32,System.Int32)">
<summary>
Read a range of elements from the first array and write them into the second.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.combine(System.Object[],System.Object[])">
<summary>
Combine the two arrays into an array of pairs. The two arrays must have equal lengths.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.concat(Microsoft.FSharp.Collections.List)">
<summary>
Build a new array that contains the elements of each of the given list of arrays
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.concat_seq(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.Array.copy(System.Object[])">
<summary>
Build a new array that contains the elements of the given array
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.create(System.Int32,System.Object)">
<summary>
 Create an array whose elements are all initially the given value.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.create_matrix(System.Int32,System.Int32,System.Object)">
<summary>
Create a jagged 2 dimensional array.

 This member is primarily provided for compatibility with implementations 
 of ML. F# also supports non-jagged 2D arrays - see the Array2 module and 
 types such as "int[,]".
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.exists(Microsoft.FSharp.Core.FastFunc,System.Object[])">
<summary>
Test if any element of the array satisfies the given predicate.
If the elements are "i0...iN" 
then computes "p i0 or ... or p iN".
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.fill(System.Object[],System.Int32,System.Int32,System.Object)">
<summary>
Fill a range of an array with the given element
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.filter(Microsoft.FSharp.Core.FastFunc,System.Object[])">
<summary>
Return a new collection containing only the elements of the collection
for which the given predicate returns "true"
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.find(Microsoft.FSharp.Core.FastFunc,System.Object[])">
<summary>
Return the first element for which the given function returns "true".
Raise Not_found if no such element exists.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.find_index(Microsoft.FSharp.Core.FastFunc,System.Object[])">

</member>
<member name="M:Microsoft.FSharp.Collections.Array.find_indexi(Microsoft.FSharp.Core.FastFunc,System.Object[])">

</member>
<member name="M:Microsoft.FSharp.Collections.Array.first(Microsoft.FSharp.Core.FastFunc,System.Object[])">
<summary>
Apply the given function to successive elements, returning the first
result where function returns "Some(x)" for some x.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.fold1_left(Microsoft.FSharp.Core.FastFunc,System.Object[])">

</member>
<member name="M:Microsoft.FSharp.Collections.Array.fold1_right(Microsoft.FSharp.Core.FastFunc,System.Object[])">

</member>
<member name="M:Microsoft.FSharp.Collections.Array.fold_left(Microsoft.FSharp.Core.FastFunc,System.Object,System.Object[])">
<summary>
Apply a function to each element of the collection, threading an 'accumulator' argument
through the computation. If the elements are "i0...iN" then computes "f (... (f s i0)...) iN"
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.fold_right(Microsoft.FSharp.Core.FastFunc,System.Object[],System.Object)">
<summary>
Apply a function to each element of the array, threading an 'accumulator' argument
through the computation. If the elements are "i0...iN" then computes "f i0 (...(f iN s))".
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.for_all(Microsoft.FSharp.Core.FastFunc,System.Object[])">
<summary>
Test if all elements of the array satisfy the given predicate.
If the elements are "i0...iN" and "j0...jN"
then computes "p i0 &amp;&amp; ... &amp;&amp; p iN".
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.get(System.Object[],System.Int32)">
<summary>
 Fetch an element from an array.  You can also use the syntax arr.(idx).
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.get_IEnumerator(System.Object[])">
<summary>
Return an enumerator for performing imperative enumerations over the given
array.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.init(System.Int32,Microsoft.FSharp.Core.FastFunc)">
<summary>
 Create an array given the dimension and a generator function to compute the elements.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.iter(Microsoft.FSharp.Core.FastFunc,System.Object[])">
<summary>
Apply the given function to each element of the array. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.iter2(Microsoft.FSharp.Core.FastFunc,System.Object[],System.Object[])">
<summary>
Apply the given function to two arrays simultaneously. The
two arrays must have the same lengths, otherwise an Invalid_argument exception is
raised.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.iteri(Microsoft.FSharp.Core.FastFunc,System.Object[])">
<summary>
Apply the given function to each element of the array.  The integer passed to the
function indicates the index of element.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.length(System.Object[])">
<summary>
 Return the length of an array.  You can also use property arr.Length.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.make(System.Int32,System.Object)">
<summary>
 Create an array whose elements are all initially the given value
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.make_matrix(System.Int32,System.Int32,System.Object)">
<summary>
Create a jagged 2 dimensional array.  Synonym for create.

 This member is primarily provided for compatibility with implementations 
 of ML. F# also supports non-jagged 2D arrays - see the Array2 module and 
 types such as "int[,]".
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.map(Microsoft.FSharp.Core.FastFunc,System.Object[])">
<summary>
Build a new array whose elements are the results of applying the given function
to each of the elements of the array.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.map2(Microsoft.FSharp.Core.FastFunc,System.Object[],System.Object[])">
<summary>
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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.mapi(Microsoft.FSharp.Core.FastFunc,System.Object[])">
<summary>
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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.of_IEnumerable(System.Object)">
<summary>
Build a new array from the given enumerable object
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.of_list(Microsoft.FSharp.Collections.List)">
<summary>
Build an array from the given list
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.of_llist(Microsoft.FSharp.Collections.LazyList)">
<summary>
Build an array from the given lazy list
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.of_seq(System.Object)">
<summary>
Build a new array from the given enumerable object
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.permute(Microsoft.FSharp.Collections.Permutation,System.Object[])">

</member>
<member name="M:Microsoft.FSharp.Collections.Array.pin(System.Object[]`1,Microsoft.FSharp.Core.FastFunc)">
<summary>
 Pin the given array for the duration of a single call to the given function.  A native pointer to
 the first element in the array is passed to the given function.  Cleanup the GCHandle associated with the 
 pin when the function completes, even if an exception is raised.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.pin_unscoped(System.Object[]`1)">
<summary>
 As for Array.pin, except that the caller is responsible for calling Free on the returned GCHandle in order
 to release the pin.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.rev(System.Object[])">
<summary>
Return a new array with the elements in reverse order
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.scan1_left(Microsoft.FSharp.Core.FastFunc,System.Object[])">

</member>
<member name="M:Microsoft.FSharp.Collections.Array.scan1_right(Microsoft.FSharp.Core.FastFunc,System.Object[])">

</member>
<member name="M:Microsoft.FSharp.Collections.Array.scan_left(Microsoft.FSharp.Core.FastFunc,System.Object,System.Object[])">

</member>
<member name="M:Microsoft.FSharp.Collections.Array.scan_right(Microsoft.FSharp.Core.FastFunc,System.Object[],System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.Array.set(System.Object[],System.Int32,System.Object)">
<summary>
 Set the value of an element in an array.  You can also use the syntax 'arr.(idx) &lt;- e'.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.sort(Microsoft.FSharp.Core.FastFunc,System.Object[])">
<summary>
Sort the elements of an array, using the given comparison function as the order 
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.split(Microsoft.FSharp.Core.Tuple2[])">
<summary>
Split a list of pairs into two lists
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.sub(System.Object[],System.Int32,System.Int32)">
<summary>
Build a new array that contains the given subrange specified by
starting index and length.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.sumByFloat(Microsoft.FSharp.Core.FastFunc,System.Object[])">

</member>
<member name="M:Microsoft.FSharp.Collections.Array.sumByFloat32(Microsoft.FSharp.Core.FastFunc,System.Object[])">

</member>
<member name="M:Microsoft.FSharp.Collections.Array.sumByInt(Microsoft.FSharp.Core.FastFunc,System.Object[])">

</member>
<member name="M:Microsoft.FSharp.Collections.Array.sumByInt64(Microsoft.FSharp.Core.FastFunc,System.Object[])">

</member>
<member name="M:Microsoft.FSharp.Collections.Array.to_IEnumerable(System.Object[])">
<summary>
Return a view of the array as an enumerable object
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.to_list(System.Object[])">
<summary>
Build a list from the given array
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.to_llist(System.Object[])">
<summary>
Build a lazy list from the given array
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.to_seq(System.Object[])">
<summary>
Return a view of the array as an enumerable object
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.tryfind(Microsoft.FSharp.Core.FastFunc,System.Object[])">
<summary>
Return the first element for which the given function returns "true".
Return None if no such element exists.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array.tryfind_index(Microsoft.FSharp.Core.FastFunc,System.Object[])">

</member>
<member name="M:Microsoft.FSharp.Collections.Array.tryfind_indexi(Microsoft.FSharp.Core.FastFunc,System.Object[])">

</member>
<member name="M:Microsoft.FSharp.Collections.Array.zero_create(System.Int32)">
<summary>
 Create an array where the entries are initially the
 a "default" value. For .NET reference types this will
 be "null".  For other types behaviour is undefined if 
 you access an entry of the array before setting it.
</summary>
</member>
<member name="T:Microsoft.FSharp.Collections.Array">
<summary>
 1-dimensional (generic) arrays.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array2.geta(System.Object[,]`1,System.Int32,System.Int32)">
<summary>
 Get the address of an element in the array
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array2.pin(System.Object[,]`1,Microsoft.FSharp.Core.FastFunc)">
<summary>
 Pin the given array for the duration of a single call to the given function.  A native pointer to
 the first element in the array is passed to the given function.  Cleanup the GCHandle associated with the 
 pin when the function completes, even if an exception is raised.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Array2.pin_unscoped(System.Object[,]`1)">
<summary>
 As for Array2.pin, except that the caller is responsible for calling Free on the returned GCHandle in order
 to release the pin.
</summary>
</member>
<member name="T:Microsoft.FSharp.Collections.Array2">
<summary>
 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 [[Array2.map]] and [[Array2.mapi]] operations.
 Non-zero-based arrays can also be created using [[Array2.zero_create_based]], 
 [[Array2.create_based]] and [[Array2.init_based]].

 This module is only available for F# on .NET 2.0.
 If using .NET 1.x then use Microsoft.FSharp.Compatiblity.CompatMatrix instead.
</summary>
</member>
<member name="T:Microsoft.FSharp.Collections.Array3">
<summary>
 Basic operations on 3-dimensional arrays.  Only available for F# on .NET 2.0.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.ComparisonIdentity.Custom(Microsoft.FSharp.Core.FastFunc)">

</member>
<member name="M:Microsoft.FSharp.Collections.ComparisonIdentity.FromFunction(Microsoft.FSharp.Core.FastFunc)">
<summary>
 Compare using the given comparer comparer function
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.ComparisonIdentity.Structural">
<summary>
 Structural comparison.  Compare using LanguagePrimitives.StructuralComparer.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.ComparisonIdentity.ViaIComparable">
<summary>
 Compare using any implementation of System.IComparable interfaces. This differs from structural comparison
 because arrays are not compared structurally, and many optimizations are not applied.
</summary>
</member>
<member name="T:Microsoft.FSharp.Collections.ComparisonIdentity">
<summary>
 Common notions of comparison identity used with sorted data structures.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashIdentity.Custom(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Core.FastFunc)">

</member>
<member name="M:Microsoft.FSharp.Collections.HashIdentity.FromFunction(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Core.FastFunc)">
<summary>
 Physical hashing (hash on reference identity of objects, and the contents of value types).  
 Hash using LanguagePrimitives.PhysicalEquality and LanguagePrimitives.PhysicalHash,
 i.e. 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. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashIdentity.Object">
<summary>
 Hash using Object.GetHashCode and Object.Equals(Object)
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashIdentity.Reference">
<summary>
 Physical hashing (hash on reference identity of objects, and the contents of value types).  
 Hash using LanguagePrimitives.PhysicalEquality and LanguagePrimitives.PhysicalHash,
 i.e. 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. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashIdentity.Structural">
<summary>
 Structural hashing.  Hash using LanguagePrimitives.StructuralEquality and LanguagePrimitives.StructuralComparer.
 i.e. for value types use GetHashCode and Object.Equals (if no other optimization available),
 and for reference types use the F# cooperative structural term hashing scheme.  Object.GetHashCode(obj)
 is used if no other choice is available.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.HashIdentity.ViaGetHashCode">
<summary>
 Hash using Object.GetHashCode and Object.Equals(Object)
</summary>
</member>
<member name="T:Microsoft.FSharp.Collections.HashIdentity">
<summary>
 Common notions of value identity used with hash tables.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.append(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.choose(Microsoft.FSharp.Core.FastFunc,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.combine(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.compare(Microsoft.FSharp.Core.FastFunc,System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.concat(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.delay(Microsoft.FSharp.Core.FastFunc)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.empty">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.exists(Microsoft.FSharp.Core.FastFunc,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.filter(Microsoft.FSharp.Core.FastFunc,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.find(Microsoft.FSharp.Core.FastFunc,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.first(Microsoft.FSharp.Core.FastFunc,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.fold(Microsoft.FSharp.Core.FastFunc,System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.for_all(Microsoft.FSharp.Core.FastFunc,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.generate(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Core.FastFunc)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.generate_using(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Core.FastFunc)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.hd(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.init_finite(System.Int32,Microsoft.FSharp.Core.FastFunc)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.init_infinite(Microsoft.FSharp.Core.FastFunc)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.iter(Microsoft.FSharp.Core.FastFunc,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.iter2(Microsoft.FSharp.Core.FastFunc,System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.iteri(Microsoft.FSharp.Core.FastFunc,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.length(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.map(Microsoft.FSharp.Core.FastFunc,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.map2(Microsoft.FSharp.Core.FastFunc,System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.map_concat(Microsoft.FSharp.Core.FastFunc,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.map_to_typed(Microsoft.FSharp.Core.FastFunc,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.map_with_type(Microsoft.FSharp.Core.FastFunc,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.mapi(Microsoft.FSharp.Core.FastFunc,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.nonempty(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.nth(System.Int32,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.of_array(System.Object[])">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.of_functions(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Core.FastFunc)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.of_list(Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.pairwise(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.singleton(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.take(System.Int32,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.to_array(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.to_list(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.truncate(System.Int32,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.tryfind(Microsoft.FSharp.Core.FastFunc,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.unfold(Microsoft.FSharp.Core.FastFunc,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.untyped_filter(Microsoft.FSharp.Core.FastFunc,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.untyped_fold(Microsoft.FSharp.Core.FastFunc,System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.untyped_iter(Microsoft.FSharp.Core.FastFunc,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.untyped_map(Microsoft.FSharp.Core.FastFunc,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.untyped_to_list(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.IEnumerable.untyped_to_typed(System.Object)">

</member>
<member name="T:Microsoft.FSharp.Collections.IEnumerable">

</member>
<member name="T:Microsoft.FSharp.Collections.LazyList.llist`1">

</member>
<member name="T:Microsoft.FSharp.Collections.LazyList.t`1">

</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.append(Microsoft.FSharp.Collections.LazyList,Microsoft.FSharp.Collections.LazyList)">
<summary>
Return the stream which contains on demand the elements of the first stream followed
by the elements of the second list
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.combine(Microsoft.FSharp.Collections.LazyList,Microsoft.FSharp.Collections.LazyList)">

</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.concat(Microsoft.FSharp.Collections.LazyList)">

</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.cons(System.Object,Microsoft.FSharp.Collections.LazyList)">
<summary>
Return a new stream which contains on demand the given item followed by the
given stream.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.consf(System.Object,Microsoft.FSharp.Core.FastFunc)">
<summary>
Return a new stream which contains on demand the given item followed by the
stream returned by the given computation.  The computation is
not executed until the elements of the stream are consumed.  The
computation is only executed once.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.delayed(Microsoft.FSharp.Core.FastFunc)">
<summary>
Return a stream that is in effect the stream returned by the given computation.
The given computation is not executed until the first element on the stream is
consumed.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.drop(System.Int32,Microsoft.FSharp.Collections.LazyList)">
<summary>
Return the stream without the first 'n' elements of the given stream.  Does
not force the evaluation of any cells in the stream.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.empty">
<summary>
Evaluates to the stream that contains no items
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.filter(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.LazyList)">
<summary>
Return a new collection which on consumption will consist of only the elements of the collection
for which the given predicate returns "true"
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.find(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.LazyList)">

</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.first(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.LazyList)">

</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.folds(Microsoft.FSharp.Core.FastFunc,System.Object,Microsoft.FSharp.Collections.LazyList)">
<summary>
Return a new stream consisting of the results of applying the given accumulating function
to successive elements of the stream
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.get(Microsoft.FSharp.Collections.LazyList)">
<summary>
Get the first cell of the stream.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.get_IEnumerator(Microsoft.FSharp.Collections.LazyList)">
<summary>
Return an enumerator for performing imperative enumerations over the given
collection.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.hd(Microsoft.FSharp.Collections.LazyList)">
<summary>
Return the first element of the stream.  Raise 'Invalid_argument "hd"' if the
stream is empty. Forces the evaluation of
the first cell of the stream if it is not already evaluated.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.map(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.LazyList)">
<summary>
Build a new collection whose elements are the results of applying the given function
to each of the elements of the collection.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.map2(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.LazyList,Microsoft.FSharp.Collections.LazyList)">
<summary>
Build a new collection whose elements are the results of applying the given function
to the corresponding elements of the two collections pairwise.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.nonempty(Microsoft.FSharp.Collections.LazyList)">
<summary>
Test if a stream contains at least one element.  Forces the evaluation of
the first element of the stream if it is not already evaluated.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.of_IEnumerable(System.Object)">
<summary>
Build a new collection from the given enumerable object
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.of_array(System.Object[])">
<summary>
Build a collection from the given array.
 This function will eagerly evaluate all of the stream (and thus may not terminate). 
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.of_list(Microsoft.FSharp.Collections.List)">
<summary>
Build a collection from the given list.
 This function will eagerly evaluate all of the stream (and thus may not terminate). 
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.of_seq(System.Object)">
<summary>
Build a new collection from the given enumerable object
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.repeat(System.Object)">
<summary>
Return the stream which on consumption will consist of an infinite sequence of the given item
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.take(System.Int32,Microsoft.FSharp.Collections.LazyList)">
<summary>
Return the stream which on consumption will consist of at most 'n' elements of the given stream.  Does
not force the evaluation of any cells in the stream.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.tl(Microsoft.FSharp.Collections.LazyList)">
<summary>
Return the stream corresponding to the remaining items in the sequence.  
Raise 'Invalid_argument "tl"' if the
stream is empty. Forces the evaluation of
the first cell of the stream if it is not already evaluated.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.to_IEnumerable(Microsoft.FSharp.Collections.LazyList)">
<summary>
Return a view of the collection as an enumerable object
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.to_array(Microsoft.FSharp.Collections.LazyList)">
<summary>
Build an array from the given collection
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.to_list(Microsoft.FSharp.Collections.LazyList)">
<summary>
Build a list from the given collection
 This function will eagerly evaluate all of the stream (and thus may not terminate). 
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.to_seq(Microsoft.FSharp.Collections.LazyList)">
<summary>
Return a view of the collection as an enumerable object
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.unfold(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
Return a stream that contains the elements returned by the given computation.
The given computation is not executed until the first element on the stream is
consumed.  The given argument is passed to the computation.  Subsequent elements
 in the stream are generated by again applying the residual 'b to the computation.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.LazyList.|Cons|Nil|(Microsoft.FSharp.Collections.LazyList)">

</member>
<member name="T:Microsoft.FSharp.Collections.LazyList">

</member>
<member name="M:Microsoft.FSharp.Collections.List.append(Microsoft.FSharp.Collections.List,Microsoft.FSharp.Collections.List)">
<summary>
Return a new list that contains the elements of the first list
followed by elements of the second
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.assoc(System.Object,Microsoft.FSharp.Collections.List)">
<summary>
 Lookup key's data in association list, uses (=) equality.
 Raises [[Not_found]] exception if key not found, in which case you should typically use [[try_assoc]] instead.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.assq(System.Object,Microsoft.FSharp.Collections.List)">
<summary>
 See [[assoc]], but uses the physical equality operator (==) for equality tests
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.choose(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">
<summary>
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)
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.combine(Microsoft.FSharp.Collections.List,Microsoft.FSharp.Collections.List)">
<summary>
A synonym for List.combine
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.concat(System.Object)">
<summary>
Return a new list that contains the elements of each the lists in order
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.exists(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">
<summary>
Test if any element of the collection satisfies the given predicate.
If the elements are "i0...iN" 
then computes "p i0 or ... or p iN".
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.exists2(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List,Microsoft.FSharp.Collections.List)">
<summary>
Test if any corresponding elements of the collection satisfy the given predicate pairwise.
If the elements are "i0...iN" and "j0...jN"
then computes "p i0 j0 or ... or p iN jN".
Raises [[Invalid_argument]] exception if the lists do not zip (have different lengths).
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.filter(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">
<summary>
Return a new collection containing only the elements of the collection
for which the given predicate returns "true"
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.find(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">
<summary>
Return the first element for which the given function returns "true".
Raise Not_found if no such element exists.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.find_all(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">
<summary>
Return a list containing allthe elements for which the given function returns
 "true".  Same as "filter"
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.find_index(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">
<summary>
Raise Not_found if no such element exists.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.find_indexi(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">
<summary>
Raise Not_found if no such element exists.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.first(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">
<summary>
Apply the given function to successive elements, returning the first
result where function returns "Some(x)" for some x.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.flatten(System.Object)">
<summary>
Return a new list that contains the elements of each the lists in order.
Same as concat.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.fold1_left(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">
<summary>
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 elements are "i0...iN" then computes "f (... (f i0 i1) i2 ...) iN"
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.fold1_right(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Collections.List.fold_left(Microsoft.FSharp.Core.FastFunc,System.Object,Microsoft.FSharp.Collections.List)">
<summary>
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 elements are "i0...iN" then computes "f (... (f s i0) i1 ...) iN"
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.fold_left2(Microsoft.FSharp.Core.FastFunc,System.Object,Microsoft.FSharp.Collections.List,Microsoft.FSharp.Collections.List)">
<summary>
Apply a function to corresponding elements of two collections, threading an 'accumulator' argument
through the computation. The collections must have identical sizes.
If the elements are "i0...iN" and "j0...jN"
then computes "f (... (f s i0 j0)...) iN jN".
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.fold_right(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List,System.Object)">
<summary>
Apply a function to each element of the collection, threading an 'accumulator' argument
through the computation. If the elements are "i0...iN" then computes "f i0 (...(f iN s))".
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.fold_right2(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List,Microsoft.FSharp.Collections.List,System.Object)">
<summary>
Apply a function to corresponding elements of two collections, threading an 'accumulator' argument
through the computation. The collections must have identical sizes.
If the elements are "i0...iN" and "j0...jN"
then computes "f i0 j0 (...(f iN jN s))".
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.for_all(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">
<summary>
Test if all elements of the collection satisfy the given predicate.
If the elements are "i0...iN" 
then computes "p i0 &amp;&amp; ... &amp;&amp; p iN".
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.for_all2(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List,Microsoft.FSharp.Collections.List)">
<summary>
Test if all corresponding elements of the collection satisfy the given predicate pairwise.
If the elements are "i0...iN" and "j0...jN"
then computes "p i0 j0 &amp;&amp; ... &amp;&amp; p iN jN".
Raises [[Invalid_argument]] if the lists do not zip (have different lengths).
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.get_IEnumerator(Microsoft.FSharp.Collections.List)">
<summary>
Return an enumerator for performing imperative enumerations over the given
collection.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.hd(Microsoft.FSharp.Collections.List)">
<summary>
Return the first element of the list.  Raise (Invalid_argument "hd") if undefined.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.init(System.Int32,Microsoft.FSharp.Core.FastFunc)">
<summary>
 Create a list by calling the given generator on each index
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.iter(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">
<summary>
Apply the given function to each element of the collection. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.iter2(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List,Microsoft.FSharp.Collections.List)">
<summary>
Apply the given function to two collections simultaneously. The
collections must have identical size.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.iteri(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">
<summary>
Apply the given function to each element of the collection. The integer passed to the
function indicates the index of element.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.iteri2(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List,Microsoft.FSharp.Collections.List)">
<summary>
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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.length(Microsoft.FSharp.Collections.List)">
<summary>
Return the length of the list
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.map(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">
<summary>
Build a new collection whose elements are the results of applying the given function
to each of the elements of the collection.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.map2(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List,Microsoft.FSharp.Collections.List)">
<summary>
Build a new collection whose elements are the results of applying the given function
to the corresponding elements of the two collections pairwise.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.map3(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List,Microsoft.FSharp.Collections.List,Microsoft.FSharp.Collections.List)">
<summary>
Build a new collection whose elements are the results of applying the given function
to the corresponding elements of the three collections simultaneously.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.mapi(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">
<summary>
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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.mapi2(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List,Microsoft.FSharp.Collections.List)">
<summary>
Like mapi, but mapping corresponding elements from two lists of equal length.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.mem(System.Object,Microsoft.FSharp.Collections.List)">
<summary>
 Is an element in the list, uses (=) equality.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.mem_assoc(System.Object,Microsoft.FSharp.Collections.List)">
<summary>
 Does the key have pair in the association list?
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.mem_assq(System.Object,Microsoft.FSharp.Collections.List)">
<summary>
 See [[mem_assoc]], but uses the physical equality operator (==) for equality tests.      
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.memq(System.Object,Microsoft.FSharp.Collections.List)">
<summary>
 See [[mem]], but uses the physical equality operator (==) for equality tests.        
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.nonempty(Microsoft.FSharp.Collections.List)">
<summary>
Return true if the list is not empty.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.nth(Microsoft.FSharp.Collections.List,System.Int32)">
<summary>
Index into the list.  The first element has index 0.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.of_IEnumerable(System.Object)">
<summary>
Build a new collection from the given enumerable object
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.of_array(System.Object[])">
<summary>
Build a collection from the given array
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.of_llist(Microsoft.FSharp.Collections.LazyList)">
<summary>
Build a collection from the given lazy list
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.of_seq(System.Object)">
<summary>
Build a new collection from the given enumerable object
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.partition(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">
<summary>
Split the collection into two collections, containing the 
elements for which the given predicate returns "true" and "false"
respectively 
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.remove_assoc(System.Object,Microsoft.FSharp.Collections.List)">
<summary>
 Remove pair for key from the association list (if it's there).
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.remove_assq(System.Object,Microsoft.FSharp.Collections.List)">
<summary>
 See [[remove_assoc]], but uses the physical equality operator (==) for equality tests.        
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.rev(Microsoft.FSharp.Collections.List)">
<summary>
Return a new list with the elements in reverse order
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.rev_append(Microsoft.FSharp.Collections.List,Microsoft.FSharp.Collections.List)">
<summary>
"rev_append l1 l2" evaluates to "append (rev l1) l2"
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.rev_map(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">
<summary>
"rev_map f l1" evaluates to "map f (rev l1)"
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.rev_map2(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List,Microsoft.FSharp.Collections.List)">
<summary>
"rev_map2 f l1 l2" evaluates to "map2 f (rev l1) (rev l2)"
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.scan1_left(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Collections.List.scan1_right(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Collections.List.scan_left(Microsoft.FSharp.Core.FastFunc,System.Object,Microsoft.FSharp.Collections.List)">
<summary>
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 list of intermediate results and the final result.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.scan_right(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.List.sort(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">
<summary>
Sort the given list using the given comparison function
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.split(Microsoft.FSharp.Collections.List)">
<summary>
A synonym for List.unzip
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.stable_sort(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">
<summary>
Sort the given list using the given comparison function, preserving order for equal elements.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.sumByFloat(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Collections.List.sumByFloat32(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Collections.List.sumByInt(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Collections.List.sumByInt64(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Collections.List.tl(Microsoft.FSharp.Collections.List)">
<summary>
Return the tail of the list.  Raise (Invalid_argument "tl") if undefined.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.to_IEnumerable(Microsoft.FSharp.Collections.List)">
<summary>
Return a view of the collection as an enumerable object
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.to_array(Microsoft.FSharp.Collections.List)">
<summary>
Build an array from the given collection
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.to_llist(Microsoft.FSharp.Collections.List)">
<summary>
Build a lazy list from the given collection
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.to_seq(Microsoft.FSharp.Collections.List)">
<summary>
Return a view of the collection as an enumerable object
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.try_assoc(System.Object,Microsoft.FSharp.Collections.List)">
<summary>
 Lookup key's data in association list, uses (=) equality,
 returning "Some data" or "None".  
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.try_assq(System.Object,Microsoft.FSharp.Collections.List)">
<summary>
 See [[try_assoc]], but uses the physical equality operator (==) for equality tests.    
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.tryfind(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">
<summary>
Return the first element for which the given function returns "true".
Return None if no such element exists.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.tryfind_index(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">
<summary>
Return None if no such element exists.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.tryfind_indexi(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">
<summary>
Return None if no such element exists.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.unzip(Microsoft.FSharp.Collections.List)">
<summary>
Split a list of pairs into two lists
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.unzip3(Microsoft.FSharp.Collections.List)">
<summary>
Split a list of triples into three lists
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.zip(Microsoft.FSharp.Collections.List,Microsoft.FSharp.Collections.List)">
<summary>
Combine the two lists into a list of pairs. The two lists must have equal lengths.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.List.zip3(Microsoft.FSharp.Collections.List,Microsoft.FSharp.Collections.List,Microsoft.FSharp.Collections.List)">
<summary>
Combine the three lists into a list of triples. The lists must have equal lengths.
</summary>
</member>
<member name="T:Microsoft.FSharp.Collections.List">
<summary>
 Basic operations on lists.  
</summary>
</member>
<member name="T:Microsoft.FSharp.Collections.Map.CMapOps`2">

</member>
<member name="T:Microsoft.FSharp.Collections.Map.CMap`2">

</member>
<member name="T:Microsoft.FSharp.Collections.Map.Map`2">

</member>
<member name="T:Microsoft.FSharp.Collections.Map.ProviderUntagged`2">

</member>
<member name="T:Microsoft.FSharp.Collections.Map.Provider`2">

</member>
<member name="T:Microsoft.FSharp.Collections.Map.Provider`3">
<summary>
A collection of operations for creating and using maps based on a particular comparison function.
The 'tag type parameter is used to track information about the comparison function.
</summary>
</member>
<member name="T:Microsoft.FSharp.Collections.Map.t`2">
<summary>
 For use when not opening module, e.g. Map.t.  Used mainly in OCaml-compatible code.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map.Make(Microsoft.FSharp.Core.FastFunc)">

</member>
<member name="M:Microsoft.FSharp.Collections.Map.MakeTagged(System.Object)">
<summary>
A functor to build a collection of operations for creating and using 
 maps based on the given comparison function. This returns a record that 
 contains the functions you use to create and manipulate maps of
 this kind.  The returned value is much like an ML module. 

 Language restrictions related to polymorphism may mean you
 have to create a new instantiation of for each toplevel
 key/value type pair.

 To use this function you need to define a new named class that implements IComparer and
 pass an instance of that class as the first argument. For example:
      type MyComparer = 
          new() = { }
          interface IComparer&lt;string&gt; with 
            member self.Compare(x,y) = ...

 let MyStringMapProvider : Map.Provider &lt; string,int &gt; = Map.MakeTagged(new MyComparer())
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map.add(System.Object,System.Object,Microsoft.FSharp.Collections.Map)">
<summary>
 Return a new map with the binding added to the given map.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map.empty">
<summary>
 The empty map
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map.exists(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.Map)">
<summary>
Return true if the given predicate returns true for one of the
bindings in the map.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map.filter(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.Map)">
<summary>
Build a new map containing only the bindings for which the given predicate returns 'true'
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map.find(System.Object,Microsoft.FSharp.Collections.Map)">
<summary>
 Lookup an element in the map, raising [[Not_found]]/[[IndexOutOfRangeException]] if no binding
 exists in the map.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map.find_index(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.Map)">

</member>
<member name="M:Microsoft.FSharp.Collections.Map.first(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.Map)">
<summary>
 Search the map looking for the first element where the given function returns a [[Some]] value
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map.fold(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.Map,System.Object)">
<summary>
 Fold over the bindings in the map 
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map.for_all(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.Map)">
<summary>
Return true if the given predicate returns true for all of the
bindings in the map.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map.is_empty(Microsoft.FSharp.Collections.Map)">
<summary>
 Is the map empty?
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map.iter(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.Map)">
<summary>
Apply the given function to each binding in the dictionary
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map.map(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.Map)">
<summary>
Build a new collection whose elements are the results of applying the given function
to each of the elements of the collection.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map.mapi(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.Map)">
<summary>
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 of element being transformed.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map.mem(System.Object,Microsoft.FSharp.Collections.Map)">
<summary>
 Test is an element is in the domain of the map
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map.of_IEnumerable(System.Object)">
<summary>
 Return a new map made from the given bindings
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map.of_array(Microsoft.FSharp.Core.Tuple2[])">
<summary>
 Return a new map made from the given bindings
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map.of_list(Microsoft.FSharp.Collections.List)">
<summary>
 Return a new map made from the given bindings
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map.of_seq(System.Object)">
<summary>
 Return a new map made from the given bindings
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map.partition(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.Map)">
<summary>
Build two new maps, one containing the bindings for which the given predicate returns 'true',
and the other the remaining bindings.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map.remove(System.Object,Microsoft.FSharp.Collections.Map)">
<summary>
 Remove an element from the domain of the map.  No exception is raised if the element is not present.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map.to_array(Microsoft.FSharp.Collections.Map)">

</member>
<member name="M:Microsoft.FSharp.Collections.Map.to_list(Microsoft.FSharp.Collections.Map)">

</member>
<member name="M:Microsoft.FSharp.Collections.Map.to_seq(Microsoft.FSharp.Collections.Map)">
<summary>
 View the collection as an enumerable sequence. This collection
 type is also directly compatible with 'seq&lt;KeyValuePair&lt;_,_&gt; &gt;'.

 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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map.tryfind(System.Object,Microsoft.FSharp.Collections.Map)">
<summary>
 Lookup an element in the map, returning a [[Some]] value if the element is in the domain 
 of the map and [[None]] if not.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Map.tryfind_index(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.Map)">

</member>
<member name="T:Microsoft.FSharp.Collections.Map">
 <summary>
   Immutable maps using structural comparison
 </summary>

 <performance> Maps based on structural comparison are  
 efficient. They are not a suitable choice if keys are recursive data structures 
 or require non-structural comparison semantics.</performance>
</member>
<member name="T:Microsoft.FSharp.Collections.ReadonlyArray.t`1">

</member>
<member name="M:Microsoft.FSharp.Collections.ReadonlyArray.append(Microsoft.FSharp.Collections.ReadonlyArray,Microsoft.FSharp.Collections.ReadonlyArray)">
<summary>
 "append a1 a2" is equivalent to "[|a1.(0);...;a1.(n-1);a2.(0);...;a2.(m-1)|]"
 where "n" is the length of "a1" and "m" is the length of "a2".
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.ReadonlyArray.concat(Microsoft.FSharp.Collections.List)">
<summary>
 "concat" is similar to [append] but conjoins a list of read-only array.  Only
 one new roarray is allocated.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.ReadonlyArray.fold_left(Microsoft.FSharp.Core.FastFunc,System.Object,Microsoft.FSharp.Collections.ReadonlyArray)">
<summary>
Apply a function to each element of the collection, threading an 'accumulator' argument
through the computation. If the elements are "i0...iN" then computes "f (... (f s i0)...) iN"
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.ReadonlyArray.fold_right(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.ReadonlyArray,System.Object)">
<summary>
Apply a function to each element of the collection, threading an 'accumulator' argument
through the computation. If the elements are "i0...iN" then computes "f i0 (...(f iN s))".
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.ReadonlyArray.get(Microsoft.FSharp.Collections.ReadonlyArray,System.Int32)">
<summary>
Get an element from a read-only array
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.ReadonlyArray.get_IEnumerator(Microsoft.FSharp.Collections.ReadonlyArray)">
<summary>
Return an enumerator for performing imperative enumerations over the given
collection.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.ReadonlyArray.init(System.Int32,Microsoft.FSharp.Core.FastFunc)">
<summary>
 Create a read-only array by index
 "init n f" creates the roarray "[| f 0; ...; f (n-1) |]".
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.ReadonlyArray.iter(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.ReadonlyArray)">
<summary>
Apply the given function to each element of the collection. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.ReadonlyArray.iteri(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.ReadonlyArray)">
<summary>
Apply the given function to each element of the collection. The integer passed to the
function indicates the index of element.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.ReadonlyArray.length(Microsoft.FSharp.Collections.ReadonlyArray)">
<summary>
Get the length of a read-only array
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.ReadonlyArray.map(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.ReadonlyArray)">
<summary>
Build a new collection whose elements are the results of applying the given function
to each of the elements of the collection.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.ReadonlyArray.mapi(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.ReadonlyArray)">
<summary>
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 of element being transformed.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.ReadonlyArray.of_IEnumerable(System.Object)">
<summary>
Build a new collection from the given enumerable object
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.ReadonlyArray.of_list(Microsoft.FSharp.Collections.List)">
<summary>
Build a collection from the given list
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.ReadonlyArray.of_llist(Microsoft.FSharp.Collections.LazyList)">
<summary>
Build a collection from the given lazy list
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.ReadonlyArray.of_seq(System.Object)">
<summary>
Build a new collection from the given enumerable object
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.ReadonlyArray.sub(Microsoft.FSharp.Collections.ReadonlyArray,System.Int32,System.Int32)">
<summary>
 "sub a n m" is equivalent to "[| a.(n); ...; a.(n+m) |]".
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.ReadonlyArray.to_IEnumerable(Microsoft.FSharp.Collections.ReadonlyArray)">
<summary>
Return a view of the collection as an enumerable object
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.ReadonlyArray.to_list(Microsoft.FSharp.Collections.ReadonlyArray)">
<summary>
Build a list from the given collection
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.ReadonlyArray.to_llist(Microsoft.FSharp.Collections.ReadonlyArray)">
<summary>
Build a lazy list from the given collection
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.ReadonlyArray.to_seq(Microsoft.FSharp.Collections.ReadonlyArray)">
<summary>
Return a view of the collection as an enumerable object
</summary>
</member>
<member name="T:Microsoft.FSharp.Collections.ReadonlyArray">

</member>
<member name="M:Microsoft.FSharp.Collections.Seq.append(System.Object,System.Object)">
<summary>
Wrap the two given enumeration-of-enumerations as a single concatenated
enumeration.

The returned IEnumerable may be passed between threads safely. However, 
individual IEnumerator values generated from the returned IEnumerable should not be accessed from
multiple threads simultaneously.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.choose(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
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 IEnumerable may be passed between threads safely. However, 
individual IEnumerator values generated from the returned IEnumerable should not be accessed from
multiple threads simultaneously.

Remember IEnumerable is lazy, effects are delayed until it is enumerated.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.combine(System.Object,System.Object)">
<summary>
A synonym for Seq.zip
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.compare(Microsoft.FSharp.Core.FastFunc,System.Object,System.Object)">
<summary>
 Compare two IEnumerable's using the given comparison function.  Both
 input IEnumerables are assumed to be in a canonical order (i.e. sorted)
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.concat(System.Object)">
<summary>
Wrap the given enumeration-of-enumerations as a single concatenated
enumeration.

The returned IEnumerable may be passed between threads safely. However, 
individual IEnumerator values generated from the returned IEnumerable should not be accessed from
multiple threads simultaneously.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.cons(System.Object,System.Object)">
<summary>
Return an IEnumerable that when iterated yields
the given item followed by the items in the given sequence
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.delay(Microsoft.FSharp.Core.FastFunc)">
<summary>
Return an IEnumerable that is built from the given delayed specification of an
IEnumerable. The input function is evaluated each time an IEnumerator for the IEnumerable 
is requested.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.do_finally(System.Object,Microsoft.FSharp.Core.FastFunc)">
<summary>
 Call the given function every time an enumerator for the returned sequence is disposed.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.empty">
<summary>
 Create an empty IEnumerable 
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.exists(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
Test if any element of the collection satisfies the given predicate.
If the elements are "i0...iN" 
then computes "p i0 or ... or p iN".
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.filter(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
Return a new collection containing only the elements of the collection
for which the given predicate returns "true"

The returned IEnumerable may be passed between threads safely. However, 
individual IEnumerator values generated from the returned IEnumerable should not be accessed from
multiple threads simultaneously.

Remember IEnumerable is lazy, effects are delayed until it is enumerated.      
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.find(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
Return the first element for which the given function returns "true".
Raise Not_found if no such element exists.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.find_index(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
Raise Not_found if no such element exists.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.find_indexi(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
Raise Not_found if no such element exists.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.first(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
Apply the given function to successive elements, returning the first
result where function returns "Some(x)" for some x.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.fold(Microsoft.FSharp.Core.FastFunc,System.Object,System.Object)">
<summary>
Apply a function to each element of the collection, threading an 'accumulator' argument
through the computation. If the elements are "i0...iN" then computes "f (... (f s i0)...) iN"
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.fold1(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
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. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.for_all(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
Test if all elements of the collection satisfy the given predicate.
If the elements are "i0...iN" 
then computes "p i0 &amp;&amp; ... &amp;&amp; p iN".
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.generate(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Core.FastFunc)">
<summary>
 Imperative generation of an IEnumerable from a cursor handle (e.g. from a file handle
 or database connection).

 A cursor is created by calling the 'open' function, which will typically
 open a file, a database connection or some other resource.

 One cursor is created each time an IEnumerator is generated for the IEnumerable, hence
 you can use this funciton to create IEnumerables for a logical structure (e.g. a file) that has
 multiple active independent readers (e.g. open file handles).  Individual elements are
 read from the file using the element generator. The element generator is executed on demand 
 as an enumeration proceeds over the IEnumerator, until a None value is returned by the element generator.

 The 'close' function is called when the None condition is reached or when the IEnumerator object
 is explicitly disposed.  The close function is called at most once per active 
 enumeration (i.e. once per IEnumerator object created for this IEnumerable). The close function 
 is not called during finalization, since the enumerator is not itself the immediate owner of
 any resources.

 Note a fresh call to 'opener' will be used and the stream will be recomputed each time 
 an IEnumerator is requested for the IEnumerable.  

 The returned IEnumerable may be passed between threads safely.  However, 
 individual IEnumerator values generated from it should not be accessed from
 multiple threads simultaneously. The 'close' function may also be called from the finalization thread.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.generate_using(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Core.FastFunc)">
<summary>
Similar to generate, except the 'close' function is implicit from the IDisposable
interface implemented by the state value

Equivalent to "generate opener generator (fun s -> s.Dispose())"
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.generated(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
 Generate a sequence by repeatedly calling the given function and
 concatenating the results (similar to a while loop)
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.hd(System.Object)">
<summary>
Return the first element of the IEnumerable.  Raise (Invalid_argument "hd") if undefined.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.init_finite(System.Int32,Microsoft.FSharp.Core.FastFunc)">
<summary>
Generate a new IEnumerable 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 IEnumerable may be passed between threads safely. However, 
individual IEnumerator values generated from the returned IEnumerable should not be accessed from
multiple threads simultaneously.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.init_infinite(Microsoft.FSharp.Core.FastFunc)">
<summary>
Generate a new IEnumerable 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 IEnumerable may be passed between threads safely. However, 
individual IEnumerator values generated from the returned IEnumerable should not be accessed from
multiple threads simultaneously.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.iter(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
Apply the given function to each element of the collection. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.iter2(Microsoft.FSharp.Core.FastFunc,System.Object,System.Object)">
<summary>
Apply the given function to two collections simultaneously. The
collections must have identical size.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.iteri(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
Apply the given function to each element of the collection. The integer passed to the
function indicates the index of element.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.length(System.Object)">
<summary>
Return the length of the IEnumerable
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.map(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
Build a new collection whose elements are the results of applying the given function
to each of the elements of the collection.  The function will be applied
as elements are demanded using the 'Current' property on iterators retrieved from the
object.  Generating multiple iterators or calling the 'Current' property multiple
times may result in the function being called multiple times.

The returned IEnumerable may be passed between threads safely. However, 
individual IEnumerator values generated from the returned IEnumerable should not be accessed from
multiple threads simultaneously.

Remember IEnumerable is lazy, effects are delayed until it is enumerated.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.map2(Microsoft.FSharp.Core.FastFunc,System.Object,System.Object)">
<summary>
Build a new collection whose elements are the results of applying the given function
to the corresponding elements of the two collections pairwise.

Remember IEnumerable is lazy, effects are delayed until it is enumerated.        
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.map_concat(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
For each element of the enumeration apply the given function and concatenate all the results.

Remember IEnumerable is lazy, effects are delayed until it is enumerated.    
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.map_to_typed(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
Transform a loosely-typed System.Collections IEnumerable
to a new collection whose elements are the results of applying the given function
to each of the elements of the collection.

The use of this function usually requires a type annotation.
An incorrect type annotation may result in runtime type
errors.

The returned IEnumerable may be passed between threads safely. However, 
individual IEnumerator values generated from the returned IEnumerable should not be accessed from
multiple threads simultaneously.

Remember IEnumerable is lazy, effects are delayed until it is enumerated.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.map_with_type(Microsoft.FSharp.Core.FastFunc,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.Seq.mapi(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
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.

Remember IEnumerable is lazy, effects are delayed until it is enumerated.            
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.nonempty(System.Object)">
<summary>
Return true if the IEnumerable is not empty.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.nth(System.Int32,System.Object)">
<summary>
Compute the nth element in the collection.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.of_array(System.Object[])">
<summary>
Build a collection from the given array
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.of_functions(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Core.FastFunc)">
<summary>
 Generate an IEnumerable based on a function that generates an arbitrarily typed enumerator,
 two functions that are effectively the same as IEnumerator.MoveNext and IEnumerator.Current
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.of_list(Microsoft.FSharp.Collections.List)">
<summary>
Build a collection from the given array
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.pairwise(System.Object)">
<summary>
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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.scan(Microsoft.FSharp.Core.FastFunc,System.Object,System.Object)">
<summary>
Like fold, but compute on-demand and return the sequence of intermediary and final results
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.scan1(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
Like fold1, but compute on-demand and return the sequence of intermediary and final results
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.singleton(System.Object)">
<summary>
Return an IEnumerable that yields one item only.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.tail_cons(System.Object,System.Object)">
<summary>
Return an IEnumerable that when iterated yields
the items in the given sequence followed by the given item
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.take(System.Int32,System.Object)">
<summary>
Return the first N elements of the IEnumerable.  Raise (Invalid_argument "take") if undefined.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.to_array(System.Object)">
<summary>
Build an array from the given collection
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.to_list(System.Object)">
<summary>
Build a list from the given collection
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.truncate(System.Int32,System.Object)">
<summary>
Return an IEnumerable that when enumerated returns at most N elements.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.tryfind(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
Return the first element for which the given function returns "true".
Return None if no such element exists.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.tryfind_index(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
Return None if no such element exists.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.tryfind_indexi(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
Return None if no such element exists.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.unfold(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
Return an IEnumerable 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 IEnumerable.

The returned IEnumerable may be passed between threads safely. However, 
individual IEnumerator values generated from the returned IEnumerable should not be accessed from
multiple threads simultaneously.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.untyped_filter(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
Return a new collection containing only the elements of the collection
for which the given predicate returns "true"

The use of this function usually requires a type annotation.
An incorrect type annotation may result in runtime type
errors.

Remember IEnumerable is lazy, effects are delayed until it is enumerated.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.untyped_fold(Microsoft.FSharp.Core.FastFunc,System.Object,System.Object)">
<summary>
Apply a function to each element of the collection, threading an 'accumulator' argument
through the computation. If the elements are "i0...iN" then computes "f (... (f s i0)...) iN"

The use of this function usually requires a type annotation.
An incorrect type annotation may result in runtime type
errors.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.untyped_iter(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
Apply the given function to each element of the collection. 

The use of this function usually requires a type annotation.
An incorrect type annotation may result in runtime type
errors.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.untyped_map(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
Build a new collection whose elements are the results of applying the given function
to each of the elements of the collection.

The use of this function usually requires a type annotation.
An incorrect type annotation may result in runtime type
errors.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.untyped_to_list(System.Object)">
<summary>
Transform a loosely-typed System.Collections IEnumerable to a strongly typed F# list.

The use of this function usually requires a type annotation.
An incorrect type annotation may result in runtime type
errors.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.untyped_to_typed(System.Object)">
<summary>
Wrap a loosely-typed System.Collections IEnumerable as a typed 
System.Collections.Generic.IEnumerable.

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 IEnumerable should not be accessed from
multiple threads simultaneously.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.using(System.Object,Microsoft.FSharp.Core.FastFunc)">
<summary>
 Use the given function to create a resource, then passs the resource
 to the second function. An instance of the resource will be created each
 time an IEnumerator for the sequence is created, and disposed when the IEnumerator 
 is disposed.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Seq.zip(System.Object,System.Object)">
<summary>
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.
</summary>
</member>
<member name="T:Microsoft.FSharp.Collections.Seq">

</member>
<member name="T:Microsoft.FSharp.Collections.Set.CSetOps`1">

</member>
<member name="T:Microsoft.FSharp.Collections.Set.CSet`1">
<summary>
 Sets with a user-defined comparison function.
</summary>
</member>
<member name="T:Microsoft.FSharp.Collections.Set.ProviderUntagged`1">

</member>
<member name="T:Microsoft.FSharp.Collections.Set.Provider`1">

</member>
<member name="T:Microsoft.FSharp.Collections.Set.Provider`2">
<summary>
A collection of operations for creating and using sets based on a particular comparison function.
The 'tag' type parameter is used to track information about the comparison function.
</summary>
</member>
<member name="T:Microsoft.FSharp.Collections.Set.Set`1">

</member>
<member name="T:Microsoft.FSharp.Collections.Set.t`1">
<summary>
 For use when not opening the Set module, e.g. Set.t
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.Make(Microsoft.FSharp.Core.FastFunc)">
<summary>
 Build a collection of operations for creating and using 
 maps based on a single consistent comparison function. This returns a record
 that contains the functions you use to create and manipulate maps all of which 
 use this comparison function.  The returned value is much like an ML module. 

 Use MakeTagged if you want additional type safety that guarantees that two sets
 based on different comparison functions can never be combined in inconsistent ways.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.MakeTagged(System.Object)">
<summary>
A functor to build a collection of operations for creating and using 
 sets based on the given comparison function. This returns a record that 
 contains the functions you use to create and manipulate maps of
 this kind.  The returned value is much like an ML module. 

 To use this function you need to define a new named class that implements IComparer and
 pass an instance of that class as the first argument. For example:
      type MyComparer() = 
          interface IComparer&lt;string&gt; with 
            member self.Compare(x,y) = ...

 let MyStringSetProvider = Set.MakeTagged(new MyComparer())
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.add(System.Object,Microsoft.FSharp.Collections.Set)">
<summary>
 Return a new set with an element added to the set.  No exception is raised if
the set already contains the given element.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.cardinal(Microsoft.FSharp.Collections.Set)">
<summary>
Return the number of elements in the set.  Same as "size"
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.choose(Microsoft.FSharp.Collections.Set)">
<summary>
Choose an arbitrary element from a set
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.compare(Microsoft.FSharp.Collections.Set,Microsoft.FSharp.Collections.Set)">
<summary>
Compare two sets. Places sets into a total order. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.diff(Microsoft.FSharp.Collections.Set,Microsoft.FSharp.Collections.Set)">
<summary>
Return a new set with the elements of the second set
removed from the first.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.elements(Microsoft.FSharp.Collections.Set)">
<summary>
The elements of the set as a list.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.empty">
<summary>
The empty set.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.equal(Microsoft.FSharp.Collections.Set,Microsoft.FSharp.Collections.Set)">
<summary>
Test if two sets are equal
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.exists(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.Set)">
<summary>
Test if any element of the collection satisfies the given predicate.
If the elements are "i0...iN" 
then computes "p i0 or ... or p iN".
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.filter(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.Set)">
<summary>
Return a new collection containing only the elements of the collection
for which the given predicate returns "true"
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.fold(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.Set,System.Object)">
<summary>
Apply the given accumulating function to all the elements of the set
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.for_all(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.Set)">
<summary>
Test if all elements of the collection satisfy the given predicate.
If the elements are "i0...iN" and "j0...jN"
then computes "p i0 &amp;&amp; ... &amp;&amp; p iN".
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.get_IEnumerator(Microsoft.FSharp.Collections.Set)">
<summary>
 Return an enumerator for performing imperative enumerations over the given
 collection.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.inter(Microsoft.FSharp.Collections.Set,Microsoft.FSharp.Collections.Set)">
<summary>
Compute the intersection of the two sets.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.is_empty(Microsoft.FSharp.Collections.Set)">
<summary>
Return "true" if the set is empty
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.iter(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.Set)">
<summary>
Apply the given function to each element of the set, in order according
to the comparison function
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.map(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.Set)">
<summary>
Return a new collection containing the results of applying the
given function to each element of the input set
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.max_elt(Microsoft.FSharp.Collections.Set)">
<summary>
Returns the highest element in the set according to the ordering being used for the set
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.mem(System.Object,Microsoft.FSharp.Collections.Set)">
<summary>
Evaluates to "true" if the given element is in the given set
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.min_elt(Microsoft.FSharp.Collections.Set)">
<summary>
Returns the lowest element in the set according to the ordering being used for the set
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.of_IEnumerable(System.Object)">
<summary>
 Build a new collection from the given enumerable object
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.of_array(System.Object[])">
<summary>
 Build a set that contains the same elements as the given array
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.of_list(Microsoft.FSharp.Collections.List)">
<summary>
 Build a set that contains the same elements as the given list
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.of_llist(Microsoft.FSharp.Collections.LazyList)">
<summary>
 Build a set that contains the same elements as the given stream. The stream must be finite.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.of_seq(System.Object)">
<summary>
 Build a new collection from the given enumerable object
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.partition(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.Set)">
<summary>
Split the set into two sets containing the elements for which the given predicate
returns true and false respectively
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.remove(System.Object,Microsoft.FSharp.Collections.Set)">
<summary>
Return a new set with the given element removed.  No exception is raised in 
the set doesn't contain the given element.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.singleton(System.Object)">
<summary>
The set containing the given one element.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.size(Microsoft.FSharp.Collections.Set)">
<summary>
Return the number of elements in the set
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.subset(Microsoft.FSharp.Collections.Set,Microsoft.FSharp.Collections.Set)">
<summary>
Evaluates to "true" if all elements of the first set are in the second
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.to_IEnumerable(Microsoft.FSharp.Collections.Set)">
<summary>
 Return a view of the collection as an enumerable object
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.to_array(Microsoft.FSharp.Collections.Set)">
<summary>
 Build an array that contains the elements of the set in order
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.to_list(Microsoft.FSharp.Collections.Set)">
<summary>
 Build a list that contains the elements of the set in order
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.to_llist(Microsoft.FSharp.Collections.Set)">
<summary>
 Build a lazy list that contains the elements of the set in order
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.to_seq(Microsoft.FSharp.Collections.Set)">
<summary>
 Return a view of the collection as an enumerable object
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Set.union(Microsoft.FSharp.Collections.Set,Microsoft.FSharp.Collections.Set)">
<summary>
Compute the union of the two sets.
</summary>
</member>
<member name="T:Microsoft.FSharp.Collections.Set">

</member>
<member name="T:Microsoft.FSharp.Collections.Tagged.HashMultiMapUntagged`2">

</member>
<member name="T:Microsoft.FSharp.Collections.Tagged.HashMultiMap`2">

</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.HashMultiMap`3.Add(System.Object,System.Object)">
<summary>
Add a binding for the element to the table
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.HashMultiMap`3.Clear">
<summary>
Clear all elements from the collection
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.HashMultiMap`3.Contains(System.Object)">
<summary>
Test if the collection contains any bindings for the given element
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.HashMultiMap`3.Copy">
<summary>
Make a shallow copy of the collection
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.HashMultiMap`3.Create(System.Object,System.Int32)">
<summary>
Create a new empty mutable hash table with an internal bucket array of the given approximate size
and with the given key hash/equality functions
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.HashMultiMap`3.Create(System.Object,Microsoft.FSharp.Collections.HashStats,System.Int32)">
<summary>
Create a new empty mutable hash table with an internal bucket array of the given approximate size
and with the given key hash/equality functions
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.HashMultiMap`3.Find(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.HashMultiMap`3.FindAll(System.Object)">
<summary>
Find all bindings for the given element in the table, if any
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.HashMultiMap`3.Fold(Microsoft.FSharp.Core.FastFunc)">
<summary>
Apply the given function to each element in the collection threading the accumulating parameter
through the sequence of function applications
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.HashMultiMap`3.GetLongestChain">
<summary>
Get the longest chain in the hash table as a list.  Use for debugging
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.HashMultiMap`3.Iterate(Microsoft.FSharp.Core.FastFunc)">
<summary>
Apply the given function to each binding in the hash table 
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.HashMultiMap`3.Remove(System.Object)">
<summary>
Remove the latest binding (if any) for the given element from the table
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.HashMultiMap`3.Replace(System.Object,System.Object)">
<summary>
Replace the latest binding (if any) for the given element.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.HashMultiMap`3.TryFind(System.Object)">
<summary>
Lookup the given element in the table, returning the result as an Option
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.Tagged.HashMultiMap`3.Count">

</member>
<member name="P:Microsoft.FSharp.Collections.Tagged.HashMultiMap`3.Item(System.Object)">
<summary>
Lookup or set the given element in the table.  Raise Not_found/IndexOutOfRangeException if the element is not found.
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.Tagged.HashMultiMap`3.Item(System.Object,System.Object)">
<summary>
Lookup or set the given element in the table.  Raise Not_found/IndexOutOfRangeException if the element is not found.
</summary>
</member>
<member name="T:Microsoft.FSharp.Collections.Tagged.HashMultiMap`3">
<summary>
 HashMultiMap, but where a constraint tag tracks information about the hash/equality functions used
 for the hashing. When the tag is Tags.StructuralHash this is identical to HashMultiMap.
</summary>
</member>
<member name="T:Microsoft.FSharp.Collections.Tagged.HashSetUntagged`1">

</member>
<member name="T:Microsoft.FSharp.Collections.Tagged.HashSet`1">
<summary>
 Mutable hash sets based on F# structural "hash" and (=) functions. Implemented via a hash table and/or Dictionary.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.HashSet`2.Add(System.Object)">
<summary>
Add an element to the collection
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.HashSet`2.Clear">
<summary>
Clear all elements from the set
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.HashSet`2.Contains(System.Object)">
<summary>
Test if the set contains the given element
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.HashSet`2.Copy">
<summary>
Make a shallow copy of the set
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.HashSet`2.Create(System.Object,System.Int32)">
<summary>
Create a new empty mutable hash set with an internal bucket array of the given approximate size
and with the given key hash/equality functions 
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.HashSet`2.Create(System.Object,Microsoft.FSharp.Collections.HashStats,System.Int32)">
<summary>
Create a new empty mutable hash set with an internal bucket array of the given approximate size
and with the given key hash/equality functions and the given HashStats collector
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.HashSet`2.Fold(Microsoft.FSharp.Core.FastFunc)">
<summary>
Apply the given function to the set threading the accumulating parameter
through the sequence of function applications
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.HashSet`2.GetLongestChain">
<summary>
 Use to debug poorly performing hash tables
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.HashSet`2.Iterate(Microsoft.FSharp.Core.FastFunc)">
<summary>
Apply the given function to each binding in the hash table 
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.HashSet`2.Remove(System.Object)">
<summary>
Remove the given element from the set
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.Tagged.HashSet`2.Count">

</member>
<member name="T:Microsoft.FSharp.Collections.Tagged.HashSet`2">
<summary>
 Mutable hash sets where a constraint tag tracks information about the hash/equality functions used
 for the hashing. When the tag is Tags.StructuralHash this is identical to HashSet.
</summary>
</member>
<member name="T:Microsoft.FSharp.Collections.Tagged.MapUntagged`2">

</member>
<member name="T:Microsoft.FSharp.Collections.Tagged.Map`2">
<summary>
Immutable maps.  Keys are ordered by construction function specified
when creating empty maps or by F# structural comparison if no
construction function is specified.

<performance> 
  Maps based on structural comparison are  
  efficient for small keys. They are not a suitable choice if keys are recursive data structures 
  or require non-structural comparison semantics.
</performance>
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Map`3.Add(System.Object,System.Object)">
<summary>
 Return a new map with the binding added to the given map.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Map`3.ContainsKey(System.Object)">
<summary>
 Test is an element is in the domain of the map
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Map`3.Create(System.Object,Microsoft.FSharp.Compatibility.IEnumerable)">
<summary>
 Build a map that contains the bindings of the given IEnumerable
 and where comparison of elements is based on the given comparison function
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Map`3.Empty(System.Object)">
<summary>
 The empty map, and use the given comparer comparison function for all operations associated
 with any maps built from this map.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Map`3.Equals(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Map`3.Exists(Microsoft.FSharp.Core.FastFunc)">
<summary>
Return true if the given predicate returns true for one of the
bindings in the map. Always returns false if the map is empty.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Map`3.Filter(Microsoft.FSharp.Core.FastFunc)">
<summary>
Build a new map containing the bindings for which the given predicate returns 'true'.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Map`3.Find(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Map`3.First(Microsoft.FSharp.Core.FastFunc)">
<summary>
 Search the map looking for the first element where the given function returns a [[Some]] value
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Map`3.Fold(Microsoft.FSharp.Core.FastFunc)">
<summary>
 Fold over the bindings in the map.  
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Map`3.FoldAndMap(Microsoft.FSharp.Core.FastFunc)">
<summary>
 Fold over the bindings in the map.  
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Map`3.FoldSection(System.Object)">
<summary>
 Given the start and end points of a key range,
 Fold over the bindings in the map that are in the range,
 and the end points are included if present (the range is considered a closed interval).
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Map`3.ForAll(Microsoft.FSharp.Core.FastFunc)">
<summary>
Return true if the given predicate returns true for all of the
bindings in the map. Always returns true if the map is empty.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Map`3.FromList(System.Object,Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Map`3.Iterate(Microsoft.FSharp.Core.FastFunc)">
<summary>
Apply the given function to each binding in the dictionary
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Map`3.Map(Microsoft.FSharp.Core.FastFunc)">
<summary>
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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Map`3.MapRange(Microsoft.FSharp.Core.FastFunc)">
<summary>
Build a new collection whose elements are the results of applying the given function
to each of the elements of the collection.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Map`3.Partition(Microsoft.FSharp.Core.FastFunc)">
<summary>
Build two new maps, one containing the bindings for which the given predicate returns 'true',
and the other the remaining bindings.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Map`3.Remove(System.Object)">
<summary>
 Remove an element from the domain of the map.  No exception is raised if the element is not present.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Map`3.ToArray">
<summary>
The elements of the set as an array
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Map`3.ToList">
<summary>
The elements of the set as a list.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Map`3.TryFind(System.Object)">
<summary>
 Lookup an element in the map, returning a [[Some]] value if the element is in the domain 
 of the map and [[None]] if not.
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.Tagged.Map`3.Count">
<summary>
 The number of bindings in the map
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.Tagged.Map`3.IsEmpty">
<summary>
 Return true if there are no bindings in the map.
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.Tagged.Map`3.Item(System.Object)">
<summary>
 Lookup an element in the map, raising [[Not_found]]/[[IndexOutOfRangeException]] if no binding
 exists in the map.
</summary>
</member>
<member name="T:Microsoft.FSharp.Collections.Tagged.Map`3">
<summary>
 Immutable maps.  A constraint tag carries information about the key-comparer 
 being used.  If 'comparerTag is Tags.StructuralComparer then 
 this type is the same as Set (the tag can be ignored).
</summary>
</member>
<member name="T:Microsoft.FSharp.Collections.Tagged.SetUntagged`1">

</member>
<member name="T:Microsoft.FSharp.Collections.Tagged.Set`1">
<summary>
 Immutable sets based on binary trees, where comparison is the
 F# structural comparison function.

 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.  

 Efficiency: Structural comparison is relatively efficient but is not a suitable
 choice in all circumstances, e.g. it may not compare efficiently on 
 non-reference types and deeply-structured types. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Set`2.Add(System.Object)">
<summary>
 A useful shortcut for Set.add.  Note this operation prodcues 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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Set`2.Compare(Microsoft.FSharp.Collections.Tagged.Set,Microsoft.FSharp.Collections.Tagged.Set)">

</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Set`2.Contains(System.Object)">
<summary>
 A useful shortcut for Set.mem.  See the Set module for further operations on sets.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Set`2.Create(System.Object,Microsoft.FSharp.Compatibility.IEnumerable)">
<summary>
 The empty set based on the given comparer
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Set`2.Difference(Microsoft.FSharp.Collections.Tagged.Set,Microsoft.FSharp.Collections.Tagged.Set)">
<summary>
Return a new set with the elements of the second set removed from the first.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Set`2.Empty(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Set`2.Equality(Microsoft.FSharp.Collections.Tagged.Set,Microsoft.FSharp.Collections.Tagged.Set)">

</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Set`2.Equals(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Set`2.Exists(Microsoft.FSharp.Core.FastFunc)">
<summary>
Test if any element of the collection satisfies the given predicate.
If the elements are "i0...iN" 
then computes "p i0 or ... or p iN".
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Set`2.Filter(Microsoft.FSharp.Core.FastFunc)">
<summary>
Return a new collection containing only the elements of the collection
for which the given predicate returns "true"
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Set`2.Fold(Microsoft.FSharp.Core.FastFunc)">
<summary>
Apply the given accumulating function to all the elements of the set
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Set`2.ForAll(Microsoft.FSharp.Core.FastFunc)">
<summary>
Test if all elements of the collection satisfy the given predicate.
If the elements are "i0...iN" and "j0...jN"
then computes "p i0 &amp;&amp; ... &amp;&amp; p iN".
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Set`2.Intersection(Microsoft.FSharp.Collections.Tagged.Set,Microsoft.FSharp.Collections.Tagged.Set)">
<summary>
Compute the intersection of the two sets.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Set`2.IsSubsetOf(Microsoft.FSharp.Collections.Tagged.Set)">
<summary>
Evaluates to "true" if all elements of the second set are in the first
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Set`2.IsSupersetOf(Microsoft.FSharp.Collections.Tagged.Set)">
<summary>
Evaluates to "true" if all elements of the first set are in the second
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Set`2.Iterate(Microsoft.FSharp.Core.FastFunc)">
<summary>
Apply the given function to each binding in the collection
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Set`2.Partition(Microsoft.FSharp.Core.FastFunc)">

</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Set`2.Remove(System.Object)">
<summary>
 A useful shortcut for Set.remove.  Note this operation prodcues 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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Set`2.Singleton(System.Object,System.Object)">
<summary>
 A singleton set based on the given comparison operator
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Set`2.ToArray">

</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Set`2.ToList">
<summary>
The elements of the set as a list.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Set`2.Union(Microsoft.FSharp.Collections.Tagged.Set,Microsoft.FSharp.Collections.Tagged.Set)">
<summary>
Compute the union of the two sets.
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.Tagged.Set`2.CheckBalanceInvariant">

</member>
<member name="P:Microsoft.FSharp.Collections.Tagged.Set`2.Choose">

</member>
<member name="P:Microsoft.FSharp.Collections.Tagged.Set`2.Count">
<summary>
 Return the number of elements in the set
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.Tagged.Set`2.IsEmpty">
<summary>
 A useful shortcut for Set.is_empty.  See the Set module for further operations on sets.
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.Tagged.Set`2.MaximumElement">
<summary>
Returns the highest element in the set according to the ordering being used for the set
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.Tagged.Set`2.MinimumElement">
<summary>
Returns the lowest element in the set according to the ordering being used for the set
</summary>
</member>
<member name="P:Microsoft.FSharp.Collections.Tagged.Set`2.Size">
<summary>
 A useful shortcut for Set.size.  See the Set module for further operations on sets.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Set`2.op_Addition(Microsoft.FSharp.Collections.Tagged.Set,Microsoft.FSharp.Collections.Tagged.Set)">
<summary>
Compute the union of the two sets.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tagged.Set`2.op_Subtraction(Microsoft.FSharp.Collections.Tagged.Set,Microsoft.FSharp.Collections.Tagged.Set)">
<summary>
Return a new set with the elements of the second set removed from the first.
</summary>
</member>
<member name="T:Microsoft.FSharp.Collections.Tagged.Set`2">
<summary>
 Immutable sets where a constraint tag carries information about the key-comparer 
 being used.  If 'comparerTag is Tags.StructuralComparer then 
 this type is the same as Set (the tag can be ignored).
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tags.ReferenceHash`1..ctor">

</member>
<member name="T:Microsoft.FSharp.Collections.Tags.ReferenceHash`1">
<summary>
 This tag indicates the collection uses physical hashing (hash on reference 
 identity of objects, and the contents of value types).  
 i.e. 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. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tags.StructuralComparer`1..ctor">

</member>
<member name="T:Microsoft.FSharp.Collections.Tags.StructuralComparer`1">
<summary>
 This tag indicates the collection uses structural comparison on keys, except where the structural comparison
 semantics has been altered for particular types through re-implementations of the IComparer interface.
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tags.StructuralHash`1..ctor">

</member>
<member name="T:Microsoft.FSharp.Collections.Tags.StructuralHash`1">
<summary>
 This tag indicates the collection uses structural hashing on keys, except where the structural hashing
 semantics has been altered through re-implementations of the IStructuralHash interface
</summary>
</member>
<member name="M:Microsoft.FSharp.Collections.Tags.Optimizations.StructuralComparerInt..ctor">

</member>
<member name="T:Microsoft.FSharp.Collections.Tags.Optimizations.StructuralComparerInt">

</member>
<member name="M:Microsoft.FSharp.Collections.Tags.Optimizations.StructuralHashInt..ctor">

</member>
<member name="T:Microsoft.FSharp.Collections.Tags.Optimizations.StructuralHashInt">

</member>
<member name="T:Microsoft.FSharp.Collections.Tags.Optimizations">

</member>
<member name="M:Microsoft.FSharp.Compatibility.IComparer`1.Compare(System.Object,System.Object)">

</member>
<member name="T:Microsoft.FSharp.Compatibility.IComparer`1">

</member>
<member name="M:Microsoft.FSharp.Compatibility.IEnumerable`1.GetEnumerator">

</member>
<member name="T:Microsoft.FSharp.Compatibility.IEnumerable`1">

</member>
<member name="P:Microsoft.FSharp.Compatibility.IEnumerator`1.Current">

</member>
<member name="T:Microsoft.FSharp.Compatibility.IEnumerator`1">

</member>
<member name="M:Microsoft.FSharp.Compatibility.IEqualityComparer`1.Equals(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Compatibility.IEqualityComparer`1.GetHashCode(System.Object)">

</member>
<member name="T:Microsoft.FSharp.Compatibility.IEqualityComparer`1">

</member>
<member name="M:Microsoft.FSharp.Compatibility.KeyValuePair`2..ctor(System.Object,System.Object)">

</member>
<member name="T:Microsoft.FSharp.Compatibility.KeyValuePair`2">

</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatArray.append(System.Object[]`1,System.Object[]`1)">
<summary>
Build a new array that contains the elements of the first array followed by the elements of the second array
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatArray.blit(System.Object[]`1,System.Int32,System.Object[]`1,System.Int32,System.Int32)">
<summary>
Read a range of elements from the first array and write them into the second.
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatArray.concat(Microsoft.FSharp.Collections.List)">
<summary>
Build a new array that contains the elements of each of the given list of arrays
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatArray.copy(System.Object[]`1)">
<summary>
Build a new array that contains the elements of the given array
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatArray.create(System.Int32,System.Object)">
<summary>
Create a new array of the given length, each entry of which holds the given element
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatArray.fill(System.Object[]`1,System.Int32,System.Int32,System.Object)">
<summary>
Fill a range of an array with the given element
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatArray.fold_left(Microsoft.FSharp.Core.FastFunc,System.Object,System.Object[]`1)">
<summary>
Apply a function to each element of the collection, threading an 'accumulator' argument
through the computation. If the elements are "i0...iN" then computes "f (... (f s i0)...) iN"
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatArray.fold_right(Microsoft.FSharp.Core.FastFunc,System.Object[]`1,System.Object)">
<summary>
Compute f (get arr n) (...(f (get arr n) s))
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatArray.get(System.Object[]`1,System.Int32)">
<summary>
Fetch the given element of the array, indexed by 0
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatArray.init(System.Int32,Microsoft.FSharp.Core.FastFunc)">
<summary>
Build a new array whose elements are f 0, ... f N
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatArray.iter(Microsoft.FSharp.Core.FastFunc,System.Object[]`1)">
<summary>
Execute the given function for each element of the given array
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatArray.iteri(Microsoft.FSharp.Core.FastFunc,System.Object[]`1)">
<summary>
Execute the given function for each element of the given array.  The integer
index indicates the index of the element.
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatArray.length(System.Object[]`1)">
<summary>
The length of the array
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatArray.make(System.Int32,System.Object)">
<summary>
Build a new array of the given length, each entry of which holds the given element.
Same as create.
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatArray.map(Microsoft.FSharp.Core.FastFunc,System.Object[]`1)">
<summary>
Build a new array whose elements are the results of applying the given function
to each of the elements of the array.
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatArray.mapi(Microsoft.FSharp.Core.FastFunc,System.Object[]`1)">
<summary>
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 funciton indicates the index of the element.
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatArray.of_array(System.Object[])">
<summary>
Build a .NET compatible array from the F# array.  Note that F# arrays and .NET
compatible arrays are only different types when using .NET 1.0 or 1.1
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatArray.of_list(Microsoft.FSharp.Collections.List)">
<summary>
Convert the given list to a .NET compatible array suitable for passing to .NET functions
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatArray.set(System.Object[]`1,System.Int32,System.Object)">
<summary>
Set the given element of the array
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatArray.sub(System.Object[]`1,System.Int32,System.Int32)">
<summary>
Build a new .NET compatible array that contains the given subrange specified by
starting index and length 
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatArray.to_array(System.Object[]`1)">
<summary>
Build an F# array from the given .NET compatible array.  Note that F# arrays and .NET
compatible arrays are only different types when using .NET 1.0 or 1.1
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatArray.to_list(System.Object[]`1)">
<summary>
Convert the given .NET compatible array to a list
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatArray.zero_create(System.Int32)">
<summary>
Create a new array filled with zero (null or default) values.  Warning: Use of this
function may result in subsequent exceptions if the elements of the array
are accessed before initialized.
</summary>
</member>
<member name="T:Microsoft.FSharp.Compatibility.CompatArray">
<summary>
 Operations to manipulate .NET-compatible arrays, only really necessary
 use when using .NET 1.x.
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatMatrix.create(System.Int32,System.Int32,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatMatrix.get(System.Object[,]`1,System.Int32,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatMatrix.init(System.Int32,System.Int32,Microsoft.FSharp.Core.FastFunc)">

</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatMatrix.iter(Microsoft.FSharp.Core.FastFunc,System.Object[,]`1)">

</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatMatrix.iteri(Microsoft.FSharp.Core.FastFunc,System.Object[,]`1)">

</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatMatrix.length1(System.Object[,]`1)">

</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatMatrix.length2(System.Object[,]`1)">

</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatMatrix.make(System.Int32,System.Int32,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatMatrix.map(Microsoft.FSharp.Core.FastFunc,System.Object[,]`1)">

</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatMatrix.mapi(Microsoft.FSharp.Core.FastFunc,System.Object[,]`1)">

</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatMatrix.set(System.Object[,]`1,System.Int32,System.Int32,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Compatibility.CompatMatrix.zero_create(System.Int32,System.Int32)">

</member>
<member name="T:Microsoft.FSharp.Compatibility.CompatMatrix">
<summary>
 Pseudo-polymorphic 2-dimensional arrays.  Only really used when working with .NET 1.x.

 For any particular 'a , the "'a[,]" type is type-compatible with 
 the corresponding C# 2-dimensional array type. The module contains
 operations to manipulate these values.  The operations may be used 
 on any version of the .NET CLR.  See the 'Advanced' section of 
 the manual for when 'Compatibility' array operations are needed to write
 code that will function on any version of the CLR.

 <example>
 See the sample fsharp/Automation/Excel for an example of passing one of
 these values to fill in the cells of an Excel spreadsheet.
 </example>
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.MATLAB.diagn(Microsoft.FSharp.Math.Vector,System.Int32)">
<summary>
 Create a matrix containing the given vector along the nth diagonal.
 The 0th index is the main diagonal, and higher indexes are further to the upper-right of the matrix.
 The element type of the matrix must have an associated instance of INumeric&lt;'a&gt; (see [[GlobalAssociations]]) (else InvalidArgumentException).
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.MATLAB.tril(Microsoft.FSharp.Math.Matrix)">
<summary>
 The lower triangular part of a matrix including the main diagonal
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.MATLAB.triln(Microsoft.FSharp.Math.Matrix,System.Int32)">
<summary>
 The lower triangular part of a matrix.  Positive offsets indicate further into upper
 upper-right triangular region.  The 0th index inculdes the main diagonal.
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.MATLAB.triu(Microsoft.FSharp.Math.Matrix)">
<summary>
 The upper triangular part of a matrix including the main diagonal
</summary>
</member>
<member name="M:Microsoft.FSharp.Compatibility.MATLAB.triun(Microsoft.FSharp.Math.Matrix,System.Int32)">
<summary>
 The upper triangular part of a matrix.  Positive offsets indicate further into upper
 upper-right triangular region.  The 0th index inculdes the main diagonal.
</summary>
</member>
<member name="T:Microsoft.FSharp.Compatibility.MATLAB">
<summary>
 Functions to make F# math-related code look a bit like MATLAB (TM) code.
</summary>
</member>
<member name="M:Microsoft.FSharp.Control.Handler`1.Invoke(System.Object,System.Object)">

</member>
<member name="T:Microsoft.FSharp.Control.Handler`1">
<summary>
 Fresh .NET-compatible events declared in F# are typically 
 values of type IHandlerEvent&lt;'a&gt;. These 
 hold event handlers of type Handler&lt;'a&gt;. 
</summary>
</member>
<member name="T:Microsoft.FSharp.Control.ICompatEvent`1">

</member>
<member name="T:Microsoft.FSharp.Control.IDelegateEvent`2">
<summary>
 .NET events are revealed to F# code as instances of the type IDelegateEvent,
 which is a subtype of the type [IEvent]. The delegate type parameter and 
 arguments are determined by the F# type checker based on information stored
 for the .NET event.

 F# code may also declare .NET events over any .NET delegate type.
 For example, DelegateEvent&lt;PaintEventHandler,PaintEventArgs&gt; 
 can be used for an event whose callbacks are of type PaintEventHandler.  The delegate
 and argument types must match.

</summary>
</member>
<member name="M:Microsoft.FSharp.Control.IEvent`1.Add(Microsoft.FSharp.Core.FastFunc)">
<summary>
 Connect a listener function to the event. The listener will
 be invoked when the event is fired.
</summary>
</member>
<member name="T:Microsoft.FSharp.Control.IEvent`1">
<summary>
 First-class listening points (i.e. objects that permit you to register a 'callback'
 activated when the event is triggered). See the module <tt>IEvent</tt>
 for functions to create events, and the type <tt>IDelegateEvent</tt>
 which extends this type.
</summary>
</member>
<member name="T:Microsoft.FSharp.Control.IHandlerEvent`1">
<summary>
 Any instance property that has type ICompatEvent will be published as a standard 
 .NET event using standard .NET delegates and metadata, and will 
 be recognized as an event by any language that supports the 
 CLI Common Language Specification. The event will accept 
 handlers of type Handler*lt;'a&gt;.
</summary>
</member>
<member name="M:Microsoft.FSharp.Control.IPrimitiveDelegateEvent`1.AddHandler(System.Object)">
<summary>
 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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Control.IPrimitiveDelegateEvent`1.RemoveHandler(System.Object)">
<summary>
 Remove a listener delegate from an event listener store
</summary>
</member>
<member name="T:Microsoft.FSharp.Control.IPrimitiveDelegateEvent`1">
<summary>
 F# gives special status to non-virtual instance member properties compatible with type IPrimitiveDelegateEvent, 
 generating approriate .NET metadata to make the member appear to other .NET languages as a
 .NET event.
</summary>
</member>
<member name="M:Microsoft.FSharp.Control.Lazy`1.Create(Microsoft.FSharp.Core.FastFunc)">
<summary>
 The module 'Lazy' contains additional values and functions related to this type.
</summary>
</member>
<member name="M:Microsoft.FSharp.Control.Lazy`1.Force">
<summary>
 Force the execution of this value and return its result. Same as Value.
</summary>
</member>
<member name="M:Microsoft.FSharp.Control.Lazy`1.SynchronizedForce">
<summary>
 Force the execution of this value and return its result, using mutual exclusion to 
 prevent other threads also computing the value.
</summary>
</member>
<member name="P:Microsoft.FSharp.Control.Lazy`1.IsDelayed">
<summary>
 The module 'Lazy' contains additional values and functions related to this type.
</summary>
</member>
<member name="P:Microsoft.FSharp.Control.Lazy`1.IsException">
<summary>
 The module 'Lazy' contains additional values and functions related to this type.
</summary>
</member>
<member name="P:Microsoft.FSharp.Control.Lazy`1.IsForced">
<summary>
 The module 'Lazy' contains additional values and functions related to this type.
</summary>
</member>
<member name="P:Microsoft.FSharp.Control.Lazy`1.Value">
<summary>
 Force the execution of this value and return its result. Same as Value.
</summary>
</member>
<member name="T:Microsoft.FSharp.Control.Lazy`1">
<summary>
 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.
</summary>
</member>
<member name="T:Microsoft.FSharp.Control.lazy`1">

</member>
<member name="T:Microsoft.FSharp.Control.UndefinedException">

</member>
<member name="M:Microsoft.FSharp.Control.IEvent.choose(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Control.IEvent.create">
<summary>
 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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Control.IEvent.create1">
<summary>
 Create an IEvent with no initial listeners and at most one active listener. Adding extra
 listeners causes subsequent listeners to be dropped. Two items are returned: 
 a function to invoke (trigger) the event, and the event that clients 
 can plug listeners into.
</summary>
</member>
<member name="M:Microsoft.FSharp.Control.IEvent.createCompat">

</member>
<member name="M:Microsoft.FSharp.Control.IEvent.create_HandlerEvent">
<summary>
 Create an event that is to be published as a standard .NET event using  .NET
 delegates and metadata, and which will be recognized as an event by 
 any language that supports the CLI Common Language Specification. Two items
 are returned: a function to invoke (trigger) the event, and the event itself.
 The event value should be published as a public instance property in order for it to be 
 published as a standard .NET event.

 When firing the event the "sender" of the event must be specified, e.g. the form
 or control firing the event. This parameter is not normally of use for F# events,
 but is used by some other .NET event consumers. The sender is passed to 
 the handler implementation as type 'object'
</summary>
</member>
<member name="M:Microsoft.FSharp.Control.IEvent.create_public">

</member>
<member name="M:Microsoft.FSharp.Control.IEvent.filter(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
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
</summary>
</member>
<member name="M:Microsoft.FSharp.Control.IEvent.fold(Microsoft.FSharp.Core.FastFunc,System.Object,System.Object)">
<summary>
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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Control.IEvent.fold_and_emit(Microsoft.FSharp.Core.FastFunc,System.Object,System.Object)">
<summary>
Return a new event consisting of the observed results of applying the given accumulating function
to successive values triggered on the input event.  The observed results are the
second items in the pairs returned.  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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Control.IEvent.listen(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
Run the given function each time the given event is triggered.
</summary>
</member>
<member name="M:Microsoft.FSharp.Control.IEvent.map(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
 Create an event that is to be published as standard .NET event using .NET
 delegates and metadata, and which will be recognized as an event by 
 any language that supports the CLI Common Language Specification. Two items
 are returned: a function to invoke (trigger) the event, and the event itself.
 The event value should be published as a public instance property in order for it to be 
 published as a standard .NET event.

 This function creates event of any .NET EventHandler type (inherited from System.Delegate)
 and will be exported as event of that type. Function used to invoke the event accepts
 arguments as a list of objects and the event is invoked dynamically. When possible
 use 'create_HandlerEvent'. 
Return a new event that passes values transformed by the given function
</summary>
</member>
<member name="M:Microsoft.FSharp.Control.IEvent.merge(System.Object,System.Object)">
<summary>
Fire the output event when either of the input events fire
</summary>
</member>
<member name="M:Microsoft.FSharp.Control.IEvent.pairwise(System.Object)">
<summary>
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.    
</summary>
</member>
<member name="M:Microsoft.FSharp.Control.IEvent.partition(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
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
</summary>
</member>
<member name="M:Microsoft.FSharp.Control.IEvent.split(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
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 Choice2_1, and the second event if it returns a Choice2_2
</summary>
</member>
<member name="T:Microsoft.FSharp.Control.IEvent">
<summary>
 Basic operations on IEvents.  
</summary>
</member>
<member name="T:Microsoft.FSharp.Control.Lazy.t`1">

</member>
<member name="M:Microsoft.FSharp.Control.Lazy.force(Microsoft.FSharp.Control.Lazy)">
<summary>
Force the computation of the given lazy value if not already forced.
Raises an exception if the computation raises (or previously raised) an exception.
Raises Undefined if executingg the computation recursively forces the
evaluation of the computation.
Concurrency: This function does not take a lock while forcing execution
</summary>
</member>
<member name="M:Microsoft.FSharp.Control.Lazy.force_val(Microsoft.FSharp.Control.Lazy)">

</member>
<member name="M:Microsoft.FSharp.Control.Lazy.force_with_lock(Microsoft.FSharp.Control.Lazy)">
<summary>
Like force, but this function uses the thunks itselfs as a lock while forcing execution
If you have multiple threads and your lazy values can be 
accessed via multiple threads then you should 
consider using force_with_lock.  If you do not the lazy computations 
may be executed multiple times, and the values produced by some of the 
computations will be discarded. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Control.Lazy.force_without_lock(Microsoft.FSharp.Control.Lazy)">
<summary>
Equivalent to force
</summary>
</member>
<member name="M:Microsoft.FSharp.Control.Lazy.lazy_from_fun(Microsoft.FSharp.Core.FastFunc)">
<summary>
Build a lazy (delayed) value from the given computation
</summary>
</member>
<member name="M:Microsoft.FSharp.Control.Lazy.lazy_from_val(System.Object)">
<summary>
Build a lazy (delayed) value from the given pre-computed value.
</summary>
</member>
<member name="M:Microsoft.FSharp.Control.Lazy.lazy_is_val(Microsoft.FSharp.Control.Lazy)">
<summary>
Check if a lazy (delayed) value has already been computed
</summary>
</member>
<member name="M:Microsoft.FSharp.Control.Lazy.|Lazy|(Microsoft.FSharp.Control.Lazy)">

</member>
<member name="T:Microsoft.FSharp.Control.Lazy.UndefinedException">

</member>
<member name="T:Microsoft.FSharp.Control.Lazy">
<summary>
 Delayed computations.
</summary>
</member>
<member name="T:Microsoft.FSharp.Control.LazyStatus.LazyStatus`1">
<summary>
 This exception is raised when a lazy or other recursively referential value
 is used during the execution of its initialization code 
 The status of a lazy computation.  A future relases of F# may hid this type and thus it should not be used
 directly.
</summary>
</member>
<member name="T:Microsoft.FSharp.Control.LazyStatus">

</member>
<member name="M:Microsoft.FSharp.Control.SharedMemory.Helpers.readLock(System.Threading.ReaderWriterLock,Microsoft.FSharp.Core.FastFunc)">

</member>
<member name="M:Microsoft.FSharp.Control.SharedMemory.Helpers.writeLock(System.Threading.ReaderWriterLock,Microsoft.FSharp.Core.FastFunc)">

</member>
<member name="T:Microsoft.FSharp.Control.SharedMemory.Helpers">

</member>
<member name="T:Microsoft.FSharp.Core.Choice`2">

</member>
<member name="T:Microsoft.FSharp.Core.Choice`3">

</member>
<member name="T:Microsoft.FSharp.Core.Choice`4">

</member>
<member name="T:Microsoft.FSharp.Core.Choice`5">

</member>
<member name="T:Microsoft.FSharp.Core.Choice`6">

</member>
<member name="T:Microsoft.FSharp.Core.Choice`7">

</member>
<member name="M:Microsoft.FSharp.Core.ClassAttribute..ctor">

</member>
<member name="T:Microsoft.FSharp.Core.ClassAttribute">
<summary>
 Adding this attribute to a type causes it to be represented using a .NET class.
 This may only be used under very limited conditions.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.CompilationMappingAttribute..ctor(Microsoft.FSharp.Core.SourceLevelConstruct)">

</member>
<member name="M:Microsoft.FSharp.Core.CompilationMappingAttribute..ctor(Microsoft.FSharp.Core.SourceLevelConstruct,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.CompilationMappingAttribute..ctor(Microsoft.FSharp.Core.SourceLevelConstruct,System.Int32,System.Int32)">

</member>
<member name="P:Microsoft.FSharp.Core.CompilationMappingAttribute.SequenceNumber">

</member>
<member name="P:Microsoft.FSharp.Core.CompilationMappingAttribute.SourceConstruct">

</member>
<member name="P:Microsoft.FSharp.Core.CompilationMappingAttribute.VariantNumber">

</member>
<member name="T:Microsoft.FSharp.Core.CompilationMappingAttribute">
<summary>
 This attribute is used to tag generated types and methods in the 
 compiled .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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.CompilationRepresentationAttribute..ctor(Microsoft.FSharp.Core.CompilationRepresentationFlags)">

</member>
<member name="P:Microsoft.FSharp.Core.CompilationRepresentationAttribute.Flags">

</member>
<member name="T:Microsoft.FSharp.Core.CompilationRepresentationAttribute">
<summary>
 This attribute is used to tag types that the 'null' representation
 may be used for the type.  This affects how some constructs are compiled.
 You may need to add this attribute to some of your types if F# indicates
 that null may be used as a valid representation for some values your type
 and you have made the type abstract in a signature. 
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.CompilationRepresentationFlags">

</member>
<member name="M:Microsoft.FSharp.Core.DefaultAugmentationAttribute..ctor(System.Boolean)">

</member>
<member name="P:Microsoft.FSharp.Core.DefaultAugmentationAttribute.v">

</member>
<member name="T:Microsoft.FSharp.Core.DefaultAugmentationAttribute">
<summary>
 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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.ExperimentalAttribute..ctor(System.String)">

</member>
<member name="P:Microsoft.FSharp.Core.ExperimentalAttribute.Message">

</member>
<member name="T:Microsoft.FSharp.Core.ExperimentalAttribute">
<summary>
 This attribute is used to tag values that are part of an experimental library
 feature
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute..ctor(System.Int32,System.Int32,System.Int32)">

</member>
<member name="P:Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute.v1">

</member>
<member name="P:Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute.v2">

</member>
<member name="P:Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute.v3">

</member>
<member name="T:Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute">
<summary>
 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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.FastFunc`2..ctor">

</member>
<member name="M:Microsoft.FSharp.Core.FastFunc`2.Invoke(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.FastFunc`2.InvokeFast2(Microsoft.FSharp.Core.FastFunc,System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.FastFunc`2.InvokeFast3(Microsoft.FSharp.Core.FastFunc,System.Object,System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.FastFunc`2.InvokeFast4(Microsoft.FSharp.Core.FastFunc,System.Object,System.Object,System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.FastFunc`2.InvokeFast5(Microsoft.FSharp.Core.FastFunc,System.Object,System.Object,System.Object,System.Object,System.Object)">

</member>
<member name="T:Microsoft.FSharp.Core.FastFunc`2">
<summary>
 The .NET type used to represent F# function values.  This type is not
 typically used directly from F# code, though may be used from other .NET languages.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.FuncConvert.ToFastFunc(System.Converter)">

</member>
<member name="T:Microsoft.FSharp.Core.FuncConvert">

</member>
<member name="P:Microsoft.FSharp.Core.IRange`1.Finish">

</member>
<member name="P:Microsoft.FSharp.Core.IRange`1.Start">

</member>
<member name="P:Microsoft.FSharp.Core.IRange`1.Step">

</member>
<member name="T:Microsoft.FSharp.Core.IRange`1">

</member>
<member name="M:Microsoft.FSharp.Core.IStructuralHash.GetStructuralHashCode(Microsoft.FSharp.Core.byref)">

</member>
<member name="T:Microsoft.FSharp.Core.IStructuralHash">
<summary>
 F# structural types such as tuples, records and discriminated unions
 support a form of cooperative structural hashing, via implementations
 of interface IStructuralHash. Implmentations of this interface are added
 to concrete types (records, discriminated unions and classes) automatically,
 though types can also define their own implementations of this interface, 
 thus altering the hashing semantics of the type.  

 The byref argument points to a count of the
 number of significant nodes remaining to be hashed in the cooperative hash.
 Substructures and leaf nodes (such as integers) should be hashed by calling 
 Microsoft.FSharp.Core.LanguagePrimitives.StructuralHashParam, but only if the hash count
 is non-zero.  If the hash count is zero StructuralHashParam must not be called.

 Structural comparison is supported via a similar scheme, using implementations
 of the System.IComparable interface.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.InterfaceAttribute..ctor">

</member>
<member name="T:Microsoft.FSharp.Core.InterfaceAttribute">
<summary>
 Adding this attribute to a type causes it to be represented using a .NET interface.
 This may only be used under very limited conditions.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.OCamlCompatibilityAttribute..ctor">

</member>
<member name="M:Microsoft.FSharp.Core.OCamlCompatibilityAttribute..ctor(System.String)">

</member>
<member name="T:Microsoft.FSharp.Core.OCamlCompatibilityAttribute">
<summary>
 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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Option`1.Some(System.Object)">
<summary>
 Create an option value that is a 'Some' value.
</summary>
</member>
<member name="P:Microsoft.FSharp.Core.Option`1.IsNone">
<summary>
 Return 'true' if the option is a 'None' value.
</summary>
</member>
<member name="P:Microsoft.FSharp.Core.Option`1.IsSome">
<summary>
 Return 'true' if the option is a 'Some' value.
</summary>
</member>
<member name="P:Microsoft.FSharp.Core.Option`1.Item">

</member>
<member name="P:Microsoft.FSharp.Core.Option`1.None">

</member>
<member name="P:Microsoft.FSharp.Core.Option`1.Value">
<summary>
 Get the value of a 'Some' option. A NullReferenceException is raised if the option is 'None'.
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.Option`1">
 <summary>
 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.
 </summary>

 <note>'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.
 </note>
</member>
<member name="M:Microsoft.FSharp.Core.OptionalArgumentAttribute..ctor">

</member>
<member name="T:Microsoft.FSharp.Core.OptionalArgumentAttribute">
<summary>
 This attribute is added automatically for all optional arguments
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.OverloadIDAttribute..ctor(System.String)">

</member>
<member name="P:Microsoft.FSharp.Core.OverloadIDAttribute.v">

</member>
<member name="T:Microsoft.FSharp.Core.OverloadIDAttribute">
<summary>
 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.
</summary>
</member>
<member name="P:Microsoft.FSharp.Core.Ref`1.Value">
<summary>
 The current value of the reference cell
</summary>
</member>
<member name="P:Microsoft.FSharp.Core.Ref`1.Value(System.Object)">
<summary>
 The current value of the reference cell
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.Ref`1">
<summary>
 The type of mutable references.  Use the functions [:=] and [!] to get and
 set values of this type.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.ReflectedDefinitionAttribute..ctor">

</member>
<member name="T:Microsoft.FSharp.Core.ReflectedDefinitionAttribute">
<summary>
 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.
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.ReifiedType`1">
<summary>
 The result of an F# typeof operation
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.SourceLevelConstruct">

</member>
<member name="M:Microsoft.FSharp.Core.StructAttribute..ctor">

</member>
<member name="T:Microsoft.FSharp.Core.StructAttribute">
<summary>
 Adding this attribute to a type causes it to be represented using a .NET struct.
 This may only be used under very limited conditions.
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.Tuple`2">
<summary>
 Compiled versions of F# tuple types.  These are not used directly from F# code, though
 these compiled forms are seen by other .NET languages.
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.Tuple`3">
<summary>
 Compiled versions of F# tuple types.  These are not used directly from F# code, though
 these compiled forms are seen by other .NET languages.
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.Tuple`4">
<summary>
 Compiled versions of F# tuple types.  These are not used directly from F# code, though
 these compiled forms are seen by other .NET languages.
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.Tuple`5">
<summary>
 Compiled versions of F# tuple types.  These are not used directly from F# code, though
 these compiled forms are seen by other .NET languages.
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.Tuple`6">
<summary>
 Compiled versions of F# tuple types.  These are not used directly from F# code, though
 these compiled forms are seen by other .NET languages.
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.Tuple`7">
<summary>
 Compiled versions of F# tuple types.  These are not used directly from F# code, though
 these compiled forms are seen by other .NET languages.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.TypeFunc..ctor">

</member>
<member name="M:Microsoft.FSharp.Core.TypeFunc.Specialize">

</member>
<member name="T:Microsoft.FSharp.Core.TypeFunc">
<summary>
 The .NET type used to represent F# first-class type function values.  This type is not
 typically used directly from F# code.
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.Unit">
<summary>
 The type 'unit', which has only one value "()".
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.UnverifiableAttribute..ctor">

</member>
<member name="T:Microsoft.FSharp.Core.UnverifiableAttribute">
<summary>
 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.
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.[,,,]`1">
<summary>
 Four dimensional arrays, typically zero-based. Non-zero-based arrays
 can be created using methods on the System.Array type.
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.[,,]`1">
<summary>
 Three dimensional arrays, typically zero-based. Non-zero-based arrays
 can be created using methods on the System.Array type.
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.[,]`1">
<summary>
 Two dimensional arrays, typically zero-based. 

 Use the values in the [[Array2]] module
 to manipulate values of this type, or the notation 'arr.[x,y]' to get/set array
 values.   When using .NET 1.x use the values in the [[CompatArray2]]
 module.

 Non-zero-based arrays can be created using methods on the System.Array type.
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.[]`1">
<summary>
 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.   When using .NET 1.x use the values in the [[CompatArray]]
 module.
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.array`1">

</member>
<member name="T:Microsoft.FSharp.Core.bigint">

</member>
<member name="T:Microsoft.FSharp.Core.bignum">

</member>
<member name="T:Microsoft.FSharp.Core.bool">

</member>
<member name="T:Microsoft.FSharp.Core.byref`1">
<summary>
 The type for by-reference, stack-allocated argument passing.  It is used
 by .NET assemblies and by the type [[IStructuralHash]] to
 pass the hash-node-count around.  Use of this type in F# code may result in
 unverifiable code being generated.
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.byte">

</member>
<member name="T:Microsoft.FSharp.Core.char">

</member>
<member name="T:Microsoft.FSharp.Core.double">

</member>
<member name="T:Microsoft.FSharp.Core.exn">

</member>
<member name="T:Microsoft.FSharp.Core.float">

</member>
<member name="T:Microsoft.FSharp.Core.float32">

</member>
<member name="T:Microsoft.FSharp.Core.ilsigptr`1">
<summary>
 This type is for internal use by the F# code generator
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.int">

</member>
<member name="T:Microsoft.FSharp.Core.int16">

</member>
<member name="T:Microsoft.FSharp.Core.int32">

</member>
<member name="T:Microsoft.FSharp.Core.int64">

</member>
<member name="T:Microsoft.FSharp.Core.int8">

</member>
<member name="T:Microsoft.FSharp.Core.matrix">
<summary>
 The type of floating-point matrices.  See Microsoft.FSharp.Math
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.nativeint">

</member>
<member name="T:Microsoft.FSharp.Core.nativeptr`1">
<summary>
 The type of machine pointers assumed to be pointing to 
 unmanaged or pinned memory containing values or an array of
 values of the given type.

 This type should only be used when writing F# code that interoperates
 with C 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.
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.obj">

</member>
<member name="T:Microsoft.FSharp.Core.option`1">

</member>
<member name="T:Microsoft.FSharp.Core.ref`1">

</member>
<member name="T:Microsoft.FSharp.Core.rowvec">
<summary>
 The type of floating-point row vectors.  See Microsoft.FSharp.Math
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.sbyte">

</member>
<member name="T:Microsoft.FSharp.Core.seq`1">

</member>
<member name="T:Microsoft.FSharp.Core.single">

</member>
<member name="T:Microsoft.FSharp.Core.string">

</member>
<member name="T:Microsoft.FSharp.Core.uint16">

</member>
<member name="T:Microsoft.FSharp.Core.uint32">

</member>
<member name="T:Microsoft.FSharp.Core.uint64">

</member>
<member name="T:Microsoft.FSharp.Core.uint8">

</member>
<member name="T:Microsoft.FSharp.Core.unativeint">

</member>
<member name="T:Microsoft.FSharp.Core.unit">

</member>
<member name="T:Microsoft.FSharp.Core.vector">
<summary>
 The type of floating-point vectors.  See Microsoft.FSharp.Math
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.AssertionFailureException">
<summary>
 'assert' is used to check conditions and raise AssertionFailure if necessary
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.FailureException">
<summary>
 This exception is precisely the same as the exception 'Failure' in F# code.
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.InvalidArgumentException">
<summary>
 This exception is precisely the same as the exception 'Invalid_argument' in F# code.
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.MatchFailureException">
<summary>
 Non-exhaustive match failures will raise Match failures
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Byte.add(System.Byte,System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.Byte.compare(System.Byte,System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.Byte.div(System.Byte,System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.Byte.logand(System.Byte,System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.Byte.lognot(System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.Byte.logor(System.Byte,System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.Byte.logxor(System.Byte,System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.Byte.mul(System.Byte,System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.Byte.of_char(System.Char)">

</member>
<member name="M:Microsoft.FSharp.Core.Byte.of_int(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Byte.of_int32(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Byte.of_string(System.String)">

</member>
<member name="M:Microsoft.FSharp.Core.Byte.of_uint16(System.UInt16)">

</member>
<member name="M:Microsoft.FSharp.Core.Byte.of_uint32(System.UInt32)">

</member>
<member name="P:Microsoft.FSharp.Core.Byte.one">

</member>
<member name="M:Microsoft.FSharp.Core.Byte.pred(System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.Byte.rem(System.Byte,System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.Byte.shift_left(System.Byte,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Byte.shift_right(System.Byte,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Byte.sub(System.Byte,System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.Byte.succ(System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.Byte.to_char(System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.Byte.to_int(System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.Byte.to_int32(System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.Byte.to_string(System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.Byte.to_uint16(System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.Byte.to_uint32(System.Byte)">

</member>
<member name="P:Microsoft.FSharp.Core.Byte.zero">

</member>
<member name="T:Microsoft.FSharp.Core.Byte">
<summary>
 Byte (8-bit) operations.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Char.chr(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Char.code(System.Char)">

</member>
<member name="M:Microsoft.FSharp.Core.Char.compare(System.Char,System.Char)">

</member>
<member name="M:Microsoft.FSharp.Core.Char.lowercase(System.Char)">

</member>
<member name="M:Microsoft.FSharp.Core.Char.uppercase(System.Char)">

</member>
<member name="T:Microsoft.FSharp.Core.Char">
<summary>
 Unicode characters, i.e. the [[System.Char]] type.  see also the operations
 in [[System.Char]] and the [[System.Text.Encoding]] interfaces if necessary.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Enum.combine(Microsoft.FSharp.Collections.List)">
<summary>
Combine enum values using 'logical or'. The relevant enumeration type is inferred from context.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Enum.of_int(System.Int32)">
<summary>
Convert an integer to an enumeration value.  The result type is inferred from context.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Enum.test(System.Object,System.Object)">
<summary>
Test if an enumeration value has a particular flag set, using 'logical and'. 
The relevant enumeration type is inferred from context.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Enum.to_int(System.Object)">
<summary>
Convert an enumeration value to an integer.  The argument type is inferred from context.
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.Enum">
<summary>
 Simple operations to convert between .NET enuemration types and integers
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Float.add(System.Double,System.Double)">

</member>
<member name="M:Microsoft.FSharp.Core.Float.compare(System.Double,System.Double)">

</member>
<member name="M:Microsoft.FSharp.Core.Float.div(System.Double,System.Double)">

</member>
<member name="M:Microsoft.FSharp.Core.Float.mul(System.Double,System.Double)">

</member>
<member name="M:Microsoft.FSharp.Core.Float.neg(System.Double)">

</member>
<member name="M:Microsoft.FSharp.Core.Float.of_bits(System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Core.Float.of_float32(System.Single)">

</member>
<member name="M:Microsoft.FSharp.Core.Float.of_int(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Float.of_int32(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Float.of_int64(System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Core.Float.of_string(System.String)">

</member>
<member name="M:Microsoft.FSharp.Core.Float.sub(System.Double,System.Double)">

</member>
<member name="M:Microsoft.FSharp.Core.Float.to_bits(System.Double)">

</member>
<member name="M:Microsoft.FSharp.Core.Float.to_float32(System.Double)">

</member>
<member name="M:Microsoft.FSharp.Core.Float.to_int(System.Double)">

</member>
<member name="M:Microsoft.FSharp.Core.Float.to_int32(System.Double)">

</member>
<member name="M:Microsoft.FSharp.Core.Float.to_int64(System.Double)">

</member>
<member name="M:Microsoft.FSharp.Core.Float.to_string(System.Double)">

</member>
<member name="T:Microsoft.FSharp.Core.Float">
<summary>
 ML-like operations on 64-bit System.Double floating point numbers.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Float32.add(System.Single,System.Single)">

</member>
<member name="M:Microsoft.FSharp.Core.Float32.compare(System.Single,System.Single)">

</member>
<member name="M:Microsoft.FSharp.Core.Float32.div(System.Single,System.Single)">

</member>
<member name="M:Microsoft.FSharp.Core.Float32.mul(System.Single,System.Single)">

</member>
<member name="M:Microsoft.FSharp.Core.Float32.neg(System.Single)">

</member>
<member name="M:Microsoft.FSharp.Core.Float32.of_bits(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Float32.of_float(System.Double)">

</member>
<member name="M:Microsoft.FSharp.Core.Float32.of_int(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Float32.of_int32(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Float32.of_int64(System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Core.Float32.of_string(System.String)">

</member>
<member name="M:Microsoft.FSharp.Core.Float32.sub(System.Single,System.Single)">

</member>
<member name="M:Microsoft.FSharp.Core.Float32.to_bits(System.Single)">

</member>
<member name="M:Microsoft.FSharp.Core.Float32.to_float(System.Single)">

</member>
<member name="M:Microsoft.FSharp.Core.Float32.to_int(System.Single)">

</member>
<member name="M:Microsoft.FSharp.Core.Float32.to_int32(System.Single)">

</member>
<member name="M:Microsoft.FSharp.Core.Float32.to_int64(System.Single)">

</member>
<member name="M:Microsoft.FSharp.Core.Float32.to_string(System.Single)">

</member>
<member name="T:Microsoft.FSharp.Core.Float32">
<summary>
 ML-like operations on 32-bit System.Single floating point numbers.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Func.apply(Microsoft.FSharp.Core.FastFunc,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Func.compose(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Core.FastFunc)">

</member>
<member name="M:Microsoft.FSharp.Core.Func.foldUntil(Microsoft.FSharp.Core.FastFunc,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Func.repeatN(System.Int32,Microsoft.FSharp.Core.FastFunc,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Func.repeatUntil(Microsoft.FSharp.Core.FastFunc)">

</member>
<member name="T:Microsoft.FSharp.Core.Func">

</member>
<member name="M:Microsoft.FSharp.Core.Int16.abs(System.Int16)">

</member>
<member name="M:Microsoft.FSharp.Core.Int16.add(System.Int16,System.Int16)">

</member>
<member name="M:Microsoft.FSharp.Core.Int16.compare(System.Int16,System.Int16)">

</member>
<member name="M:Microsoft.FSharp.Core.Int16.div(System.Int16,System.Int16)">

</member>
<member name="M:Microsoft.FSharp.Core.Int16.logand(System.Int16,System.Int16)">

</member>
<member name="M:Microsoft.FSharp.Core.Int16.lognot(System.Int16)">

</member>
<member name="M:Microsoft.FSharp.Core.Int16.logor(System.Int16,System.Int16)">

</member>
<member name="M:Microsoft.FSharp.Core.Int16.logxor(System.Int16,System.Int16)">

</member>
<member name="P:Microsoft.FSharp.Core.Int16.max_int">

</member>
<member name="P:Microsoft.FSharp.Core.Int16.min_int">

</member>
<member name="P:Microsoft.FSharp.Core.Int16.minus_one">

</member>
<member name="M:Microsoft.FSharp.Core.Int16.mul(System.Int16,System.Int16)">

</member>
<member name="M:Microsoft.FSharp.Core.Int16.neg(System.Int16)">

</member>
<member name="M:Microsoft.FSharp.Core.Int16.of_int(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int16.of_int32(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int16.of_int8(System.SByte)">

</member>
<member name="P:Microsoft.FSharp.Core.Int16.one">

</member>
<member name="M:Microsoft.FSharp.Core.Int16.pred(System.Int16)">

</member>
<member name="M:Microsoft.FSharp.Core.Int16.rem(System.Int16,System.Int16)">

</member>
<member name="M:Microsoft.FSharp.Core.Int16.shift_left(System.Int16,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int16.shift_right(System.Int16,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int16.sub(System.Int16,System.Int16)">

</member>
<member name="M:Microsoft.FSharp.Core.Int16.succ(System.Int16)">

</member>
<member name="M:Microsoft.FSharp.Core.Int16.to_int(System.Int16)">

</member>
<member name="M:Microsoft.FSharp.Core.Int16.to_int32(System.Int16)">

</member>
<member name="M:Microsoft.FSharp.Core.Int16.to_int8(System.Int16)">

</member>
<member name="P:Microsoft.FSharp.Core.Int16.zero">

</member>
<member name="T:Microsoft.FSharp.Core.Int16">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.abs(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.add(System.Int32,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.bits_of_float(System.Double)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.bits_of_float32(System.Single)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.compare(System.Int32,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.div(System.Int32,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.float32_of_bits(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.float_of_bits(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.logand(System.Int32,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.lognot(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.logor(System.Int32,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.logxor(System.Int32,System.Int32)">

</member>
<member name="P:Microsoft.FSharp.Core.Int32.max_int">

</member>
<member name="P:Microsoft.FSharp.Core.Int32.min_int">

</member>
<member name="P:Microsoft.FSharp.Core.Int32.minus_one">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.mul(System.Int32,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.neg(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.of_float(System.Double)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.of_float32(System.Single)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.of_int(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.of_int64(System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.of_nativeint(System.IntPtr)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.of_string(System.String)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.of_uint32(System.UInt32)">

</member>
<member name="P:Microsoft.FSharp.Core.Int32.one">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.pred(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.rem(System.Int32,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.shift_left(System.Int32,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.shift_right(System.Int32,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.shift_right_logical(System.Int32,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.sub(System.Int32,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.succ(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.to_float(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.to_float32(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.to_int(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.to_int64(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.to_nativeint(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.to_string(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int32.to_uint32(System.Int32)">

</member>
<member name="P:Microsoft.FSharp.Core.Int32.zero">

</member>
<member name="T:Microsoft.FSharp.Core.Int32">
<summary>
 Basic operations on 32-bit integers. The type int32 is identical to [[System.Int64]]. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Int64.abs(System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.add(System.Int64,System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.bits_of_float(System.Double)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.compare(System.Int64,System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.div(System.Int64,System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.float_of_bits(System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.logand(System.Int64,System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.lognot(System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.logor(System.Int64,System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.logxor(System.Int64,System.Int64)">

</member>
<member name="P:Microsoft.FSharp.Core.Int64.max_int">

</member>
<member name="P:Microsoft.FSharp.Core.Int64.min_int">

</member>
<member name="P:Microsoft.FSharp.Core.Int64.minus_one">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.mul(System.Int64,System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.neg(System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.of_float(System.Double)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.of_float32(System.Single)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.of_int(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.of_int32(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.of_nativeint(System.IntPtr)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.of_string(System.String)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.of_uint64(System.UInt64)">

</member>
<member name="P:Microsoft.FSharp.Core.Int64.one">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.pred(System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.rem(System.Int64,System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.shift_left(System.Int64,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.shift_right(System.Int64,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.shift_right_logical(System.Int64,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.sub(System.Int64,System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.succ(System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.to_float(System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.to_float32(System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.to_int(System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.to_int32(System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.to_nativeint(System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.to_string(System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Core.Int64.to_uint64(System.Int64)">

</member>
<member name="P:Microsoft.FSharp.Core.Int64.zero">

</member>
<member name="T:Microsoft.FSharp.Core.Int64">
<summary>
 Basic operations on 64-bit integers. The type int64 is identical to [[System.Int64]]. 
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.Int8.int8">

</member>
<member name="M:Microsoft.FSharp.Core.Int8.abs(System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.Int8.add(System.SByte,System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.Int8.compare(System.SByte,System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.Int8.div(System.SByte,System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.Int8.logand(System.SByte,System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.Int8.lognot(System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.Int8.logor(System.SByte,System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.Int8.logxor(System.SByte,System.SByte)">

</member>
<member name="P:Microsoft.FSharp.Core.Int8.max_int">

</member>
<member name="P:Microsoft.FSharp.Core.Int8.min_int">

</member>
<member name="P:Microsoft.FSharp.Core.Int8.minus_one">

</member>
<member name="M:Microsoft.FSharp.Core.Int8.mul(System.SByte,System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.Int8.neg(System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.Int8.of_byte(System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.Int8.of_int(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int8.of_int16(System.Int16)">

</member>
<member name="M:Microsoft.FSharp.Core.Int8.of_int32(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int8.of_uint8(System.Byte)">

</member>
<member name="P:Microsoft.FSharp.Core.Int8.one">

</member>
<member name="M:Microsoft.FSharp.Core.Int8.pred(System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.Int8.rem(System.SByte,System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.Int8.shift_left(System.SByte,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int8.shift_right(System.SByte,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Int8.sub(System.SByte,System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.Int8.succ(System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.Int8.to_byte(System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.Int8.to_int(System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.Int8.to_int16(System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.Int8.to_int32(System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.Int8.to_uint8(System.SByte)">

</member>
<member name="P:Microsoft.FSharp.Core.Int8.zero">

</member>
<member name="T:Microsoft.FSharp.Core.Int8">
<summary>
 Simple operations on signed bytes
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.ArrayGet(System.Object[],System.Int32)">
<summary>
 Primitive used by pattern match compilation 
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.CreateInstance">
<summary>
 This function implements calls to default constructors
 acccessed by 'new' constraints.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.PhysicalEquality(System.Object,System.Object)">
<summary>
Reference/physical equality. 
True if boxed versions of the inputs are reference-equal, OR if
both are value types and the implementation of Object.Equals for the type
of the first argument returns true on the boxed versions of the inputs.  
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.PhysicalHash(System.Object)">
<summary>
 The physical hash.  Hashes on the object identity, except for value types,
 where we hash on the contents.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.StructuralComparison(System.Object,System.Object)">
<summary>
 Compare two values structurally
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.StructuralEquality(System.Object,System.Object)">
<summary>
 Compare two values for structural equality
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.StructuralGreaterThan(System.Object,System.Object)">
<summary>
 Compare two values structurally.  
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.StructuralGreaterThanOrEqual(System.Object,System.Object)">
<summary>
 Compare two values structurally.  
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.StructuralHash(System.Object)">
<summary>
 See the IStructuralHash interface.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.StructuralHashParam(System.Object,Microsoft.FSharp.Core.byref)">
<summary>
 Hash a value according to its structure.  See the IStructuralHash interface.
 Implementations of IStructuralHash for aggregate structured data structures
 should call this function to hash sub-structures.

 The byref argument points to a count of the
 number of significant nodes remaining to be hashed in the cooperative hash.
 Substructures and leaf nodes (such as integers) should be hashed by calling 
 Microsoft.FSharp.Core.LanguagePrimitives.StructuralHashParam, but only if the hash count
 is non-zero.  If the hash count is zero StructuralHashParam must not be called.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.StructuralInequality(System.Object,System.Object)">
<summary>
 Compare two values for structural in-equality
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.StructuralLessThan(System.Object,System.Object)">
<summary>
 Compare two values structurally.  
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.StructuralLessThanOrEqual(System.Object,System.Object)">
<summary>
 Compare two values structurally.  
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.StructuralMaximum(System.Object,System.Object)">
<summary>
 Take the maximum of two values structurally according to the order given by StructuralComparison
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.StructuralMinimum(System.Object,System.Object)">
<summary>
 Take the minimum of two values structurally according to the order given by StructuralComparison
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.op_Amp(System.Boolean,System.Boolean)">
<summary>
 Binary 'and'.  When used as a binary operator the right hand value is evaluated only on demand
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.op_AmpAmp(System.Boolean,System.Boolean)">
<summary>
 Binary 'and'.  When used as a binary operator the right hand value is evaluated only on demand
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.op_BarBar(System.Boolean,System.Boolean)">
<summary>
 Binary 'or'.  When used as a binary operator the right hand value is evaluated only on demand
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.op_TwiddleAmp(System.Object)">
<summary>
 Address-of. Uses of this value may result in the generation of unverifiable code.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.op_TwiddleAmpAmp(System.Object)">
<summary>
 Address-of. Uses of this value may result in the generation of unverifiable code.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.op_UnaryNegation(System.Object)">
<summary>
 Overloaded unary negation.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.or(System.Boolean,System.Boolean)">
<summary>
 Binary 'or'.  When used as a binary operator the right hand value is evaluated only on demand
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.HashCompare.PhysicalEqualityGeneric(System.Object,System.Object)">
<summary>
 A primitive entry point used by the F# compiler for optimization purposes. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.HashCompare.PhysicalHashGeneric(System.Object)">
<summary>
 A primitive entry point used by the F# compiler for optimization purposes. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.HashCompare.StructuralComparisonGeneric(System.Object,System.Object)">
<summary>
 A primitive entry point used by the F# compiler for optimization purposes. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.HashCompare.StructuralEqualityGeneric(System.Object,System.Object)">
<summary>
 A primitive entry point used by the F# compiler for optimization purposes. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.HashCompare.StructuralGreaterThanGeneric(System.Object,System.Object)">
<summary>
 A primitive entry point used by the F# compiler for optimization purposes. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.HashCompare.StructuralGreaterThanOrEqualGeneric(System.Object,System.Object)">
<summary>
 A primitive entry point used by the F# compiler for optimization purposes. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.HashCompare.StructuralHashParamGeneric(System.Object,Microsoft.FSharp.Core.byref)">
<summary>
 A primitive entry point used by the F# compiler for optimization purposes. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.HashCompare.StructuralLessThanGeneric(System.Object,System.Object)">
<summary>
 A primitive entry point used by the F# compiler for optimization purposes. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.LanguagePrimitives.HashCompare.StructuralLessThanOrEqualGeneric(System.Object,System.Object)">
<summary>
 A primitive entry point used by the F# compiler for optimization purposes. 
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.LanguagePrimitives.HashCompare">

</member>
<member name="T:Microsoft.FSharp.Core.LanguagePrimitives">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.GetSlice(System.Object,Microsoft.FSharp.Core.Option,Microsoft.FSharp.Core.Option)">
<summary>
 The standard overloaded 1D-slice operator, generally used on strings, arrays and vectors. 
 The source collection type must support a GetSlice member. The resulting collection type must support 
 an Item property index.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.GetSlice2D(System.Object,Microsoft.FSharp.Core.Option,Microsoft.FSharp.Core.Option,Microsoft.FSharp.Core.Option,Microsoft.FSharp.Core.Option)">
<summary>
 The standard overloaded 2D-slice operator
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.abs(System.Object)">
<summary>
Absolute value of the given integer
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.acos(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.asin(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.atan(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.atan2(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.box(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.byte(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.ceil(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.compare(System.Object,System.Object)">
<summary>
Generic comparison
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.cos(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.cosh(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.defaultArg(Microsoft.FSharp.Core.Option,System.Object)">
<summary>
 Used to specify a default value for an optional argument in the implementation of a function
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.double(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.exp(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.failwith(System.String)">
<summary>
 Throw a 'FailureException' exception
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.float(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.float32(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.floor(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.fst(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.hash(System.Object)">
<summary>
The "hash" function is a structural hash function.  It is 
designed to return equal hash values for items that are 
equal according to the polymorphic equality 
function Pervasives.(=) (i.e. the standard "=" operator). The exact
behaviour of the function can be adjusted on a type-by-type
basis by implementing the IStructuralHash interface for each type.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.hashq(System.Object)">
<summary>
The "hashq" function is designed to return equal hash values
for reference types that are equal according 
to the physical equality '==' (see also Obj.eq). For .NET value types
the implementation of Object.GetHashCode is used on a boxed version of
the input.  For efficiency reasons this should not typically
be used on .NET value types.  
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.ignore(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.int(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.int16(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.int32(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.int64(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.invalid_arg(System.String)">
<summary>
 Throw an 'InvalidArgumentException' exception
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.invalid_op(System.String)">
<summary>
 Throw an 'InvalidOperationException' exception
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.lock(System.Object,Microsoft.FSharp.Core.FastFunc)">
<summary>
 Execute the function as a mutual-exlcusion region using the input value as a lock. Use as:
   lock (x) (fun () -> ...)
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.log(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.log10(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.max(System.Object,System.Object)">
<summary>
Maximum based on generic comparison
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.min(System.Object,System.Object)">
<summary>
Minimum based on generic comparison
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.nativeint(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.not(System.Boolean)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.not_found">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_Addition">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_AdditionAssignment(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_ArrayAssign(System.Object[],System.Int32,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_ArrayAssign2(System.Object[,]`1,System.Int32,System.Int32,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_ArrayAssign3(System.Object[,,]`1,System.Int32,System.Int32,System.Int32,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_ArrayLookup(System.Object[],System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_ArrayLookup2(System.Object[,]`1,System.Int32,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_ArrayLookup3(System.Object[,,]`1,System.Int32,System.Int32,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_BitwiseAnd(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_BitwiseOr(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_ColonEquals(Microsoft.FSharp.Core.Ref,System.Object)">
<summary>
Assign to a mutable reference cell
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_ComposeLeft(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Core.FastFunc)">
<summary>
 Compose two functions, the function on the right being applied first
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_ComposeRight(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Core.FastFunc)">
<summary>
 Compose two functions, the function on the left being applied first
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_Dereference(Microsoft.FSharp.Core.Ref)">
<summary>
Dereference a mutable reference cell
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_Division">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_DivisionAssignment(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_DollarMultiply(System.Object,System.Object)">
<summary>
Associate other operator values with their corresponding
 The left-oriented scalar multiplication operator, when the scalar is on the left side.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_DollarMultiplyDollar(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_DotDivide(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_DotDivideEquals(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_DotHat(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_DotHatEquals(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_DotMultiply(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_DotMultiplyEquals(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_DotPercent(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_DotPercentEquals(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_DotPlus(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_DotPlusEquals(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_Equals(System.Object,System.Object)">
<summary>
Structural equality
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_ExclusiveOr(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_GreaterThan(System.Object,System.Object)">
<summary>
Structural greater-than
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_GreaterThanOrEqual(System.Object,System.Object)">
<summary>
Structural greater-than-or-equal
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_IndexedAssign(System.Object,System.Object,System.Object)">
<summary>
 The standard overloaded associative (indexed) mutation operator
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_IndexedAssign2(System.Object,System.Object,System.Object,System.Object)">
<summary>
 The standard overloaded associative (2-indexed) mutation operator
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_IndexedAssign3(System.Object,System.Object,System.Object,System.Object,System.Object)">
<summary>
 The standard overloaded associative (3-indexed) mutation operator
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_IndexedLookup(System.Object,System.Object)">
<summary>
 The standard overloaded associative (indexed) lookup operator
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_IndexedLookup2(System.Object,System.Object,System.Object)">
<summary>
 The standard overloaded associative (2-indexed) lookup operator
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_IndexedLookup3(System.Object,System.Object,System.Object,System.Object)">
<summary>
 The standard overloaded associative (3-indexed) lookup operator
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_LeftShift(System.Object,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_LessGreater(System.Object,System.Object)">
<summary>
Structural inequality
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_LessThan(System.Object,System.Object)">
<summary>
Structural less-than comparison
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_LessThanOrEqual(System.Object,System.Object)">
<summary>
Structural less-than-or-equal comparison
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_LogicalNot(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_Modulus(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_Multiply">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_MultiplyAssignment(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_MultiplyDollar(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_MultiplyDollarEquals(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_MultiplyMultiply(System.Object,System.Object)">
<summary>
 Overloaded power operator.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_MultiplyPercent(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_MultiplyPercentEquals(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_OverloadedLogicalRightShift(System.Object,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_PercentMultiply(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_PercentMultiplyEquals(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_PercentMultiplyPercent(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_PipeLeft(Microsoft.FSharp.Core.FastFunc,System.Object)">
<summary>
 Apply a function to a value, the value being on the right, the function on the left
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_PipeRight(System.Object,Microsoft.FSharp.Core.FastFunc)">
<summary>
 Apply a function to a value, the value being on the left, the function on the right
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_Range(System.Object,System.Object)">
<summary>
 The standard overloaded range operator, e.g. '[n..m]' for lists, '{n..m}' for sequences
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_RangeStep(System.Object,System.Object,System.Object)">
<summary>
 The standard overloaded skip range operator, e.g. '[n..m]' for lists, '{n..m}' for sequences
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_RightShift(System.Object,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_Subtraction">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_SubtractionAssignment(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.op_UnaryPlus(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.raise(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.ref(System.Object)">
<summary>
Create a mutable reference cell
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.rethrow">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.sbyte(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.sin(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.single(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.sinh(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.sizeof">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.snd(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.sqrt(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.tan(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.tanh(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.typeof">
<summary>
 Generate a 'typ' value containing a System.Type runtime represenation of an F# type.
 The static type is still maintained on the value returned.

 The syntax '(type ...)' can now be used as a replacement for the 
 use of this operator when a System.Type object is required.
 Note parentheses are required when using '(type ...)'.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.uint16(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.uint32(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.uint64(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.unativeint(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.unbox(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.using(System.Object,Microsoft.FSharp.Core.FastFunc)">
<summary>
 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. Use as:
   using (myResource) (fun () -> ... )
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.Checked.byte(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.Checked.int(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.Checked.int16(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.Checked.int32(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.Checked.int64(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.Checked.nativeint(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.Checked.op_Addition">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.Checked.op_Multiply">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.Checked.op_Subtraction">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.Checked.sbyte(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.Checked.uint16(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.Checked.uint32(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.Checked.uint64(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.Checked.unativeint(System.Object)">

</member>
<member name="T:Microsoft.FSharp.Core.Operators.Checked">

</member>
<member name="M:Microsoft.FSharp.Core.Operators.StandardRanges.byte(System.Byte,System.Byte,System.Byte)">
<summary>
 Generate a range of byte values
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.StandardRanges.char(System.Char,System.Char)">
<summary>
 Generate a range of char values
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.StandardRanges.float(System.Double,System.Double,System.Double)">
<summary>
 Generate a range of float values
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.StandardRanges.float32(System.Single,System.Single,System.Single)">
<summary>
 Generate a range of float32 values
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.StandardRanges.generate(System.Object,Microsoft.FSharp.Core.FastFunc,System.Object,System.Object,System.Object)">
<summary>
 Generate a range of values using the given zero, add, start, step and stop values
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.StandardRanges.int(System.Int32,System.Int32,System.Int32)">
<summary>
 Generate a range of integers  
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.StandardRanges.int16(System.Int16,System.Int16,System.Int16)">
<summary>
 Generate a range of int16 values
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.StandardRanges.int64(System.Int64,System.Int64,System.Int64)">
<summary>
 Generate a range of int64 values
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.StandardRanges.nativeint(System.IntPtr,System.IntPtr,System.IntPtr)">
<summary>
 Generate a range of nativeint values
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.StandardRanges.sbyte(System.SByte,System.SByte,System.SByte)">
<summary>
 Generate a range of sbyte values
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.StandardRanges.uint16(System.UInt16,System.UInt16,System.UInt16)">
<summary>
 Generate a range of uint16 values
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.StandardRanges.uint32(System.UInt32,System.UInt32,System.UInt32)">
<summary>
 Generate a range of uint32 values
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.StandardRanges.uint64(System.UInt64,System.UInt64,System.UInt64)">
<summary>
 Generate a range of uint64 values
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Operators.StandardRanges.unativeint(System.UIntPtr,System.UIntPtr,System.UIntPtr)">
<summary>
 Generate a range of unativeint values
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.Operators.StandardRanges">

</member>
<member name="T:Microsoft.FSharp.Core.Operators">

</member>
<member name="M:Microsoft.FSharp.Core.OptimizedClosures.FastFunc2`3..ctor">

</member>
<member name="M:Microsoft.FSharp.Core.OptimizedClosures.FastFunc2`3.Invoke(System.Object,System.Object)">

</member>
<member name="T:Microsoft.FSharp.Core.OptimizedClosures.FastFunc2`3">
<summary>
 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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.OptimizedClosures.FastFunc3`4..ctor">

</member>
<member name="M:Microsoft.FSharp.Core.OptimizedClosures.FastFunc3`4.Invoke(System.Object,System.Object,System.Object)">

</member>
<member name="T:Microsoft.FSharp.Core.OptimizedClosures.FastFunc3`4">
<summary>
 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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.OptimizedClosures.FastFunc4`5..ctor">

</member>
<member name="M:Microsoft.FSharp.Core.OptimizedClosures.FastFunc4`5.Invoke(System.Object,System.Object,System.Object,System.Object)">

</member>
<member name="T:Microsoft.FSharp.Core.OptimizedClosures.FastFunc4`5">
<summary>
 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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.OptimizedClosures.FastFunc5`6..ctor">

</member>
<member name="M:Microsoft.FSharp.Core.OptimizedClosures.FastFunc5`6.Invoke(System.Object,System.Object,System.Object,System.Object,System.Object)">

</member>
<member name="T:Microsoft.FSharp.Core.OptimizedClosures.FastFunc5`6">
<summary>
 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.
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.OptimizedClosures">
<summary>
 An implementation module used to hold some private implementations of function
 value invocation.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Option.bind(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Core.Option)">
<summary>
"bind f inp" evaluates to "match inp with None -> None | Some x -> f x"
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Option.exists(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Core.Option)">
<summary>
"exists p inp" evaluates to "match inp with None -> false | Some x -> p x"
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Option.filter(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Core.Option)">
<summary>
"filter p inp" evaluates to "match inp with None -> None | Some x -> if p x then inp else None"
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Option.fold_left(Microsoft.FSharp.Core.FastFunc,System.Object,Microsoft.FSharp.Core.Option)">
<summary>
"fold_left f s inp " evaluates to "match inp with None -> s | Some x -> f s x"
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Option.fold_right(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Core.Option,System.Object)">
<summary>
"fold_right f inp s" evaluates to "match inp with None -> s | Some x -> f x s"
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Option.for_all(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Core.Option)">
<summary>
"forall p inp" evaluates to "match inp with None -> true | Some x -> p x"
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Option.get(Microsoft.FSharp.Core.Option)">
<summary>
Gets the value associated with the option.  If the option is None then
raises Invalid_argument "Option.get"
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Option.is_none(Microsoft.FSharp.Core.Option)">
<summary>
Returns true if the option is None
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Option.is_some(Microsoft.FSharp.Core.Option)">
<summary>
Returns true if the option is not None
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Option.iter(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Core.Option)">
<summary>
"iter f inp" executes "match inp with None -> () | Some x -> f x"
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Option.length(Microsoft.FSharp.Core.Option)">
<summary>
"length inp" evaluates to "match inp with None -> 0 | Some _ -> 1"
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Option.map(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Core.Option)">
<summary>
"map f inp" evaluates to "match inp with None -> None | Some x -> Some (f x)"
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Option.partition(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Core.Option)">
<summary>
"partition p inp" evaluates to 
"match inp with None -> None,None | Some x -> if p x then inp,None else None,inp"
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Option.to_array(Microsoft.FSharp.Core.Option)">
<summary>
Convert the option to an array of length 0 or 1
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Option.to_list(Microsoft.FSharp.Core.Option)">
<summary>
Convert the option to a list of length 0 or 1
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.Option">
<summary>
 Basic operations on options.  
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.Pervasives.FormatOptions">
<summary>
 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.

 <example>
 From F# Interactive the default settings can be adjusted using, for example, 
 <pre>
   open Microsoft.FSharp.Compiler.Interactive.Settings;;
   setPrintWidth 120;;
 </pre>
 </example>
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.any_to_layout(Microsoft.FSharp.Text.StructuredFormat.FormatOptions,System.Object)">
<summary>
 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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.any_to_string(System.Object)">
<summary>
 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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.complex(System.Double,System.Double)">

</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.decr(Microsoft.FSharp.Core.Ref)">
<summary>
Decrement a mutable reference cell containing an integer
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.eprintf(Microsoft.FSharp.Text.Format)">
<summary>
Print to stderr using the given format
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.eprintfn(Microsoft.FSharp.Text.Format)">
<summary>
Print to stderr using the given format, and add a newline
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.exit(System.Int32)">
<summary>
Exit the current hardware isolated process, if security settings permit,
otherwise raise an exception.  Calls System.Environment.Exit.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.failwithf(Microsoft.FSharp.Text.Format)">
<summary>
 Print to a string buffer and raise an exception with the given
 result.   Helper printers must return strings.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.fprintf(System.IO.TextWriter,Microsoft.FSharp.Text.Format)">
<summary>
Print to a file using the given format
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.fprintfn(System.IO.TextWriter,Microsoft.FSharp.Text.Format)">
<summary>
Print to a file using the given format, and add a newline
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.incr(Microsoft.FSharp.Core.Ref)">
<summary>
Increment a mutable reference cell containing an integer
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.layout_as_string(Microsoft.FSharp.Text.StructuredFormat.FormatOptions,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.layout_to_string(Microsoft.FSharp.Text.StructuredFormat.FormatOptions,Microsoft.FSharp.Text.StructuredFormat.Layout)">

</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.matrix(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.op_Append(Microsoft.FSharp.Collections.List,Microsoft.FSharp.Collections.List)">
<summary>
 Concatenate two lists.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.op_Concatenate(System.String,System.String)">
<summary>
 Concatenate two strings.  The overlaoded operator '+' may also be used.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.output_any(System.Object,System.Object)">
<summary>
 Ouput any value to a channel using the same set of formatting rules
 as any_to_string
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.output_layout(Microsoft.FSharp.Text.StructuredFormat.FormatOptions,System.Object,Microsoft.FSharp.Text.StructuredFormat.Layout)">

</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.prerr_any(System.Object)">
<summary>
Print any value to stderr using any_to_string. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.print_any(System.Object)">
<summary>
Print any value to stdin using any_to_string. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.printf(Microsoft.FSharp.Text.Format)">
<summary>
Print to stdout using the given format
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.printfn(Microsoft.FSharp.Text.Format)">
<summary>
Print to stdout using the given format, and add a newline
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.rowvec(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.set(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.sprintf(Microsoft.FSharp.Text.Format)">
<summary>
Print to a string using the given format
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.squash_layout(Microsoft.FSharp.Text.StructuredFormat.FormatOptions,Microsoft.FSharp.Text.StructuredFormat.Layout)">

</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.truncate(System.Double)">

</member>
<member name="M:Microsoft.FSharp.Core.Pervasives.vector(System.Object)">

</member>
<member name="T:Microsoft.FSharp.Core.Pervasives">
<summary>
Pervasives: Additional bindings available at the top level 
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.SByte.abs(System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.SByte.add(System.SByte,System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.SByte.compare(System.SByte,System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.SByte.div(System.SByte,System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.SByte.logand(System.SByte,System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.SByte.lognot(System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.SByte.logor(System.SByte,System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.SByte.logxor(System.SByte,System.SByte)">

</member>
<member name="P:Microsoft.FSharp.Core.SByte.max_int">

</member>
<member name="P:Microsoft.FSharp.Core.SByte.min_int">

</member>
<member name="P:Microsoft.FSharp.Core.SByte.minus_one">

</member>
<member name="M:Microsoft.FSharp.Core.SByte.mul(System.SByte,System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.SByte.neg(System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.SByte.of_byte(System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.SByte.of_int(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.SByte.of_int16(System.Int16)">

</member>
<member name="M:Microsoft.FSharp.Core.SByte.of_int32(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.SByte.of_uint8(System.Byte)">

</member>
<member name="P:Microsoft.FSharp.Core.SByte.one">

</member>
<member name="M:Microsoft.FSharp.Core.SByte.pred(System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.SByte.rem(System.SByte,System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.SByte.shift_left(System.SByte,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.SByte.shift_right(System.SByte,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.SByte.sub(System.SByte,System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.SByte.succ(System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.SByte.to_byte(System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.SByte.to_int(System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.SByte.to_int16(System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.SByte.to_int32(System.SByte)">

</member>
<member name="M:Microsoft.FSharp.Core.SByte.to_uint8(System.SByte)">

</member>
<member name="P:Microsoft.FSharp.Core.SByte.zero">

</member>
<member name="T:Microsoft.FSharp.Core.SByte">
<summary>
 Simple operations on signed bytes
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.String.capitalize(System.String)">
<summary>
 Return a string with the first character converted to uppercase.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.String.compare(System.String,System.String)">
<summary>
 Compare the given strings using ordinal comparison
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.String.concat(System.String,Microsoft.FSharp.Collections.List)">
<summary>
 Return a new string made by concatenating the given strings
 with separator 'sep', i.e. 'a1 + sep + ... + sep + aN'
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.String.contains(System.String,System.Char)">
<summary>
 Return true is the given string contains the given character
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.String.contains_between(System.String,System.Int32,System.Int32,System.Char)">
<summary>
 Return true is the given string contains the given character in the
 range specified by the given start index and the given length
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.String.contains_from(System.String,System.Int32,System.Char)">
<summary>
 Return true is the given string contains the given character in the
 range from the given start index to the end of the string.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.String.exists(Microsoft.FSharp.Core.FastFunc,System.String)">
<summary>
Test if any character of the string satisfies the given predicate.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.String.for_all(Microsoft.FSharp.Core.FastFunc,System.String)">
<summary>
Test if all characters in the string satisfy the given predicate.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.String.get(System.String,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.String.index(System.String,System.Char)">
<summary>
 Return the first index of the given character in the
 string.  Raise IndexOutOfRangeException (Not_found) if
 the string does not contain the given character.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.String.index_from(System.String,System.Int32,System.Char)">
<summary>
 Return the first index of the given character in the
 range from the given start position to the end of the string.  
 Raise IndexOutOfRangeException (Not_found) if
 the string does not contain the given character.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.String.iter(Microsoft.FSharp.Core.FastFunc,System.String)">
<summary>
Apply the given function to each character in the string
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.String.length(System.String)">
<summary>
 Return the length of the string.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.String.lowercase(System.String)">
<summary>
 Return a new string with all characters converted to lowercase
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.String.make(System.Int32,System.Char)">
<summary>
 Return a string of the given length containing repetitions of the given character
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.String.map(Microsoft.FSharp.Core.FastFunc,System.String)">
<summary>
Build a new string whose characters are the results of applying the given function
to each of the characters of the input string.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.String.map_concat(Microsoft.FSharp.Core.FastFunc,System.String)">
<summary>
Build a new string whose characters are the results of applying the given function
to each of the characters of the input string and concatenating the resulting
strings.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.String.of_char(System.Char)">
<summary>
 Return s string of length 1 contianing the given character
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.String.rcontains_from(System.String,System.Int32,System.Char)">
<summary>
 Return true if the string contains the given character prior to the given index
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.String.rindex(System.String,System.Char)">
<summary>
 Return the index of the first occurrence of the given character 
 from the end of the string proceeding backwards
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.String.rindex_from(System.String,System.Int32,System.Char)">
<summary>
 Return the index of the first occurrence of the given character 
 starting from the given index proceeding backwards.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.String.sub(System.String,System.Int32,System.Int32)">
<summary>
 Return a substring of length 'length' starting index 'start'.
 Raise IndexOutOfRangeException (Not_found) if the start index
 is out of range or start+length is greatere than the length of the string
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.String.uncapitalize(System.String)">
<summary>
 Return a string with the first character converted to lowercase.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.String.uppercase(System.String)">
<summary>
 Return a string with all characters converted to uppercase.
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.String">
<summary>
 Compatibility module for ML string processing.  Richer string operations
 are available via the member functions on strings and other functionality in
  <a href="http://msdn2.microsoft.com/en-us/library/system.string.aspx">System.String</a> 
 and <a href="http://msdn2.microsoft.com/library/system.text.regularexpressions.aspx">System.Text.RegularExpressions</a> types.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.UInt16.add(System.UInt16,System.UInt16)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt16.compare(System.UInt16,System.UInt16)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt16.div(System.UInt16,System.UInt16)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt16.logand(System.UInt16,System.UInt16)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt16.lognot(System.UInt16)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt16.logor(System.UInt16,System.UInt16)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt16.logxor(System.UInt16,System.UInt16)">

</member>
<member name="P:Microsoft.FSharp.Core.UInt16.max_int">

</member>
<member name="P:Microsoft.FSharp.Core.UInt16.min_int">

</member>
<member name="M:Microsoft.FSharp.Core.UInt16.mul(System.UInt16,System.UInt16)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt16.of_int(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt16.of_int16(System.Int16)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt16.of_int32(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt16.of_uint32(System.UInt32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt16.of_uint8(System.Byte)">

</member>
<member name="P:Microsoft.FSharp.Core.UInt16.one">

</member>
<member name="M:Microsoft.FSharp.Core.UInt16.pred(System.UInt16)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt16.rem(System.UInt16,System.UInt16)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt16.shift_left(System.UInt16,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt16.shift_right(System.UInt16,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt16.sub(System.UInt16,System.UInt16)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt16.succ(System.UInt16)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt16.to_int(System.UInt16)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt16.to_int16(System.UInt16)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt16.to_int32(System.UInt16)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt16.to_uint32(System.UInt16)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt16.to_uint8(System.UInt16)">

</member>
<member name="P:Microsoft.FSharp.Core.UInt16.zero">

</member>
<member name="T:Microsoft.FSharp.Core.UInt16">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.add(System.UInt32,System.UInt32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.bits_of_float(System.Double)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.bits_of_float32(System.Single)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.compare(System.UInt32,System.UInt32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.div(System.UInt32,System.UInt32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.float32_of_bits(System.UInt32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.float_of_bits(System.UInt32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.logand(System.UInt32,System.UInt32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.lognot(System.UInt32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.logor(System.UInt32,System.UInt32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.logxor(System.UInt32,System.UInt32)">

</member>
<member name="P:Microsoft.FSharp.Core.UInt32.max_int">

</member>
<member name="P:Microsoft.FSharp.Core.UInt32.min_int">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.mul(System.UInt32,System.UInt32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.of_float(System.Double)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.of_float32(System.Single)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.of_int(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.of_int32(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.of_string(System.String)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.of_uint64(System.UInt64)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.of_unativeint(System.UIntPtr)">

</member>
<member name="P:Microsoft.FSharp.Core.UInt32.one">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.pred(System.UInt32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.rem(System.UInt32,System.UInt32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.shift_left(System.UInt32,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.shift_right(System.UInt32,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.sub(System.UInt32,System.UInt32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.succ(System.UInt32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.to_float(System.UInt32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.to_float32(System.UInt32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.to_int(System.UInt32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.to_int32(System.UInt32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.to_string(System.UInt32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.to_uint64(System.UInt32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt32.to_unativeint(System.UInt32)">

</member>
<member name="P:Microsoft.FSharp.Core.UInt32.zero">

</member>
<member name="T:Microsoft.FSharp.Core.UInt32">
<summary>
 UInt32: ML-like operations on 32-bit System.UInt32 numbers.
</summary>
</member>
<member name="M:Microsoft.FSharp.Core.UInt64.add(System.UInt64,System.UInt64)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.bits_of_float(System.Double)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.compare(System.UInt64,System.UInt64)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.div(System.UInt64,System.UInt64)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.float_of_bits(System.UInt64)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.logand(System.UInt64,System.UInt64)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.lognot(System.UInt64)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.logor(System.UInt64,System.UInt64)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.logxor(System.UInt64,System.UInt64)">

</member>
<member name="P:Microsoft.FSharp.Core.UInt64.max_int">

</member>
<member name="P:Microsoft.FSharp.Core.UInt64.min_int">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.mul(System.UInt64,System.UInt64)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.of_float(System.Double)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.of_float32(System.Single)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.of_int(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.of_int64(System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.of_string(System.String)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.of_uint32(System.UInt32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.of_unativeint(System.UIntPtr)">

</member>
<member name="P:Microsoft.FSharp.Core.UInt64.one">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.pred(System.UInt64)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.rem(System.UInt64,System.UInt64)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.shift_left(System.UInt64,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.shift_right(System.UInt64,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.sub(System.UInt64,System.UInt64)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.succ(System.UInt64)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.to_float(System.UInt64)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.to_float32(System.UInt64)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.to_int(System.UInt64)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.to_int64(System.UInt64)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.to_string(System.UInt64)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.to_uint32(System.UInt64)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt64.to_unativeint(System.UInt64)">

</member>
<member name="P:Microsoft.FSharp.Core.UInt64.zero">

</member>
<member name="T:Microsoft.FSharp.Core.UInt64">
<summary>
 UInt64: basic operations on 64-bit System.UInt64 numbers.
</summary>
</member>
<member name="T:Microsoft.FSharp.Core.UInt8.uint8">

</member>
<member name="M:Microsoft.FSharp.Core.UInt8.add(System.Byte,System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt8.compare(System.Byte,System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt8.div(System.Byte,System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt8.logand(System.Byte,System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt8.lognot(System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt8.logor(System.Byte,System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt8.logxor(System.Byte,System.Byte)">

</member>
<member name="P:Microsoft.FSharp.Core.UInt8.max_int">

</member>
<member name="P:Microsoft.FSharp.Core.UInt8.min_int">

</member>
<member name="M:Microsoft.FSharp.Core.UInt8.mul(System.Byte,System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt8.of_byte(System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt8.of_int(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt8.of_int32(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt8.of_uint16(System.UInt16)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt8.of_uint32(System.UInt32)">

</member>
<member name="P:Microsoft.FSharp.Core.UInt8.one">

</member>
<member name="M:Microsoft.FSharp.Core.UInt8.pred(System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt8.rem(System.Byte,System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt8.shift_left(System.Byte,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt8.shift_right(System.Byte,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt8.sub(System.Byte,System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt8.succ(System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt8.to_byte(System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt8.to_int(System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt8.to_int32(System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt8.to_uint16(System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Core.UInt8.to_uint32(System.Byte)">

</member>
<member name="P:Microsoft.FSharp.Core.UInt8.zero">

</member>
<member name="T:Microsoft.FSharp.Core.UInt8">
<summary>
 Simple operations on unsigned bytes
</summary>
</member>
<member name="M:Microsoft.FSharp.Idioms.EventListeners`1..ctor">
<summary>
 Build a new store of listeneres for an event
</summary>
</member>
<member name="M:Microsoft.FSharp.Idioms.EventListeners`1.Fire(System.Object)">
<summary>
 Fire the event associated with this EventListeners store
</summary>
</member>
<member name="P:Microsoft.FSharp.Idioms.EventListeners`1.Event">
<summary>
 Return the IEvent object that mediates access to this store.
</summary>
</member>
<member name="T:Microsoft.FSharp.Idioms.EventListeners`1">

</member>
<member name="T:Microsoft.FSharp.Idioms.Handler`1">
<summary>
 Fresh events declared in F# are typically values of type Idioms.ICompatEvent&lt;'a&gt;. These 
 hold event handlers of type Idioms.Handler&lt;'a&gt;. 
</summary>
</member>
<member name="T:Microsoft.FSharp.Idioms.IDelegateEvent`2">
<summary>
 See Microsoft.FSharp.IDelegateEvent
</summary>
</member>
<member name="T:Microsoft.FSharp.Idioms.IEvent`1">
<summary>
 See Microsoft.FSharp.Control.IEvent
</summary>
</member>
<member name="T:Microsoft.FSharp.Idioms.IHandlerEvent`1">

</member>
<member name="T:Microsoft.FSharp.Idioms.sizeof`1">

</member>
<member name="T:Microsoft.FSharp.Idioms.typ`1">

</member>
<member name="M:Microsoft.FSharp.Idioms.CombineEnumFlags(Microsoft.FSharp.Collections.List)">
<summary>
Combine enum values using 'logical or'. The relevant enumeration type is inferred from context.
</summary>
</member>
<member name="M:Microsoft.FSharp.Idioms.EnumToInt(System.Object)">
<summary>
Convert an enumeration value to an integer. The argument type is inferred from context.
</summary>
</member>
<member name="M:Microsoft.FSharp.Idioms.IntToEnum(System.Int32)">
<summary>
Convert an integer to an enumeration value. The result type is inferred from context.
</summary>
</member>
<member name="M:Microsoft.FSharp.Idioms.ParamArray(Microsoft.FSharp.Collections.List)">
<summary>
 Use when calling a method from another .NET language that expects a variable number of
 arguments.
</summary>
</member>
<member name="M:Microsoft.FSharp.Idioms.TestEnumFlag(System.Object,System.Object)">
<summary>
Test if an enumeration value has a particular flag set, using 'logical and'. 
The relevant enumeration type is inferred from context.
</summary>
</member>
<member name="M:Microsoft.FSharp.Idioms.box(System.Object)">
<summary>
Convert a value to the univeral representation type 'obj',
where the argument type is inferred from context.
</summary>
</member>
<member name="M:Microsoft.FSharp.Idioms.foreach(System.Object,Microsoft.FSharp.Core.FastFunc)">
<summary>
 This idiom corresponds to the C# "foreach" construct.
 Use as: 'foreach (collection) (fun (x:expectedType) -&gt; ...)'.
 Try using 'Idioms.foreachG' before using this function, as that
 detects if the collection supports a typesafe IEnumerable&lt;T&gt;.
 If any element of the heterogeneous collection does not
 have the given type then a runtime error will be raised.
 Not all F# collection types directly implement the required interfaces,
 hence you may need to call a projection function such as 'CollectionType.to_IEnumerable'.
</summary>
</member>
<member name="M:Microsoft.FSharp.Idioms.lock(System.Object,Microsoft.FSharp.Core.FastFunc)">
<summary>
 The idiom corresponding to the C# "lock(x) { ... }"  construct. Use as:
   lock (x) (fun () -> ...)
</summary>
</member>
<member name="M:Microsoft.FSharp.Idioms.sizeof">
<summary>
Return a sizeof value containing an integer representing the runtime allocated size of handles to values of
a given F# type. Most F# types will have a handle size of 1 native machine word.
</summary>
</member>
<member name="M:Microsoft.FSharp.Idioms.typeof">
<summary>
 Generate a 'typ' value containing a System.Type runtime represenation of an F# type.
 The static type is still maintained on the value returned.

 The syntax '(type ...)' can now be used as a replacement for the 
 use of this operator when a System.Type object is required.
 This operator may be marked 'deprecated' in a suture release of F#.
 Note parentheses are currently required when using '(type ...)'.
</summary>
</member>
<member name="M:Microsoft.FSharp.Idioms.unbox(System.Object)">
<summary>
Convert a value from the univeral representation type 'obj' to another type,
where the result type is inferred from context.
</summary>
</member>
<member name="M:Microsoft.FSharp.Idioms.using(System.Object,Microsoft.FSharp.Core.FastFunc)">
<summary>
 The idiom corresponding to the C# "using" construct, which uses
 the IDisposable interface to dispose of a native
 resource even when an exception is raised by the protected
 code. Use as:
   using (myResource) (fun () -> ... )
</summary>
</member>
<member name="T:Microsoft.FSharp.Idioms">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.Equals(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.GetHashCode">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.op_Addition(Microsoft.FSharp.Math.BigInt,Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.op_Division(Microsoft.FSharp.Math.BigInt,Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.op_Multiply(Microsoft.FSharp.Math.BigInt,Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.op_Range(Microsoft.FSharp.Math.BigInt,Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.op_RangeStep(Microsoft.FSharp.Math.BigInt,Microsoft.FSharp.Math.BigInt,Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.op_Subtraction(Microsoft.FSharp.Math.BigInt,Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.op_UnaryNegation(Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.op_UnaryPlus(Microsoft.FSharp.Math.BigInt)">

</member>
<member name="T:Microsoft.FSharp.Math.BigInt">
<summary>
 The type of arbitrary-sized integers
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.BigNum.GetHashCode">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.ToString">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.op_Addition(Microsoft.FSharp.Math.BigNum,Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.op_Division(Microsoft.FSharp.Math.BigNum,Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.op_Multiply(Microsoft.FSharp.Math.BigNum,Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.op_Range(Microsoft.FSharp.Math.BigNum,Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.op_RangeStep(Microsoft.FSharp.Math.BigNum,Microsoft.FSharp.Math.BigNum,Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.op_Subtraction(Microsoft.FSharp.Math.BigNum,Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.op_UnaryNegation(Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.op_UnaryPlus(Microsoft.FSharp.Math.BigNum)">

</member>
<member name="T:Microsoft.FSharp.Math.BigNum">
<summary>
 The type of arbitrary-sized rational numbers
</summary>
</member>
<member name="T:Microsoft.FSharp.Math.BigRational">

</member>
<member name="M:Microsoft.FSharp.Math.Complex.Abs(Microsoft.FSharp.Math.Complex)">

</member>
<member name="M:Microsoft.FSharp.Math.Complex.Cos(Microsoft.FSharp.Math.Complex)">

</member>
<member name="M:Microsoft.FSharp.Math.Complex.Create(System.Double,System.Double)">
<summary>
 Create a complex number x+ij using rectangular coordinates
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.CreatePolar(System.Double,System.Double)">
<summary>
 Create a complex number using magnitude/phase polar coordinates
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.Exp(Microsoft.FSharp.Math.Complex)">

</member>
<member name="M:Microsoft.FSharp.Math.Complex.Log(Microsoft.FSharp.Math.Complex)">

</member>
<member name="M:Microsoft.FSharp.Math.Complex.Sin(Microsoft.FSharp.Math.Complex)">

</member>
<member name="M:Microsoft.FSharp.Math.Complex.Sqrt(Microsoft.FSharp.Math.Complex)">

</member>
<member name="M:Microsoft.FSharp.Math.Complex.Tan(Microsoft.FSharp.Math.Complex)">

</member>
<member name="P:Microsoft.FSharp.Math.Complex.Conjugate">
<summary>
 The conjugate of a complex number, i.e. x-yi
</summary>
</member>
<member name="P:Microsoft.FSharp.Math.Complex.ImaginaryPart">
<summary>
 The imaginary part of a complex number
</summary>
</member>
<member name="P:Microsoft.FSharp.Math.Complex.Magnitude">
<summary>
 The polar-coordinate magnitude of a complex number
</summary>
</member>
<member name="P:Microsoft.FSharp.Math.Complex.One">
<summary>
 The complex number 1+0i
</summary>
</member>
<member name="P:Microsoft.FSharp.Math.Complex.OneI">
<summary>
 The complex number 0+1i
</summary>
</member>
<member name="P:Microsoft.FSharp.Math.Complex.Phase">
<summary>
 The polar-coordinate phase of a complex number
</summary>
</member>
<member name="P:Microsoft.FSharp.Math.Complex.RealPart">
<summary>
 The real part of a complex number
</summary>
</member>
<member name="P:Microsoft.FSharp.Math.Complex.Zero">
<summary>
 The complex number 0+0i
</summary>
</member>
<member name="P:Microsoft.FSharp.Math.Complex.i">
<summary>
 The imaginary part of a complex number
</summary>
</member>
<member name="P:Microsoft.FSharp.Math.Complex.r">
<summary>
 The real part of a complex number
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.op_Addition(Microsoft.FSharp.Math.Complex,Microsoft.FSharp.Math.Complex)">
<summary>
 Add two complex numbers
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.op_Division(Microsoft.FSharp.Math.Complex,Microsoft.FSharp.Math.Complex)">
<summary>
 Complex division of two complex numbers
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.op_DollarMultiply(System.Double,Microsoft.FSharp.Math.Complex)">
<summary>
 Multiply a scalar by a complex number 
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.op_Multiply(Microsoft.FSharp.Math.Complex,Microsoft.FSharp.Math.Complex)">
<summary>
 Multiply two complex numbers
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.op_MultiplyDollar(Microsoft.FSharp.Math.Complex,System.Double)">
<summary>
 Multiply a complex number by a scalar
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.op_Subtraction(Microsoft.FSharp.Math.Complex,Microsoft.FSharp.Math.Complex)">
<summary>
 Subtract one complex number from another
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.op_UnaryNegation(Microsoft.FSharp.Math.Complex)">
<summary>
 Unary negation of a complex number
</summary>
</member>
<member name="T:Microsoft.FSharp.Math.Complex">
<summary>
 The type of complex numbers stored as pairs of 64-bit floating point numbers in rectangular coordinates
</summary>
</member>
<member name="T:Microsoft.FSharp.Math.DenseMatrix`1">
 <summary>
 The type of matrices.  The arithmetic operations on the element type are determined by inspection on the element type itself
 </summary>
</member>
<member name="M:Microsoft.FSharp.Math.IFloating`1.Acos(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.IFloating`1.Asin(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.IFloating`1.Atan(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.IFloating`1.Atan2(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.IFloating`1.Cos(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.IFloating`1.Cosh(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.IFloating`1.Exp(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.IFloating`1.Log(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.IFloating`1.LogN(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.IFloating`1.Sin(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.IFloating`1.Sinh(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.IFloating`1.Sqrt(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.IFloating`1.Tan(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.IFloating`1.Tanh(System.Object)">

</member>
<member name="P:Microsoft.FSharp.Math.IFloating`1.Pi">

</member>
<member name="T:Microsoft.FSharp.Math.IFloating`1">

</member>
<member name="M:Microsoft.FSharp.Math.IFractional`1.Divide(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.IFractional`1.Reciprocal(System.Object)">

</member>
<member name="T:Microsoft.FSharp.Math.IFractional`1">

</member>
<member name="M:Microsoft.FSharp.Math.IIEEE`1.IsInfinite(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.IIEEE`1.IsNaN(System.Object)">

</member>
<member name="P:Microsoft.FSharp.Math.IIEEE`1.Epsilon">

</member>
<member name="P:Microsoft.FSharp.Math.IIEEE`1.NaN">

</member>
<member name="P:Microsoft.FSharp.Math.IIEEE`1.NegativeInfinity">

</member>
<member name="P:Microsoft.FSharp.Math.IIEEE`1.PositiveInfinity">

</member>
<member name="T:Microsoft.FSharp.Math.IIEEE`1">

</member>
<member name="M:Microsoft.FSharp.Math.IIntegral`1.DivMod(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.IIntegral`1.Divide(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.IIntegral`1.Modulus(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.IIntegral`1.OfBigInt(Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.IIntegral`1.ToBigInt(System.Object)">

</member>
<member name="T:Microsoft.FSharp.Math.IIntegral`1">

</member>
<member name="M:Microsoft.FSharp.Math.INumeric`1.Abs(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.INumeric`1.Add(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.INumeric`1.Multiply(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.INumeric`1.Negate(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.INumeric`1.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)">

</member>
<member name="M:Microsoft.FSharp.Math.INumeric`1.Sign(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.INumeric`1.Subtract(System.Object,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.INumeric`1.ToString(System.Object,System.String,System.IFormatProvider)">

</member>
<member name="P:Microsoft.FSharp.Math.INumeric`1.One">

</member>
<member name="P:Microsoft.FSharp.Math.INumeric`1.Zero">

</member>
<member name="T:Microsoft.FSharp.Math.INumeric`1">

</member>
<member name="M:Microsoft.FSharp.Math.Matrix`1.Equals(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.Matrix`1.GetHashCode">

</member>
<member name="M:Microsoft.FSharp.Math.Matrix`1.GetSlice2D(Microsoft.FSharp.Core.Option,Microsoft.FSharp.Core.Option,Microsoft.FSharp.Core.Option,Microsoft.FSharp.Core.Option)">

</member>
<member name="P:Microsoft.FSharp.Math.Matrix`1.Dimensions">
<summary>
 The number of (rows,columns) in the matrix
</summary>
</member>
<member name="P:Microsoft.FSharp.Math.Matrix`1.ElementOps">
<summary>
 Retrieve the dictionary of numeric operations associated with the element
 type of this matrix.  Accessing the property may raise an NotSupportedException if the element
 type doesn't support any numeric operations.  The object returned
 may support additional numeric operations such as IFractional: 
 this can be determined by a dynamic type test against the object
 returned.
</summary>
</member>
<member name="P:Microsoft.FSharp.Math.Matrix`1.Item(System.Int32,System.Int32)">
<summary>
 Get the item at the given position in the matrix
</summary>
</member>
<member name="P:Microsoft.FSharp.Math.Matrix`1.NumCols">
<summary>
 The number of columns in the matrix
</summary>
</member>
<member name="P:Microsoft.FSharp.Math.Matrix`1.NumRows">
<summary>
 The number of rows in the matrix
</summary>
</member>
<member name="P:Microsoft.FSharp.Math.Matrix`1.Transpose">
<summary>
 Get the transpose of the matrix
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix`1.op_Addition(Microsoft.FSharp.Math.Matrix,Microsoft.FSharp.Math.Matrix)">
<summary>
 Point-wise addition of two matrices.  An InvalidArgument exception will be
 raised if the dimensions do not match.
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix`1.op_AdditionAssignment(Microsoft.FSharp.Math.Matrix,Microsoft.FSharp.Math.Matrix)">
<summary>
 Inplace matrix addition. An InvalidArgument exception will be
 raised if the dimensions do not match. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix`1.op_DollarMultiply(System.Object,Microsoft.FSharp.Math.Matrix)">
<summary>
 Multiply each element of a matrix by the given scalar value
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix`1.op_DotMultiply(Microsoft.FSharp.Math.Matrix,Microsoft.FSharp.Math.Matrix)">
<summary>
 Pointwise matrix multiplication.   An InvalidArgument exception will be
 raised if the dimensions do not match.
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix`1.op_DotMultiplyEquals(Microsoft.FSharp.Math.Matrix,Microsoft.FSharp.Math.Matrix)">
<summary>
 Inplace pointwise matrix multiplication. An InvalidArgument exception will be
 raised if the dimensions do not match.
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix`1.op_Multiply(Microsoft.FSharp.Math.Matrix,Microsoft.FSharp.Math.Matrix)">
<summary>
 Matrix multiplication.   An InvalidArgument exception will be
 raised if the dimensions do not match.
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix`1.op_Multiply(Microsoft.FSharp.Math.Matrix,Microsoft.FSharp.Math.Vector)">
<summary>
 Matrix-vector multiplication.   
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix`1.op_MultiplyDollar(Microsoft.FSharp.Math.Matrix,System.Object)">
<summary>
 Multiply each element of a matrix by the given scalar value
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix`1.op_Subtraction(Microsoft.FSharp.Math.Matrix,Microsoft.FSharp.Math.Matrix)">
<summary>
 Point-wise subtraction of two matrices. An InvalidArgument exception will be
 raised if the dimensions do not match.
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix`1.op_SubtractionAssignment(Microsoft.FSharp.Math.Matrix,Microsoft.FSharp.Math.Matrix)">
<summary>
 Inplace matrix subtraction. An InvalidArgument exception will be
 raised if the dimensions do not match.
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix`1.op_UnaryNegation(Microsoft.FSharp.Math.Matrix)">
<summary>
 Matrix negation.   
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix`1.op_UnaryPlus(Microsoft.FSharp.Math.Matrix)">
<summary>
 A nop.
</summary>
</member>
<member name="P:Microsoft.FSharp.Math.Matrix`1.Item(System.Int32,System.Int32,System.Object)">
<summary>
 Get the item at the given position in the matrix
</summary>
</member>
<member name="T:Microsoft.FSharp.Math.Matrix`1">
 <summary>
 The type of matrices.  The arithmetic operations on the element type are determined by inspection on the element type itself
 </summary>
</member>
<member name="M:Microsoft.FSharp.Math.RowVector`1.Equals(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.RowVector`1.GetHashCode">

</member>
<member name="M:Microsoft.FSharp.Math.RowVector`1.GetSlice(Microsoft.FSharp.Core.Option,Microsoft.FSharp.Core.Option)">

</member>
<member name="P:Microsoft.FSharp.Math.RowVector`1.ElementOps">

</member>
<member name="P:Microsoft.FSharp.Math.RowVector`1.Item(System.Int32)">

</member>
<member name="P:Microsoft.FSharp.Math.RowVector`1.Length">

</member>
<member name="P:Microsoft.FSharp.Math.RowVector`1.NumCols">

</member>
<member name="P:Microsoft.FSharp.Math.RowVector`1.Transpose">

</member>
<member name="M:Microsoft.FSharp.Math.RowVector`1.op_Addition(Microsoft.FSharp.Math.RowVector,Microsoft.FSharp.Math.RowVector)">

</member>
<member name="M:Microsoft.FSharp.Math.RowVector`1.op_AdditionAssignment(Microsoft.FSharp.Math.RowVector,Microsoft.FSharp.Math.RowVector)">

</member>
<member name="M:Microsoft.FSharp.Math.RowVector`1.op_DollarMultiply(System.Object,Microsoft.FSharp.Math.RowVector)">

</member>
<member name="M:Microsoft.FSharp.Math.RowVector`1.op_DotMultiply(Microsoft.FSharp.Math.RowVector,Microsoft.FSharp.Math.RowVector)">

</member>
<member name="M:Microsoft.FSharp.Math.RowVector`1.op_DotMultiplyEquals(Microsoft.FSharp.Math.RowVector,Microsoft.FSharp.Math.RowVector)">

</member>
<member name="M:Microsoft.FSharp.Math.RowVector`1.op_Multiply(Microsoft.FSharp.Math.RowVector,Microsoft.FSharp.Math.Vector)">

</member>
<member name="M:Microsoft.FSharp.Math.RowVector`1.op_Multiply(Microsoft.FSharp.Math.RowVector,Microsoft.FSharp.Math.Matrix)">

</member>
<member name="M:Microsoft.FSharp.Math.RowVector`1.op_Multiply(Microsoft.FSharp.Math.RowVector,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.RowVector`1.op_Subtraction(Microsoft.FSharp.Math.RowVector,Microsoft.FSharp.Math.RowVector)">

</member>
<member name="M:Microsoft.FSharp.Math.RowVector`1.op_SubtractionAssignment(Microsoft.FSharp.Math.RowVector,Microsoft.FSharp.Math.RowVector)">

</member>
<member name="M:Microsoft.FSharp.Math.RowVector`1.op_UnaryNegation(Microsoft.FSharp.Math.RowVector)">

</member>
<member name="M:Microsoft.FSharp.Math.RowVector`1.op_UnaryPlus(Microsoft.FSharp.Math.RowVector)">

</member>
<member name="P:Microsoft.FSharp.Math.RowVector`1.Item(System.Int32,System.Object)">

</member>
<member name="T:Microsoft.FSharp.Math.RowVector`1">
 <summary>
 The type of row vectors.  This type is included mostly only for completeness
 and is used relatively rarely.
</summary>
</member>
<member name="T:Microsoft.FSharp.Math.SparseMatrix`1">

</member>
<member name="M:Microsoft.FSharp.Math.Vector`1.Equals(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.Vector`1.GetHashCode">

</member>
<member name="M:Microsoft.FSharp.Math.Vector`1.GetSlice(Microsoft.FSharp.Core.Option,Microsoft.FSharp.Core.Option)">

</member>
<member name="P:Microsoft.FSharp.Math.Vector`1.ElementOps">

</member>
<member name="P:Microsoft.FSharp.Math.Vector`1.Item(System.Int32)">

</member>
<member name="P:Microsoft.FSharp.Math.Vector`1.Length">

</member>
<member name="P:Microsoft.FSharp.Math.Vector`1.NumRows">

</member>
<member name="P:Microsoft.FSharp.Math.Vector`1.Transpose">

</member>
<member name="M:Microsoft.FSharp.Math.Vector`1.op_Addition(Microsoft.FSharp.Math.Vector,Microsoft.FSharp.Math.Vector)">

</member>
<member name="M:Microsoft.FSharp.Math.Vector`1.op_AdditionAssignment(Microsoft.FSharp.Math.Vector,Microsoft.FSharp.Math.Vector)">

</member>
<member name="M:Microsoft.FSharp.Math.Vector`1.op_DollarMultiply(System.Object,Microsoft.FSharp.Math.Vector)">
<summary>
 Multiply each element of a vector by the given scalar value. An InvalidArgument exception will be
 raised if the dimensions do not match.
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Vector`1.op_DotMultiply(Microsoft.FSharp.Math.Vector,Microsoft.FSharp.Math.Vector)">
<summary>
 Pointwise multiplication of two vectors.
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Vector`1.op_DotMultiplyEquals(Microsoft.FSharp.Math.Vector,Microsoft.FSharp.Math.Vector)">

</member>
<member name="M:Microsoft.FSharp.Math.Vector`1.op_Multiply(Microsoft.FSharp.Math.Vector,Microsoft.FSharp.Math.RowVector)">

</member>
<member name="M:Microsoft.FSharp.Math.Vector`1.op_Multiply(Microsoft.FSharp.Math.Vector,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.Vector`1.op_Subtraction(Microsoft.FSharp.Math.Vector,Microsoft.FSharp.Math.Vector)">

</member>
<member name="M:Microsoft.FSharp.Math.Vector`1.op_SubtractionAssignment(Microsoft.FSharp.Math.Vector,Microsoft.FSharp.Math.Vector)">

</member>
<member name="M:Microsoft.FSharp.Math.Vector`1.op_UnaryNegation(Microsoft.FSharp.Math.Vector)">

</member>
<member name="M:Microsoft.FSharp.Math.Vector`1.op_UnaryPlus(Microsoft.FSharp.Math.Vector)">

</member>
<member name="P:Microsoft.FSharp.Math.Vector`1.Item(System.Int32,System.Object)">

</member>
<member name="T:Microsoft.FSharp.Math.Vector`1">
 <summary>
 The type of column vectors.  The arithmetic operations on the element type are determined by inspection on the element type itself
 </summary>
</member>
<member name="T:Microsoft.FSharp.Math.complex">
<summary>
 The type of complex numbers 
</summary>
</member>
<member name="T:Microsoft.FSharp.Math.matrix">
<summary>
 The type of floating point matrices
</summary>
</member>
<member name="T:Microsoft.FSharp.Math.opsData`1">

</member>
<member name="T:Microsoft.FSharp.Math.rowvec">
<summary>
 The type of floating point row vectors
</summary>
</member>
<member name="T:Microsoft.FSharp.Math.vector">
<summary>
 The type of floating point column vectors
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.BigInt.abs(Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.add(Microsoft.FSharp.Math.BigInt,Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.bits(Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.compare(Microsoft.FSharp.Math.BigInt,Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.div(Microsoft.FSharp.Math.BigInt,Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.divmod(Microsoft.FSharp.Math.BigInt,Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.equal(Microsoft.FSharp.Math.BigInt,Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.factorial(Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.gt(Microsoft.FSharp.Math.BigInt,Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.gte(Microsoft.FSharp.Math.BigInt,Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.hash(Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.hcf(Microsoft.FSharp.Math.BigInt,Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.isOne(Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.isZero(Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.lt(Microsoft.FSharp.Math.BigInt,Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.lte(Microsoft.FSharp.Math.BigInt,Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.max(Microsoft.FSharp.Math.BigInt,Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.min(Microsoft.FSharp.Math.BigInt,Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.mul(Microsoft.FSharp.Math.BigInt,Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.neg(Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.negative(Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.of_int(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.of_int64(System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.of_string(System.String)">

</member>
<member name="P:Microsoft.FSharp.Math.BigInt.one">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.positive(Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.pow(Microsoft.FSharp.Math.BigInt,Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.powi(Microsoft.FSharp.Math.BigInt,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.rem(Microsoft.FSharp.Math.BigInt,Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.scale(System.Int32,Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.sign(Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.sub(Microsoft.FSharp.Math.BigInt,Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.to_float(Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.to_int(Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.to_int64(Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigInt.to_string(Microsoft.FSharp.Math.BigInt)">

</member>
<member name="P:Microsoft.FSharp.Math.BigInt.zero">

</member>
<member name="T:Microsoft.FSharp.Math.BigInt">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.abs(Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.add(Microsoft.FSharp.Math.BigNum,Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.compare(Microsoft.FSharp.Math.BigNum,Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.div(Microsoft.FSharp.Math.BigNum,Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.equal(Microsoft.FSharp.Math.BigNum,Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.gt(Microsoft.FSharp.Math.BigNum,Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.gte(Microsoft.FSharp.Math.BigNum,Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.lt(Microsoft.FSharp.Math.BigNum,Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.lte(Microsoft.FSharp.Math.BigNum,Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.max(Microsoft.FSharp.Math.BigNum,Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.min(Microsoft.FSharp.Math.BigNum,Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.mul(Microsoft.FSharp.Math.BigNum,Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.neg(Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.negative(Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.of_bigint(Microsoft.FSharp.Math.BigInt)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.of_int(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.of_string(System.String)">

</member>
<member name="P:Microsoft.FSharp.Math.BigNum.one">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.positive(Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.powi(Microsoft.FSharp.Math.BigNum,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.sign(Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.sub(Microsoft.FSharp.Math.BigNum,Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.to_bigint(Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.to_float(Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.to_int(Microsoft.FSharp.Math.BigNum)">

</member>
<member name="M:Microsoft.FSharp.Math.BigNum.to_string(Microsoft.FSharp.Math.BigNum)">

</member>
<member name="P:Microsoft.FSharp.Math.BigNum.zero">

</member>
<member name="T:Microsoft.FSharp.Math.BigNum">

</member>
<member name="P:Microsoft.FSharp.Math.Complex.Numerics">
<summary>
 An abstract representation of the numeric operations
 supported by this type.
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.add(Microsoft.FSharp.Math.Complex,Microsoft.FSharp.Math.Complex)">
<summary>
 Add two complex numbers
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.cis(System.Double)">
<summary>
 A complex of magnitude 1 and the given phase and , i.e. cis x = mkPolar 1.0 x
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.conjugate(Microsoft.FSharp.Math.Complex)">
<summary>
 The conjugate of a complex number, i.e. x-yi
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.cos(Microsoft.FSharp.Math.Complex)">
<summary>
 Cosine
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.div(Microsoft.FSharp.Math.Complex,Microsoft.FSharp.Math.Complex)">
<summary>
 Complex division of two complex numbers
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.exp(Microsoft.FSharp.Math.Complex)">
<summary>
 exp(x) = e^x
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.imagPart(Microsoft.FSharp.Math.Complex)">
<summary>
 The imaginary part of a complex number
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.log(Microsoft.FSharp.Math.Complex)">
<summary>
 log(x) is natural log (base e)
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.magnitude(Microsoft.FSharp.Math.Complex)">
<summary>
 The polar-coordinate magnitude of a complex number
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.mkPolar(System.Double,System.Double)">
<summary>
 Create a complex number using magnitude/phase polar coordinates
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.mkRect(System.Double,System.Double)">

</member>
<member name="M:Microsoft.FSharp.Math.Complex.mul(Microsoft.FSharp.Math.Complex,Microsoft.FSharp.Math.Complex)">
<summary>
 Multiply two complex numbers
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.muls(Microsoft.FSharp.Math.Complex,System.Double)">
<summary>
 Multiply a complex number by a scalar
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.neg(Microsoft.FSharp.Math.Complex)">
<summary>
 Unary negation of a complex number
</summary>
</member>
<member name="P:Microsoft.FSharp.Math.Complex.one">
<summary>
 The complex number 1+0i
</summary>
</member>
<member name="P:Microsoft.FSharp.Math.Complex.onei">
<summary>
 The complex number 0+1i
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.phase(Microsoft.FSharp.Math.Complex)">
<summary>
 The polar-coordinate phase of a complex number
</summary>
</member>
<member name="P:Microsoft.FSharp.Math.Complex.pi">
<summary>
 pi
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.realPart(Microsoft.FSharp.Math.Complex)">
<summary>
 The real part of a complex number
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.sin(Microsoft.FSharp.Math.Complex)">
<summary>
 Sine
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.smul(System.Double,Microsoft.FSharp.Math.Complex)">
<summary>
 Multiply a scalar by a complex number 
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.sqrt(Microsoft.FSharp.Math.Complex)">
<summary>
 sqrt(x) and 0 &lt;= phase(x) &lt; pi
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.sub(Microsoft.FSharp.Math.Complex,Microsoft.FSharp.Math.Complex)">
<summary>
 Subtract one complex number from another
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Complex.tan(Microsoft.FSharp.Math.Complex)">
<summary>
 Tagent
</summary>
</member>
<member name="P:Microsoft.FSharp.Math.Complex.zero">
<summary>
 The complex number 0+0i
</summary>
</member>
<member name="T:Microsoft.FSharp.Math.Complex">

</member>
<member name="M:Microsoft.FSharp.Math.GlobalAssociations.Get(System.Type)">

</member>
<member name="M:Microsoft.FSharp.Math.GlobalAssociations.GetNumericAssociation">

</member>
<member name="M:Microsoft.FSharp.Math.GlobalAssociations.GetNumericAssociationOption">

</member>
<member name="M:Microsoft.FSharp.Math.GlobalAssociations.Put(System.Type,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.GlobalAssociations.RegisterNumericAssociation(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.GlobalAssociations.getNumericAssociation(Microsoft.FSharp.Core.ReifiedType)">
<summary>
 Attempt to determine a numeric association for the given type, i.e. a registered dictionary of
 numeric operations.  The interface can be queried dynamically for additional functionality in the numerics
 hierarchy.
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.GlobalAssociations.registerNumericAssociation(Microsoft.FSharp.Core.ReifiedType,System.Object)">
<summary>
 Record an AppDomain-wide association between the given type and the given dictionary of
 numeric operations.  Raise an error if an existing association already exists. 
</summary>
</member>
<member name="T:Microsoft.FSharp.Math.GlobalAssociations">
<summary>
 Associations are a way of associating dictionaries of
 operations with given types at runtime.  Associations are global to a 
 .NET application domain.  Once specified an association may not be deleted
 or modified.

 In this release the system of associations is simply 
 limited to a registry of types that support dictionaries (i.e. interface objects)
 of numeric operations.  The following types are pre-registered with associated numeric
 operations: float, int32, int64, bigint, float32, Complex, bignum.  Other types must be
 registered explicitly by user code.

</summary>
</member>
<member name="P:Microsoft.FSharp.Math.Instances.BigIntNumerics">

</member>
<member name="P:Microsoft.FSharp.Math.Instances.BigNumNumerics">

</member>
<member name="P:Microsoft.FSharp.Math.Instances.Float32Numerics">

</member>
<member name="P:Microsoft.FSharp.Math.Instances.FloatNumerics">

</member>
<member name="P:Microsoft.FSharp.Math.Instances.Int32Numerics">

</member>
<member name="P:Microsoft.FSharp.Math.Instances.Int64Numerics">

</member>
<member name="T:Microsoft.FSharp.Math.Instances">

</member>
<member name="M:Microsoft.FSharp.Math.LinearAlgebra.cholesky(Microsoft.FSharp.Math.Matrix)">

</member>
<member name="M:Microsoft.FSharp.Math.LinearAlgebra.choleskyFactor(Microsoft.FSharp.Math.Matrix)">

</member>
<member name="M:Microsoft.FSharp.Math.LinearAlgebra.determinant(Microsoft.FSharp.Math.Matrix)">

</member>
<member name="M:Microsoft.FSharp.Math.LinearAlgebra.isLowerTriangular(Microsoft.FSharp.Math.Matrix)">

</member>
<member name="M:Microsoft.FSharp.Math.LinearAlgebra.isSymmetric(Microsoft.FSharp.Math.Matrix)">

</member>
<member name="M:Microsoft.FSharp.Math.LinearAlgebra.lowerTriangularInverse(Microsoft.FSharp.Math.Matrix)">

</member>
<member name="M:Microsoft.FSharp.Math.LinearAlgebra.symmetricInverse(Microsoft.FSharp.Math.Matrix)">

</member>
<member name="T:Microsoft.FSharp.Math.LinearAlgebra">

</member>
<member name="M:Microsoft.FSharp.Math.Matrix.add(Microsoft.FSharp.Math.Matrix,Microsoft.FSharp.Math.Matrix)">
<summary>
Add two matrices (operator +)
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.constDiag(System.Int32,System.Double)">
<summary>
 Create a square matrix with the constant lying on diagonal
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.copy(Microsoft.FSharp.Math.Matrix)">
<summary>
 Create a new matrix that is a copy of the given array
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.cptMax(Microsoft.FSharp.Math.Matrix,Microsoft.FSharp.Math.Matrix)">
<summary>
Point-wise maximum element of two matrices
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.cptMin(Microsoft.FSharp.Math.Matrix,Microsoft.FSharp.Math.Matrix)">
<summary>
Point-wise minimum element of two matrices
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.cptMul(Microsoft.FSharp.Math.Matrix,Microsoft.FSharp.Math.Matrix)">
<summary>
Point-wise multiplication of two matrices (operator .*)
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.cptPow(Microsoft.FSharp.Math.Matrix,System.Double)">
<summary>
Pointwise exponential of a matrix.
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.create(System.Int32,System.Int32,System.Double)">
<summary>
 Create a matrix with all entries the given constant
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.diag(Microsoft.FSharp.Math.Vector)">
<summary>
 Create a square matrix with the given vector lying on diagonal
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.dims(Microsoft.FSharp.Math.Matrix)">
<summary>
 Get the dimensions of a matrix (rows x columns)
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.dot(Microsoft.FSharp.Math.Matrix,Microsoft.FSharp.Math.Matrix)">
<summary>
Dot product
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.exists(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Math.Matrix)">
<summary>
 Check if a predicate holds for at least one element of a matrix
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.existsi(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Math.Matrix)">
<summary>
 Check if a predicate holds for at least one element of a matrix
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.fold(Microsoft.FSharp.Core.FastFunc,System.Object,Microsoft.FSharp.Math.Matrix)">
<summary>
 Fold the given function over all elements of a matrix
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.foldByCol(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Math.RowVector,Microsoft.FSharp.Math.Matrix)">
<summary>
 Fold the given function down each column of a matrix
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.foldByRow(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Math.Vector,Microsoft.FSharp.Math.Matrix)">
<summary>
 Fold the given function along each row of a matrix
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.foldCol(Microsoft.FSharp.Core.FastFunc,System.Object,Microsoft.FSharp.Math.Matrix,System.Int32)">
<summary>
 Fold the given function along a particular column of a matrix
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.foldRow(Microsoft.FSharp.Core.FastFunc,System.Object,Microsoft.FSharp.Math.Matrix,System.Int32)">
<summary>
 Fold the given function down a particular row of a matrix
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.foldi(Microsoft.FSharp.Core.FastFunc,System.Object,Microsoft.FSharp.Math.Matrix)">
<summary>
 Fold the given function over all elements of a matrix
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.forall(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Math.Matrix)">
<summary>
 Check if a predicate holds for all elements of a matrix
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.foralli(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Math.Matrix)">
<summary>
 Check if a predicate holds for all elements of a matrix
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.get(Microsoft.FSharp.Math.Matrix,System.Int32,System.Int32)">
<summary>
 Get an element of a matrix
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.getCol(Microsoft.FSharp.Math.Matrix,System.Int32)">
<summary>
 Select a column from a matrix as a vector.
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.getCols(Microsoft.FSharp.Math.Matrix,System.Int32,System.Int32)">
<summary>
 Select a number of columns from a matrix.  
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.getDiag(Microsoft.FSharp.Math.Matrix)">
<summary>
 Return the primary diagonal of a matrix, as a vector.
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.getDiagN(Microsoft.FSharp.Math.Matrix,System.Int32)">
<summary>
 Return the nth diagonal of a matrix, as a vector.  Diagonal 0 is the primary
 diagonal, positive diagonals are further to the upper-right of the matrix.
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.getRegion(Microsoft.FSharp.Math.Matrix,System.Int32,System.Int32,System.Int32,System.Int32)">
<summary>
 Select a region from a matrix.  
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.getRow(Microsoft.FSharp.Math.Matrix,System.Int32)">
<summary>
 Select a row from a matrix as a row vector.
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.getRows(Microsoft.FSharp.Math.Matrix,System.Int32,System.Int32)">
<summary>
 Select a number of rows from a matrix. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.identity(System.Int32)">
<summary>
 Create a square matrix with the constant 1.0 lying on diagonal
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.init(System.Int32,System.Int32,Microsoft.FSharp.Core.FastFunc)">

</member>
<member name="M:Microsoft.FSharp.Math.Matrix.inplace_add(Microsoft.FSharp.Math.Matrix,Microsoft.FSharp.Math.Matrix)">
<summary>
 In-place addition mutates first matrix argument.
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.inplace_assign(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Math.Matrix)">
<summary>
 In-place assign mutates matrix argument. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.inplace_cptMul(Microsoft.FSharp.Math.Matrix,Microsoft.FSharp.Math.Matrix)">
<summary>
 In-place componentwise-multiplication mutates first matrix argument. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.inplace_mapi(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Math.Matrix)">
<summary>
 In-place map mutates matrix argument.
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.inplace_scale(System.Double,Microsoft.FSharp.Math.Matrix)">
<summary>
 In-place scaling mutates matrix argument.
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.inplace_sub(Microsoft.FSharp.Math.Matrix,Microsoft.FSharp.Math.Matrix)">
<summary>
 In-place subtraction mutates first matrix argument. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.map(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Math.Matrix)">
<summary>
 Map the given function over each element of the matrix, producing a new matrix
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.mapi(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Math.Matrix)">
<summary>
 Map the given indexed function over each element of the matrix, producing a new matrix
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.mul(Microsoft.FSharp.Math.Matrix,Microsoft.FSharp.Math.Matrix)">
<summary>
Multiply two matrices (operator * )
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.mulRV(Microsoft.FSharp.Math.RowVector,Microsoft.FSharp.Math.Matrix)">
<summary>
Multiply row vector by matrix (operator *% )
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.mulV(Microsoft.FSharp.Math.Matrix,Microsoft.FSharp.Math.Vector)">
<summary>
Multiply matrix by vector (operator *% )
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.ncols(Microsoft.FSharp.Math.Matrix)">
<summary>
 Get the number of columns of a matrix
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.neg(Microsoft.FSharp.Math.Matrix)">
<summary>
Negation of the matrix (each element is negated) (unary operator -)
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.nonzero_entries(Microsoft.FSharp.Math.Matrix)">
<summary>
 Create a matrix with the given entries. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.norm(Microsoft.FSharp.Math.Matrix)">
<summary>
sum(x*x) of all the elements of a matrix
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.nrows(Microsoft.FSharp.Math.Matrix)">
<summary>
 Get the number of rows of a matrix
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.of_list(Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Math.Matrix.of_rowvec(Microsoft.FSharp.Math.RowVector)">

</member>
<member name="M:Microsoft.FSharp.Math.Matrix.of_scalar(System.Double)">

</member>
<member name="M:Microsoft.FSharp.Math.Matrix.of_seq(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.Matrix.of_vector(Microsoft.FSharp.Math.Vector)">

</member>
<member name="M:Microsoft.FSharp.Math.Matrix.prod(Microsoft.FSharp.Math.Matrix)">
<summary>
Multiply all the elements of the matrix
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.randomize(Microsoft.FSharp.Math.Matrix)">
<summary>
Generate a new matrix of the same size as the input with random entries 
drawn from the range 0..aij.  Random numbers are generated using a globally 
shared System.Random instance with the initial seed 99.
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.scale(System.Double,Microsoft.FSharp.Math.Matrix)">
<summary>
Pointwise multiplication of a matrix by a scalar
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.set(Microsoft.FSharp.Math.Matrix,System.Int32,System.Int32,System.Double)">
<summary>
 Set an element of a matrix
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.sub(Microsoft.FSharp.Math.Matrix,Microsoft.FSharp.Math.Matrix)">
<summary>
Subtract one matrix from another (operator -)
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.sum(Microsoft.FSharp.Math.Matrix)">
<summary>
Sum all the elements of a matrix
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.to_dense(Microsoft.FSharp.Math.Matrix)">
<summary>
 Ensure that a matrix uses dense representation.  See init_sparse
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.to_rowvec(Microsoft.FSharp.Math.Matrix)">

</member>
<member name="M:Microsoft.FSharp.Math.Matrix.to_scalar(Microsoft.FSharp.Math.Matrix)">

</member>
<member name="M:Microsoft.FSharp.Math.Matrix.to_vector(Microsoft.FSharp.Math.Matrix)">

</member>
<member name="M:Microsoft.FSharp.Math.Matrix.trace(Microsoft.FSharp.Math.Matrix)">
<summary>
 Sum of the diagonal elements of the matrix
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.transpose(Microsoft.FSharp.Math.Matrix)">
<summary>
Transpose of a matrix.  Use also m.Transpose
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Matrix.zero(System.Int32,System.Int32)">
<summary>
 Create a matrix with all entries zero
</summary>
</member>
<member name="T:Microsoft.FSharp.Math.Matrix">
<summary>
 Operations to manipulate floating
 point matrices.  The submodule [[Matrix.Generic]] contains a 
 matching set of operations to manipulate matrix types carrying
 arbitrary element types.
</summary>
</member>
<member name="T:Microsoft.FSharp.Math.Notation.complex">
<summary>
 The type of complex numbers
</summary>
</member>
<member name="T:Microsoft.FSharp.Math.Notation.matrix">
<summary>
 The type of floating point matrices
</summary>
</member>
<member name="T:Microsoft.FSharp.Math.Notation.rowvec">
<summary>
 The type of floating point row vectors
</summary>
</member>
<member name="T:Microsoft.FSharp.Math.Notation.vector">
<summary>
 The type of floating point column vectors
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Notation.M2S(Microsoft.FSharp.Math.Matrix)">
<summary>
 Convert a matrix to a scalar.  
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Notation.M2V(Microsoft.FSharp.Math.Matrix)">
<summary>
 Convert a matrix to a column vector. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Notation.S(System.Double)">
<summary>
 Create a matrix from a scalar.  
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Notation.V(Microsoft.FSharp.Math.Vector)">
<summary>
 Create a matrix from a column vector.  
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Notation.complex(System.Double,System.Double)">
<summary>
 Create a complex number x+ij using rectangular coordinates
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Notation.matrix(System.Object)">
<summary>
 Create a matrix from lists of floats.  
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Notation.rowvec(System.Object)">
<summary>
 Create a row vector from lists of floats. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Notation.vector(System.Object)">
<summary>
 Create a column vector from lists of floats.
</summary>
</member>
<member name="T:Microsoft.FSharp.Math.Notation">
<summary>
 This module contains notation related to matrices and vectors
</summary>
</member>
<member name="T:Microsoft.FSharp.Math.Primitives.BigNat">
<summary>
 Abstract internal type
</summary>
</member>
<member name="T:Microsoft.FSharp.Math.Primitives.BigNat.n">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.add(Microsoft.FSharp.Math.Primitives.BigNat,Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.bits(Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.compare(Microsoft.FSharp.Math.Primitives.BigNat,Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.div(Microsoft.FSharp.Math.Primitives.BigNat,Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.divmod(Microsoft.FSharp.Math.Primitives.BigNat,Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.equal(Microsoft.FSharp.Math.Primitives.BigNat,Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.factorial(Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.get_small(Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.gt(Microsoft.FSharp.Math.Primitives.BigNat,Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.gte(Microsoft.FSharp.Math.Primitives.BigNat,Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.hash(Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.hcf(Microsoft.FSharp.Math.Primitives.BigNat,Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.isOne(Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.isZero(Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.is_small(Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.lt(Microsoft.FSharp.Math.Primitives.BigNat,Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.lte(Microsoft.FSharp.Math.Primitives.BigNat,Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.max(Microsoft.FSharp.Math.Primitives.BigNat,Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.min(Microsoft.FSharp.Math.Primitives.BigNat,Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.mul(Microsoft.FSharp.Math.Primitives.BigNat,Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.of_int(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.of_int64(System.Int64)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.of_string(System.String)">

</member>
<member name="P:Microsoft.FSharp.Math.Primitives.BigNat.one">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.pow(Microsoft.FSharp.Math.Primitives.BigNat,Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.powi(Microsoft.FSharp.Math.Primitives.BigNat,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.rem(Microsoft.FSharp.Math.Primitives.BigNat,Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.scale(System.Int32,Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.sub(Microsoft.FSharp.Math.Primitives.BigNat,Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.to_float(Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.to_int(Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.to_int64(Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.BigNat.to_string(Microsoft.FSharp.Math.Primitives.BigNat)">

</member>
<member name="P:Microsoft.FSharp.Math.Primitives.BigNat.two">

</member>
<member name="P:Microsoft.FSharp.Math.Primitives.BigNat.zero">

</member>
<member name="T:Microsoft.FSharp.Math.Primitives.BigNat">

</member>
<member name="T:Microsoft.FSharp.Math.Primitives.FFT.fp">
<summary>
 fp is type for the finite field.
 Currently using p = 2^27.15+1 but do not rely on that.  
 Also, do not rely on fp being represented as uint32.
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Primitives.FFT.computeFftPaddedPolynomialProduct(System.Int32,System.Int32,System.UInt32[],System.UInt32[])">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.FFT.computeFftPolynomialProduct(System.Int32,System.Int32[],System.Int32,System.Int32[])">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.FFT.fp_of_int(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Math.Primitives.FFT.int_of_fp(System.UInt32)">

</member>
<member name="P:Microsoft.FSharp.Math.Primitives.FFT.max_bits_inside_fp">
<summary>
 "2^max_bits_inside_fp - 1" fits inside fp
</summary>
</member>
<member name="P:Microsoft.FSharp.Math.Primitives.FFT.max_fp">
<summary>
 Maximum value in Fp is p-1.
</summary>
</member>
<member name="P:Microsoft.FSharp.Math.Primitives.FFT.mone">

</member>
<member name="P:Microsoft.FSharp.Math.Primitives.FFT.mzero">

</member>
<member name="T:Microsoft.FSharp.Math.Primitives.FFT">
<summary>
 FFT multiplication used by BigNat.
 Implements polynomial multiplication provided
 the coefficients of the result (and hence of the arguments too) fit inside Fp.
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.RowVector.copy(Microsoft.FSharp.Math.RowVector)">

</member>
<member name="M:Microsoft.FSharp.Math.RowVector.create(System.Int32,System.Double)">
<summary>
 Create by constant initialization
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.RowVector.get(Microsoft.FSharp.Math.RowVector,System.Int32)">
<summary>
 Get an element of a column vector
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.RowVector.init(System.Int32,Microsoft.FSharp.Core.FastFunc)">
<summary>
 Create by comprehension
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.RowVector.length(Microsoft.FSharp.Math.RowVector)">
<summary>
 Get the dimensions (number of rows) of a column rowvec.  
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.RowVector.of_array(System.Double[])">
<summary>
 Create a vector from an array of double precision floats
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.RowVector.of_list(Microsoft.FSharp.Collections.List)">
<summary>
 Create a vector from a list of numbers
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.RowVector.of_seq(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.RowVector.set(Microsoft.FSharp.Math.RowVector,System.Int32,System.Double)">
<summary>
 Set an element of a column rowvec
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.RowVector.to_array(Microsoft.FSharp.Math.RowVector)">
<summary>
 Return a new array containing a copy of the elements of the given vector
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.RowVector.transpose(Microsoft.FSharp.Math.RowVector)">

</member>
<member name="T:Microsoft.FSharp.Math.RowVector">
<summary>
 Operations to manipulate floating
 point row vectors.  These are included for completeness and are
 nearly always transposed to column vectors.
</summary>
</member>
<member name="T:Microsoft.FSharp.Math.Types.BigInt">

</member>
<member name="T:Microsoft.FSharp.Math.Types.BigNum">

</member>
<member name="T:Microsoft.FSharp.Math.Types.BigRational">

</member>
<member name="T:Microsoft.FSharp.Math.Types.Complex">

</member>
<member name="T:Microsoft.FSharp.Math.Types.IFloating`1">

</member>
<member name="T:Microsoft.FSharp.Math.Types.IFractional`1">

</member>
<member name="T:Microsoft.FSharp.Math.Types.IIEEE`1">

</member>
<member name="T:Microsoft.FSharp.Math.Types.IIntegral`1">

</member>
<member name="T:Microsoft.FSharp.Math.Types.INumeric`1">

</member>
<member name="T:Microsoft.FSharp.Math.Types.Matrix`1">

</member>
<member name="T:Microsoft.FSharp.Math.Types.RowVector`1">

</member>
<member name="T:Microsoft.FSharp.Math.Types.Vector`1">

</member>
<member name="T:Microsoft.FSharp.Math.Types.complex">

</member>
<member name="M:Microsoft.FSharp.Math.Vector.add(Microsoft.FSharp.Math.Vector,Microsoft.FSharp.Math.Vector)">
<summary>
Add two vectors (operator +)
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Vector.copy(Microsoft.FSharp.Math.Vector)">

</member>
<member name="M:Microsoft.FSharp.Math.Vector.cptMul(Microsoft.FSharp.Math.Vector,Microsoft.FSharp.Math.Vector)">
<summary>
Point-wise multiplication of two vectors (operator .*)
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Vector.cptPow(Microsoft.FSharp.Math.Vector,System.Double)">
<summary>
Pointwise exponential of a vector.
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Vector.create(System.Int32,System.Double)">
<summary>
 Generate a vector of the given length where each entry contains the given value
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Vector.dot(Microsoft.FSharp.Math.Vector,Microsoft.FSharp.Math.Vector)">
<summary>
Dot product
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Vector.exists(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Math.Vector)">

</member>
<member name="M:Microsoft.FSharp.Math.Vector.existsi(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Math.Vector)">

</member>
<member name="M:Microsoft.FSharp.Math.Vector.fold(Microsoft.FSharp.Core.FastFunc,System.Object,Microsoft.FSharp.Math.Vector)">

</member>
<member name="M:Microsoft.FSharp.Math.Vector.foldi(Microsoft.FSharp.Core.FastFunc,System.Object,Microsoft.FSharp.Math.Vector)">

</member>
<member name="M:Microsoft.FSharp.Math.Vector.forall(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Math.Vector)">

</member>
<member name="M:Microsoft.FSharp.Math.Vector.foralli(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Math.Vector)">

</member>
<member name="M:Microsoft.FSharp.Math.Vector.get(Microsoft.FSharp.Math.Vector,System.Int32)">
<summary>
 Get an element of a column vector
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Vector.init(System.Int32,Microsoft.FSharp.Core.FastFunc)">

</member>
<member name="M:Microsoft.FSharp.Math.Vector.inplace_add(Microsoft.FSharp.Math.Vector,Microsoft.FSharp.Math.Vector)">

</member>
<member name="M:Microsoft.FSharp.Math.Vector.inplace_assign(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Math.Vector)">

</member>
<member name="M:Microsoft.FSharp.Math.Vector.inplace_cptMul(Microsoft.FSharp.Math.Vector,Microsoft.FSharp.Math.Vector)">

</member>
<member name="M:Microsoft.FSharp.Math.Vector.inplace_mapi(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Math.Vector)">

</member>
<member name="M:Microsoft.FSharp.Math.Vector.inplace_scale(System.Double,Microsoft.FSharp.Math.Vector)">

</member>
<member name="M:Microsoft.FSharp.Math.Vector.inplace_sub(Microsoft.FSharp.Math.Vector,Microsoft.FSharp.Math.Vector)">

</member>
<member name="M:Microsoft.FSharp.Math.Vector.length(Microsoft.FSharp.Math.Vector)">
<summary>
 Get the dimensions (number of rows) of a column vector.  Identical to [[nrows]]
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Vector.map(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Math.Vector)">

</member>
<member name="M:Microsoft.FSharp.Math.Vector.mapi(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Math.Vector)">

</member>
<member name="M:Microsoft.FSharp.Math.Vector.neg(Microsoft.FSharp.Math.Vector)">
<summary>
Negation of the vector (each element is negated) (unary operator -)
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Vector.norm(Microsoft.FSharp.Math.Vector)">
<summary>
sum(x*x) of all or some of the matrix
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Vector.nrows(Microsoft.FSharp.Math.Vector)">
<summary>
 Get the number of rows of a column vector. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Vector.of_array(System.Double[])">
<summary>
 Create a vector from an array of double precision floats
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Vector.of_list(Microsoft.FSharp.Collections.List)">
<summary>
 Create a vector from a list of numbers
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Vector.of_scalar(System.Double)">
<summary>
 Create a 1-element vector
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Vector.of_seq(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Math.Vector.prod(Microsoft.FSharp.Math.Vector)">
<summary>
Multiply all the elements of the matrix
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Vector.range(System.Int32,System.Int32)">
<summary>
 Create a vector that represents a integral mesh over the given range
 e.g. range 1 5 = vector [ 1.;2.;3.;4.;5. ]
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Vector.rangef(System.Double,System.Double,System.Double)">
<summary>
 Create a vector that represents a mesh over the given range
 e.g. rangef (-1.0) 0.5 1.0 = vector [ -1.0; -0.5; 0.0; 0.5; 1.0]
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Vector.scale(System.Double,Microsoft.FSharp.Math.Vector)">
<summary>
Pointwise multiplication of a matrix by a scalar
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Vector.set(Microsoft.FSharp.Math.Vector,System.Int32,System.Double)">
<summary>
 Set an element of a column vector
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Vector.sub(Microsoft.FSharp.Math.Vector,Microsoft.FSharp.Math.Vector)">
<summary>
Subtract one vector from another (operator -)
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Vector.sum(Microsoft.FSharp.Math.Vector)">
<summary>
Sum all the elements of a vector
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Vector.to_array(Microsoft.FSharp.Math.Vector)">
<summary>
 Return a new array containing a copy of the elements of the given vector
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Vector.transpose(Microsoft.FSharp.Math.Vector)">
<summary>
Transpose of a matrix.  Use also m.Transpose
</summary>
</member>
<member name="M:Microsoft.FSharp.Math.Vector.zero(System.Int32)">
<summary>
 Return a vector of the given length where every entry is zero.
</summary>
</member>
<member name="T:Microsoft.FSharp.Math.Vector">
<summary>
 Operations to manipulate floating
 point column vectors.  The submodule VectorOps.Generic contains a 
 matching set of operations to manipulate column vectors carrying
 arbitrary element types.
</summary>
</member>
<member name="T:Microsoft.FSharp.NativeInterop.CMatrix`1">
<summary>
 See NativeArray2
</summary>
</member>
<member name="M:Microsoft.FSharp.NativeInterop.FortranMatrix`1.FromPtr(Microsoft.FSharp.Core.nativeptr,System.Int32,System.Int32)">

</member>
<member name="P:Microsoft.FSharp.NativeInterop.FortranMatrix`1.Item(System.Int32,System.Int32)">
<summary>
 WARNING: use of this function may lead to unverifiable or invalid code
</summary>
</member>
<member name="P:Microsoft.FSharp.NativeInterop.FortranMatrix`1.NativeTranspose">
<summary>
 View a FortranMatrix as a CMatrix.  Doesn't actually allocate
 a new matirx - just gives a different label to the same bits, and swaps the
 row/column count information associated with the bits.
</summary>
</member>
<member name="P:Microsoft.FSharp.NativeInterop.FortranMatrix`1.NumCols">

</member>
<member name="P:Microsoft.FSharp.NativeInterop.FortranMatrix`1.NumRows">

</member>
<member name="P:Microsoft.FSharp.NativeInterop.FortranMatrix`1.Ptr">

</member>
<member name="P:Microsoft.FSharp.NativeInterop.FortranMatrix`1.Item(System.Int32,System.Int32,System.Object)">
<summary>
 WARNING: use of this function may lead to unverifiable or invalid code
</summary>
</member>
<member name="T:Microsoft.FSharp.NativeInterop.FortranMatrix`1">
<summary>
 This type wraps a pointer to a blob of unmanaged memory assumed to contain
 a Fortran-style column major two-dimensional matrix of items compatible with the (presumably blittable) 
 type 'a. The blob of memory must be allocated and managed externally, 
 e.g. by a computation routine written in C.

 All operations on this type are marked inlined
 because the code used to implement the operations is not verifiable.  

 Any code that uses these operations will be unverifiable and may 
 cause memory corruption if not used with extreme care.
</summary>
</member>
<member name="M:Microsoft.FSharp.NativeInterop.NativeArray2`1.FromPtr(Microsoft.FSharp.Core.nativeptr,System.Int32,System.Int32)">

</member>
<member name="P:Microsoft.FSharp.NativeInterop.NativeArray2`1.Item(System.Int32,System.Int32)">
<summary>
 WARNING: use of this function may lead to unverifiable or invalid code
</summary>
</member>
<member name="P:Microsoft.FSharp.NativeInterop.NativeArray2`1.NativeTranspose">
<summary>
 View a CMatrix as a FortranMatrix.  Doesn't actually allocate
 a new matirx - just gives a different label to the same bits, and swaps the
 row/column count information associated with the bits.
</summary>
</member>
<member name="P:Microsoft.FSharp.NativeInterop.NativeArray2`1.NumCols">

</member>
<member name="P:Microsoft.FSharp.NativeInterop.NativeArray2`1.NumRows">

</member>
<member name="P:Microsoft.FSharp.NativeInterop.NativeArray2`1.Ptr">

</member>
<member name="P:Microsoft.FSharp.NativeInterop.NativeArray2`1.Item(System.Int32,System.Int32,System.Object)">
<summary>
 WARNING: use of this function may lead to unverifiable or invalid code
</summary>
</member>
<member name="T:Microsoft.FSharp.NativeInterop.NativeArray2`1">
<summary>
 This type wraps a pointer to a blob of unmanaged memory assumed to contain
 a C-style row major two-dimensional matrix of items compatible with the (presumably blittable) 
 type 'a. The blob of memory must be allocated and managed externally, 
 e.g. by a computation routine written in C.

 All operations on this type are marked inlined
 because the code used to implement the operations is not verifiable.  

 Any code that uses these operations will be unverifiable and may 
 cause memory corruption if not used with extreme care.
</summary>
</member>
<member name="M:Microsoft.FSharp.NativeInterop.NativeArray`1.FromPtr(Microsoft.FSharp.Core.nativeptr,System.Int32)">

</member>
<member name="P:Microsoft.FSharp.NativeInterop.NativeArray`1.Item(System.Int32)">
<summary>
 WARNING: use of this function may lead to unverifiable or invalid code
</summary>
</member>
<member name="P:Microsoft.FSharp.NativeInterop.NativeArray`1.Length">

</member>
<member name="P:Microsoft.FSharp.NativeInterop.NativeArray`1.Ptr">

</member>
<member name="P:Microsoft.FSharp.NativeInterop.NativeArray`1.Item(System.Int32,System.Object)">
<summary>
 WARNING: use of this function may lead to unverifiable or invalid code
</summary>
</member>
<member name="T:Microsoft.FSharp.NativeInterop.NativeArray`1">
<summary>
 This type wraps a pointer to a blob of unmanaged memory assumed to contain
 a C-style one-dimensional array of items compatible with the (presumably blittable) 
 type 'a.  The blob of memory must be allocated and managed externally, 
 e.g. by a computation routine written in C.

 All operations on this type are marked inlined
 because the code used to implement the operations is not verifiable.  

 Any code that uses these operations will be unverifiable and may 
 cause memory corruption if not used with extreme care.
</summary>
</member>
<member name="M:Microsoft.FSharp.NativeInterop.NativePtr.add(Microsoft.FSharp.Core.nativeptr,System.Int32)">
<summary>
 WARNING: use of this function may lead to unverifiable or invalid code
</summary>
</member>
<member name="M:Microsoft.FSharp.NativeInterop.NativePtr.get(Microsoft.FSharp.Core.nativeptr,System.Int32)">
<summary>
 WARNING: use of this function may lead to unverifiable or invalid code
</summary>
</member>
<member name="M:Microsoft.FSharp.NativeInterop.NativePtr.of_NativeArray(Microsoft.FSharp.NativeInterop.NativeArray)">
<summary>
 WARNING: use of this function may lead to unverifiable or invalid code
</summary>
</member>
<member name="M:Microsoft.FSharp.NativeInterop.NativePtr.of_ilsigptr(Microsoft.FSharp.Core.nativeptr)">
<summary>
 WARNING: use of this function may lead to unverifiable or invalid code
</summary>
</member>
<member name="M:Microsoft.FSharp.NativeInterop.NativePtr.of_nativeint(System.IntPtr)">
<summary>
 WARNING: use of this function may lead to unverifiable or invalid code
</summary>
</member>
<member name="M:Microsoft.FSharp.NativeInterop.NativePtr.set(Microsoft.FSharp.Core.nativeptr,System.Int32,System.Object)">
<summary>
 WARNING: use of this function may lead to unverifiable or invalid code
</summary>
</member>
<member name="M:Microsoft.FSharp.NativeInterop.NativePtr.to_NativeArray(Microsoft.FSharp.Core.nativeptr,System.Int32)">
<summary>
 WARNING: use of this function may lead to unverifiable or invalid code
</summary>
</member>
<member name="M:Microsoft.FSharp.NativeInterop.NativePtr.to_ilsigptr(Microsoft.FSharp.Core.nativeptr)">
<summary>
 WARNING: use of this function may lead to unverifiable or invalid code
</summary>
</member>
<member name="M:Microsoft.FSharp.NativeInterop.NativePtr.to_nativeint(Microsoft.FSharp.Core.nativeptr)">
<summary>
 WARNING: use of this function may lead to unverifiable or invalid code
</summary>
</member>
<member name="T:Microsoft.FSharp.NativeInterop.NativePtr">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.abs(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.op_Append(Microsoft.FSharp.Collections.List,Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.op_MultiplyMultiply(System.Double,System.Double)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.string_of_int(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.Array.blit(System.Object[],System.Int32,System.Object[],System.Int32,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.Array.copy(System.Object[])">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.Array.create(System.Int32,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.Array.fold_left(Microsoft.FSharp.Core.FastFunc,System.Object,System.Object[])">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.Array.fold_right(Microsoft.FSharp.Core.FastFunc,System.Object[],System.Object)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.Array.get(System.Object[],System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.Array.geta(System.Object[]`1,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.Array.init(System.Int32,Microsoft.FSharp.Core.FastFunc)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.Array.length(System.Object[])">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.Array.make(System.Int32,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.Array.map(Microsoft.FSharp.Core.FastFunc,System.Object[])">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.Array.of_list(Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.Array.set(System.Object[],System.Int32,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.Array.sub(System.Object[],System.Int32,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.Array.to_list(System.Object[])">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.Array.zero_create(System.Int32)">

</member>
<member name="T:Microsoft.FSharp.Primitives.Basics.Array">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.Bytearray.blit(System.Byte[]`1,System.Int32,System.Byte[]`1,System.Int32,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.Bytearray.get(System.Byte[]`1,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.Bytearray.init(System.Int32,Microsoft.FSharp.Core.FastFunc)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.Bytearray.length(System.Byte[]`1)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.Bytearray.set(System.Byte[]`1,System.Int32,System.Byte)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.Bytearray.sub(System.Byte[]`1,System.Int32,System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.Bytearray.zero_create(System.Int32)">

</member>
<member name="T:Microsoft.FSharp.Primitives.Basics.Bytearray">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.Char.chr(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.Char.code(System.Char)">

</member>
<member name="T:Microsoft.FSharp.Primitives.Basics.Char">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.List.append(Microsoft.FSharp.Collections.List,Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.List.concat(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.List.exists(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.List.filter(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.List.find(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.List.for_all(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.List.init(System.Int32,Microsoft.FSharp.Core.FastFunc)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.List.iter(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.List.iteri(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.List.length(Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.List.map(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.List.mapi(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.List.nonempty(Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.List.of_array(System.Object[])">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.List.partition(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.List.rev(Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.List.rev_append(Microsoft.FSharp.Collections.List,Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.List.to_array(Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.List.tryfind(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.List.unzip(Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.List.unzip3(Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.List.zip(Microsoft.FSharp.Collections.List,Microsoft.FSharp.Collections.List)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.List.zip3(Microsoft.FSharp.Collections.List,Microsoft.FSharp.Collections.List,Microsoft.FSharp.Collections.List)">

</member>
<member name="T:Microsoft.FSharp.Primitives.Basics.List">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.NativeOps.of_ilsigptr(Microsoft.FSharp.Core.nativeptr)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.NativeOps.of_nativeint(System.IntPtr)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.NativeOps.pinAny(System.Object,Microsoft.FSharp.Core.FastFunc)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.NativeOps.pinUnscoped(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.NativeOps.to_ilsigptr(Microsoft.FSharp.Core.nativeptr)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.NativeOps.to_nativeint(Microsoft.FSharp.Core.nativeptr)">

</member>
<member name="T:Microsoft.FSharp.Primitives.Basics.NativeOps">

</member>
<member name="T:Microsoft.FSharp.Primitives.Basics.RangeOps.range">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.RangeOps.foldR(Microsoft.FSharp.Core.FastFunc,System.Object,Microsoft.FSharp.Core.Tuple2)">

</member>
<member name="M:Microsoft.FSharp.Primitives.Basics.RangeOps.sumfR(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Core.Tuple2)">

</member>
<member name="T:Microsoft.FSharp.Primitives.Basics.RangeOps">

</member>
<member name="T:Microsoft.FSharp.Primitives.Basics">
<summary>
 Definitions internal for this library.
</summary>
</member>
<member name="P:Microsoft.FSharp.Reflection.ModuleDefinition.CompiledHandle">
<summary>
 A handle that represents the compiled form of the F# module.
</summary>
</member>
<member name="P:Microsoft.FSharp.Reflection.ModuleDefinition.ConcreteValues">
<summary>
 Fetch the list of concrete values in the F# Module, i.e. those that 
 have a canonical corresponding construct in the compiled IL version of the F# code. Inlined
 values and private values optimized away during compilation are not returned.
</summary>
</member>
<member name="P:Microsoft.FSharp.Reflection.ModuleDefinition.ModuleDefinitions">
<summary>
 Fetch the list of public nexted module definitions in the F# Module.
</summary>
</member>
<member name="P:Microsoft.FSharp.Reflection.ModuleDefinition.TypeDefinitions">
<summary>
 Fetch the list of public type definitions in the F# Module.
 Private types and type abbreviations are not returned.
</summary>
</member>
<member name="T:Microsoft.FSharp.Reflection.ModuleDefinition">

</member>
<member name="P:Microsoft.FSharp.Reflection.TypeDefinition.CompiledHandle">
<summary>
 A handle that represents the compiled form of the F# type definition.
 This can be used to access all the features of the type definition, e.g. the
 type parameters, properties and other members. 
</summary>
</member>
<member name="P:Microsoft.FSharp.Reflection.TypeDefinition.TypeInfo">
<summary>
 Return the GetTypeInfoOfType decomposition of a generic instance of the type.
</summary>
</member>
<member name="T:Microsoft.FSharp.Reflection.TypeDefinition">

</member>
<member name="T:Microsoft.FSharp.Reflection.TypeInfo">
<summary>
Represents the one-level decomposition of an F# type according to the
various structural types supported by the F# language.  

 Note: Most attributes associated with a System.Type value can be accessed
 via regular .NET reflection. However, it is useful to be able to view some
 F# type definitions from the perspective of the F# language, in particular
 for record, tuple and discriminated-union definitions. Although these types
 are ultimately compiled as .NET types, the details of the encoding used is
 often irrelevant, and this type and other items in this API help hide the
 details of this encoding.

</summary>
</member>
<member name="P:Microsoft.FSharp.Reflection.ValueDefinition.CompiledHandle">
<summary>
 A handle that represents the compiled form of the F# value
</summary>
</member>
<member name="T:Microsoft.FSharp.Reflection.ValueDefinition">

</member>
<member name="T:Microsoft.FSharp.Reflection.ValueInfo">
<summary>
Represents the one-level decomposition of an F# value according to the
various structural types supported by the F# language.  
</summary>
</member>
<member name="T:Microsoft.FSharp.Reflection.typeinfo`1">

</member>
<member name="M:Microsoft.FSharp.Reflection.AbstractType(System.Type)">

</member>
<member name="M:Microsoft.FSharp.Reflection.AbstractValue(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Reflection.ExternalType(System.Type)">

</member>
<member name="M:Microsoft.FSharp.Reflection.ExternalValue(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Reflection.GetAssemblyModules(System.Reflection.Assembly)">

</member>
<member name="M:Microsoft.FSharp.Reflection.GetAssemblyTypes(System.Reflection.Assembly)">

</member>
<member name="M:Microsoft.FSharp.Reflection.GetTypeInfoOfType(System.Type)">

</member>
<member name="M:Microsoft.FSharp.Reflection.GetTypeInfoOfValue(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Reflection.GetValueInfo(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Reflection.GetValueInfoOfObject(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Reflection.IsListType(System.Type)">
<summary>
 A convenience function
</summary>
</member>
<member name="M:Microsoft.FSharp.Reflection.IsOptionType(System.Type)">
<summary>
 A convenience function
</summary>
</member>
<member name="M:Microsoft.FSharp.Reflection.IsUnitType(System.Type)">
<summary>
 A convenience function
</summary>
</member>
<member name="M:Microsoft.FSharp.Reflection.typeinfoof">

</member>
<member name="M:Microsoft.FSharp.Reflection.|AbstractType|_|(Microsoft.FSharp.Reflection.TypeInfo)">

</member>
<member name="M:Microsoft.FSharp.Reflection.|AbstractValue|_|(Microsoft.FSharp.Reflection.ValueInfo)">

</member>
<member name="M:Microsoft.FSharp.Reflection.|ExternalType|_|(Microsoft.FSharp.Reflection.TypeInfo)">

</member>
<member name="M:Microsoft.FSharp.Reflection.|ExternalValue|_|(Microsoft.FSharp.Reflection.ValueInfo)">

</member>
<member name="M:Microsoft.FSharp.Reflection.Assembly.GetFSharpModules(System.Reflection.Assembly)">
<summary>
 Get an enumeration of handles to the F#-defined concrete 
 module definitions in an assembly.  Nested module definitions
 are not returned.
</summary>
</member>
<member name="M:Microsoft.FSharp.Reflection.Assembly.GetFSharpTypeDefinitions(System.Reflection.Assembly)">
<summary>
 Get handles to the F#-defined concrete type definitions 
 in an assembly.  Type definitions nested inside modules
 are not returned, nor are type definitions hidden inside modules, 
 and nor are type abbreviations.
</summary>
</member>
<member name="T:Microsoft.FSharp.Reflection.Assembly">

</member>
<member name="M:Microsoft.FSharp.Reflection.Type.GetInfo(System.Type)">
<summary>
 Get the TypeInfo for a System.Type
</summary>
</member>
<member name="M:Microsoft.FSharp.Reflection.Type.GetTypeOfReprType(System.Type)">
<summary>
 Throw away extraneous compiler-specific information from a runtime type to return a true F# type.
</summary>
</member>
<member name="M:Microsoft.FSharp.Reflection.Type.IsListType(System.Type)">
<summary>
 A convenience function
</summary>
</member>
<member name="M:Microsoft.FSharp.Reflection.Type.IsOptionType(System.Type)">
<summary>
 A convenience function
</summary>
</member>
<member name="M:Microsoft.FSharp.Reflection.Type.IsUnitType(System.Type)">
<summary>
 A convenience function
</summary>
</member>
<member name="P:Microsoft.FSharp.Reflection.Type.MaxTupleSize">
<summary>
 The maximum size for which the structure of tuple types are faithfully reported by reflection
</summary>
</member>
<member name="T:Microsoft.FSharp.Reflection.Type">

</member>
<member name="M:Microsoft.FSharp.Reflection.Value.GetInfo(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Reflection.Value.GetRecordConstructor(System.Type)">
<summary>
 Precompute a function for constructing a record value. 

 Assumes the given type is a RecordType.
 If not an unspecified exception is raised during pre-computation.
</summary>
</member>
<member name="M:Microsoft.FSharp.Reflection.Value.GetRecordFieldReader(System.Type,System.String)">
<summary>
 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 an unspecified exception is raised during pre-computation.

 Using the computed function will be much 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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Reflection.Value.GetRecordReader(System.Type)">
<summary>
 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 an unspecified exception is raised during pre-computation.

 Using the computed function will be much 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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Reflection.Value.GetSumConstructor(System.Type,System.Int32)">
<summary>
 Precompute a function for constructing a discriminated union value for a particular tag. 

 Assumes the given type is a SumType where the tag is a legitimate tag for the type.
 If not an unspecified exception is raised during pre-computation.
</summary>
</member>
<member name="M:Microsoft.FSharp.Reflection.Value.GetSumRecordReader(System.Type,System.Int32)">
<summary>
 Precompute a function for reading all the fields for a particular discriminator tag of a sum type

 Assumes the given type is a SumType where the tag is a legitimate tag for the type.
 If not an unspecified exception is raised during pre-computation.

 Tags can be mapped to and from names using the functions returned by GetSumTagConverters

 Using the computed function will be much 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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Reflection.Value.GetSumTagConverters(System.Type)">
<summary>
 Precompute a pair of functions for converting between integer discriminator tags
 the names of the discriminators for the given sum type.

 Assumes the given type is a SumType. 
 If not an unspecified exception is raised during pre-computation.
</summary>
</member>
<member name="M:Microsoft.FSharp.Reflection.Value.GetSumTagReader(System.Type)">
<summary>
 Precompute a function for reading an integer representing the discriminator tag of a sum type.

 Assumes the given type is a SumType. 
 If not an unspecified exception is raised during pre-computation.

 Using the computed function will be much 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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Reflection.Value.GetTupleConstructor(System.Type)">
<summary>
 Precompute a function for reading the values of a particular tuple type

 Assumes the given type is a TupleType.
 If not an unspecified exception is raised during pre-computation.
</summary>
</member>
<member name="M:Microsoft.FSharp.Reflection.Value.GetTupleReader(System.Type)">
<summary>
 Precompute a function for reading the values of a particular tuple type

 Assumes the given type is a TupleType.
 If not an unspecified exception is raised during pre-computation.
</summary>
</member>
<member name="M:Microsoft.FSharp.Reflection.Value.GetType(System.Object)">

</member>
<member name="M:Microsoft.FSharp.Reflection.Value.GetTypeInfo(System.Object)">

</member>
<member name="T:Microsoft.FSharp.Reflection.Value">

</member>
<member name="T:Microsoft.FSharp.Reflection">

</member>
<member name="T:Microsoft.FSharp.Text.Format`4">

</member>
<member name="T:Microsoft.FSharp.Text.format4`4">

</member>
<member name="T:Microsoft.FSharp.Text.Printf.BuildStringFormat`1">

</member>
<member name="T:Microsoft.FSharp.Text.Printf.BuilderFormat`1">

</member>
<member name="T:Microsoft.FSharp.Text.Printf.BuilderFormat`2">

</member>
<member name="T:Microsoft.FSharp.Text.Printf.StringFormat`1">

</member>
<member name="T:Microsoft.FSharp.Text.Printf.StringFormat`2">

</member>
<member name="T:Microsoft.FSharp.Text.Printf.TextWriterFormat`1">

</member>
<member name="T:Microsoft.FSharp.Text.Printf.TextWriterFormat`2">

</member>
<member name="T:Microsoft.FSharp.Text.Printf.bstring_format`1">
<summary>
 The type of formats accepted by printers that produce strings but print intermediate results to buffers 
</summary>
</member>
<member name="T:Microsoft.FSharp.Text.Printf.buffer_format`1">
<summary>
 The type of formats accepted by printers that write to buffers
</summary>
</member>
<member name="T:Microsoft.FSharp.Text.Printf.kbuffer_format`2">
<summary>
 The type of formats accepted by print-then-call printers that write to buffers
</summary>
</member>
<member name="T:Microsoft.FSharp.Text.Printf.kstring_format`2">
<summary>
 The type of formats accepted by print-then-call printers that produce strings
</summary>
</member>
<member name="T:Microsoft.FSharp.Text.Printf.ktextwriter_format`2">
<summary>
 The type of formats accepted by print-then-call printers that write to an instance of the .NET type System.IO.TextWriter
</summary>
</member>
<member name="T:Microsoft.FSharp.Text.Printf.string_format`1">
<summary>
 The type of formats accepted by printers that produce strings
</summary>
</member>
<member name="T:Microsoft.FSharp.Text.Printf.textwriter_format`1">
<summary>
 The type of formats accepted by printers that write to an instance of the .NET type System.IO.TextWriter
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.Printf.bfailwithf(Microsoft.FSharp.Text.Format)">
<summary>
 Print to a string buffer and raise an exception with the given
 result.   Helper printers must print to string buffers.
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.Printf.bfprintf(System.IO.TextWriter,Microsoft.FSharp.Text.Format)">
<summary>
 Print to a text writer or an OCaml-compatible channel, but intermediary 
 printers write via a buffer, which is often the most convenient way to write
 intermediary printers.  Useful if your primitive printing functions 
 are defined to write to buffers, but you ultimately want to
 go to a file.
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.Printf.bprintf(System.Text.StringBuilder,Microsoft.FSharp.Text.Format)">
<summary>
 Print to a string buffer, which is a StringBuilder
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.Printf.bsprintf(Microsoft.FSharp.Text.Format)">
<summary>
 Print to a string buffer, which is a StringBuilder.
 Return the result as a string.  Helper printers must print to 
 string buffers.
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.Printf.btwprintf(System.Object,Microsoft.FSharp.Text.Format)">
<summary>
 Print to any subtype of TextWriter, but intermediary 
 printers write via a buffer, which is often the most convenient way to write
 intermediary printers.  Useful if your primitive printing functions 
 are defined to write to buffers, but you ultimately want to
 go to a file.
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.Printf.eprintf(Microsoft.FSharp.Text.Format)">
<summary>
 Formatted printing to stderr
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.Printf.eprintfn(Microsoft.FSharp.Text.Format)">
<summary>
 Formatted printing to stderr, adding a newline 
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.Printf.failwithf(Microsoft.FSharp.Text.Format)">
<summary>
 Print to a string buffer and raise an exception with the given
 result.   Helper printers must return strings.
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.Printf.fprintf(System.IO.TextWriter,Microsoft.FSharp.Text.Format)">
<summary>
 Print to a text writer or an OCaml-compatible channel
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.Printf.fprintfn(System.IO.TextWriter,Microsoft.FSharp.Text.Format)">
<summary>
 Print to a text writer or an OCaml-compatible channel, adding a newline
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.Printf.gprintf(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Text.Format)">
<summary>
A building block for processing format strings.  This processes the format character at
the given position (which normally follows a '%' in a format
string) and produces an 'obj' which can be dynamically cast to
a type that depends on the format specifier. 

The function 'cont' is called to produce the object that will be returned
after this part of the format is processed.

The function 'outa' is called to process the 'c values returned by 'a' and 't' specifiers.

The function 'outc' is called to emit characters.

The intentional type representation 'ty' should be the representation of the expected
return type for the formatting.
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.Printf.kbprintf(Microsoft.FSharp.Core.FastFunc,System.Text.StringBuilder,Microsoft.FSharp.Text.Format)">
<summary>
 bprintf, but call the given 'final' function to generate the result.
 See [[kprintf]].
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.Printf.kbsprintf(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Text.Format)">
<summary>
 bsprintf, but call the given 'final' function to generate the result.
 See [[kprintf]].
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.Printf.kfprintf(Microsoft.FSharp.Core.FastFunc,System.IO.TextWriter,Microsoft.FSharp.Text.Format)">
<summary>
 fprintf, but call the given 'final' function to generate the result.
 See [[kprintf]].
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.Printf.kprintf(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Text.Format)">
<summary>
 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. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.Printf.ksprintf(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Text.Format)">
<summary>
 sprintf, but call the given 'final' function to generate the result.
 See [[kprintf]].
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.Printf.ktwprintf(Microsoft.FSharp.Core.FastFunc,System.Object,Microsoft.FSharp.Text.Format)">
<summary>
 twprintf, but call the given 'final' function to generate the result.
 See [[kprintf]].
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.Printf.printf(Microsoft.FSharp.Text.Format)">
<summary>
 Formatted printing to stdout
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.Printf.printfn(Microsoft.FSharp.Text.Format)">
<summary>
 Formatted printing to stdout, adding a newline 
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.Printf.sprintf(Microsoft.FSharp.Text.Format)">
<summary>
 Print to a string via an internal string buffer and return 
 the result as a string.  Helper printers must return strings.
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.Printf.twprintf(System.Object,Microsoft.FSharp.Text.Format)">
<summary>
 Print to any subtype of the .NET type System.IO.TextWriter
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.Printf.twprintfn(System.Object,Microsoft.FSharp.Text.Format)">
<summary>
 Print to any subtype of the .NET type System.IO.TextWriter, and add a newline
</summary>
</member>
<member name="T:Microsoft.FSharp.Text.Printf">
<summary> Extensible printf-style formatting for numbers and other datatypes
</summary>
 <remarks>
 <p>Format specifications are strings with "%" markers indicating format 
  placeholders. Format placeholders consist of:</p>
 <pre>
    %[flags][width][.precision][type]
 </pre> 
 <p>where the type is interpreted as follows:</p>
 <pre>
    %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.StructuredFormat.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)
 </pre>
 <p>Valid flags are: </p>
 <pre>
     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)
 </pre>
 <p>The printf '#' flag is not supported in this release and a compile-time 
  error will be reported if it is used.</p>
 </remarks>
 <examples>
 <pre>
   Printf.printf "Hello %s, %d = %d * %d" "World" 6 2 3;
   Printf.sprintf "Hello %s" "World";
   Printf.printf "Hello %a" output_string "World";
 </pre>
 </examples>
</member>
<member name="P:Microsoft.FSharp.Text.StructuredFormat.FormatOptions.Default">

</member>
<member name="T:Microsoft.FSharp.Text.StructuredFormat.FormatOptions">
<summary>
 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.

 <example>
 From F# Interactive the default settings can be adjusted using, for example, 
 <pre>
   open Microsoft.FSharp.Compiler.Interactive.Settings;;
   setPrintWidth 120;;
 </pre>
 </example>
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.IEnvironment.GetLayout(System.Object)">
<summary>
 Return to the layout-generation 
 environment to layout any otherwise uninterpreted object
</summary>
</member>
<member name="P:Microsoft.FSharp.Text.StructuredFormat.IEnvironment.MaxColumns">
<summary>
 The maximum number of elements for which to generate layout for 
 list-like structures, or columns in table-like 
 structures.  -1 if no maximum.
</summary>
</member>
<member name="P:Microsoft.FSharp.Text.StructuredFormat.IEnvironment.MaxRows">
<summary>
 The maximum number of rows for which to generate layout for table-like 
 structures.  -1 if no maximum.
</summary>
</member>
<member name="T:Microsoft.FSharp.Text.StructuredFormat.IEnvironment">

</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.IFormattable.GetLayout(Microsoft.FSharp.Text.StructuredFormat.IEnvironment)">
<summary>
 Generate an object representing a structured formatting of the
 term.
</summary>
</member>
<member name="T:Microsoft.FSharp.Text.StructuredFormat.IFormattable">

</member>
<member name="T:Microsoft.FSharp.Text.StructuredFormat.Joint">
<summary>
 Data representing joints in structured layouts of terms.  The representation
 of this data type is only for the consumption of formatting engines.
</summary>
</member>
<member name="T:Microsoft.FSharp.Text.StructuredFormat.Layout">
<summary>
 Data representing structured layouts of terms.  The representation
 of this data type is only for the consumption of formatting engines.
</summary>
</member>
<member name="T:Microsoft.FSharp.Text.StructuredFormat.joint">
<summary>
 Data representing joints in structured layouts of terms.  The representation
 of this data type is only for the consumption of formatting engines.
</summary>
</member>
<member name="T:Microsoft.FSharp.Text.StructuredFormat.layout">
<summary>
 Data representing structured layouts of terms.  The representation
 of this data type is only for the consumption of formatting engines.
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.Display.any_to_layout(Microsoft.FSharp.Text.StructuredFormat.FormatOptions,System.Object)">
<summary>
 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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.Display.any_to_string(System.Object)">
<summary>
 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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.Display.layout_as_string(Microsoft.FSharp.Text.StructuredFormat.FormatOptions,System.Object)">

</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.Display.layout_to_string(Microsoft.FSharp.Text.StructuredFormat.FormatOptions,Microsoft.FSharp.Text.StructuredFormat.Layout)">

</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.Display.output_any(System.Object,System.Object)">
<summary>
 Ouput any value to a channel using the same set of formatting rules
 as any_to_string
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.Display.output_layout(Microsoft.FSharp.Text.StructuredFormat.FormatOptions,System.Object,Microsoft.FSharp.Text.StructuredFormat.Layout)">

</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.Display.squash_layout(Microsoft.FSharp.Text.StructuredFormat.FormatOptions,Microsoft.FSharp.Text.StructuredFormat.Layout)">

</member>
<member name="T:Microsoft.FSharp.Text.StructuredFormat.Display">

</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.aboveL(Microsoft.FSharp.Text.StructuredFormat.Layout,Microsoft.FSharp.Text.StructuredFormat.Layout)">
<summary>
 Layout two vertically.
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.aboveListL(Microsoft.FSharp.Collections.List)">
<summary>
 Layout list vertically.    
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.braceL(Microsoft.FSharp.Text.StructuredFormat.Layout)">
<summary>
 Wrap braces around layout.        
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.bracketL(Microsoft.FSharp.Text.StructuredFormat.Layout)">
<summary>
 Wrap round brackets around layout.
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.commaListL(Microsoft.FSharp.Collections.List)">
<summary>
 Join layouts into a comma separated list.
</summary>
</member>
<member name="P:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.emptyL">
<summary>
 The empty layout
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.isEmptyL(Microsoft.FSharp.Text.StructuredFormat.Layout)">
<summary>
 Is it the empty layout?
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.leftL(System.String)">
<summary>
 An string which is left  parenthesis (no space on the right).
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.listL(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Collections.List)">
<summary>
 Layout like an F# list.    
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.objL(System.Object)">
<summary>
 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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.op_AtAt(Microsoft.FSharp.Text.StructuredFormat.Layout,Microsoft.FSharp.Text.StructuredFormat.Layout)">
<summary>
 Join broken with ident=0
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.op_AtAtMinus(Microsoft.FSharp.Text.StructuredFormat.Layout,Microsoft.FSharp.Text.StructuredFormat.Layout)">
<summary>
 Join broken with ident=1 
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.op_AtAtMinusMinus(Microsoft.FSharp.Text.StructuredFormat.Layout,Microsoft.FSharp.Text.StructuredFormat.Layout)">
<summary>
 Join broken with ident=2 
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.op_Decrement(Microsoft.FSharp.Text.StructuredFormat.Layout,Microsoft.FSharp.Text.StructuredFormat.Layout)">
<summary>
 Join, possible break with indent=1
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.op_DollarDollar(Microsoft.FSharp.Text.StructuredFormat.Layout,Microsoft.FSharp.Text.StructuredFormat.Layout)">
<summary>
 Join, unbreakable. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.op_Increment(Microsoft.FSharp.Text.StructuredFormat.Layout,Microsoft.FSharp.Text.StructuredFormat.Layout)">
<summary>
 Join, possible break with indent=0
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.op_MinusMinusMinus(Microsoft.FSharp.Text.StructuredFormat.Layout,Microsoft.FSharp.Text.StructuredFormat.Layout)">
<summary>
 Join, possible break with indent=2 
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.optionL(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Core.Option)">
<summary>
 Layout like an F# option.
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.rightL(System.String)">
<summary>
 An string which is right parenthesis (no space on it's left).
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.semiListL(Microsoft.FSharp.Collections.List)">
<summary>
 Join layouts into a semi-colon separated list.
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.sepL(System.String)">
<summary>
 An string which requires no spaces either side.
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.sepListL(Microsoft.FSharp.Text.StructuredFormat.Layout,Microsoft.FSharp.Collections.List)">
<summary>
 Join layouts into a list separated using the given layout.
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.spaceListL(Microsoft.FSharp.Collections.List)">
<summary>
 Join layouts into a space separated list.    
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.squareBracketL(Microsoft.FSharp.Text.StructuredFormat.Layout)">
<summary>
 Wrap square brackets around layout.    
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.tagAttrL(System.String,Microsoft.FSharp.Collections.List,Microsoft.FSharp.Text.StructuredFormat.Layout)">
<summary>
 See tagL
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.tagL(System.String,Microsoft.FSharp.Text.StructuredFormat.Layout)">
<summary>
 An tag is a name which can be wrapped around a layout.
 Tag names convey structure to renderers, e.g. for syntax coloring
 or hyperlinks.  Standard tag names are in the process
 of being finalized, though 'html:a' may be used for hyperlinks.
 tagAttrL provides settings for attributes associated with the
 tag, e.g. 'href' for 'html:a'.
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.tupleL(Microsoft.FSharp.Collections.List)">
<summary>
 Form tuple of layouts.            
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.unfoldL(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Core.FastFunc,System.Object,System.Int32)">
<summary>
 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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Text.StructuredFormat.LayoutOps.wordL(System.String)">
<summary>
 An string leaf 
</summary>
</member>
<member name="T:Microsoft.FSharp.Text.StructuredFormat.LayoutOps">
<summary>
 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.
</summary>
</member>
<member name="M:Microsoft.FSharp.Tools.FsLex.AsciiTables.Create(System.Byte[]`1[],System.Byte[]`1)">

</member>
<member name="M:Microsoft.FSharp.Tools.FsLex.AsciiTables.Interpret(System.Int32,Microsoft.FSharp.Tools.FsLex.LexBuffer)">
<summary>
 Interpret tables for an ascii lexer generated by fslex. 
</summary>
</member>
<member name="T:Microsoft.FSharp.Tools.FsLex.AsciiTables">
<summary>
 The type of tables for an ascii lexer generated by fslex. 
</summary>
</member>
<member name="M:Microsoft.FSharp.Tools.FsLex.LexBuffer`2.DiscardInput">
<summary>
 Remove all input, though don't discard the current lexeme 
</summary>
</member>
<member name="M:Microsoft.FSharp.Tools.FsLex.LexBuffer`2.FromByteFunction(System.Object,Microsoft.FSharp.Core.FastFunc)">

</member>
<member name="M:Microsoft.FSharp.Tools.FsLex.LexBuffer`2.FromBytes(System.Object,System.Byte[]`1)">
<summary>
 Adjust the start position associated with the lexbuf
</summary>
</member>
<member name="M:Microsoft.FSharp.Tools.FsLex.LexBuffer`2.FromCharFunction(System.Object,Microsoft.FSharp.Core.FastFunc)">

</member>
<member name="M:Microsoft.FSharp.Tools.FsLex.LexBuffer`2.FromChars(System.Object,System.Char[]`1)">

</member>
<member name="M:Microsoft.FSharp.Tools.FsLex.LexBuffer`2.LexemeChar(System.Int32)">
<summary>
 Fetch a particular character in the matched string 
</summary>
</member>
<member name="P:Microsoft.FSharp.Tools.FsLex.LexBuffer`2.EndPos">
<summary>
 The end position for the lexeme
</summary>
</member>
<member name="P:Microsoft.FSharp.Tools.FsLex.LexBuffer`2.IsPastEndOfStream">
<summary>
 True if the refill of the buffer ever failed , or if explicitly set to true.
</summary>
</member>
<member name="P:Microsoft.FSharp.Tools.FsLex.LexBuffer`2.Lexeme">
<summary>
 The matched string 
</summary>
</member>
<member name="P:Microsoft.FSharp.Tools.FsLex.LexBuffer`2.LexemeLength">
<summary>
 The length of the matched string 
</summary>
</member>
<member name="P:Microsoft.FSharp.Tools.FsLex.LexBuffer`2.MatchEvent">
<summary>
 This event is fired each time a lexeme is matched by a client lexer
</summary>
</member>
<member name="P:Microsoft.FSharp.Tools.FsLex.LexBuffer`2.StartPos">
<summary>
 The start position for the lexeme
</summary>
</member>
<member name="P:Microsoft.FSharp.Tools.FsLex.LexBuffer`2.EndPos(System.Object)">
<summary>
 The end position for the lexeme
</summary>
</member>
<member name="P:Microsoft.FSharp.Tools.FsLex.LexBuffer`2.IsPastEndOfStream(System.Boolean)">
<summary>
 True if the refill of the buffer ever failed , or if explicitly set to true.
</summary>
</member>
<member name="P:Microsoft.FSharp.Tools.FsLex.LexBuffer`2.StartPos(System.Object)">
<summary>
 The start position for the lexeme
</summary>
</member>
<member name="T:Microsoft.FSharp.Tools.FsLex.LexBuffer`2">

</member>
<member name="M:Microsoft.FSharp.Tools.FsYacc.IParseState`1.EndOfRHS(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Tools.FsYacc.IParseState`1.GetData(System.Int32)">

</member>
<member name="M:Microsoft.FSharp.Tools.FsYacc.IParseState`1.RaiseError">

</member>
<member name="M:Microsoft.FSharp.Tools.FsYacc.IParseState`1.StartOfRHS(System.Int32)">

</member>
<member name="P:Microsoft.FSharp.Tools.FsYacc.IParseState`1.EndOfLHS">

</member>
<member name="P:Microsoft.FSharp.Tools.FsYacc.IParseState`1.StartOfLHS">

</member>
<member name="T:Microsoft.FSharp.Tools.FsYacc.IParseState`1">

</member>
<member name="M:Microsoft.FSharp.Tools.FsYacc.Tables`2.Interpret(Microsoft.FSharp.Core.FastFunc,Microsoft.FSharp.Tools.FsLex.LexBuffer,System.Int32)">

</member>
<member name="T:Microsoft.FSharp.Tools.FsYacc.Tables`2">

</member>
<member name="T:Microsoft.FSharp.Tools.FsYacc.AcceptExceptionException">

</member>
<member name="T:Microsoft.FSharp.Tools.FsYacc.RecoverableParseErrorExceptionException">

</member>
<member name="M:Microsoft.FSharp.Tools.FsYacc.ParseHelpers.parse_error(System.String)">

</member>
<member name="T:Microsoft.FSharp.Tools.FsYacc.ParseHelpers">

</member>
<member name="T:Resizearray">

</member>
<member name="M:System.Converter.Invoke(System.Object)">

</member>
<member name="T:System.Converter">

</member>
</members>
</doc>