diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.Build.dll b/tools/FSharp_1.9.6.16/bin/FSharp.Build.dll
new file mode 100644
index 00000000..c0d2908e
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/FSharp.Build.dll differ
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.Compiler.CodeDom.dll b/tools/FSharp_1.9.6.16/bin/FSharp.Compiler.CodeDom.dll
new file mode 100644
index 00000000..7851c1d3
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/FSharp.Compiler.CodeDom.dll differ
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.Compiler.CodeDom.xml b/tools/FSharp_1.9.6.16/bin/FSharp.Compiler.CodeDom.xml
new file mode 100644
index 00000000..93ee6ac8
--- /dev/null
+++ b/tools/FSharp_1.9.6.16/bin/FSharp.Compiler.CodeDom.xml
@@ -0,0 +1,679 @@
+
+
+FSharp.Compiler.CodeDom
+
+
+
+ The total number of elements in the set
+
+
+
+
+ Remove the given element from the set
+
+
+
+
+ Apply the given function to each binding in the hash table
+
+
+
+
+ Apply the given function to the set threading the accumulating parameter
+ through the sequence of function applications
+
+
+
+
+ Create a new empty mutable hash set
+ with key hash/equality based on the F# structural "hash" and (=) functions
+
+
+
+
+ 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
+
+
+
+
+ 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
+
+
+
+
+ Create a new mutable hash set containing elements drawn from the given sequence
+
+
+
+
+ Make a shallow copy of the set
+
+
+
+
+ Test if the set contains the given element
+
+
+
+
+ Clear all elements from the set
+
+
+
+
+ Add an element to the collection
+
+
+
+
+ Create a new empty mutable hash set
+ with key hash/equality based on the F# structural "hash" and (=) functions
+
+
+
+
+ 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
+
+
+
+
+ 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
+
+
+
+
+ Create a new mutable hash set containing elements drawn from the given sequence
+
+
+
+
+ Mutable hash sets based by default on F# structural "hash" and (=) functions. Implemented via a hash table and/or Dictionary.
+
+
+
+
+ The default location of FSharp.Core.dll and fsc.exe based on the version of fsc.exe that is running
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Implementation of the CodeDomProvider for the F# language.
+ This is specialized version that can be used with ASP.NET.
+
+
+
+
+
+
+
+ Implementation of the CodeDomProvider for the F# language.
+ If you intend to use CodeDom with ASP.NET you should use FSharpAspNetCodeProvider instead.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Where are we generating member?
+
+
+
+
+
+
+
+ Generates code for binary operator using function for left and right operand
+
+
+
+
+ Process collection - keeps context through the whole processing
+ calls 'f' for every element in sequence and 'fs' between every two elements
+ as a separator
+
+
+
+
+
+
+
+ Call specified function only on elements of specified type.
+ (performs dynamic type test using x.GetType())
+
+
+
+
+ Process collection - keeps context through the whole processing
+ calls 'f' for every element in sequence and 'fs' between every two elements
+ as a separator. This is a variant that works on typed collections.
+
+
+
+
+ Returns F# conversion function for the specified type (or empty string)
+
+
+
+
+
+
+
+ Create context using specified text writer and options
+
+
+
+
+ Create closure to do the counting
+ (this is usend when we need indexing during collection processing)
+
+
+
+
+
+
+
+ Call function, but give it context as an argument
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Generate array initializer. Checks generator options for ASP.NET workaround.
+
+
+
+
+
+
+
+ Generates expression which is casted to the inferred type using "(unbox (box e))"
+ this is useful if the environment where it is used specifies the type explicitly
+ for example in array initializers
+
+
+
+
+
+
+
+
+
+
+ Generates method code, adds OverloadID attribute when index isn't "-1"
+ Generates comments and than calls 'generatMethod'
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Generate code for compile unit (file)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Generate expression - with unkonw type
+
+
+
+
+ Generates expression, but generates "this" if the expression is null
+ (used in field reference etc. because some CodeDOM generators do this
+ though I believe it is a mistake)
+
+
+
+
+
+
+
+ fields
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Abstract method in the interface
+
+
+
+
+ Abstract property in the interface
+
+
+
+
+
+
+
+ Generates a main method.
+
+
+
+
+ By default all CodeDOM generated methods are 'virtual' which means that
+ we have to generate "abstract and default" (unless we're in struct or
+ we're implementing an interface, or the method is overriden)
+ (NOTE: the same logic isn't properly implemented for properties)
+
+
+
+
+ Generate code for namespace without compilation unit
+
+
+
+
+ Generates namespace code - takes output from 'preprocessNamespace'
+
+
+
+
+
+
+
+ Generate value of primitive expression
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Generate type arguments using context
+
+
+
+
+
+
+
+ Generate code for type declaration (not included in namespace)
+
+
+
+
+ Generate type reference using context
+ (this is most commonly used method)
+
+
+
+
+ Get type reference, but don't rename .NET types to F# types
+ (this is only needed when calling static methods on the type)
+
+
+
+
+
+
+
+ Generates type reference (not for arrays)
+
+
+
+
+ Generate type reference with empty context
+
+
+
+
+
+
+
+
+
+
+ Get full type reference using information from context
+
+
+
+
+ Get full type reference string using empty context
+
+
+
+
+ Identity function
+
+
+
+
+
+
+
+
+
+
+ Are both types numerical types where numeric conversion function can be applied?
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Perform map and filter operations in one
+
+
+
+
+ Output string as a valid F# identifier
+
+
+
+
+ Append specified string without line-break
+
+
+
+
+ Function composition operator
+
+
+
+
+ Break-line and append specified string
+
+
+
+
+ Returns CodeNamespace, list of classes with scope (which includes class names
+ of containing classes and sequence of class renames)
+
+
+
+
+ Preprocess collection with type parameters
+ Returns array to be used with usingTyParams and
+ function to be called to generate < ... > code
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Print object converted to string
+
+
+
+
+ Tries to resolve type of a variable and adds it to the Context dictionary
+
+
+
+
+ Tries to resolve type of an expression using a few tricks:
+ * Fields of current type may have known type
+ * Properties of current type as well
+ * We can also try to resolve other properties (sometimes it helps)
+ * Resolve type for local variables or argument reference
+
+
+
+
+ Get System.Type of know type (either standard type or resolved)
+
+
+
+
+ Tries to resolve if type is an array, so we can generate
+ appropriate code (it can be either indexer or array, but we need to generate
+ .Item call for indexers (no overloading is supported by .[]).
+ Returns: "None" - can't resolve, "Some" resovled (true/false - is it an array?)
+
+
+
+
+ Print unique id using: "+> uniqid"
+
+
+
+
+ Record specified type parameters in the context, call generating function
+ and then restore the original type parameters
+ (this works if someone uses nested type parameters with the same name)
+
+
+
+
+ Matches array or indexer expression and corrects it if the generated CodeDOM is incorrect
+
+
+
+
+ Tries to find .NET type for specified type name
+ This is used when we need to know type in order to generate something correctly,
+ but it's just a fallback case
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Walks through the CodeDom tree and keeps current "scope" and the result.
+ The result is collected through entire tree, but the modified scope is
+ passed only to sub-nodes of the current node.
+
+ First argument is a function that is called for nodes and has a
+ function as a first argument, scope and result as a second and current node as a third.
+ The function argument can be used to walk deeper in the tree if wanted.
+
+
+
+
+
+
+
+ Search for members and return flat list of selected members
+ Function given as an argument returns tuple - first item specifies
+ if the current element should be included in the result, the second
+ specifies if we should walk through child members of the current object
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.Compiler.Interactive.Settings.dll b/tools/FSharp_1.9.6.16/bin/FSharp.Compiler.Interactive.Settings.dll
new file mode 100644
index 00000000..abce86fa
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/FSharp.Compiler.Interactive.Settings.dll differ
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.Compiler.Server.Shared.dll b/tools/FSharp_1.9.6.16/bin/FSharp.Compiler.Server.Shared.dll
new file mode 100644
index 00000000..21b8c20a
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/FSharp.Compiler.Server.Shared.dll differ
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.Compiler.dll b/tools/FSharp_1.9.6.16/bin/FSharp.Compiler.dll
new file mode 100644
index 00000000..7abe6923
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/FSharp.Compiler.dll differ
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.Core.dll b/tools/FSharp_1.9.6.16/bin/FSharp.Core.dll
new file mode 100644
index 00000000..56f1b6cd
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/FSharp.Core.dll differ
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.Core.pdb b/tools/FSharp_1.9.6.16/bin/FSharp.Core.pdb
new file mode 100644
index 00000000..5dac0d2e
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/FSharp.Core.pdb differ
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.Core.xml b/tools/FSharp_1.9.6.16/bin/FSharp.Core.xml
new file mode 100644
index 00000000..376bd4cc
--- /dev/null
+++ b/tools/FSharp_1.9.6.16/bin/FSharp.Core.xml
@@ -0,0 +1,8099 @@
+
+
+FSharp.Core
+
+
+
+ Gets the tail of the list, which is a list containing all the elements of the list, excluding the first element
+
+
+
+
+ Gets the number of items contained in the list
+
+
+
+
+ Get the element of the list at the given position. Note lists are represented
+ as linked lists so this is an O(n) operation.
+
+
+
+
+ Gets a value indicating if the list contains no entries
+
+
+
+
+ Gets the first element of the list
+
+
+
+
+ Returns an empty list of a particular type
+
+
+
+
+ Returns a list with head as its first element and tail as its subsequent elements
+
+
+
+
+ The type of immutable singly-linked lists.
+
+ Use the constructors [] and :: (infix) to create values of this type, or
+ the notation [1;2;3]. Use the values in the List module to manipulate
+ values of this type, or pattern match against the values directly.
+
+
+
+
+ An abbreviation for the type of immutable singly-linked lists.
+
+
+
+
+ Lookup an element in the map. Raise KeyNotFoundException if no binding
+ exists in the map.
+
+
+
+
+ Return true if there are no bindings in the map.
+
+
+
+
+ The empty map
+
+
+
+
+ The number of bindings in the map
+
+
+
+
+ Lookup an element in the map, returning a Some value if the element is in the domain
+ of the map and None if not.
+
+
+
+
+ Remove an element from the domain of the map. No exception is raised if the element is not present.
+
+
+
+
+
+
+
+ Test if an element is in the domain of the map
+
+
+
+
+ Return a new map with the binding added to the given map.
+
+
+
+
+ Build a map that contains the bindings of the given IEnumerable
+
+
+
+
+ Immutable maps. Keys are ordered by F# generic comparison.
+
+
+ Maps based on generic comparison are efficient for small keys. They are not a suitable choice if keys are recursive data structures
+ or if keys require bespoke comparison semantics.
+
+
+
+
+
+ An abbreviation for the .NET type System.Collections.Generic.List<_>
+
+
+
+
+ Return a new set with the elements of the second set removed from the first.
+
+
+
+
+ Compute the union of the two sets.
+
+
+
+
+ Returns the lowest element in the set according to the ordering being used for the set
+
+
+
+
+ Returns the highest element in the set according to the ordering being used for the set
+
+
+
+
+ A useful shortcut for Set.isEmpty. See the Set module for further operations on sets.
+
+
+
+
+ The empty set for the type 'T.
+
+
+
+
+ The number of elements in the set
+
+
+
+
+ Return a new set with the elements of the second set removed from the first.
+
+
+
+
+ A useful shortcut for Set.remove. Note this operation produces a new set
+ and does not mutate the original set. The new set will share many storage
+ nodes with the original. See the Set module for further operations on sets.
+
+
+
+
+ Evaluates to "true" if all elements of the first set are in the second
+
+
+
+
+ Evaluates to "true" if all elements of the second set are in the first
+
+
+
+
+ Returns the greatest element in the set that is less than the given key
+ according to the ordering being used for the set
+
+
+
+
+ Returns the least element in the set that is greater than the given key
+ according to the ordering being used for the set
+
+
+
+
+
+
+
+ A useful shortcut for Set.contains. See the Set module for further operations on sets.
+
+
+
+
+ A useful shortcut for Set.add. Note this operation produces a new set
+ and does not mutate the original set. The new set will share many storage
+ nodes with the original. See the Set module for further operations on sets.
+
+
+
+
+ Create a set containing elements drawn from the given sequence.
+
+
+
+
+ Immutable sets based on binary trees, where comparison is the
+ F# structural comparison function, potentially using implementations
+ of the IComparable interface on key values.
+
+ See the Set module for further operations on sets.
+
+ These sets can be used with elements of any type, but you should check that
+ structural hashing and equality on the element type are correct for your type.
+
+
+
+
+ An abbreviation for the type of immutable singly-linked lists.
+
+ Use the constructors [] and :: (infix) to create values of this type, or
+ the notation [1;2;3]. Use the values in the List module to manipulate
+ values of this type, or pattern match against the values directly.
+
+
+
+
+ An abbreviation for the .NET type System.Collections.Generic.IEnumerable<_>
+
+
+
+
+ Fetch the base-index for the first dimension of the array.
+
+ See notes on the Array2D module re. zero-basing.
+
+
+
+
+ Fetch the base-index for the second dimension of the array.
+
+ See notes on the Array2D module re. zero-basing.
+
+
+
+
+ Read a range of elements from the first array and write them into the second.
+
+
+
+
+ Build a new array whose elements are the same as the input array.
+
+ For non-zero-based arrays the basing on an input array will be propogated to the output
+ array.
+
+
+
+
+ Create an array whose elements are all initially the given value
+
+
+
+
+ Create a based array whose elements are all initially the given value
+
+
+
+
+
+
+
+ Fetch an element from a 2D array. You can also use the syntax 'array.[index1,index2]'
+
+
+
+
+ Create an array given the dimensions and a generator function to compute the elements.
+
+
+
+
+ Create a based array given the dimensions and a generator function to compute the elements.
+
+
+
+
+
+
+
+ Apply the given function to each element of the array.
+
+
+
+
+ Apply the given function to each element of the array. The integer indicies passed to the
+ function indicates the index of element.
+
+
+
+
+ Return the length of an array in the first dimension
+
+
+
+
+ Return the length of an array in the second dimension
+
+
+
+
+ Build a new array whose elements are the results of applying the given function
+ to each of the elements of the array.
+
+ For non-zero-based arrays the basing on an input array will be propogated to the output
+ array.
+
+
+
+
+ Build a new array whose elements are the results of applying the given function
+ to each of the elements of the array. The integer indices passed to the
+ function indicates the element being transformed.
+
+ For non-zero-based arrays the basing on an input array will be propogated to the output
+ array.
+
+
+
+
+ Build a new array whose elements are the same as the input array but
+ where a non-zero-based input array generates a corresponding zero-based
+ output array.
+
+
+
+
+ Set the value of an element in an array. You can also use the syntax 'array.[index1,index2] <- value'
+
+
+
+
+
+
+
+ Create an array where the entries are initially Unchecked.defaultof<'T>.
+
+
+
+
+ Create a based array where the entries are initially Unchecked.defaultof<'T>.
+
+
+
+
+
+
+
+
+
+
+ Basic operations on 2-dimensional arrays.
+
+ F# and .NET multi-dimensional arrays are typically zero-based.
+ However, .NET multi-dimensional arrays used in conjunction with external
+ libraries (e.g. libraries associated with Visual Basic) be
+ non-zero based, using a potentially different base for each dimension.
+ The operations in this module will accept such arrays, and
+ the basing on an input array will be propogated to a matching output
+ array on the Array2D.map and Array2D.mapi operations.
+ Non-zero-based arrays can also be created using Array2D.zero_create_based,
+ Array2D.create_based and Array2D.init_based.
+
+
+
+
+ Create an array whose elements are all initially the given value
+
+
+
+
+ Fetch an element from a 3D array. You can also use the syntax 'array.[index1,index2,index3]'
+
+
+
+
+ Create an array given the dimensions and a generator function to compute the elements.
+
+
+
+
+ Apply the given function to each element of the array.
+
+
+
+
+ Apply the given function to each element of the array. The integer indicies passed to the
+ function indicates the index of element.
+
+
+
+
+ Return the length of an array in the first dimension
+
+
+
+
+ Return the length of an array in the second dimension
+
+
+
+
+ Return the length of an array in the third dimension
+
+
+
+
+ Build a new array whose elements are the results of applying the given function
+ to each of the elements of the array.
+
+ For non-zero-based arrays the basing on an input array will be propogated to the output
+ array.
+
+
+
+
+ Build a new array whose elements are the results of applying the given function
+ to each of the elements of the array. The integer indices passed to the
+ function indicates the element being transformed.
+
+ For non-zero-based arrays the basing on an input array will be propogated to the output
+ array.
+
+
+
+
+ Set the value of an element in an array. You can also
+ use the syntax 'array.[index1,index2,index3] <- value'.
+
+
+
+
+ Create an array where the entries are initially the "default" value.
+
+
+
+
+
+
+
+ Basic operations on rank 3 arrays.
+
+
+
+
+ Create an array whose elements are all initially the given value
+
+
+
+
+ Fetch an element from a 4D array. You can also use the syntax 'array.[index1,index2,index3,index4]'
+
+
+
+
+ Create an array given the dimensions and a generator function to compute the elements.
+
+
+
+
+ Return the length of an array in the first dimension
+
+
+
+
+ Return the length of an array in the second dimension
+
+
+
+
+ Return the length of an array in the third dimension
+
+
+
+
+ Return the length of an array in the fourth dimension
+
+
+
+
+ Set the value of an element in an array. You can also
+ use the syntax 'array.[index1,index2,index3,index4] <- value'.
+
+
+
+
+ Create an array where the entries are initially the "default" value.
+
+
+
+
+ Basic operations on rank 4 arrays.
+
+
+
+
+ Build a new array that contains the elements of the first array followed by the elements of the second array
+
+
+
+
+ Return the average of the elements in the array. If the array is empty an ArgumentException is thrown.
+
+
+
+
+ Return the average of the elements generated by applying the function to each element of the array.
+ If the array is empty an ArgumentException is thrown.
+
+
+
+
+
+
+
+ Read a range of elements from the first array and write them into the second.
+
+
+
+
+ Apply the given function to each element of the array. Return
+ the array comprised of the results "x" for each element where
+ the function returns Some(x)
+
+
+
+
+ For each element of the array, apply the given function. Concatenate all the results and return the combined array.
+
+
+
+
+
+
+
+ Build a new array that contains the elements of each of the given sequence of arrays
+
+
+
+
+ Build a new array that contains the elements of the given array
+
+
+
+
+ Create an array whose elements are all initially the given value.
+
+
+
+
+ Return an empty array of the given type
+
+
+
+
+ Test if any element of the array satisfies the given predicate.
+
+ The predicate is applied to the elements of the input array. If any application
+ returns true then the overall result is true and no further elements are tested.
+ Otherwise, false is returned.
+
+
+
+
+ Test if any pair of corresponding elements of the arrays satisfies the given predicate.
+
+ The predicate is applied to matching elements in the two collections up to the lesser of the
+ two lengths of the collections. If any application returns true then the overall result is
+ true and no further elements are tested. Otherwise, if one collections is longer
+ than the other then the ArgumentException exception is raised.
+ Otherwise, false is returned.
+
+
+
+
+ Fill a range of elements of the array with the given value.
+
+
+
+
+ Return a new collection containing only the elements of the collection
+ for which the given predicate returns "true"
+
+
+
+
+ Return the first element for which the given function returns 'true'.
+ Raise KeyNotFoundException if no such element exists.
+
+
+
+
+ Return the index of the first element in the array
+ that satisfies the given predicate. Raise KeyNotFoundException if
+ none of the elements satisy the predicate.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Apply a function to each element of the collection, threading an accumulator argument
+ through the computation. If the input function is f and the elements are i0...iN then computes
+ f (... (f s i0)...) iN
+
+
+
+
+ Apply a function to pairs of elements drawn from the two collections,
+ left-to-right, threading an accumulator argument
+ through the computation. The two input
+ arrays must have the same lengths, otherwise an ArgumentException is
+ raised.
+
+
+
+
+ Apply a function to each element of the array, threading an accumulator argument
+ through the computation. If the input function is f and the elements are i0...iN then computes
+ f i0 (...(f iN s))
+
+
+
+
+ Apply a function to pairs of elements drawn from the two collections, right-to-left,
+ threading an accumulator argument through the computation. The two input
+ arrays must have the same lengths, otherwise an ArgumentException is
+ raised.
+
+
+
+
+
+
+
+ Apply a function to pairs of elements drawn from the two collections,
+ left-to-right, threading an accumulator argument
+ through the computation. The two input
+ arrays must have the same lengths, otherwise an ArgumentException is
+ raised.
+
+
+
+
+ Apply a function to each element of the array, threading an accumulator argument
+ through the computation. If the input function is f and the elements are i0...iN
+ then computes f i0 (...(f iN s))
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Test if all elements of the array satisfy the given predicate.
+
+ The predicate is applied to the elements of the input collection. If any application
+ returns false then the overall result is false and no further elements are tested.
+ Otherwise, true is returned.
+
+
+
+
+ Test if all corresponding elements of the array satisfy the given predicate pairwise.
+
+ The predicate is applied to matching elements in the two collections up to the lesser of the
+ two lengths of the collections. If any application returns false then the overall result is
+ false and no further elements are tested. Otherwise, if one collection is longer
+ than the other then the ArgumentException exception is raised.
+ Otherwise, true is returned.
+
+
+
+
+ Get an element from an array
+
+
+
+
+ Create an array given the dimension and a generator function to compute the elements.
+
+
+
+
+ Return true if the given array is empty, otherwise false
+
+
+
+
+
+
+
+ Apply the given function to each element of the array.
+
+
+
+
+ Apply the given function to pair of elements drawn from matching indices in two arrays. The
+ two arrays must have the same lengths, otherwise an ArgumentException is
+ raised.
+
+
+
+
+ Apply the given function to each element of the array. The integer passed to the
+ function indicates the index of element.
+
+
+
+
+ Apply the given function to pair of elements drawn from matching indices in two arrays,
+ also passing the index of the elements. The two arrays must have the same lengths,
+ otherwise an ArgumentException is raised.
+
+
+
+
+ Return the length of an array. You can also use property arr.Length.
+
+
+
+
+
+
+
+ Build a new array whose elements are the results of applying the given function
+ to each of the elements of the array.
+
+
+
+
+ Build a new collection whose elements are the results of applying the given function
+ to the corresponding elements of the two collections pairwise. The two input
+ arrays must have the same lengths, otherwise an ArgumentException is
+ raised.
+
+
+
+
+ Build a new array whose elements are the results of applying the given function
+ to each of the elements of the array. The integer index passed to the
+ function indicates the index of element being transformed.
+
+
+
+
+ Build a new collection whose elements are the results of applying the given function
+ to the corresponding elements of the two collections pairwise, also passing the index of
+ the elements. The two input arrays must have the same lengths, otherwise an ArgumentException is
+ raised.
+
+
+
+
+ Return the greatest of all elements of the array, compared via Operators.max on the function result
+
+
+
+
+ Return the greatest of all elements of the array, compared via Operators.max on the function result
+
+
+
+
+
+
+
+ Return the lowest of all elements of the array, compared via Operators.min
+
+
+
+
+ Return the lowest of all elements of the array, compared via Operators.min on the function result
+
+
+
+
+
+
+
+ Build an array from the given list
+
+
+
+
+ Build a new array from the given enumerable object
+
+
+
+
+ Split the collection into two collections, containing the
+ elements for which the given predicate returns "true" and "false"
+ respectively
+
+
+
+
+ Returns an array with all elements permuted according to the
+ specified permutation
+
+
+
+
+ Apply the given function to successive elements, returning the first
+ result where function returns Some(x) for some x. If the function
+ never returns Some(x) then KeyNotFoundException is raised.
+
+
+
+
+ Apply a function to each element of the array, threading an accumulator argument
+ through the computation. If the input function is f and the elements are i0...iN
+ then computes f (... (f i0 i1)...) iN.
+ Raises ArgumentException if the array has size zero.
+
+
+
+
+ Apply a function to each element of the array, threading an accumulator argument
+ through the computation. If the input function is f and the elements are i0...iN
+ then computes f i0 (...(f iN-1 iN)).
+ Raises ArgumentException if the array has size zero.
+
+
+
+
+
+
+
+
+
+
+ Return a new array with the elements in reverse order
+
+
+
+
+ Like fold_left, but return the intermediary and final results
+
+
+
+
+ Like fold_right, but return both the intermediary and final results
+
+
+
+
+
+
+
+
+
+
+ Set an element of an array
+
+
+
+
+ Sort the elements of an array, returning a new array. Elements are compared using Operators.compare.
+
+
+
+
+ Sort the elements of an array, using the given projection for the keys and returning a new array. Elements are compared using Operators.compare.
+
+
+
+
+ Sort the elements of an array by mutating the array in-place, using the given comparison function. Elements are compared using Operators.compare.
+
+
+
+
+ Sort the elements of an array by mutating the array in-place, using the given projection for the keys. Elements are compared using Operators.compare.
+
+
+
+
+ Sort the elements of an array by mutating the array in-place, using the given comparison function as the order
+
+
+
+
+ Sort the elements of an array, using the given comparison function as the order, returning a new array
+
+
+
+
+ Sort the elements of an array, using the given projection for the keys. Elements are compared using Operators.compare.
+
+
+
+
+
+
+
+ Build a new array that contains the given subrange specified by
+ starting index and length.
+
+
+
+
+ Return the sum of the elements in the array
+
+
+
+
+ Return the sum of the results generated by applying the function to each element of the array.
+
+
+
+
+
+
+
+ Build a list from the given array
+
+
+
+
+ View the given array as a sequence
+
+
+
+
+ Return the first element for which the given function returns true.
+ Return None if no such element exists.
+
+
+
+
+ Return the index of the first element in the array
+ that satisfies the given predicate.
+
+
+
+
+ Apply the given function to successive elements, returning the first
+ result where function returns Some(x) for some x. If the function
+ never returns Some(x) then None is returned.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Split an array of pairs into two arrays
+
+
+
+
+ Split an array of triples into three arrays
+
+
+
+
+ Create an array where the entries are initially the default value Unchecked.defaultof<'T>.
+
+
+
+
+ Create an array where the entries are initially the default value Unchecked.defaultof<'T>.
+
+
+
+
+ Combine the two arrays into an array of pairs. The two arrays must have equal lengths, otherwise an ArgumentException is
+ raised.
+
+
+
+
+ Combine three arrays into an array of pairs. The three arrays must have equal lengths, otherwise an ArgumentException is
+ raised.
+
+
+
+
+ Basic operations on arrays
+
+
+
+
+ Compare using the given comparer function
+
+
+
+
+ Convert an existing IComparer object into a comparison function with a fast entry point
+ If comparer was originally built using ComparisonIdentity.FromFunction then the original function will be
+ returned
+
+
+
+
+ Convert an existing IComparer object into a comparison function with a fast entry point
+
+
+
+
+ Structural comparison. Compare using Operators.compare.
+
+
+
+
+ Common notions of comparison identity used with sorted data structures.
+
+
+
+
+ Hash using the given hashing and equality functions
+
+
+
+
+
+
+
+ Physical hashing (hash on reference identity of objects, and the contents of value types).
+ Hash using LanguagePrimitives.PhysicalEquality and LanguagePrimitives.PhysicalHash,
+ That is, for value types use GetHashCode and Object.Equals (if no other optimization available),
+ and for reference types use System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode and
+ reference equality.
+
+
+
+
+ Structural hashing. Hash using Operators.(=) and Operators.hash.
+
+
+
+
+ Common notions of value identity used with hash tables.
+
+
+
+
+ Return a new list that contains the elements of the first list
+ followed by elements of the second
+
+
+
+
+ Return the average of the elements in the list.
+ If the list is empty an ArgumentException is thrown.
+
+
+
+
+ Return the average of the elements generated by applying the function to each element of the list.
+ If the list is empty an ArgumentException is thrown.
+
+
+
+
+
+
+
+ Apply the given function to each element of the list. Return
+ the list comprised of the results x for each element where
+ the function returns Some(x)
+
+
+
+
+ For each element of the list, apply the given function. Concatenate all the results and return the combined list.
+
+
+
+
+
+
+
+ Return a new list that contains the elements of each the lists in order
+
+
+
+
+ Return an empty list of the given type
+
+
+
+
+ Test if any element of the list satisfies the given predicate.
+
+ The predicate is applied to the elements of the input list. If any application
+ returns true then the overall result is true and no further elements are tested.
+ Otherwise, false is returned.
+
+
+
+
+ Test if any pair of corresponding elements of the lists satisfies the given predicate.
+
+ The predicate is applied to matching elements in the two collections up to the lesser of the
+ two lengths of the collections. If any application returns true then the overall result is
+ true and no further elements are tested. Otherwise, if one collections is longer
+ than the other then the ArgumentException exception is raised.
+ Otherwise, false is returned.
+
+
+
+
+ Return a new collection containing only the elements of the collection
+ for which the given predicate returns "true"
+
+
+
+
+ Return the first element for which the given function returns true.
+ Raise KeyNotFoundException if no such element exists.
+
+
+
+
+ Return the index of the first element in the list
+ that satisfies the given predicate.
+ Raise KeyNotFoundException if no such element exists.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Apply a function to each element of the collection, threading an accumulator argument
+ through the computation. Take the second argument, and apply the function to it
+ and the first element of the list. Then feed this result into the function along
+ with the second element and so on. Return the final result.
+ If the input function is f and the elements are i0...iN then
+ computes f (... (f s i0) i1 ...) iN
+
+
+
+
+ Apply a function to corresponding elements of two collections, threading an accumulator argument
+ through the computation. The collections must have identical sizes.
+ If the input function is f and the elements are i0...iN and j0...jN
+ then computes f (... (f s i0 j0)...) iN jN.
+
+
+
+
+ Apply a function to each element of the collection, threading an accumulator argument
+ through the computation. If the input function is f and the elements are i0...iN then
+ computes f i0 (...(f iN s)).
+
+
+
+
+ Apply a function to corresponding elements of two collections, threading an accumulator argument
+ through the computation. The collections must have identical sizes.
+ If the input function is f and the elements are i0...iN and j0...jN
+ then computes f i0 j0 (...(f iN jN s)).
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Test if all elements of the collection satisfy the given predicate.
+
+ The predicate is applied to the elements of the input list. If any application
+ returns false then the overall result is false and no further elements are tested.
+ Otherwise, true is returned.
+
+
+
+
+ Test if all corresponding elements of the collection satisfy the given predicate pairwise.
+
+ The predicate is applied to matching elements in the two collections up to the lesser of the
+ two lengths of the collections. If any application returns false then the overall result is
+ false and no further elements are tested. Otherwise, if one collection is longer
+ than the other then the ArgumentException exception is raised.
+ Otherwise, true is returned.
+
+
+
+
+ Return the first element of the list. Raise (Invalid_argument "hd") if undefined.
+
+
+
+
+ Create a list by calling the given generator on each index
+
+
+
+
+ Return true if the list contains no elements, false otherwise
+
+
+
+
+
+
+
+ Apply the given function to each element of the collection.
+
+
+
+
+ Apply the given function to two collections simultaneously. The
+ collections must have identical size.
+
+
+
+
+ Apply the given function to each element of the collection. The integer passed to the
+ function indicates the index of element.
+
+
+
+
+ Apply the given function to two collections simultaneously. The
+ collections must have identical size. The integer passed to the
+ function indicates the index of element.
+
+
+
+
+ Return the length of the list
+
+
+
+
+ Build a new collection whose elements are the results of applying the given function
+ to each of the elements of the collection.
+
+
+
+
+ Build a new collection whose elements are the results of applying the given function
+ to the corresponding elements of the two collections pairwise.
+
+
+
+
+ Build a new collection whose elements are the results of applying the given function
+ to the corresponding elements of the three collections simultaneously.
+
+
+
+
+
+
+
+ Build a new collection whose elements are the results of applying the given function
+ to each of the elements of the collection. The integer index passed to the
+ function indicates the index (from 0) of element being transformed.
+
+
+
+
+ Like mapi, but mapping corresponding elements from two lists of equal length.
+
+
+
+
+ Return the greatest of all elements of the list, compared via Operators.max
+
+
+
+
+ Return the greatest of all elements of the array, compared via Operators.max on the function result
+
+
+
+
+
+
+
+ Return the lowest of all elements of the list, compared via Operators.min
+
+
+
+
+ Return the lowest of all elements of the array, compared via Operators.min on the function result
+
+
+
+
+
+
+
+ Index into the list. The first element has index 0.
+
+
+
+
+ Build a collection from the given array
+
+
+
+
+ Build a new collection from the given enumerable object
+
+
+
+
+ Split the collection into two collections, containing the
+ elements for which the given predicate returns true and false
+ respectively
+
+
+
+
+ Returns a list with all elements permuted according to the
+ specified permutation
+
+
+
+
+ Apply the given function to successive elements, returning the first
+ result where function returns Some(x) for some x. If no such
+ element exists then raise System.Collections.Generic.KeyNotFoundException
+
+
+
+
+ Apply a function to each element of the collection, threading an accumulator argument
+ through the computation. Apply the function to the first two elements of the list.
+ Then feed this result into the function along with the third element and so on.
+ Return the final result. If the input function is f and the elements are i0...iN then computes
+ f (... (f i0 i1) i2 ...) iN.
+ Raises ArgumentException if the list has no elements.
+
+
+
+
+ Apply a function to each element of the collection, threading an accumulator argument
+ through the computation. If the input function is f and the elements are i0...iN then computes
+ f i0 (...(f iN-1 iN)).
+ Raises ArgumentException if the list has no elements.
+
+
+
+
+
+
+
+
+
+
+ Create a list by calling the given generator on each index
+
+
+
+
+ Return a new list with the elements in reverse order
+
+
+
+
+ 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.
+
+
+
+
+ Like foldBack, but return both the intermediary and final results
+
+
+
+
+
+
+
+
+
+
+ Sort the given list using the given comparison function
+
+
+
+
+ Sort the given list using keys given by the given projection. Keys are compared using Operators.compare.
+
+
+
+
+ Sort the given list using the given comparison function
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Return the sum of the elements in the list
+
+
+
+
+ Return the sum of the results generated by applying the function to each element of the list.
+
+
+
+
+
+
+
+ Return the tail of the list. Raise (Invalid_argument "tl") if undefined.
+
+
+
+
+ Build an array from the given collection
+
+
+
+
+ Build a new collection from the given enumerable object
+
+
+
+
+ Return the first element for which the given function returns true.
+ Return None if no such element exists.
+
+
+
+
+ Return the index of the first element in the list
+ that satisfies the given predicate.
+ Return None if no such element exists.
+
+
+
+
+ Apply the given function to successive elements, returning Some(x) the first
+ result where function returns Some(x) for some x. If no such element
+ exists then return None
+
+
+
+
+
+
+
+
+
+
+ Split a list of pairs into two lists
+
+
+
+
+ Split a list of triples into three lists
+
+
+
+
+ Combine the two lists into a list of pairs. The two lists must have equal lengths.
+
+
+
+
+ Combine the three lists into a list of triples. The lists must have equal lengths.
+
+
+
+
+ Basic operations on lists.
+
+
+
+
+ Return a new map with the binding added to the given map.
+
+
+
+
+ Test is an element is in the domain of the map
+
+
+
+
+ The empty map
+
+
+
+
+ Return true if the given predicate returns true for one of the
+ bindings in the map.
+
+
+
+
+ Build a new map containing only the bindings for which the given predicate returns 'true'
+
+
+
+
+ Lookup an element in the map, raising KeyNotFoundException if no binding
+ exists in the map.
+
+
+
+
+ Evaluates the function on each mapping in the collection. Returns the key for the first mapping
+ where the function returns 'true'. Raise KeyNotFoundException if no such element exists.
+
+
+
+
+
+
+
+ Search the map looking for the first element where the given function returns a Some value
+
+
+
+
+ Fold over the bindings in the map
+
+
+
+
+ Fold over the bindings in the map
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Return true if the given predicate returns true for all of the
+ bindings in the map.
+
+
+
+
+ Is the map empty?
+
+
+
+
+
+
+
+ Apply the given function to each binding in the dictionary
+
+
+
+
+ Build a new collection whose elements are the results of applying the given function
+ to each of the elements of the collection. The index passed to the
+ function indicates the index of element being transformed.
+
+
+
+
+
+
+
+
+
+
+ Return a new map made from the given bindings
+
+
+
+
+ Return a new map made from the given bindings
+
+
+
+
+ Return a new map made from the given bindings
+
+
+
+
+ Build two new maps, one containing the bindings for which the given predicate returns 'true',
+ and the other the remaining bindings.
+
+
+
+
+ Search the map looking for the first element where the given function returns a Some value
+
+
+
+
+ Remove an element from the domain of the map. No exception is raised if the element is not present.
+
+
+
+
+ Returns an array of all key-value pairs in the mappinng
+
+
+
+
+ Returns a list of all key-value pairs in the mappinng
+
+
+
+
+ View the collection as an enumerable sequence. This collection
+ type is also directly compatible with 'seq<KeyValuePair<_,_> >'.
+
+ Note this function returns a sequence of tuples, whereas the collection
+ itself is compatible with the logically equivalent sequence of KeyValuePairs.
+ Using sequences of tuples tends to be more convenient in F#, however the
+ collection itself must enumerate KeyValuePairs to conform to the .NET
+ design guidelines and the IDictionary interface.
+
+
+
+
+ Lookup an element in the map, returning a Some value if the element is in the domain
+ of the map and None if not.
+
+
+
+
+ Return the key of the first mapping in the collection that satisfies the given predicate.
+ Return 'None' if no such element exists.
+
+
+
+
+ Search the map looking for the first element where the given function returns a Some value
+
+
+
+
+
+
+
+
+
+
+ Functional programming operators related to the Map<_,_> type.
+
+
+
+
+ Wrap the two given enumeration-of-enumerations as a single concatenated
+ enumeration.
+
+ The returned sequence may be passed between threads safely. However,
+ individual IEnumerator values generated from the returned sequence should not be accessed concurrently.
+
+
+
+
+ Return the average of the elements in the sequence
+
+ The elements are averaged using the '+' operator, 'DivideByInt' method and 'Zero' property
+ associated with the element type.
+
+
+
+
+ Return the average of the results generated by applying the function to each element of the sequence.
+
+ The elements are averaged using the '+' operator, 'DivideByInt' method and 'Zero' property
+ associated with the generated type.
+
+
+
+
+
+
+
+ Return a sequence that corresponds to a cached version of the input sequence.
+ This result sequence will have the same elements as the input sequence. The result
+ can be enumerated multiple times. The input sequence will be enumerated at most
+ once and only as far as is necessary.
+
+ Enumeration of the result sequence is thread safe in the sense that multiple independent IEnumerator
+ values may be used simultaneously from different threads (accesses to
+ the internal lookaside table are thread safe). Each individual IEnumerator
+ is not typically thread safe and should not be accessed concurrently.
+
+ Note, once enumeration of the input sequence has started,
+ it's enumerator will be kept live by this object until the enumeration has completed.
+ At that point, the enumerator will be disposed.
+
+ The enumerator may be disposed and underlying cache storage released by
+ converting the returned sequence object to type IDisposable, and calling the Dispose method
+ on this object. The sequence object may then be re-enumerated and a fresh enumerator will
+ be used.
+
+
+
+
+ Wrap a loosely-typed System.Collections sequence as a typed sequence.
+
+ The use of this function usually requires a type annotation.
+ An incorrect type annotation may result in runtime type
+ errors.
+
+ Individual IEnumerator values generated from the returned sequence should not be accessed concurrently.
+
+
+
+
+ Apply the given function to each element of the list. Return
+ the list comprised of the results "x" for each element where
+ the function returns Some(x)
+
+ The returned sequence may be passed between threads safely. However,
+ individual IEnumerator values generated from the returned sequence should not be accessed concurrently.
+
+ Remember sequence is lazy, effects are delayed until it is enumerated.
+
+
+
+
+ For each element of the enumeration apply the given function and concatenate all the results.
+
+ Remember sequence is lazy, effects are delayed until it is enumerated.
+
+
+
+
+ Compare two sequence's using generic comparison, element by element.
+
+
+
+
+ Compare two sequence's using the given comparison function, element by element.
+
+
+
+
+ Wrap the given enumeration-of-enumerations as a single concatenated
+ enumeration.
+
+ The returned sequence may be passed between threads safely. However,
+ individual IEnumerator values generated from the returned sequence should not be accessed concurrently.
+
+
+
+
+ Apply a key-generating function to each element of a sequence and return a sequence yielding unique
+ keys and their number of occurences in the original sequence.
+
+ Note that this function returns a sequence that digests the whole initial sequence as soon as
+ that sequence is iterated. As a result this function should not be used with
+ large or infinite sequences. The function makes no assumption on the ordering of the original
+ sequence.
+
+
+
+
+
+
+
+ Return a sequence that is built from the given delayed specification of an
+ Seq. The input function is evaluated each time an IEnumerator for the sequence
+ is requested.
+
+
+
+
+ Return a sequence that contains no duplicate entries according to generic hash and equality comparisons on the entries.
+ If an element occurs multiple times in the sequence then the later occurrences are discarded.
+
+
+
+
+ Return a sequence that contains no duplicate entries according to the
+ generic hash and equality comparisons on the keys returned by the given key-generating function.
+ If an element occurs multiple times in the sequence then the later occurrences are discarded.
+
+
+
+
+
+
+
+ Create an empty sequence
+
+
+
+
+ Test if any element of the sequence satisfies the given predicate.
+
+ The predicate is applied to the elements of the input sequence. If any application
+ returns true then the overall result is true and no further elements are tested.
+ Otherwise, false is returned.
+
+
+
+
+ Test if any pair of corresponding elements of the input sequences satisfies the given predicate.
+
+ The predicate is applied to matching elements in the two sequences up to the lesser of the
+ two lengths of the collections. If any application returns true then the overall result is
+ true and no further elements are tested. Otherwise, false is returned. If one sequence is shorter than
+ the other then the remaining elements of the longer sequence are ignored.
+
+
+
+
+ Return a new collection containing only the elements of the collection
+ for which the given predicate returns "true"
+
+ The returned sequence may be passed between threads safely. However,
+ individual IEnumerator values generated from the returned sequence should not be accessed concurrently.
+
+ Remember sequence is lazy, effects are delayed until it is enumerated.
+
+
+
+
+ Return the first element for which the given function returns true.
+ Raise KeyNotFoundException if no such element exists.
+
+
+
+
+ Return the index of the first element in the sequence of pairs
+ that satisfies the given predicate. Raise KeyNotFoundException if no such element exists.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Apply a function to each element of the collection, threading an accumulator argument
+ through the computation. If the input function is f and the elements are i0...iN
+ then computes f (... (f s i0)...) iN
+
+
+
+
+
+
+
+
+
+
+ Test if all elements of the sequence satisfy the given predicate.
+
+ The predicate is applied to the elements of the input sequence. If any application
+ returns false then the overall result is false and no further elements are tested.
+ Otherwise, true is returned.
+
+
+
+
+ Test the all pairs of elements drawn from the two sequences satisfies the
+ given predicate. If one sequence is shorter than
+ the other then the remaining elements of the longer sequence are ignored
+
+
+
+
+ Apply a key-generating function to each element of a sequence and yields a sequence of
+ unique keys. Each unique key has also contains a sequence of all elements that match
+ to this key.
+
+ Note that this function returns a sequence that digests the whole initial sequence as soon as
+ that sequence is iterated. As a result this function should not be used with
+ large or infinite sequences. The function makes no assumption on the ordering of the original
+ sequence.
+
+
+
+
+
+
+
+ Return the first element of the sequence.
+
+
+
+
+ Generate a new sequence which, when iterated, will return successive
+ elements by calling the given function, up to the given count. The results of calling the function
+ will not be saved, i.e. the function will be reapplied as necessary to
+ regenerate the elements. The function is passed the index of the item being
+ generated.
+
+ The returned sequence may be passed between threads safely. However,
+ individual IEnumerator values generated from the returned sequence should not be accessed concurrently.
+
+
+
+
+ Generate a new sequence which, when iterated, will return successive
+ elements by calling the given function. The results of calling the function
+ will not be saved, i.e. the function will be reapplied as necessary to
+ regenerate the elements. The function is passed the index of the item being
+ generated
+
+ The returned sequence may be passed between threads safely. However,
+ individual IEnumerator values generated from the returned sequence should not be accessed concurrently.
+
+
+
+
+
+
+
+
+
+
+ Return true if the sequence contains no elements, false otherwise
+
+
+
+
+
+
+
+ Apply the given function to each element of the collection.
+
+
+
+
+ Apply the given function to two collections simultaneously. If one sequence is shorter than
+ the other then the remaining elements of the longer sequence are ignored.
+
+
+
+
+ Apply the given function to each element of the collection. The integer passed to the
+ function indicates the index of element.
+
+
+
+
+ Return the length of the sequence
+
+
+
+
+ Build a new collection whose elements are the results of applying the given function
+ to each of the elements of the collection. The given function will be applied
+ as elements are demanded using the 'MoveNext' method on enumerators retrieved from the
+ object.
+
+ The returned sequence may be passed between threads safely. However,
+ individual IEnumerator values generated from the returned sequence should not be accessed concurrently.
+
+
+
+
+ Build a new collection whose elements are the results of applying the given function
+ to the corresponding pairs of elements from the two sequences. If one input sequence is shorter than
+ the other then the remaining elements of the longer sequence are ignored.
+
+
+
+
+
+
+
+ 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.
+
+
+
+
+ Return the greatest of all elements of the sequence, compared via Operators.max
+
+
+
+
+ Return the greatest of all elements of the array, compared via Operators.max on the function result
+
+
+
+
+
+
+
+ Return the lowest of all elements of the sequence, compared via Operators.min
+
+
+
+
+ Return the lowest of all elements of the array, compared via Operators.min on the function result
+
+
+
+
+
+
+
+ Compute the nth element in the collection.
+
+
+
+
+ Build a collection from the given array
+
+
+
+
+ Build a collection from the given array
+
+
+
+
+ Return a sequence of each element in the input sequence and its predecessor, with the
+ exception of the first element which is only returned as the predecessor of the second element.
+
+
+
+
+ Apply the given function to successive elements, returning the first
+ 'x' where the function returns "Some(x)".
+
+
+
+
+ Build a new sequence object that delegates to the given sequence object. This ensures
+ the original sequence can't be rediscovered and mutated by a type cast. For example,
+ if given an array the returned sequence will return the elements of the array, but
+ you can't cast the returned sequence object to an array.
+
+
+
+
+ Apply a function to each element of the sequence, threading an accumulator argument
+ through the computation. Begin by applying the function to the first two elements.
+ Then feed this result into the function along with the third element and so on.
+ Return the final result.
+ Raises ArgumentException if the sequence has no elements.
+
+
+
+
+ Like fold, but compute on-demand and return the sequence of intermediary and final results
+
+
+
+
+ Return a sequence that yields one item only.
+
+
+
+
+ Return a sequence that skips N elements of the underlying sequence and then yields the
+ remaining elements of the sequence
+
+
+
+
+ Return a sequence that, when iterated, skips elements of the underlying sequence while the
+ given predicate returns 'true', and then yields the remaining elements of the sequence
+
+
+
+
+
+
+
+ Yield a sequence ordered by keys.
+
+ Note that this function returns a sequence that digests the whole initial sequence as soon as
+ that sequence is iterated. As a result this function should not be used with
+ large or infinite sequences. The function makes no assumption on the ordering of the original
+ sequence.
+
+
+
+
+ Apply a key-generating function to each element of a sequence and yield a sequence ordered
+ by keys. The keys are compared using generic comparison as implemented by Operators.compare.
+
+ Note that this function returns a sequence that digests the whole initial sequence as soon as
+ that sequence is iterated. As a result this function should not be used with
+ large or infinite sequences. The function makes no assumption on the ordering of the original
+ sequence.
+
+
+
+
+
+
+
+ Return the sum of the elements in the sequence.
+
+ The elements are summed using the '+' operator and 'Zero' property associated with the generated type.
+
+
+
+
+ Return the sum of the results generated by applying the function to each element of the sequence.
+ The generated elements are summed using the '+' operator and 'Zero' property associated with the generated type.
+
+
+
+
+
+
+
+ Return the first N elements of the sequence.
+
+
+
+
+ Return a sequence that, when iterated, yields elements of the underlying sequence while the
+ given predicate returns 'true', and returns no further elements
+
+
+
+
+
+
+
+ Build an array from the given collection
+
+
+
+
+ Build a list from the given collection
+
+
+
+
+ Return a sequence that when enumerated returns at most N elements.
+
+
+
+
+ Return the first element for which the given function returns true.
+ Return None if no such element exists.
+
+
+
+
+ Return the index of the first element in the sequence
+ that satisfies the given predicate. Return 'None' if no such element exists.
+
+
+
+
+ Apply the given function to successive elements, returning the first
+ result where the function returns "Some(x)".
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Return a sequence that contains the elements generated by the given computation.
+ The given initial 'state' argument is passed to the element generator.
+ For each IEnumerator elements in the stream are generated on-demand by applying the element
+ generator, until a None value is returned by the element generator. Each call to the element
+ generator returns a new residual 'state'.
+
+ Note the stream will be recomputed each time an IEnumerator is requested and iterated for the Seq.
+
+ The returned sequence may be passed between threads safely. However,
+ individual IEnumerator values generated from the returned sequence should not be accessed concurrently.
+
+
+
+
+ Return a sequence that yields 'sliding windows' of containing elements drawn from the input
+ sequence. Each window is returned as a fresh array.
+
+
+
+
+ Combine the two sequences into a list of pairs. The two sequences need not have equal lengths:
+ when one sequence is exhausted any remaining elements in the other
+ sequence are ignored.
+
+
+
+
+ Combine the three sequences into a list of triples. The two sequences need not have equal lengths:
+ when one sequence is exhausted any remaining elements in the other
+ sequence are ignored.
+
+
+
+
+ Basic operations on IEnumerables.
+
+
+
+
+ The F# compiler emits implementations of this method for compiled sequence expressions
+
+
+
+
+ The F# compiler emits implementations of this method for compiled sequence expressions
+
+
+
+
+ The F# compiler emits implementations of this method for compiled sequence expressions
+
+
+
+
+ The F# compiler emits implementations of this method for compiled sequence expressions
+
+
+
+
+ The F# compiler emits implementations of this method for compiled sequence expressions
+
+
+
+
+ The F# compiler emits implementations of this method for compiled sequence expressions
+
+
+
+
+ The F# compiler emits implementations of this type for compiled sequence expressions
+
+
+
+
+ The F# compiler emits calls to this function to implement the compiler-intrinsic
+ conversions from untyped System.Collections.IEnumerable sequences to typed sequences
+
+
+
+
+ The F# compiler emits calls to this function to
+ implement the 'try/finally' operator for F# sequence expressions
+
+
+
+
+ The F# compiler emits calls to this function to implement the 'use' operator for F# sequence expressions
+
+
+
+
+ The F# compiler emits calls to this function to
+ implement the 'while' operator for F# sequence expressions
+
+
+
+
+ A group of functions used as part of the compiled representation of F# sequence expressions
+
+
+
+
+ Return a new set with an element added to the set. No exception is raised if
+ the set already contains the given element.
+
+
+
+
+ Returns the minimum element of the set
+
+
+
+
+
+
+
+Evaluates to "true" if the given element is in the given set
+
+
+
+
+Return the number of elements in the set. Same as size
+
+
+
+
+ Return a new set with the elements of the second set removed from the first.
+
+
+
+
+ The empty set for the type 'T .
+
+
+
+
+Test if any element of the collection satisfies the given predicate.
+If the input function is f and the elements are i0...iN
+then computes p i0 or ... or p iN.
+
+
+
+
+ Return a new collection containing only the elements of the collection
+ for which the given predicate returns true
+
+
+
+
+ Apply the given accumulating function to all the elements of the set
+
+
+
+
+ Apply the given accumulating function to all the elements of the set
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Test if all elements of the collection satisfy the given predicate.
+ If the input function is f and the elements are i0...iN and "j0...jN"
+ then computes p i0 && ... && p iN.
+
+
+
+
+ Compute the intersection of the two sets.
+
+
+
+
+Compute the intersection of a sequence of sets. The sequence must be non-empty
+
+
+
+
+
+
+
+Return "true" if the set is empty
+
+
+
+
+
+
+
+Apply the given function to each element of the set, in order according
+to the comparison function
+
+
+
+
+ Return a new collection containing the results of applying the
+ given function to each element of the input set
+
+
+
+
+
+
+
+Evaluates to "true" if the given element is in the given set
+
+
+
+
+
+
+
+
+
+
+ Build a set that contains the same elements as the given array
+
+
+
+
+ Build a set that contains the same elements as the given list
+
+
+
+
+ Build a new collection from the given enumerable object
+
+
+
+
+Split the set into two sets containing the elements for which the given predicate
+returns true and false respectively
+
+
+
+
+
+
+
+Return a new set with the given element removed. No exception is raised in
+the set doesn't contain the given element.
+
+
+
+
+ The set containing the given one element.
+
+
+
+
+
+
+
+ Evaluates to "true" if all elements of the second set are in the first
+
+
+
+
+ Build an array that contains the elements of the set in order
+
+
+
+
+ Build a list that contains the elements of the set in order
+
+
+
+
+ Return a view of the collection as an enumerable object
+
+
+
+
+Compute the union of the two sets.
+
+
+
+
+Compute the union of a sequence of sets.
+
+
+
+
+
+
+
+ Functional programming operators related to the Set<_> type.
+
+
+
+
+ Get the default group for executing asynchronous computations
+
+
+
+
+ Specify an asynchronous computation that, when run, executes computation,
+ If p is effectively cancelled before its termination then
+ the process f exn is executed.
+
+
+
+
+ Specify an asynchronous computation that, when run, queues a CPU-intensive work in the thread pool item that runs
+ its continutation.
+
+
+
+
+ Specify an asynchronous computation that, when run, creates a new thread and runs
+ its continutation in that thread
+
+
+
+
+ Specify an asynchronous computation that, when run, runs
+ its continuation using syncContext.Post. If syncContext is null
+ then the asynchronous computation is equivalent to SwitchToThreadPool().
+
+
+
+
+ Start a child computation within an asynchronous workflow.
+ This allows multiple asynchronous computations to be executed simultaneously.
+
+ This method should normally be used as the immediate
+ right-hand-side of a 'let!' binding in an F# asynchronous workflow, i.e.,
+
+ async { ...
+ let! completor1 = childComputation1 |> Async.StartChild
+ let! completor2 = childComputation2 |> Async.StartChild
+ ...
+ let! result1 = completor1
+ let! result2 = completor2
+ ... }
+
+ When used in this way, each use of StartChild starts an instance of childComputation
+ and returns a completor object representing a computation to wait for the completion of the operation.
+ When executed, the completor awaits the completion of childComputation.
+
+
+
+
+ Start the asynchronous computation in the thread pool. Do not await its result.
+
+ Run as part of the default AsyncGroup
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Run an asynchronous computation, initially as a work item.
+
+ Run as part of the default AsyncGroup
+
+
+
+
+ Run the asynchronous computation and await its result.
+
+ If an exception occurs in the asynchronous computation then an exception is re-raised by this
+ function.
+
+ Run as part of the default AsyncGroup
+
+
+
+
+
+
+
+
+
+
+ Specify an asynchronous computation that, when run, executes the given callback.
+ The callback must eventually call either the continuation,
+ the exception continuation or the cancel exception.
+
+
+
+
+ Specify an asynchronous computation that, when run, executese the three asynchronous computations, starting each in the thread pool.
+ If any raise an exception then the overall computation will raise an exception, and attempt to cancel the others.
+ All the sub-computations belong to an AsyncGroup that is a subsidiary of the AsyncGroup of the outer computations.
+
+
+
+
+ Specify an asynchronous computation that, when run, executes the two asynchronous computations, starting each in the thread pool.
+ If any raise an exception then the overall computation will raise an exception, and attempt to cancel the others.
+ All the sub-computations belong to an AsyncGroup that is a subsidiary of the AsyncGroup of the outer computations.
+
+
+
+
+ Specify an asynchronous computation that, when run, executes all the given asynchronous computations, initially
+ queueing each as work items and using a fork/join pattern. If any raise an exception then the
+ overall computation will raise the first detected exception, and attempt to cancel the others.
+ All the sub-computations belong to an AsyncGroup that is a subsidiary of the AsyncGroup of the outer computations.
+
+
+
+
+ Generate a scoped, cooperative cancellation handler for use within an asynchronous workflow.
+
+ async { use! holder = Async.OnCancel f ... } generates an asynchronous computation where,
+ if a cancellation happens any time during the execution of the asynchronous computation in the scope of 'holder',
+ then action 'f' is executed on the thread that is performing the cancellation. You can use
+ this to arrange for your own computation to be asynchronously notified that a cancellation has occurred, e.g.
+ by setting a flag, or deregistering a pending I/O action.
+
+
+
+
+ Specify an asynchronous computation that, when run, runs 'p', ignoring the result and
+ returning the result '()'.
+
+
+
+
+
+
+
+ Get the default group for executing asynchronous computations
+
+
+
+
+ Raise the cancellation condition for the most recent set of Async computations started without any specific AsyncGroup.
+ Replace the global group with a new global group for any asynchronous computations created after this point without
+ any specific AsyncGroup.
+
+
+
+
+
+
+
+ Specify an asynchronous computation in terms of a Begin/End pair of actions in
+ the style used in .NET APIs where the overall operation is not qualified by any arguments. For example,
+ Async.BuildPrimitive(ws.BeginGetWeather,ws.EndGetWeather)
+ When the computation is run, the 'Begin' half of the operation is executed, and
+ an asynchronous computation is returned that, when run, awaits the completion
+ of the computation and fetches its overall result using the 'End' operation.
+
+
+
+
+ Specify an asynchronous computation in terms of a Begin/End pair of actions in
+ the style used in .NET APIs where the
+ overall operation is qualified by one argument. For example,
+ Async.BuildPrimitive(place,ws.BeginGetWeather,ws.EndGetWeather)
+ When the computation is run, the 'Begin' half of the operation is executed, and
+ an asynchronous computation is returned that, when run, awaits the completion
+ of the computation and fetches its overall result using the 'End' operation.
+
+
+
+
+ Specify an asynchronous computation in terms of a Begin/End pair of actions in
+ the style used in .NET APIs where the
+ overall operation is qualified by two arguments. For example,
+ Async.BuildPrimitive(arg1,arg2,ws.BeginGetWeather,ws.EndGetWeather)
+ When the computation is run, the 'Begin' half of the operation is executed, and
+ an asynchronous computation is returned that, when run, awaits the completion
+ of the computation and fetches its overall result using the 'End' operation.
+
+
+
+
+ Specify an asynchronous computation in terms of a Begin/End pair of actions in
+ the style used in .NET APIs where the overall operation is qualified by three arguments. For example,
+ Async.BuildPrimitive(arg1,arg2,arg3,ws.BeginGetWeather,ws.EndGetWeather)
+ When the computation is run, the 'Begin' half of the operation is executed, and
+ an asynchronous computation is returned that, when run, awaits the completion
+ of the computation and fetches its overall result using the 'End' operation.
+
+
+
+
+ This static class holds members for creating and manipulating asynchronous computations
+
+
+
+
+ Specify an asynchronous computation that, when run, just returns '()'
+
+
+
+
+ Specify an asynchronous computation that, when run, runs 'p' repeatedly
+ until 'gd()' becomes false.
+
+
+
+
+ Specify an asynchronous computation that, when run, runs 'f(resource)'.
+ The action 'resource.Dispose()' is executed as this computation yields its result
+ or if the asynchronous computation exits by an exception or by cancellation.
+
+
+
+
+ Specify an asynchronous computation that, when run, runs 'p' and returns its result.
+ If an exception happens then 'f(exn)' is called and the resulting computation executed instead.
+
+
+
+
+ Specify an asynchronous computation that, when run, runs 'p'. The action 'f' is executed
+ after 'p' completes, whether 'p' exits normally or by an exception. If 'f' raises an exception itself
+ the original exception is discarded and the new exception becomes the overall result of the computation.
+
+
+
+
+ Specify an asynchronous computation that, when run, returns the result 'v'
+
+
+
+
+ Specify an asynchronous computation that, when run, enumerates the sequence 'seq'
+ on demand and runs 'f' for each element.
+
+
+
+
+ Specify an asynchronous computation that, when run, runs 'f()'
+
+
+
+
+ Specify an asynchronous computation that, when run, first runs 'p1' and then runs 'p2', returning the result of 'p2'.
+
+
+
+
+ Specify an asynchronous computation that, when run, runs 'p', and when
+ 'p' generates a result 'T', runs 'f res'.
+
+
+
+
+ Generate an object used to build asynchronous computations using F# computation expressions. The value
+ 'async' is a pre-defined instance of this type.
+
+
+
+
+ The type of the 'async' operator, used to build workflows for asynchronous computations.
+
+
+
+
+ Wait for the completion of the operation and get its result
+
+
+
+
+
+
+
+ Raise the cancellation condition for this group of computations
+
+
+
+
+ Start the asynchronous computation as a work item. Do not await its result.
+
+
+
+
+
+
+
+
+
+
+ Start the asynchronous computation as a work item.
+ Return a handle to the computation as an AsyncFuture.
+
+
+
+
+ Run the asynchronous computation and await its result.
+
+ If an exception occurs in the asynchronous computation then an exception is re-raised by this
+ function.
+
+
+
+
+
+
+
+ Generate a new asynchronous group
+
+
+
+
+ A handle to a capability to cancel a set of asynchronous computations.
+
+
+
+
+ Send a reply to a PostAndReply message
+
+
+
+
+ A handle to a capability to reply to a PostAndReply message
+
+
+
+
+ An asynchronous computation, which, when run, will eventually produce a value
+ of the given type, or else raise an exception. The value and/or exception is not returned
+ to the caller immediately, but is rather passed to a success continuation, exception continuation
+ or cancellation continuation.
+
+ Asynchronous computations are normally specified using the F# 'workflow' syntax for building
+ computations.
+
+ When run, asynchronous computations can normally be thought of as running run in one of
+ two modes: 'work item mode' or 'waiting mode'.
+
+ - 'work item mode' indicates that the computation is executing as a work item,
+ e.g. in the .NET Thread Pool via ThreadPool.QueueUserWorkItem, or is running
+ a brief event-response action on the GUI thread.
+
+ - 'waiting mode' indicates the computations a waiting for asynchronous I/O completions,
+ typically suspended as thunks using ThreadPool.RegisterWaitForSingleObject.
+
+ Asynchronous computations running as 'work items' should not generally perform blocking
+ operations, e.g. long running synchronous loops. However, some asynchronous
+ computations may, out of necessity, need to execute blocking I/O operations:
+ these should be run on new threads or a user-managed pool of threads specifically
+ dedicated to resolving blocking conditions. For example, System.IO.OpenFile is, by
+ design, a blocking operation. However frequently it is important to code as
+ if this is asynchronous. This can be done by executing Async.SwitchToNewThread
+ as part of the workflow.
+
+ When run, asynchronous computations belong to an AsyncGroup. This can usually be specified
+ when the async computation is started. The only action on an AsyncGroup is to raise a cancellation
+ condition for the AsyncGroup. Async values check the cancellation condition for their AsyncGroup
+ regularly, though synchronous computations within an asynchronous computation will not automatically
+ check this condition. This gives a user-level cooperative cancellation protocol.
+
+
+
+
+ Publish the event as a first class event value
+
+
+
+
+ Trigger the event using the given parameters
+
+
+
+
+ Create an event object suitable for implementing an arbitrary type of delegate
+
+
+
+
+ Event implementations for an arbitrary type of delegate
+
+
+
+
+ Publish the event as a first class event value
+
+
+
+
+ Trigger the event using the given parameters
+
+
+
+
+ Create an event object suitable for implementing for the IEvent<_> type
+
+
+
+
+ Event implementations for the IEvent<_> type
+
+
+
+
+ Publish the event as a first class event value
+
+
+
+
+ Trigger the event using the given sender object and parameters. The sender object may be null.
+
+
+
+
+ Create an event object suitable for delegate types following the standard .NET Framework convention of a first 'sender' argument
+
+
+
+
+ Event implementations for a delegate types following the standard .NET Framework convention of a first 'sender' argument
+
+
+
+
+
+
+
+ A delegate type associated with the F# event type IEvent<_>
+
+
+
+
+ Remove a listener delegate from an event listener store
+
+
+
+
+ Connect a handler delegate object to the event. A handler can
+ be later removed using RemoveHandler. The listener will
+ be invoked when the event is fired.
+
+
+
+
+ F# gives special status to non-virtual instance member properties compatible with type IDelegateEvent,
+ generating approriate .NET metadata to make the member appear to other .NET languages as a
+ .NET event.
+
+
+
+
+ First-class listening points (i.e. objects that permit you to register a 'callback'
+ activated when the event is triggered). See the module Event
+ for functions to create events.
+
+
+
+
+ Connect a listener function to the event. The listener will
+ be invoked when the event is fired.
+
+
+
+
+The family of first class event values for delegate types that satisfy the F# delegate constraint.
+
+
+
+
+ Force the execution of this value and return its result. Same as Value. Mutual exclusion is used to
+ prevent other threads also computing the value.
+
+
+
+
+ Indicates if the lazy value has been successfully computed
+
+
+
+
+ Indicates if the lazy value is being computed or the computation raised an exception
+
+
+
+
+ Indicates if the lazy value has yet to be computed
+
+
+
+
+ Same as Force, except no lock is taken.
+
+
+
+
+ Same as Force
+
+
+
+
+ Force the execution of this value and return its result. Same as Value. Mutual exclusion is used to
+ prevent other threads also computing the value. If the value is re-forced during its own computation
+ the Undefined exception is raised.
+
+
+
+
+ Create a lazy computation that evaluates to the given value when forced
+
+
+
+
+ Create a lazy computation that evaluates to the result of the given function when forced
+
+
+
+
+ The type of delayed computations.
+
+ Use the values in the Lazy module to manipulate
+ values of this type, and the notation 'lazy expr' to create values
+ of this type.
+
+
+
+
+ Raise a timeout exception if a message not received in this amount of time. Default infinite.
+
+
+
+
+ Raise a timeout exception if a message not received in this amount of time. Default infinite.
+
+
+
+
+ Return an asynchronous computation which will
+ look through messages in arrival order until 'scanner' returns a Some value. No thread
+ is blocked while waiting for further messages. Return None
+ if the timeout is exceeded.
+
+
+
+
+ Return an asynchronous computation which will
+ consume the first message in arrival order. No thread
+ is blocked while waiting for further messages. Return None
+ if the timeout is exceeded.
+
+
+
+
+ Like PostAndReply, but return None if no reply within the timeout period.
+
+
+
+
+ Create and start an instance of a MailboxProcessor. The asynchronous computation executed by the
+ processor is the one returned by the 'initial' function.
+
+
+
+
+ Start the MailboxProcessor
+
+
+
+
+ Return an asynchronous computation which will
+ look through messages in arrival order until 'scanner' returns a Some value. No thread
+ is blocked while waiting for further messages. Raise a TimeoutException
+ if the timeout is exceeded.
+
+
+
+
+ Return an asynchronous computation which will
+ consume the first message in arrival order. No thread
+ is blocked while waiting for further messages. Raise a TimeoutException
+ if the timeout is exceeded.
+
+
+
+
+ Post a message to the message queue of the MailboxProcessor and await a reply on the channel synchronously.
+ The message is produced by a single call to the first function which must build a message
+ containing the reply channel. The receiving MailboxProcessor must process this message and
+ invoke the Reply method on the reply channel precisly once.
+
+
+
+
+ Post a message to the message queue of the MailboxProcessor, asynchronously
+
+
+
+
+ Like AsyncPostAndReply, but return None if no reply within the timeout period.
+
+
+
+
+ Post a message to the message queue of the MailboxProcessor and await a reply on the channel asynchronously.
+ The message is produced by a single call to the first function which must build a message
+ containing the reply channel. The receiving MailboxProcessor must process this message and
+ invoke the Reply method on the reply channel precisly once.
+
+
+
+
+ Create an instance of a MailboxProcessor. The asynchronous computation executed by the
+ processor is the one returned by the 'initial' function. This function is not executed until
+ 'Start' is called.
+
+
+
+
+ A MailboxProcessor is a message-processing agent defined using an asynchronous workflow.
+ The agent encapsulates a message queue that supports multiple-writers and the single reader agent.
+ Writers send messages to the agent by using the Post, PostAndReply or AsyncPostAndReply methods.
+
+ The reader agent is specified when creating the MailboxProcessor. The
+ agent is usually an asychronous workflow that waits for messages
+ by using the Receive or TryReceive methods.
+ A MailboxProcessor may also scan through all available messages by using the
+ Scan or TryScan method. The encapsulated message queue only
+ supports a single active reader, thus at most one concurrent call to Receive, TryReceive,
+ Scan and/or TryScan may be active at any one time.
+
+
+
+
+ The type of delayed computations.
+
+ Use the values in the Lazy module to manipulate
+ values of this type, and the notation 'lazy expr' to create values
+ of this type.
+
+
+
+
+ An exeption type raised when the evaluation of a lazy value recursively depend upon itself
+
+
+
+
+ A module of extension members that provide asynchronous operations for some basic .NET types related to concurrency and I/O.
+
+
+
+
+ Return a new event which fires on a selection of messages from the original event.
+ The selection function takes an original message to an optional new message.
+
+
+
+
+ Create an IEvent with no initial listeners. Two items are returned:
+ a function to invoke (trigger) the event, and the event that clients
+ can plug listeners into.
+
+
+
+
+ Return a new event that listens to the original event and triggers the resulting
+ event only when the argument to the event passes the given function
+
+
+
+
+ Run the given function each time the given event is triggered.
+
+
+
+
+ Return a new event that passes values transformed by the given function
+
+
+
+
+ Fire the output event when either of the input events fire
+
+
+
+
+ Return a new event that triggers on the second and subsequent triggerings of the input event.
+ The Nth triggering of the input event passes the arguments from the N-1th and Nth triggering as
+ a pair. The argument passed to the N-1th triggering is held in hidden internal state until the
+ Nth triggering occurs.
+
+ You should ensure that the contents of the values being sent down the event are
+ not mutable. Note that many EventArgs types are mutable, e.g. MouseEventArgs, and
+ each firing of an event using this argument type may reuse the same physical
+ argument obejct with different values. In this case you should extract the necessary
+ information from the argument before using this combinator.
+
+
+
+
+ Return a new event that listens to the original event and triggers the
+ first resulting event if the application of the predicate to the event arguments
+ returned true, and the second event if it returned false
+
+
+
+
+ Return a new event consisting of the results of applying the given accumulating function
+ to successive values triggered on the input event. An item of internal state
+ records the current value of the state parameter. The internal state is not locked during the
+ execution of the accumulation function, so care should be taken that the
+ input IEvent not triggered by multiple threads simultaneously.
+
+
+
+
+ Return a new event that listens to the original event and triggers the
+ first resulting event if the application of the function to the event arguments
+ returned a Choice1Of2, and the second event if it returns a Choice2Of2
+
+
+
+
+ Basic operations on first class event objects.
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Adding this attribute to class definition makes it abstract, which means it need not
+ implement all its methods. Instances of abstract classes may not be constructed directly.
+
+
+
+
+ Indicates the namespace or module to be automatically opened when an assembly is referenced
+ or an enclosing module opened.
+
+
+
+
+ Create an attribute used to mark a module as 'automatically opened' when the enclosing namespace is opened
+
+
+
+
+ Create an attribute used to mark a namespace or module path to be 'automatically opened' when an assembly is referenced
+
+
+
+
+ This attribute is used for two purposes. When applied to an assembly, it must be given a string
+ argument, and this argument must indicate a valid module or namespace in that assembly. Source
+ code files compiled with a reference to this assembly are processed in an environment
+ where the given path is automatically oepned.
+
+ When applied to a module within an assembly, then the attribute must not be given any arguments.
+ When the enclosing namespace is opened in user source code, the module is also implicitly opened.
+
+
+
+
+ The value of the attribute, indicating whether the type is automatically marked serializable or not
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Adding this attribute to a type with value 'false' disables the behaviour where F# makes the
+ type Serializable by default.
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Adding this attribute to a property with event type causes it to be compiled with as a .NET
+ Common Language Infrastructure metadata event, through a syntactic translation to a pair of
+ 'add_EventName' and 'remove_EventName' methods.
+
+
+
+
+ Helper types for active patterns with 2 choices.
+
+
+
+
+ Helper types for active patterns with 3 choices.
+
+
+
+
+ Helper types for active patterns with 4 choices.
+
+
+
+
+ Helper types for active patterns with 5 choices.
+
+
+
+
+ Helper types for active patterns with 6 choices.
+
+
+
+
+ Helper types for active patterns with 7 choices.
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Adding this attribute to a type causes it to be represented using a .NET class.
+
+
+
+
+ Indicates the variant number of the entity, if any, in a linear sequence of elements with F# source code
+
+
+
+
+ Indicates the relationship between the compiled entity and F# source code
+
+
+
+
+ Indicates the sequence number of the entity, if any, in a linear sequence of elements with F# source code
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ This attribute is inserted automatically by the F# compiler to tag
+ types and methods in the gneerated .NET code with flags indicating the correspondence with
+ original source constructs. It is used by the functions in the
+ Microsoft.FSharp.Reflection library to reverse-map compiled constructs
+ to their original forms. It is not intended for use from use code.
+
+
+
+
+ Indicates one or more adjustments to the compiled representation of an F# type or member
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ This attribute is used to adjust the runtime representation for a type.
+ For example, it may be used to note that the null representation
+ may be used for a type. This affects how some constructs are compiled.
+
+
+
+
+ Indicates one or more adjustments to the compiled representation of an F# type or member
+
+
+
+
+ The value of the attribute, indicating whether the type has a default augmentation or not
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Adding this attribute to a discriminated union with value false
+ turns off the generation of standard helper member tester, constructor
+ and accessor members for the generated .NET class for that type.
+
+
+
+
+ Indicates if a constraint is asserted that the field type supports 'null'
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Adding this attribute to a field declaration means that the field is
+ not initialized. During type checking a constraint is asserted that the field type supports 'null'.
+ If the 'check' value is false then the constraint is not asserted.
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Adding this attribute to a function indicates it is the entrypoint for an application.
+ If this absent is not speficied for an EXE then the initialization implicit in the
+ module bindings in the last file in the compilation sequence are used as the entrypoint.
+
+
+
+
+ Indicates the warning message to be emitted when F# source code uses this construct
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ This attribute is used to tag values that are part of an experimental library
+ feature
+
+
+
+
+ The release number of the F# version associated with the attribute
+
+
+
+
+ The minor version number of the F# version associated with the attribute
+
+
+
+
+ The major version number of the F# version associated with the attribute
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ This attribute is added to generated assemblies to indicate the
+ version of the data schema used to encode additional F#
+ specific information in the resource attached to compiled F# libraries.
+
+
+
+
+ Convert an F# first class function value to a value of type System.Converter
+
+
+
+
+ Convert an value of type System.Converter to a F# first class function value
+
+
+
+
+ Convert an F# first class function value to a value of type System.Converter
+
+
+
+
+ Invoke an F# first class function value with five curried arguments. In some cases this
+ will result in a more efficient application than applying the arguments successively.
+
+
+
+
+ Invoke an F# first class function value with four curried arguments. In some cases this
+ will result in a more efficient application than applying the arguments successively.
+
+
+
+
+ Invoke an F# first class function value with three curried arguments. In some cases this
+ will result in a more efficient application than applying the arguments successively.
+
+
+
+
+ Invoke an F# first class function value with two curried arguments. In some cases this
+ will result in a more efficient application than applying the arguments successively.
+
+
+
+
+ Invoke an F# first class function value with one argument
+
+
+
+
+ Convert an value of type System.Converter to a F# first class function value
+
+
+
+
+ Construct an instance of an F# first class function value
+
+
+
+
+ The .NET type used to represent F# function values. This type is not
+ typically used directly, though may be used from other .NET languages.
+
+
+
+
+ Convert the given Action delegate object to an F# function value
+
+
+
+
+ Convert the given Converter delegate object to an F# function value
+
+
+
+
+ A utility funcion to convert function values from tupled to curried form
+
+
+
+
+ A utility funcion to convert function values from tupled to curried form
+
+
+
+
+ A utility funcion to convert function values from tupled to curried form
+
+
+
+
+ A utility funcion to convert function values from tupled to curried form
+
+
+
+
+ A utility funcion to convert function values from tupled to curried form
+
+
+
+
+ Helper functions for converting F# first class function values to and from .NET representaions
+ of functions using delegates.
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Adding this attribute to a non-function value with generic parameters indicates that
+ uses of the construct can give rise to generic code through type inference.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Adding this attribute to a type causes it to be represented using a .NET interface.
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Adding this attribute to a value causes it to be compiled as a .NET constant literal.
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Adding this attribute to a type causes it to be interpreted as a refined type, currently limited to measure-parameterized types.
+ This may only be used under very limited conditions.
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Adding this attribute to a type causes it to be interpreted as a unit of measure.
+ This may only be used under very limited conditions.
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ This attribute is used to tag values that may not be dynamically invoked at runtime. This is
+ typically added to inlined functions whose implementations include unverifiable code. It
+ causes the method body emitted for the inlined function to raise an exception if
+ dynamically invoked, rather than including the unverifiable code in the generated
+ assembly.
+
+
+
+
+ Indicates the warning message to be emitted when F# source code uses this construct
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ This attribute is used to tag values, modules and types that are only
+ present in F# to permit a degree of code-compatibility and cross-compilation
+ with other implementations of ML-familty languages, in particular OCaml. The
+ use of the construct will give a warning unless the --ml-compatibility flag
+ is specified.
+
+
+
+
+ Get the value of a 'Some' option. A NullReferenceException is raised if the option is 'None'.
+
+
+
+
+ Create an option value that is a 'None' value.
+
+
+
+
+ Return 'true' if the option is a 'Some' value.
+
+
+
+
+ Return 'true' if the option is a 'None' value.
+
+
+
+
+ Create an option value that is a 'Some' value.
+
+
+
+
+ The type of optional values. When used from other .NET languages the
+ empty option is the null value.
+
+ Use the constructors Some and None to create values of this type.
+ Use the values in the Option module to manipulate values of this type,
+ or pattern match against the values directly.
+
+ None values will appear as the value null to other .NET languages.
+ Instance methods on this type will appear as static methods to other .NET languages
+ due to the use of null as a value representation.
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ This attribute is added automatically for all optional arguments
+
+
+
+
+ A unique identifier for this overloaded member within a given overload set
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Adding the OverloadID attribute to a member permits it to
+ be part of a group overloaded by the same name and arity. The string
+ must be a unique name amongst those in the overload set. Overrides
+ of this method, if permitted, must be given the same OverloadID,
+ and the OverloadID must be specified in both signature and implementation
+ files if signature files are used.
+
+
+
+
+ The current value of the reference cell
+
+
+
+
+ The current value of the reference cell
+
+
+
+
+ The type of mutable references. Use the functions [:=] and [!] to get and
+ set values of this type.
+
+
+
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Adding this attribute to a record or union type disables the automatic generation
+ of overrides for 'System.Object.Equals(obj)', 'System.Object.GetHashCode()'
+ and 'System.IComparable' for the type. The type will by default use reference equality.
+ This is identical to adding attributes StructuralEquality(false) and StructuralComparison(false).
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Adding this attribute to the let-binding for the definition of a top-level
+ value makes the quotation expression that implements the value available
+ for use at runtime.
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ This attribute is used to indicate that references to a the elements of a module, record or union
+ type require explicit qualified access.
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Adding this attribute to a type, value or member requires that
+ uses of the construct must explicitly instantiate any generic type parameters.
+
+
+
+
+ The value of the attribute, indicating whether the type is sealed or not
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Adding this attribute to class definition makes it sealed, which means it may not
+ be extended or implemented.
+
+
+
+
+ Indicates the relationship between a compiled entity in a CLI binary and an element in F# source code
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Adding this attribute to a type causes it to be represented using a .NET struct.
+
+
+
+
+ The value of the attribute, indicating whether the type uses structural comparison or not
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Adding this attribute to a record, union or struct type with value 'false' disables the automatic generation
+ of implementations for 'System.IComparable' for the type.
+
+
+
+
+ The value of the attribute, indicating whether the type uses structural equality or not
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ Adding this attribute to a record, union or struct type with value 'false'
+ confirms the automatic generation of overrides for 'System.Object.Equals(obj)'
+ and 'System.Object.GetHashCode()' for the type. This attribute is usually used in
+ conjunction with StructuralComparison(false) to generate a type that supports
+ structural equality but not structural comparison.
+
+
+
+
+ Indicates the text to display by default when objects of this type are displayed
+ using '%A' printf formatting patterns and other two-dimensional text-based display
+ layouts.
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ This attribute is used to mark how a type is displayed by default when using
+ '%A' printf formatting patterns and other two-dimensional text-based display layouts.
+ In this version of F# the only valid values are of the form PreText {PropertyName} PostText.
+ The property name indicates a property to evaluate and to display instead of the object itself.
+
+
+
+
+
+
+
+
+
+
+ Compiled versions of F# tuple types. These are not used directly, though
+ these compiled forms are seen by other .NET languages.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Specialize the type function at a given type
+
+
+
+
+ Construct an instance of an F# first class type function value
+
+
+
+
+ The .NET type used to represent F# first-class type function values. This type is for use
+ by compiled F# code.
+
+
+
+
+ The type 'unit', which has only one value "()". This value is special and
+ always uses the representation 'null'.
+
+
+
+
+ Create an instance of the attribute
+
+
+
+
+ This attribute is used to tag values whose use will result in the generation
+ of unverifiable code. These values are inevitably marked 'inline' to ensure that
+ the unverifiable constructs are not present in the actual code for the F# library,
+ but are rather copied to the source code of the caller.
+
+
+
+
+ Four dimensional arrays, typically zero-based. Non-zero-based arrays
+ can be created using methods on the System.Array type.
+
+ Use the values in the Array4D module
+ to manipulate values of this type, or the notation 'arr.[x1,x2,x3,x4]' to get and set array
+ values.
+
+
+
+
+ Three dimensional arrays, typically zero-based. Non-zero-based arrays
+ can be created using methods on the System.Array type.
+
+ Use the values in the Array3D module
+ to manipulate values of this type, or the notation 'arr.[x1,x2,x3]' to get and set array
+ values.
+
+
+
+
+ Two dimensional arrays, typically zero-based.
+
+ Use the values in the Array2D module
+ to manipulate values of this type, or the notation 'arr.[x,y]' to get/set array
+ values.
+
+ Non-zero-based arrays can also be created using methods on the System.Array type.
+
+
+
+
+ Single dimensional, zero-based arrays, written 'int[]', 'string[]' etc.
+ Use the values in the Array module to manipulate values
+ of this type, or the notation 'arr.[x]' to get/set array
+ values.
+
+
+
+
+ Single dimensional, zero-based arrays, written 'int[]', 'string[]' etc.
+ Use the values in the Array module to manipulate values
+ of this type, or the notation 'arr.[x]' to get/set array
+ values.
+
+
+
+
+ An abbreviation for the type Microsoft.FSharp.Math.BigInt
+
+
+
+
+ An abbreviation for the .NET type System.Boolean
+
+
+
+
+ Represents a managed pointer in F# code.
+
+
+
+
+ An abbreviation for the .NET type System.Byte
+
+
+
+
+ An abbreviation for the .NET type System.Char
+
+
+
+
+ An abbreviation for the .NET type System.Decimal
+
+
+
+
+ The type of decimal numbers, annotated with a unit of measure. The unit
+ of measure is erased in compiled code and when values of this type
+ are analyzed using reflection. The type is representationally equivalent to
+ System.Decimal.
+
+
+
+
+ An abbreviation for the .NET type System.Double
+
+
+
+
+ An abbreviation for the .NET type System.Exception
+
+
+
+
+ An abbreviation for the .NET type System.Double
+
+
+
+
+ An abbreviation for the .NET type System.Single
+
+
+
+
+ The type of floating point numbers, annotated with a unit of measure. The unit
+ of measure is erased in compiled code and when values of this type
+ are analyzed using reflection. The type is representationally equivalent to
+ System.Single.
+
+
+
+
+ The type of floating point numbers, annotated with a unit of measure. The unit
+ of measure is erased in compiled code and when values of this type
+ are analyzed using reflection. The type is representationally equivalent to
+ System.Double.
+
+
+
+
+ This type is for internal use by the F# code generator
+
+
+
+
+ An abbreviation for the .NET type System.Int32
+
+
+
+
+ An abbreviation for the .NET type System.Int16
+
+
+
+
+ The type of 16-bit signed integer numbers, annotated with a unit of measure. The unit
+ of measure is erased in compiled code and when values of this type
+ are analyzed using reflection. The type is representationally equivalent to
+ System.Int16.
+
+
+
+
+ An abbreviation for the .NET type System.Int32
+
+
+
+
+ An abbreviation for the .NET type System.Int64
+
+
+
+
+ The type of 64-bit signed integer numbers, annotated with a unit of measure. The unit
+ of measure is erased in compiled code and when values of this type
+ are analyzed using reflection. The type is representationally equivalent to
+ System.Int64.
+
+
+
+
+ An abbreviation for the .NET type System.SByte
+
+
+
+
+ The type of 8-bit signed integer numbers, annotated with a unit of measure. The unit
+ of measure is erased in compiled code and when values of this type
+ are analyzed using reflection. The type is representationally equivalent to
+ System.SByte.
+
+
+
+
+ The type of 32-bit signed integer numbers, annotated with a unit of measure. The unit
+ of measure is erased in compiled code and when values of this type
+ are analyzed using reflection. The type is representationally equivalent to
+ System.Int32.
+
+
+
+
+ An abbreviation for the .NET type System.IntPtr
+
+
+
+
+ Represents an unmanaged pointer in F# code.
+
+ This type should only be used when writing F# code that interoperates
+ with native code. Use of this type in F# code may result in
+ unverifiable code being generated. Conversions to and from the
+ nativeint type may be required. Values of this type can be generated
+ by the functions in the NativeInterop.NativePtr module.
+
+
+
+
+ An abbreviation for the .NET type System.Object
+
+
+
+
+ The type of optional values. When used from other .NET languages the
+ empty option is the null value.
+
+ Use the constructors Some and None to create values of this type.
+ Use the values in the Option module to manipulate values of this type,
+ or pattern match against the values directly.
+
+ 'None' values will appear as the value null to other .NET languages.
+ Instance methods on this type will appear as static methods to other .NET languages
+ due to the use of null as a value representation.
+
+
+
+
+ The type of mutable references. Use the functions [:=] and [!] to get and
+ set values of this type.
+
+
+
+
+ An abbreviation for the .NET type System.SByte
+
+
+
+
+ An abbreviation for the .NET type System.Single
+
+
+
+
+ An abbreviation for the .NET type System.String
+
+
+
+
+ An abbreviation for the .NET type System.UInt16
+
+
+
+
+ An abbreviation for the .NET type System.UInt32
+
+
+
+
+ An abbreviation for the .NET type System.UInt64
+
+
+
+
+ An abbreviation for the .NET type System.Byte
+
+
+
+
+ An abbreviation for the .NET type System.UIntPtr
+
+
+
+
+ The type 'unit', which has only one value "()". This value is special and
+ always uses the representation 'null'.
+
+
+
+
+ Dynamic invocations of functions marked with the NoDynamicInvocationAttribute attribute raise this exception
+
+
+
+
+ This exception is raised by 'failwith'
+
+
+
+
+ Non-exhaustive match failures will raise the MatchFailure exception
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Build an aysnchronous workflow using computation expression syntax
+
+
+
+
+ Builds a lookup table from a sequence of key/value pairs. The key objects are indexed using generic hashing and equality.
+
+
+
+
+ Print to stderr using the given format
+
+
+
+
+ Print to stderr using the given format, and add a newline
+
+
+
+
+ Print to a string buffer and raise an exception with the given
+ result. Helper printers must return strings.
+
+
+
+
+ Print to a file using the given format
+
+
+
+
+ Print to a file using the given format, and add a newline
+
+
+
+
+ Special prefix operator for splicing typed expressions into quotation holes
+
+
+
+
+ Special prefix operator for splicing untyped expressions into quotation holes
+
+
+
+
+
+
+
+
+
+
+ Print to stdout using the given format
+
+
+
+
+ Print to stdout using the given format, and add a newline
+
+
+
+
+ Builds a sequence using sequence expression syntax
+
+
+
+
+ Builds a set from a sequence of objects. The key objects are indexed using generic comparison
+
+
+
+
+ Print to a string using the given format
+
+
+
+
+ An active pattern to force the execution of values of type Lazy<_>
+
+
+
+
+Pervasives: Additional bindings available at the top level
+
+
+
+
+ A compiler intrinsic that implements dynamic invocations to the '+' operator
+
+
+
+
+ A compiler intrinsic that implements dynamic invocations to the checked '+' operator
+
+
+
+
+ A compiler intrinsic that implements dynamic invocations to the checked '+' operator
+
+
+
+
+ Generate a null value for reference types.
+
+
+
+
+ Divide a floating point value by an integer
+
+
+
+
+ A compiler intrinsic that implements dynamic invocations for the DivideByInt primitive
+
+
+
+
+ Build an enum value from an underlying value
+
+
+
+
+ Get the underlying value for an enum value
+
+
+
+
+ A static F# comparer object
+
+
+
+
+ Return an F# comparer object suitable for hashing and equality. This hashing behaviour
+ of the returned comparer is not limited by an overall node count when hashing F#
+ records, lists and union types.
+
+
+
+
+ Make an F# comparer object for the given type
+
+
+
+
+ Make an F# hash/equality object for the given type
+
+
+
+
+ Make an F# hash/equality object for the given type using node-limited hashing when hashing F#
+ records, lists and union types.
+
+
+
+
+ Compare two values
+
+
+
+
+ Compare two values. May be called as a recursive case from an implementation of System.IComparable to
+ ensure consistent NaN comparison semantics.
+
+
+
+
+ Compare two values for equality
+
+
+
+
+ Compare two values for equality
+
+
+
+
+ Compare two values
+
+
+
+
+ Compare two values
+
+
+
+
+ Hash a value according to its structure. This hash is not limited by an overall node count when hashing F#
+ records, lists and union types.
+
+
+
+
+ Recursively hash a part of a value according to its structure.
+
+
+
+
+ Compare two values
+
+
+
+
+ Compare two values
+
+
+
+
+ Hash a value according to its structure. Use the given limit to restrict the hash when hashing F#
+ records, lists and union types.
+
+
+
+
+ Take the maximum of two values structurally according to the order given by GenericComparison
+
+
+
+
+ Take the minimum of two values structurally according to the order given by GenericComparison
+
+
+
+
+ Resolves to the one value for any primitive numeric type or any type with a static member called 'One'
+
+
+
+
+ Resolves to the zero value for any primitive numeric type or any type with a static member called 'Zero'
+
+
+
+
+ Resolves to the zero value for any primitive numeric type or any type with a static member called 'Zero'
+
+
+
+
+ Resolves to the zero value for any primitive numeric type or any type with a static member called 'Zero'
+
+
+
+
+ A compiler intrinsic that implements dynamic invocations to the '+' operator
+
+
+
+
+ Parse an int32 according to the rules used by the overloaded 'int32' conversion operator when applied to strings
+
+
+
+
+ Parse an int64 according to the rules used by the overloaded 'int64' conversion operator when applied to strings
+
+
+
+
+ Parse an uint32 according to the rules used by the overloaded 'uint32' conversion operator when applied to strings
+
+
+
+
+ Parse an uint64 according to the rules used by the overloaded 'uint64' conversion operator when applied to strings
+
+
+
+
+ Reference/physical equality.
+ True if boxed versions of the inputs are reference-equal, OR if
+ both are primitive numeric types and the implementation of Object.Equals for the type
+ of the first argument returns true on the boxed versions of the inputs.
+
+
+
+
+ The physical hash. Hashes on the object identity, except for value types,
+ where we hash on the contents.
+
+
+
+
+ A primitive entry point used by the F# compiler for optimization purposes.
+
+
+
+
+ A primitive entry point used by the F# compiler for optimization purposes.
+
+
+
+
+ A primitive entry point used by the F# compiler for optimization purposes.
+
+
+
+
+ A primitive entry point used by the F# compiler for optimization purposes.
+
+
+
+
+ A primitive entry point used by the F# compiler for optimization purposes.
+
+
+
+
+ A primitive entry point used by the F# compiler for optimization purposes.
+
+
+
+
+ A primitive entry point used by the F# compiler for optimization purposes.
+
+
+
+
+ A primitive entry point used by the F# compiler for optimization purposes.
+
+
+
+
+ A primitive entry point used by the F# compiler for optimization purposes.
+
+
+
+
+ A primitive entry point used by the F# compiler for optimization purposes.
+
+
+
+
+ A primitive entry point used by the F# compiler for optimization purposes.
+
+
+
+
+ A primitive entry point used by the F# compiler for optimization purposes.
+
+
+
+
+ A primitive entry point used by the F# compiler for optimization purposes.
+
+
+
+
+ A primitive entry point used by the F# compiler for optimization purposes.
+
+
+
+
+ A primitive entry point used by the F# compiler for optimization purposes.
+
+
+
+
+
+
+
+ A primitive entry point used by the F# compiler for optimization purposes.
+
+
+
+
+ A primitive entry point used by the F# compiler for optimization purposes.
+
+
+
+
+ A primitive entry point used by the F# compiler for optimization purposes.
+
+
+
+
+ A primitive entry point used by the F# compiler for optimization purposes.
+
+
+
+
+ A primitive entry point used by the F# compiler for optimization purposes.
+
+
+
+
+ A primitive entry point used by the F# compiler for optimization purposes.
+
+
+
+
+ A primitive entry point used by the F# compiler for optimization purposes.
+
+
+
+
+ A primitive entry point used by the F# compiler for optimization purposes.
+
+
+
+
+ A primitive entry point used by the F# compiler for optimization purposes.
+
+
+
+
+ The F# compiler emits calls to some of the functions in this module as part of the compiled form of some language constructs
+
+
+
+
+ This function implements calls to default constructors
+ acccessed by 'new' constraints.
+
+
+
+
+ A compiler intrinsic for the efficeint compilation of sequence expressions
+
+
+
+
+ The standard overloaded associative (indexed) lookup operator
+
+
+
+
+ The standard overloaded associative (2-indexed) lookup operator
+
+
+
+
+ The standard overloaded associative (3-indexed) lookup operator
+
+
+
+
+ The standard overloaded associative (4-indexed) lookup operator
+
+
+
+
+ Primitive used by pattern match compilation
+
+
+
+
+ This function implements parsing of decimal constants
+
+
+
+
+ The standard overloaded associative (indexed) mutation operator
+
+
+
+
+ The standard overloaded associative (2-indexed) mutation operator
+
+
+
+
+ The standard overloaded associative (3-indexed) mutation operator
+
+
+
+
+ The standard overloaded associative (4-indexed) mutation operator
+
+
+
+
+ A compiler intrinsic that implements the ':?' operator
+
+
+
+
+ A compiler intrinsic that implements the ':?' operator
+
+
+
+
+ A compiler intrinsic that implements the ':?>' operator
+
+
+
+
+ A compiler intrinsic that implements the ':?>' operator
+
+
+
+
+ The F# compiler emits calls to some of the functions in this module as part of the compiled form of some language constructs
+
+
+
+
+ Address-of. Uses of this value may result in the generation of unverifiable code.
+
+
+
+
+ Binary 'and'. When used as a binary operator the right hand value is evaluated only on demand
+
+
+
+
+ Binary 'and'. When used as a binary operator the right hand value is evaluated only on demand
+
+
+
+
+ Binary 'or'. When used as a binary operator the right hand value is evaluated only on demand
+
+
+
+
+ Address-of. Uses of this value may result in the generation of unverifiable code.
+
+
+
+
+ Binary 'or'. When used as a binary operator the right hand value is evaluated only on demand
+
+
+
+
+ The F# compiler emits calls to some of the functions in this module as part of the compiled form of some language constructs
+
+
+
+
+ Language primitives associated with the F# language
+
+
+
+
+ Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
+
+
+
+
+ Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
+
+
+
+
+ Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
+
+
+
+
+ Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
+
+
+
+
+ Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
+
+
+
+
+ Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Provide a default implementation of the F# numeric literal syntax 'dddN'
+
+
+
+
+ Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
+
+
+
+
+
+
+
+
+
+
+ Absolute value of the given number
+
+
+
+
+ Inverse cosine of the given number
+
+
+
+
+ Inverse sine of the given number
+
+
+
+
+ Inverse tangent of the given number
+
+
+
+
+ Inverse tangent of x/y where x and y are specified separately
+
+
+
+
+ Boxes a strongly typed value.
+
+
+
+
+ Converts the argument to byte. This is a direct conversion for all
+ primitive numeric types. For strings, the input is converted using Byte.Parse() on strings and otherwise requires a ToByte method on the input type
+
+
+
+
+ Ceiling of the given number
+
+
+
+
+ Converts the argument to character. Numeric inputs are converted according to the UTF-16
+ encoding for characters. String inputs must be exactly one character long.
+ For other types a static member ToChar must exist on the type.
+
+
+
+
+ Generic comparison
+
+
+
+
+ Cosine of the given number
+
+
+
+
+ Hyperbolic cosine of the given number
+
+
+
+
+ Converts the argument to System.Decimal using a direct conversion for all
+ primitive numeric types and requiring a ToDecimal method otherwise
+
+
+
+
+ Decrement a mutable reference cell containing an integer
+
+
+
+
+ Used to specify a default value for an optional argument in the implementation of a function
+
+
+
+
+ Converts the argument to 64-bit float. This is a direct conversion for all
+ primitive numeric types. For strings, the input is converted using Double.Parse() with InvariantCulture settings. Otherwise the operation requires and invokes a ToDouble method on the input type
+
+
+
+
+ Converts the argument to a particular enum type.
+
+
+
+
+ Exit the current hardware isolated process, if security settings permit,
+ otherwise raise an exception. Calls System.Environment.Exit.
+
+
+
+
+ Exponential of the given number
+
+
+
+
+ Throw a FailureException exception
+
+
+
+
+ Converts the argument to 64-bit float. This is a direct conversion for all
+ primitive numeric types. For strings, the input is converted using Double.Parse() with InvariantCulture settings. Otherwise the operation requires and invokes a ToDouble method on the input type
+
+
+
+
+ Converts the argument to 32-bit float. This is a direct conversion for all
+ primitive numeric types. For strings, the input is converted using Single.Parse() with InvariantCulture settings. Otherwise the operation requires and invokes a ToSingle method on the input type
+
+
+
+
+ Floor of the given number
+
+
+
+
+ Return the first element of a tuple, fst (a,b) = a.
+
+
+
+
+ A generic hash function, designed to return equal hash values for items that are
+ equal according to the "=" operator. By default it will use structural hashing
+ for F# union, record and tuple types, hashing the complete contents of the
+ type. The exact behaviour of the function can be adjusted on a
+ type-by-type basis by implementing GetHashCode for each type.
+
+
+
+
+ The identity function
+
+
+
+
+ Ignore the passed value. This is often used to throw away results of a computation.
+
+
+
+
+ Increment a mutable reference cell containing an integer
+
+
+
+
+ Equivalent to System.Double.PositiveInfinity
+
+
+
+
+ Equivalent to System.Single.PositiveInfinity
+
+
+
+
+ Converts the argument to signed 32-bit integer. This is a direct conversion for all
+ primitive numeric types. For strings, the input is converted using Int32.Parse() with InvariantCulture settings. Otherwise the operation requires and invokes a ToInt32 method on the input type
+
+
+
+
+ Converts the argument to signed 16-bit integer. This is a direct conversion for all
+ primitive numeric types. For strings, the input is converted using Int16.Parse() with InvariantCulture settings. Otherwise the operation requires and invokes a ToInt16 method on the input type
+
+
+
+
+ Converts the argument to signed 32-bit integer. This is a direct conversion for all
+ primitive numeric types. For strings, the input is converted using Int32.Parse() with InvariantCulture settings. Otherwise the operation requires and invokes a ToInt32 method on the input type
+
+
+
+
+ Converts the argument to signed 64-bit integer. This is a direct conversion for all
+ primitive numeric types. For strings, the input is converted using Int64.Parse() with InvariantCulture settings. Otherwise the operation requires and invokes a ToInt64 method on the input type
+
+
+
+
+ Throw an ArgumentException exception
+
+
+
+
+ Throw an InvalidOperationException exception
+
+
+
+
+
+
+
+
+
+
+ A generic hash function. This function has the same behaviour as 'hash',
+ however the default structural hashing for F# union, record and tuple
+ types stops when the given limit of nodes is reached. The exact behaviour of
+ the function can be adjusted on a type-by-type basis by implementing
+ GetHashCode for each type.
+
+
+
+
+ Execute the function as a mutual-exlcusion region using the input value as a lock.
+
+
+
+
+ Natural logarithm of the given number
+
+
+
+
+ Logarithm to base 10 of the given number
+
+
+
+
+ Maximum based on generic comparison
+
+
+
+
+ Minimum based on generic comparison
+
+
+
+
+ Equivalent to System.Double.NaN
+
+
+
+
+ Equivalent to System.Single.NaN
+
+
+
+
+ Converts the argument to signed native integer. This is a direct conversion for all
+ primitive numeric types and ToIntPtr method otherwise)
+
+
+
+
+ Negate a logical value. not true equals false and not false equals true
+
+
+
+
+ Throw an KeyNotFoundException exception
+
+
+
+
+ Throw an ArgumentNullException exception
+
+
+
+
+ Overloaded addition operator
+
+
+
+
+ Concatenate two lists.
+
+
+
+
+ Apply a function to three values, the values being a triple on the left, the function on the right
+
+
+
+
+ Apply a function to two values, the values being a pair on the left, the function on the right
+
+
+
+
+ Overloaded logical-AND operator
+
+
+
+
+ Overloaded logical-OR operator
+
+
+
+
+ Assign to a mutable reference cell
+
+
+
+
+ Compose two functions, the function on the right being applied first
+
+
+
+
+ Compose two functions, the function on the left being applied first
+
+
+
+
+ Concatenate two strings. The overlaoded operator '+' may also be used.
+
+
+
+
+ Dereference a mutable reference cell
+
+
+
+
+ Overloaded division operator
+
+
+
+
+Structural equality
+
+
+
+
+ Overloaded logical-XOR operator
+
+
+
+
+ Overloaded power operator.
+
+
+
+
+ Structural greater-than
+
+
+
+
+Structural greater-than-or-equal
+
+
+
+
+ Overloaded byte-shift left operator by a specified number of bits
+
+
+
+
+ Apply a function to two values, the values being a pair on the right, the function on the left
+
+
+
+
+ Apply a function to three values, the values being a triple on the right, the function on the left
+
+
+
+
+Structural inequality
+
+
+
+
+ Structural less-than comparison
+
+
+
+
+Structural less-than-or-equal comparison
+
+
+
+
+ Overloaded logical-NOT operator
+
+
+
+
+ Overloaded modulo operator
+
+
+
+
+ Overloaded multiplication operator
+
+
+
+
+ Apply a function to a value, the value being on the right, the function on the left
+
+
+
+
+ Apply a function to a value, the value being on the left, the function on the right
+
+
+
+
+ The standard overloaded range operator, e.g. [n..m] for lists, seq {n..m} for sequences
+
+
+
+
+ The standard overloaded skip range operator, e.g. [n..skip..m] for lists, seq {n..skip..m} for sequences
+
+
+
+
+ Overloaded byte-shift right operator by a specified number of bits
+
+
+
+
+ Overloaded subtraction operator
+
+
+
+
+ Overloaded unary negation.
+
+
+
+
+ Overloaded prefix=plus operator
+
+
+
+
+ Overloaded power operator. If n > 0 then equivalent to x*...*x for n occurrences of x.
+
+
+
+
+ Raises an exception
+
+
+
+
+ Create a mutable reference cell
+
+
+
+
+ Rethrows an exception. This should only be used when handling an exception
+
+
+
+
+ Round the given number
+
+
+
+
+ Converts the argument to signed byte. This is a direct conversion for all
+ primitive numeric types. For strings, the input is converted using SByte.Parse() with InvariantCulture settings. Otherwise the operation requires and invokes a ToSByte method on the input type
+
+
+
+
+ Sign of the given number
+
+
+
+
+ Sine of the given number
+
+
+
+
+ Converts the argument to 32-bit float. This is a direct conversion for all
+ primitive numeric types. For strings, the input is converted using Single.Parse() with InvariantCulture settings. Otherwise the operation requires and invokes a ToSingle method on the input type
+
+
+
+
+ Hyperbolic sine of the given number
+
+
+
+
+ Returns the internal size of a type in bytes. For example, sizeof<int> returns 4.
+
+
+
+
+ Return the second element of a tuple, snd (a,b) = b.
+
+
+
+
+ Square root of the given number
+
+
+
+
+ Reads the value of the property System.Console.Error.
+
+
+
+
+ Reads the value of the property System.Console.In.
+
+
+
+
+ Reads the value of the property System.Console.Out.
+
+
+
+
+ Converts the argument to a string using ToString.
+ For standard integer and floating point values the ToString conversion uses CultureInfo.InvariantCulture.
+ Note, native integer ToString does not support specifying CultureInfo.
+
+
+
+
+ Tangent of the given number
+
+
+
+
+ Hyperbolic tangent of the given number
+
+
+
+
+ Overloaded truncate operator.
+
+
+
+
+ Generate a System.Type representation for a type definition. If the
+ input type is a generic type instantiation then return the
+ generic type definition associated with all such instantiations.
+
+
+
+
+ Generate a System.Type runtime represenation of a static type.
+ The static type is still maintained on the value returned.
+
+
+
+
+ Converts the argument to unsigned 16-bit integer. This is a direct conversion for all
+ primitive numeric types. For strings, the input is converted using UInt16.Parse() with InvariantCulture settings. Otherwise the operation requires and invokes a ToUInt16 method on the input type
+
+
+
+
+ Converts the argument to unsigned 32-bit integer. This is a direct conversion for all
+ primitive numeric types. For strings, the input is converted using UInt32.Parse() with InvariantCulture settings. Otherwise the operation requires and invokes a ToUInt32 method on the input type
+
+
+
+
+ Converts the argument to unsigned 64-bit integer. This is a direct conversion for all
+ primitive numeric types. For strings, the input is converted using UInt64.Parse() with InvariantCulture settings. Otherwise the operation requires and invokes a ToUInt64 method on the input type
+
+
+
+
+ Converts the argument to unsigned native integer using a direct conversion for all
+ primitive numeric types and requiring a ToUintPtr method otherwise
+
+
+
+
+ Unboxes a strongly typed value. This is the inverse of box, unbox<t>(box<t> a) equals a.
+
+
+
+
+ Clean up resources associated with the input object after the completion of the given function.
+ Cleanup occurs even when an exception is raised by the protected
+ code.
+
+
+
+
+
+
+
+ An active pattern to match values of type System.Collections.Generic.KeyValuePair
+
+
+
+
+ Converts the argument to byte. This is a direct conversion for all
+ primitive numeric types and ToByte method otherwise)
+
+
+
+
+ Converts the argument to unicode character based on UTF16 encoding (a direct conversion for all
+ primitive numeric types and ToUIntPtr method otherwise)
+
+
+
+
+ Converts the argument to signed 32-bit integer. This is a direct conversion for all
+ primitive numeric types and ToInt32 method otherwise)
+
+
+
+
+ Converts the argument to signed 16-bit integer. This is a direct conversion for all
+ primitive numeric types and ToInt16 method otherwise)
+
+
+
+
+ Converts the argument to signed 32-bit integer. This is a direct conversion for all
+ primitive numeric types and ToInt32 method otherwise)
+
+
+
+
+ Converts the argument to signed 64-bit integer. This is a direct conversion for all
+ primitive numeric types and ToInt64 method otherwise)
+
+
+
+
+ Converts the argument to signed native integer. This is a direct conversion for all
+ primitive numeric types and ToIntPtr method otherwise)
+
+
+
+
+ Overloaded addition operator (checks for overflow)
+
+
+
+
+ Overloaded multiplication operator (checks for overflow)
+
+
+
+
+ Overloaded subtraction operator (checks for overflow)
+
+
+
+
+ Overloaded unary negation (checks for overflow)
+
+
+
+
+ Converts the argument to signed byte. This is a direct conversion for all
+ primitive numeric types and ToSByte method otherwise)
+
+
+
+
+ Converts the argument to unsigned 16-bit integer. This is a direct conversion for all
+ primitive numeric types and ToUInt16 method otherwise)
+
+
+
+
+ Converts the argument to unsigned 32-bit integer. This is a direct conversion for all
+ primitive numeric types and ToUInt32 method otherwise)
+
+
+
+
+ Converts the argument to unsigned 64-bit integer. This is a direct conversion for all
+ primitive numeric types and ToUInt64 method otherwise)
+
+
+
+
+ Converts the argument to unsigned native integer. This is a direct conversion for all
+ primitive numeric types and ToUIntPtr method otherwise)
+
+
+
+
+ This module contains the basic arithmetic operations with overflow checks.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Get a slice of an array
+
+
+
+
+ Get a slice of an array
+
+
+
+
+ Get a slice of an array
+
+
+
+
+ Get a slice of an array
+
+
+
+
+ Get a slice from a string
+
+
+
+
+
+
+
+
+
+
+ This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'byte'
+
+
+
+
+ This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'decimal'
+
+
+
+
+ This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'float'
+
+
+
+
+
+
+
+ This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator
+
+
+
+
+ This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'int16'
+
+
+
+
+ This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'int32'
+
+
+
+
+ This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'int64'
+
+
+
+
+ This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'nativeint'
+
+
+
+
+ This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'sbyte'
+
+
+
+
+ This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'float32'
+
+
+
+
+ This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'uint16'
+
+
+
+
+ This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'uint32'
+
+
+
+
+ This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'uint64'
+
+
+
+
+ This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'unativeint'
+
+
+
+
+ Generate a range of byte values
+
+
+
+
+ Generate a range of char values
+
+
+
+
+ Generate a range of float values
+
+
+
+
+ Generate a range of values using the given zero, add, start, step and stop values
+
+
+
+
+ Generate a range of int16 values
+
+
+
+
+ Generate a range of integers
+
+
+
+
+ Generate a range of int64 values
+
+
+
+
+ Generate a range of nativeint values
+
+
+
+
+ Generate a range of sbyte values
+
+
+
+
+ Generate a range of float32 values
+
+
+
+
+ Generate a range of values using the given zero, add, start, step and stop values
+
+
+
+
+ Generate a range of uint16 values
+
+
+
+
+ Generate a range of uint32 values
+
+
+
+
+ Generate a range of uint64 values
+
+
+
+
+ Generate a range of unativeint values
+
+
+
+
+
+
+
+ Set a slice of an array
+
+
+
+
+ Set a slice of an array
+
+
+
+
+ Set a slice of an array
+
+
+
+
+ Set a slice of an array
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A module of compiler intrinsic functions for efficient implementations of F# integer ranges
+ and dynamic invocations of other F# operators
+
+
+
+
+ Generate a defult value for any type. This is null for reference types,
+ For structs, this is struct value where all fields have the default value.
+ This function is unsafe in the sense that some F# values do not have proper null values.
+
+
+
+
+ This module contains basic operations which do not apply runtime and/or static checks
+
+
+
+
+ Basic F# Operators. This module is automatically opened in all F# code.
+
+
+
+
+ Invoke the optimized function value with two curried arguments
+
+
+
+
+ Adapt an F# first class function value to be an optimized function value that can
+ accept two curried arguments without intervening execution.
+
+
+
+
+ Construct an optimized function value that can accept two curried
+ arguments without intervening execution.
+
+
+
+
+ The .NET type used to represent F# function values that accept
+ two iterated (curried) arguments without intervening execution. This type should not
+ typically used directly from either F# code or from other .NET languages.
+
+
+
+
+ Invoke an F# first class function value that accepts three curried arguments
+ without intervening execution
+
+
+
+
+ Adapt an F# first class function value to be an optimized function value that can
+ accept three curried arguments without intervening execution.
+
+
+
+
+ Construct an optimized function value that can accept three curried
+ arguments without intervening execution.
+
+
+
+
+ The .NET type used to represent F# function values that accept
+ three iterated (curried) arguments without intervening execution. This type should not
+ typically used directly from either F# code or from other .NET languages.
+
+
+
+
+ Invoke an F# first class function value that accepts four curried arguments
+ without intervening execution
+
+
+
+
+ Adapt an F# first class function value to be an optimized function value that can
+ accept four curried arguments without intervening execution.
+
+
+
+
+ Construct an optimized function value that can accept four curried
+ arguments without intervening execution.
+
+
+
+
+ The .NET type used to represent F# function values that accept
+ four iterated (curried) arguments without intervening execution. This type should not
+ typically used directly from either F# code or from other .NET languages.
+
+
+
+
+ Invoke an F# first class function value that accepts five curried arguments
+ without intervening execution
+
+
+
+
+ Adapt an F# first class function value to be an optimized function value that can
+ accept five curried arguments without intervening execution.
+
+
+
+
+ Construct an optimized function value that can accept five curried
+ arguments without intervening execution.
+
+
+
+
+ The .NET type used to represent F# function values that accept
+ five iterated (curried) arguments without intervening execution. This type should not
+ typically used directly from either F# code or from other .NET languages.
+
+
+
+
+ An implementation module used to hold some private implementations of function
+ value invocation.
+
+
+
+ bind f inp evaluates to match inp with None -> None | Some x -> f x
+
+
+ length inp evaluates to match inp with None -> 0 | Some _ -> 1
+
+
+ exists p inp evaluates to match inp with None -> false | Some x -> p x
+
+
+ filter p inp evaluates to match inp with None -> None | Some x -> if p x then inp else None
+
+
+ fold_left f s inp evaluates to match inp with None -> s | Some x -> f s x
+
+
+ fold_right f inp s evaluates to "match inp with None -> s | Some x -> f x s"
+
+
+
+
+
+
+
+
+
+
+
+ forall p inp" evaluates to "match inp with None -> true | Some x -> p x
+
+
+
+ Gets the value associated with the option. If the option is None then
+ raises ArgumentException
+
+
+
+
+ Returns true if the option is None
+
+
+
+
+ Returns true if the option is not None
+
+
+
+
+
+
+
+
+
+ iter f inp executes match inp with None -> () | Some x -> f x
+
+
+ filter p inp evaluates to match inp with None -> None | Some x -> if p x then inp else None
+
+
+ map f inp evaluates to match inp with None -> None | Some x -> Some (f x)
+
+
+ partition p inp evaluates to
+ match inp with None -> None,None | Some x -> if p x then inp,None else None,inp
+
+
+
+ Convert the option to an array of length 0 or 1
+
+
+
+
+ Convert the option to a list of length 0 or 1
+
+
+
+
+ Basic operations on options.
+
+
+
+
+ Build a new string whose characters are the results of applying the function mapping
+ to each of the characters of the input string and concatenating the resulting
+ strings.
+
+
+
+
+ Return a new string made by concatenating the given strings
+ with separator 'sep', i.e. 'a1 + sep + ... + sep + aN'
+
+
+
+
+ Test if any character of the string satisfies the given predicate.
+
+
+
+
+
+
+
+ Test if all characters in the string satisfy the given predicate.
+
+
+
+
+ Build a new string whose characters are the results of applying the function mapping
+ to each index from 0 to count-1 and concatenating the resulting
+ strings.
+
+
+
+
+ Apply the function action to each character in the string.
+
+
+
+
+ Apply the function action to the index of each character in the string and the character itself.
+
+
+
+
+ Return the length of the string.
+
+
+
+
+ Build a new string whose characters are the results of applying the function mapping
+ to each of the characters of the input string.
+
+
+
+
+
+
+
+ Build a new string whose characters are the results of applying the function mapping
+ to each character in the string and the character itself.
+
+
+
+
+ Return a string by concatenating count instances of str.
+
+
+
+
+ Functional programming operators for string processing. Further string operations
+ are available via the member functions on strings and other functionality in
+ System.String
+ and System.Text.RegularExpressions types.
+
+
+
+
+ Return the given big integer
+
+
+
+
+ Return the negation of a big integer
+
+
+
+
+ Return the difference of big integers
+
+
+
+
+ Generate a range of big integers, with a step
+
+
+
+
+ Generate a range of big integers
+
+
+
+
+ Return the product of big integers
+
+
+
+
+ Return the modulus of big integers
+
+
+
+
+ This operator is for use from other .NET languages
+
+
+
+
+ This operator is for use from other .NET languages
+
+
+
+
+ This operator is for use from other .NET languages
+
+
+
+
+ This operator is for use from other .NET languages
+
+
+
+
+ This operator is for use from other .NET languages
+
+
+
+
+ This operator is for use from other .NET languages
+
+
+
+
+ Return the ratio of big integers
+
+
+
+
+ Return the sum of two big integers
+
+
+
+
+ Get the big integer for zero
+
+
+
+
+ Return the sign of a big integer: 0, +1 or -1
+
+
+
+
+ Get the big integer for one
+
+
+
+
+ Return true if a big integer is 'zero'
+
+
+
+
+ Return true if a big integer is 'one'
+
+
+
+
+
+
+
+ Convert a big integer to a 64-bit signed integer
+
+
+
+
+ Convert a big integer to a 32-bit signed integer
+
+
+
+
+ Convert a big integer to a floating point number
+
+
+
+
+ Return n^m for two big integers
+
+
+
+
+ Parse a big integer from a string format
+
+
+
+
+
+
+
+ Return the greatest common divisor of two big integers
+
+
+
+
+ Compute the factorial function as a big integer
+
+
+
+
+
+
+
+ Compute the ratio and remainder of two big integers
+
+
+
+
+ Compute the absolute value of a big integer
+
+
+
+
+ Construct a BigInt value for the given integer
+
+
+
+
+ Construct a BigInt value for the given 64-bit integer
+
+
+
+
+ The type of arbitrary-sized integers
+
+
+
+
+ Abstract internal type
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Return a typed native pointer by adding index * sizeof<'T> to the
+ given input pointer
+
+
+
+
+ Dereference the typed native pointer computed by adding index * sizeof<'T> to the
+ given input pointer
+
+
+
+
+ Get the address of an element of a pinned array
+
+
+
+
+ Get the address of an element of a pinned 2-dimensional array
+
+
+
+
+ Return a typed native pointer for a given machine address
+
+
+
+
+ Dereference the given typed native pointer
+
+
+
+
+ Assign the value into the memory location referenced by the typed native
+ pointer computed by adding index * sizeof<'T> to the given input pointer
+
+
+
+
+ Return a machine address for a given typed native pointer
+
+
+
+
+ Assign the value into the memory location referenced by the given typed native pointer
+
+
+
+
+ Contains operations on native pointers. Use of these operators may
+ result in the generation of unverifiable code.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns type of an expression
+
+
+
+
+ Returns the custom attributes of an expression
+
+
+
+
+ Build an expression that represents a while loop
+
+
+
+
+ Build an expression that represents setting a mutable variable
+
+
+
+
+ Build an expression that represents a variable
+
+
+
+
+ Build an expression that represents a constant value of a particular type
+
+
+
+
+ Build an expression that represents a constant value
+
+
+
+
+ Build an expression that represents a test of a value is of a particular union case
+
+
+
+
+ Build an expression that represents a type test
+
+
+
+
+ Build an expression that represents getting a field of a tuple
+
+
+
+
+ Build an expression that represents a try/with construct for exception filtering and catching
+
+
+
+
+ Try and find a stored reflection definition for the given method. Stored reflection
+ definitions are added to an F# assembly through the use of the [<ReflectedDefinition>] attribute.
+
+
+
+
+ Build an expression that represents a try/finally construct
+
+
+
+
+ Substitute through the given expression using the given functions
+ to map variables to new values. The functions must give consistent results
+ at each application. Variable renaming may occur on the target expression
+ if variable capture occurs.
+
+
+
+
+ Build an expression that represents the sequential execution of one expression followed by another
+
+
+
+
+ Permit interactive environments such as F# Interactive
+ to explicitly register new pickled resources that represent persisted
+ top level definitions. The string indicates a unique name for the resources
+ being added. The format for the bytes is the encoding generated by the F# compiler.
+
+
+
+
+ Build an expression that represents a nested quotation literal
+
+
+
+
+ Build an expression that represents writing to a property of an object
+
+
+
+
+ Build an expression that represents writing to a static property
+
+
+
+
+ Build an expression that represents reading a property of an object
+
+
+
+
+ Build an expression that represents reading a static property
+
+
+
+
+ Build an expression that represents the creation of a union case value
+
+
+
+
+ Build an expression that represents the creation of an F# tuple value
+
+
+
+
+ Build record-construction expressions
+
+
+
+
+ Build an expression that represents the invocation of an object constructor
+
+
+
+
+ Build an expression that represents the creation of a delegate value for the given type
+
+
+
+
+ Build an expression that represents the creation of an array value initialized with the given elements
+
+
+
+
+ Build recursives expressions associated with 'let rec' constructs
+
+
+
+
+ Build expressions associated with 'let' constructs
+
+
+
+
+ Build an expression that represents the constrution of an F# function value
+
+
+
+
+ Build 'if ... then ... else' expressions
+
+
+
+
+ Fetch or create a new variable with the given name and type from a global pool of shared variables
+ indexed by name and type. The type is given by the expicit or inferred type parameter
+
+
+
+
+ Get the free expression variables of an expression as a list
+
+
+
+
+ Build a 'for i = ... to ... do ...' expression that represent loops over integer ranges
+
+
+
+
+ Build an expression that represents writing to a static field
+
+
+
+
+ Build an expression that represents writing to a field of an object
+
+
+
+
+ Build an expression that represents the access of a static field
+
+
+
+
+ Build an expression that represents the access of a field of an object
+
+
+
+
+
+
+
+ This function is called automatically when quotation syntax (<@ @>) and related typed-expression
+ quotations are used. The bytes are a pickled binary representation of an unlinked form of the qutoed expression,
+ and the System.Type argument is any type in the assembly where the quoted
+ expression occurs, i.e. it helps scope the interpretation of the cross-assembly
+ references in the bytes.
+
+
+
+
+ Build an expression that represents the invocation of a default object constructor
+
+
+
+
+ Build an expression that represents the coercion of an expression to a type
+
+
+
+
+ Return a new typed expression given an underlying runtime-typed expression.
+ A type annotation is usually required to use this function, and
+ using an incorrect type annotation may result in a later runtime exception.
+
+
+
+
+ Build an expression that represents a call to an static method or module-bound function
+
+
+
+
+ Build an expression that represents a call to an instance method associated with an object
+
+
+
+
+ Build an expression that represents the application of a first class function value to multiple arguments
+
+
+
+
+ Build an expression that represents the application of a first class function value to a single argument
+
+
+
+
+ Build an expression that represents setting the value held at a particular address
+
+
+
+
+ Build an expression that represents getting the address of a value
+
+
+
+
+ Quoted expressions annotated with System.Type values.
+
+
+
+
+ Get the raw expression associated with this type-carrying expression
+
+
+
+
+ Type-carrying quoted expressions. Expressions are generated either
+ by quotations in source text or programatically
+
+
+
+
+ The type associated with the variable
+
+
+
+
+ The declared name of the variable
+
+
+
+
+ Indicates if the variable represents a mutable storage location
+
+
+
+
+ Fetch or create a new variable with the given name and type from a global pool of shared variables
+ indexed by name and type
+
+
+
+
+ Create a new variable with the given name, type and mutability
+
+
+
+
+ Information at the binding site of a variable
+
+
+
+
+ An active pattern to recognize expressions of the form a && b
+
+
+
+
+ An active pattern to recognize expressions that represent the application of a (possibly curried or tupled) first class function value
+
+
+
+
+ An active pattern to recognize constant boolean expressions
+
+
+
+
+ An active pattern to recognize constant byte expressions
+
+
+
+
+ An active pattern to recognize constant unicode character expressions
+
+
+
+
+ An active pattern to recognize constant 64-bit floating point number expressions
+
+
+
+
+ An active pattern to recognize constant int16 expressions
+
+
+
+
+ An active pattern to recognize constant int32 expressions
+
+
+
+
+ An active pattern to recognize constant int64 expressions
+
+
+
+
+ An active pattern to recognize expressions that represent a (possibly curried or tupled) first class function value
+
+
+
+
+ An active pattern to recognize methods that have an associated ReflectedDefinition
+
+
+
+
+ An active pattern to recognize expressions of the form a || b
+
+
+
+
+ An active pattern to recognize property getters or values in modules that have an associated ReflectedDefinition
+
+
+
+
+ An active pattern to recognize property setters that have an associated ReflectedDefinition
+
+
+
+
+ An active pattern to recognize constant signed byte expressions
+
+
+
+
+ An active pattern to recognize constant 32-bit floating point number expressions
+
+
+
+
+ A parameterized active pattern to recognize calls to a specified function or method
+
+
+
+
+ An active pattern to recognize constant string expressions
+
+
+
+
+ An active pattern to recognize constant unsigned int16 expressions
+
+
+
+
+ An active pattern to recognize constant unsigned int32 expressions
+
+
+
+
+ An active pattern to recognize constant unsigned int64 expressions
+
+
+
+
+ An active pattern to recognize () constant expressions
+
+
+
+
+ Contains a set of derived F# active patterns to analyze F# expression objects
+
+
+
+
+ Re-build combination expressions. The first parameter should be an object
+ returned by the ShapeCombination case of the active pattern in this module.
+
+
+
+
+ An active pattern that performs a complete decomposition viewing the expression tree as a binding structure
+
+
+
+
+ Active patterns for traversing, visiting, rebuilding and tranforming expressions in a generic way
+
+
+
+
+ An active pattern to recognize expressions that represent getting the address of a value
+
+
+
+
+ An active pattern to recognize expressions that represent setting the value held at an address
+
+
+
+
+ An active pattern to recognize expressions that represent applications of first class function values
+
+
+
+
+ An active pattern to recognize expressions that represent calls to static and instance methods, and functions defined in modules
+
+
+
+
+ An active pattern to recognize expressions that represent coercions from one type to another
+
+
+
+
+ An active pattern to recognize expressions that represent invocations of a default constructor of a struct
+
+
+
+
+ An active pattern to recognize expressions that represent getting a static or instance field
+
+
+
+
+ An active pattern to recognize expressions that represent setting a static or instance field
+
+
+
+
+ An active pattern to recognize expressions that represent loops over integer ranges
+
+
+
+
+ An active pattern to recognize expressions that represent conditionals
+
+
+
+
+ An active pattern to recognize expressions that represent first class function values
+
+
+
+
+ An active pattern to recognize expressions that represent recursive let bindings of one or more variables
+
+
+
+
+ An active pattern to recognize expressions that represent let bindings
+
+
+
+
+ An active pattern to recognize expressions that represent the construction of arrays
+
+
+
+
+ An active pattern to recognize expressions that represent construction of delegate values
+
+
+
+
+ An active pattern to recognize expressions that represent invocation of object constructors
+
+
+
+
+ An active pattern to recognize expressions that represent construction of record values
+
+
+
+
+ An active pattern to recognize expressions that represent construction of tuple values
+
+
+
+
+ An active pattern to recognize expressions that represent construction of particular union case values
+
+
+
+
+ An active pattern to recognize expressions that represent the read of a static or instance property, or a non-function value declared in a module
+
+
+
+
+ An active pattern to recognize expressions that represent setting a static or instance property, or a non-function value declared in a module
+
+
+
+
+ An active pattern to recognize expressions that represent a nested quotation literal
+
+
+
+
+ An active pattern to recognize expressions that represent sequential exeuction of one expression followed by another
+
+
+
+
+ An active pattern to recognize expressions that represent a try/finally construct
+
+
+
+
+ An active pattern to recognize expressions that represent a try/with construct for exception filtering and catching
+
+
+
+
+ An active pattern to recognize expressions that represent getting a tuple field
+
+
+
+
+ An active pattern to recognize expressions that represent a dynamic type test
+
+
+
+
+ An active pattern to recognize expressions that represent a test if a value is of a particular union case
+
+
+
+
+ An active pattern to recognize expressions that represent a constant value
+
+
+
+
+ An active pattern to recognize expressions that represent setting a mutable variable
+
+
+
+
+ An active pattern to recognize expressions that represent a variable
+
+
+
+
+ An active pattern to recognize expressions that represent while loops
+
+
+
+
+ Contains a set of primitive F# active patterns to analyze F# expression objects
+
+
+
+
+ Return a System.Type representing an F# tuple type with the given element types
+
+
+
+
+ Return a System.Type representing the F# function type with the given domain and range
+
+
+
+
+ Return true if the typ is a representation of an F# union type or the runtime type of a value of that type
+
+
+
+
+ Return true if the typ is a representation of an F# tuple type
+
+
+
+
+ Return true if the typ is a representation of an F# record type
+
+
+
+
+ Return true if the typ is a System.Type value corresponding to the compiled form of an F# module
+
+
+
+
+ Return true if the typ is a representation of an F# function type or the runtime type of a closure implementing an F# function type
+
+
+
+
+ Return true if the typ is a representation of an F# exception declaration
+
+
+
+
+ Get the cases of a union type.
+
+ Assumes the given type is a union type. If not, ArgumentException is raised during pre-computation.
+
+
+
+
+ Get the tuple elements from the representation of an F# tuple type
+
+
+
+
+ Read all the fields from a record value, in declaration order
+
+ Assumes the given input is a record value. If not, ArgumentException is raised.
+
+
+
+
+ Get the domain and range types from an F# function type or from the runtime type of a closure implementing an F# type
+
+
+
+
+ Read all the fields from an F# exception declaration, in declaration order
+
+ Assumes exceptionType is an exception representation type. If not, ArgumentException is raised.
+
+
+
+
+ Contains operations associated with constructing and analyzing F# types such as records, unions and tuples
+
+
+
+
+ Assumes the given type is a union type.
+ If not, ArgumentException is raised during pre-computation.
+
+ Using the computed function is more efficient than calling GetUnionCase
+ because the path executed by the computed function is optimized given the knowledge that it will be
+ used to read values of the given type.
+
+
+
+
+ Precompute a property or static method for reading an integer representing the case tag of a union type.
+
+
+
+
+ Precompute a function for reading all the fields for a particular discriminator case of a union type
+
+ Using the computed function will typically be faster than executing a corresponding call to GetFields
+
+
+
+
+ A method that constructs objects of the given case
+
+
+
+
+ Precompute a function for constructing a discriminated union value for a particular union case.
+
+
+
+
+ Precompute a function for reading the values of a particular tuple type
+
+ Assumes the given type is a TupleType.
+ If not, ArgumentException is raised during pre-computation.
+
+
+
+
+ Get information that indicates how to read a field of a tuple
+
+
+
+
+ Get a method that constructs objects of the given tuple type.
+ For small tuples, no additional typoe will be returned.
+
+ For large tuples, an additional type is returned indicating that
+ a nested encoding has been used for the tuple type. In this case
+ the suffix portion of the tuple type has the given type and an
+ object of this type must be created and passed as the last argument
+ to the ConstructorInfo. A recursive call to PreComputeTupleConstructorInfo
+ can be used to determine the constructor for that the suffix type.
+
+
+
+
+ Precompute a function for reading the values of a particular tuple type
+
+ Assumes the given type is a TupleType.
+ If not, ArgumentException is raised during pre-computation.
+
+
+
+
+ Precompute a function for reading all the fields from a record. The fields are returned in the
+ same order as the fields reported by a call to Microsoft.FSharp.Reflection.Type.GetInfo for
+ this type.
+
+ Assumes the given type is a RecordType.
+ If not, ArgumentException is raised during pre-computation.
+
+ Using the computed function will typically be faster than executing a corresponding call to Value.GetInfo
+ because the path executed by the computed function is optimized given the knowledge that it will be
+ used to read values of the given type.
+
+
+
+
+ Precompute a function for reading a particular field from a record.
+ Assumes the given type is a RecordType with a field of the given name.
+ If not, ArgumentException is raised during pre-computation.
+
+ Using the computed function will typically be faster than executing a corresponding call to Value.GetInfo
+ because the path executed by the computed function is optimized given the knowledge that it will be
+ used to read values of the given type.
+
+
+
+
+ Get a ConstructorInfo for a record type
+
+
+
+
+ Precompute a function for constructing a record value.
+
+ Assumes the given type is a RecordType.
+ If not, ArgumentException is raised during pre-computation.
+
+
+
+
+ Create a union case value
+
+
+
+
+ Create an instance of a tuple type
+
+ Assumes at least one element is given. If not, ArgumentException is raised.
+
+
+
+
+ Create an instance of a record type
+
+ Assumes the given input is a record type. If not, ArgumentException is raised.
+
+
+
+
+ Build a typed function from object from a dynamic function implementation
+
+
+
+
+ Identify the union case and its fields for an object
+
+ Assumes the given input is a union case value. If not, ArgumentException is raised.
+
+ If the type is not given, then the runtime type of the input object is used to identify the
+ relevant union type. The type should always be given if the input object may be null. For example,
+ option values may be represented using the 'null'.
+
+
+
+
+ Read all fields from a tuple
+
+ Assumes the given input is a tuple value. If not, ArgumentException is raised.
+
+
+
+
+ Read a field from a tuple value
+
+ Assumes the given input is a tuple value. If not, ArgumentException is raised.
+
+
+
+
+ Read all the fields from a record value
+
+ Assumes the given input is a record value. If not, ArgumentException is raised.
+
+
+
+
+ Read a field from a record value
+
+ Assumes the given input is a record value. If not, ArgumentException is raised.
+
+
+
+
+ Read all the fields from a value built using an instance of an F# exception declaration
+
+ Assumes the given input is an F# exception value. If not, ArgumentException is raised.
+
+
+
+
+ Contains operations associated with constructing and analyzing values associated with F# types such as records, unions and tuples
+
+
+
+
+ The integer tag for the case
+
+
+
+
+ The name of the case
+
+
+
+
+ The type in which the case occurs
+
+
+
+
+ The fields associated with the case, represented by PropertyInfo
+
+
+
+
+ Return the custom attributes associated with the case
+
+
+
+
+ Return the custom attributes associated with the case matching the given attribute type
+
+
+
+
+Represents a case of a discriminated union type
+
+
+
+
+ Type of a formatting expression
+ 'Printer : function type generated by printf
+ 'State: type argument passed to %a formatters
+ 'Residue: value generated by the overall printf action (e.g. sprint generates a string)
+ 'Result: value generated after post processing (e.g. failwithf generates a string internally then raises an exception)
+
+
+
+
+ Type of a formatting expression
+ 'Printer : function type generated by printf
+ 'State: type argument passed to %a formatters
+ 'Residue: value generated by the overall printf action (e.g. sprint generates a string)
+ 'Result: value generated after post processing (e.g. failwithf generates a string internally then raises an exception)
+ 'Tuple: tuple of values generated by scan or match
+
+
+
+
+ The raw text of the format string
+
+
+
+
+ Construct a format string
+
+
+
+
+ Type of a formatting expression.
+ 'Printer : function type generated by printf
+ 'State: type argument passed to %a formatters
+ 'Residue: value generated by the overall printf action (e.g. sprint generates a string)
+ 'Result: value generated after post processing (e.g. failwithf generates a string internally then raises an exception)
+
+
+
+
+ Construct a format string
+
+
+
+
+ Type of a formatting expression.
+ 'Printer : function type generated by printf
+ 'State: type argument passed to %a formatters
+ 'Residue: value generated by the overall printf action (e.g. sprint generates a string)
+ 'Result: value generated after post processing (e.g. failwithf generates a string internally then raises an exception)
+ 'Tuple: tuple of values generated by scan or match
+
+
+
+
+ Represents a statically-analyzed format associated with writing to a System.Text.StringBuilder. The type parameter indicates the
+ arguments and return type of the format operation.
+
+
+
+
+ Represents a statically-analyzed format associated with writing to a System.Text.StringBuilder. The first type parameter indicates the
+ arguments of the format operation and the last the overall return type.
+
+
+
+
+ Represents a statically-analyzed format when formatting builds a string. The type parameter indicates the
+ arguments and return type of the format operation.
+
+
+
+
+ Represents a statically-analyzed format when formatting builds a string. The first type parameter indicates the
+ arguments of the format operation and the last the overall return type.
+
+
+
+
+ Represents a statically-analyzed format associated with writing to a System.IO.TextWriter. The type parameter indicates the
+ arguments and return type of the format operation.
+
+
+
+
+ Represents a statically-analyzed format associated with writing to a System.IO.TextWriter. The first type parameter indicates the
+ arguments of the format operation and the last the overall return type.
+
+
+
+
+ Print to a System.Text.StringBuilder
+
+
+
+
+ Formatted printing to stderr
+
+
+
+
+ Formatted printing to stderr, adding a newline
+
+
+
+
+ Print to a string buffer and raise an exception with the given
+ result. Helper printers must return strings.
+
+
+
+
+ Print to a text writer or an OCaml-compatible channel
+
+
+
+
+ Print to a text writer or an OCaml-compatible channel, adding a newline
+
+
+
+
+ bprintf, but call the given 'final' function to generate the result.
+ See kprintf.
+
+
+
+
+ fprintf, but call the given 'final' function to generate the result.
+ See kprintf.
+
+
+
+
+ printf, but call the given 'final' function to generate the result.
+ For example, these let the printing force a flush after all output has
+ been entered onto the channel, but not before.
+
+
+
+
+ sprintf, but call the given 'final' function to generate the result.
+ See kprintf.
+
+
+
+
+ twprintf, but call the given 'final' function to generate the result.
+ See kprintf.
+
+
+
+
+ Formatted printing to stdout
+
+
+
+
+ Formatted printing to stdout, adding a newline
+
+
+
+
+ Print to a string via an internal string buffer and return
+ the result as a string. Helper printers must return strings.
+
+
+
+
+ Print to any subtype of the .NET type System.IO.TextWriter
+
+
+
+
+ Print to any subtype of the .NET type System.IO.TextWriter, and add a newline
+
+
+
+
+ Extensible printf-style formatting for numbers and other datatypes
+
+ Format specifications are strings with "%" markers indicating format
+ placeholders. Format placeholders consist of:
+
+ %[flags][width][.precision][type]
+
+ where the type is interpreted as follows:
+
+ %b: bool, formatted as "true" or "false"
+ %s: string, formatted as its unescaped contents
+ %d, %i: any basic integer type formatted as a decimal integer, signed if the basic integer type is signed.
+ %u: any basic integer type formatted as an unsigned decimal integer
+ %x, %X, %o: any basic integer type formatted as an unsigned hexadecimal
+ (a-f)/Hexadecimal (A-F)/Octal integer
+
+ %e, %E, %f, %F, %g, %G:
+ any basic floating point type (float,float32) formatted
+ using a C-style floating point format specifications, i.e
+
+ %e, %E: Signed value having the form [-]d.dddde[sign]ddd where
+ d is a single decimal digit, dddd is one or more decimal
+ digits, ddd is exactly three decimal digits, and sign
+ is + or -
+
+ %f: Signed value having the form [-]dddd.dddd, where dddd is one
+ or more decimal digits. The number of digits before the
+ decimal point depends on the magnitude of the number, and
+ the number of digits after the decimal point depends on
+ the requested precision.
+
+ %g, %G: Signed value printed in f or e format, whichever is
+ more compact for the given value and precision.
+
+
+ %M: System.Decimal value
+
+ %O: Any value, printed by boxing the object and using it's ToString method(s)
+
+ %A: Any value, printed by using Microsoft.FSharp.Text.StructuredPrintfImpl.Display.any_to_string with the default layout settings
+
+ %a: A general format specifier, requires two arguments:
+ (1) a function which accepts two arguments:
+ (a) a context parameter of the appropriate type for the
+ given formatting function (e.g. an #System.IO.TextWriter)
+ (b) a value to print
+ and which either outputs or returns appropriate text.
+
+ (2) the particular value to print
+
+
+ %t: A general format specifier, requires one argument:
+ (1) a function which accepts a context parameter of the
+ appropriate type for the given formatting function (e.g.
+ an System.IO.TextWriter)and which either outputs or returns
+ appropriate text.
+
+ Basic integer types are:
+ byte,sbyte,int16,uint16,int32,uint32,int64,uint64,nativeint,unativeint
+ Basic floating point types are:
+ float, float32
+
+ The following format patterns are accepted but a warning is printed:
+
+ %h(d|u|x|X|o)
+ %l(d|u|x|X|o)
+
+ The following format patterns are now deprecated:
+
+ %Ld, %Li, %Lu, %Lx, %LX, %Lo: same, but an int64
+ %nd, %ni, %nu, %nx, %nX, %no: same, but a nativeint
+ %Ud, %Ui, %Uu, %Ux, %UX, %Uo: same, but an unsigned int32 (uint32)
+ %ULd, %ULi, %ULu, %ULx, %ULX, %ULo: same, but an unsigned int64 (uint64)
+ %Und, %Uni, %Unu, %Unx, %UnX, %Uno: same, but an unsigned nativeint (unativeint)
+
+ The optional width is an integer indicating the minimal width of the
+ result. For instance, %6d prints an integer, prefixing it with spaces
+ to fill at least 6 characters. If width is '*', then an extra integer
+ argument is taken to specify the corresponding width.
+
+ any number
+ '*':
+
+ Valid flags are:
+
+ 0: add zeros instead of spaces to make up the required width
+ '-': left justify the result within the width specified
+ '+': add a '+' character if the number is positive (to match a '-' sign
+ for negatives)
+ ' ': add an extra space if the number is positive (to match a '-'
+ sign for negatives)
+
+ The printf '#' flag is invalid and a compile-time error will be reported if it is used.
+
+
+
+
+
+
+
+ A record of options to control structural formatting.
+ For F# Interactive properties matching those of this value can be accessed via the 'fsi'
+ value.
+
+ Floating Point format given in the same format accepted by System.Double.ToString,
+ e.g. f6 or g15.
+
+ If ShowProperties is set the printing process will evaluate properties of the values being
+ displayed. This may cause additional computation.
+
+ The ShowIEnumerable is set the printing process will force the evalution of IEnumerable objects
+ to a small, finite depth, as determined by the printing parameters.
+ This may lead to additional computation being performed during printing.
+
+
+ From F# Interactive the default settings can be adjusted using, for example,
+
+ open Microsoft.FSharp.Compiler.Interactive.Settings;;
+ setPrintWidth 120;;
+
+
+
+
+
+
+ Data representing structured layouts of terms.
+
+
+
+
+ Convert any value to a string using a standard formatter
+ Data is typically formatted in a structured format, e.g.
+ lists are formatted using the "[1;2]" notation.
+ The details of the format are not specified and may change
+ from version to version and according to the flags given
+ to the F# compiler. The format is intended to be human-readable,
+ not machine readable. If alternative generic formats are required
+ you should develop your own formatter, using the code in the
+ implementation of this file as a starting point.
+
+ Data from other .NET languages is formatted using a virtual
+ call to Object.ToString() on the boxed version of the input.
+
+
+
+
+ Convert any value to a layout using the given formatting options. The
+ layout can then be processed using formatting display engines such as
+ those in the LayoutOps module. any_to_string and output_any are
+ built using any_to_layout with default format options.
+
+
+
+
+ Ouput any value to a channel using the same set of formatting rules
+ as any_to_string
+
+
+
+
+
+
+
+
+
+
+ Layout two vertically.
+
+
+
+
+ Layout list vertically.
+
+
+
+
+ Wrap braces around layout.
+
+
+
+
+ Wrap round brackets around Layout.
+
+
+
+
+ Join layouts into a comma separated list.
+
+
+
+
+ The empty layout
+
+
+
+
+ Is it the empty layout?
+
+
+
+
+ An string which is left parenthesis (no space on the right).
+
+
+
+
+ Layout like an F# list.
+
+
+
+
+ An uninterpreted leaf, to be interpreted into a string
+ by the layout engine. This allows leaf layouts for numbers, strings and
+ other atoms to be customized according to culture.
+
+
+
+
+ Join broken with ident=0
+
+
+
+
+ Join broken with ident=1
+
+
+
+
+ Join broken with ident=2
+
+
+
+
+ Join, unbreakable.
+
+
+
+
+ Join, possible break with indent=1
+
+
+
+
+ Join, possible break with indent=2
+
+
+
+
+ Join, possible break with indent=0
+
+
+
+
+ Layout like an F# option.
+
+
+
+
+ An string which is right parenthesis (no space on it's left).
+
+
+
+
+ Join layouts into a semi-colon separated list.
+
+
+
+
+ An string which requires no spaces either side.
+
+
+
+
+ Join layouts into a list separated using the given Layout.
+
+
+
+
+ Join layouts into a space separated list.
+
+
+
+
+ Wrap square brackets around layout.
+
+
+
+
+ See tagL
+
+
+
+
+ Form tuple of layouts.
+
+
+
+
+ For limitting layout of list-like sequences (lists,arrays,etc).
+ unfold a list of items using (project and z) making layout list via itemL.
+ If reach maxLength (before exhausting) then truncate.
+
+
+
+
+ An string leaf
+
+
+
+
+ A layout is a sequence of strings which have been joined together.
+ The strings are classified as words, separators and left and right parenthesis.
+ This classification determines where spaces are inserted.
+ A joint is either unbreakable, breakable or broken.
+ If a joint is broken the RHS layout occurs on the next line with optional indentation.
+ A layout can be squashed to for given width which forces breaks as required.
+
+
+
+
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.LanguageService.Base.dll b/tools/FSharp_1.9.6.16/bin/FSharp.LanguageService.Base.dll
new file mode 100644
index 00000000..b06cbf74
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/FSharp.LanguageService.Base.dll differ
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.LanguageService.dll b/tools/FSharp_1.9.6.16/bin/FSharp.LanguageService.dll
new file mode 100644
index 00000000..0b6a0d99
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/FSharp.LanguageService.dll differ
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Build.Tasks.dll b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Build.Tasks.dll
new file mode 100644
index 00000000..916899c0
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Build.Tasks.dll differ
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Build.Tasks.pdb b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Build.Tasks.pdb
new file mode 100644
index 00000000..f2ccb594
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Build.Tasks.pdb differ
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Build.Tasks.xml b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Build.Tasks.xml
new file mode 100644
index 00000000..a282a109
--- /dev/null
+++ b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Build.Tasks.xml
@@ -0,0 +1,104 @@
+
+
+FSharp.PowerPack.Build.Tasks
+
+
+
+ The default location of FSharp.Core.dll and fsc.exe based on the version of fsc.exe that is running
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Linq.dll b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Linq.dll
new file mode 100644
index 00000000..e721d495
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Linq.dll differ
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Linq.pdb b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Linq.pdb
new file mode 100644
index 00000000..333f518e
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Linq.pdb differ
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Linq.xml b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Linq.xml
new file mode 100644
index 00000000..529a7c69
--- /dev/null
+++ b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Linq.xml
@@ -0,0 +1,337 @@
+
+
+FSharp.PowerPack.Linq
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ When used in queries, this operator corresponds to the LINQ Min operator and the query convertor recognises it as such
+ It differs in return type from Seq.min_by
+
+
+
+
+ When used in queries, this operator corresponds to the LINQ Join operator and the query convertor recognises it as such
+
+
+
+
+ This join operator implements the LINQ GroupJoin operator and the query convertor recognises it as such
+
+
+
+
+ When used in queries, this operator corresponds to the LINQ Join operator and the query convertor recognises it as such
+
+
+
+
+ This join operator implements the LINQ GroupJoin operator and the query convertor recognises it as such
+
+
+
+
+ This join operator corresponds to the LINQ Join operator and the query convertor recognises it as such
+
+
+
+
+ When used in queries, this operator corresponds to the LINQ Max operator and the query convertor recognises it as such
+ It differs in return type from Seq.max_by
+
+
+
+
+ When used in queries, this operator corresponds to the LINQ Max operator and the query convertor recognises it as such
+ It differs in return type from Seq.max_by
+
+
+
+
+ When used in queries, this operator corresponds to the LINQ Min operator and the query convertor recognises it as such
+ It differs in return type from Seq.min_by
+
+
+
+
+ When used in queries, this operator corresponds to the LINQ Min operator and the query convertor recognises it as such
+ It differs in return type from Seq.min_by
+
+
+
+
+ Evaluate the quotation expression by first converting to a LINQ expression tree
+ making use of IQueryable operators and then executing expression tree
+
+ Exceptions: InvalidArgumentException will be raised if the input expression is
+ not in the subset that can be converted to a LINQ expression tree
+
+
+
+
+
+
+
+ This function should not be called directly.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A set of types used for implementing quotation conversions.
+ These are public only because targets of Linq Lambda expressions require them to be so
+
+
+
+
+ This module provides Compile and Eval extension members
+ for F# quotation values, implemented by translating to LINQ
+ expression trees and using the LINQ dynamic compiler.
+
+
+
+
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Math.Providers.dll b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Math.Providers.dll
new file mode 100644
index 00000000..5b503731
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Math.Providers.dll differ
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Metadata.dll b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Metadata.dll
new file mode 100644
index 00000000..90fe9a2f
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Metadata.dll differ
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Metadata.pdb b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Metadata.pdb
new file mode 100644
index 00000000..ebe05c3d
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Metadata.pdb differ
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Metadata.xml b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Metadata.xml
new file mode 100644
index 00000000..f518051f
--- /dev/null
+++ b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Metadata.xml
@@ -0,0 +1,5569 @@
+
+
+FSharp.PowerPack.Metadata
+
+
+
+
+
+
+ Return the System.Reflection.Assembly object for the assembly
+
+
+
+
+ Holds the full qualified assembly name
+
+
+
+
+ Get the object representing the F# core library (FSharp.Core.dll) for the running program
+
+
+
+
+ A handle to the full specification of the contents of the module contained in this Assembly
+
+
+
+
+ A hint as to where does the code for the CCU live (e.g what was the tcConfig.implicitIncludeDir at compilation time for this DLL?)
+
+
+
+
+ Return the System.Reflection.Assembly object for the assembly
+
+
+
+
+ This is one way of starting the loading process off.
+
+
+
+
+ This is one way of starting the loading process off. Dependencies are automatically
+ resolved by calling System.Reflection.Assembly.Load.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The declared documentation for the type or module
+
+
+
+
+ Indicates the type prefers the "tycon<a,b>" syntax for display etc.
+
+
+
+
+ The cases of a discriminated union
+
+
+
+
+ The fields of the class, struct or enum
+
+
+
+
+ The declaration location for the type constructor
+
+
+
+
+ Get the fully qualified name of the type or module
+
+
+
+
+
+
+
+ The name of the type, possibly with `n mangling
+
+
+
+
+ Properties, methods etc. with implementations, also values in a module
+
+
+
+
+ Indicates the type is a struct
+
+
+
+
+ Indicates the entity is an F# module definition
+
+
+
+
+ Indicates the entity is a measure definition
+
+
+
+
+ If true, then this is a reference to something in some .NET assembly from another .NET language
+
+
+
+
+ Indicates an F# exception declaration
+
+
+
+
+ Indicates the type is a measure, type or exception abbreviation
+
+
+
+
+ Interface implementations - boolean indicates compiler-generated
+
+
+
+
+ Indicates that a module is compiled to a class with the given mangled name. The mangling is reversed during lookup
+
+
+
+
+ Indicates the type is implemented through a mapping to IL assembly code. THis is only
+ true for types in FSharp.Core.dll
+
+
+
+
+ Get the generic parameters, possibly including unit-of-measure parameters
+
+
+
+
+ Base type, if any
+
+
+
+
+ The declared attributes for the type
+
+
+
+
+
+
+
+ Return the System.Type for the type
+
+ Raises InvalidOperationException if the type is an abbreviation or has an assembly code representation.
+
+
+
+
+ Return the FSharpEntity corresponding to a .NET type
+
+
+
+
+
+
+
+ The documentation for the type parameter.
+
+
+
+
+
+
+
+
+
+
+ Is this a ^a type variable
+
+
+
+
+ Is this a measure variable
+
+
+
+
+ The declared attributes of the type parameter.
+
+
+
+
+
+
+
+ An F# discriminated union, as an object model
+
+
+
+
+
+
+
+ XML documentation attached to a value.
+
+
+
+
+ The full type of the member or value when used as a first class value
+
+
+
+
+
+
+
+
+
+
+ Is this an F# type function
+
+
+
+
+ Is this a mutable value
+
+
+
+
+ Is this a module or member value
+
+
+
+
+ Is this an implicit constructor?
+
+
+
+
+ Is this an extension member?
+
+
+
+
+ Is this a compiler generated value
+
+
+
+
+ Is this a must-inline value
+
+
+
+
+ The typars of the member or value
+
+
+
+
+
+
+
+ The member name in compiled code
+
+
+
+
+ Custom attributes attached to the value. These contain references to other values (i.e. constructors in types). Mutable to fixup
+ these value references after copying a colelction of values.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Documentation for the field
+
+
+
+
+ The type of the field, w.r.t. the generic parameters of the enclosing type constructor
+
+
+
+
+ Declaration-location of the field
+
+
+
+
+ Attributes attached to generated property
+
+
+
+
+ Name of the field
+
+
+
+
+ Indicates a static field
+
+
+
+
+ Is the field declared in F#?
+
+
+
+
+ Indicates a compiler generated field, not visible to Intellisense or name resolution
+
+
+
+
+ Attributes attached to generated field
+
+
+
+
+
+
+
+ Get the named entity for a type constructed using a named entity
+
+
+
+
+ Indicates the type is a tuple type. The GenericArguments property returns the elements of the tuple type.
+
+
+
+
+ Indicates the type is constructed using a named entity
+
+
+
+
+ Indicates the type is a variable type, whether declared, generalized or an inference type parameter
+
+
+
+
+ Indicates the type is a function type. The GenericArguments property returns the domain and range of the function type.
+
+
+
+
+ Get the index for a generic parameter type
+
+
+
+
+ Get the generic parameter data for a generic parameter type
+
+
+
+
+ Get the generic arguments for a tuple type, a function type or a type constructed using a named entity
+
+
+
+
+
+
+
+ Documentation for the case
+
+
+
+
+ Return type constructed by the case. Normally exactly the type of the enclosing type, sometimes an abbreviation of it
+
+
+
+
+ Range of the name of the case
+
+
+
+
+ Name of the case
+
+
+
+
+ Data carried by the case.
+
+
+
+
+ Name of the case in generated IL code
+
+
+
+
+ Attributes, attached to the generated static method to make instances of the case
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Calling conventions. These are used in method pointer types.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Global state: table of all assembly references keyed by AssemblyRefData
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The explicit offset in bytes when explicit layout is used.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Index table by name and arity.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ This is used to store event, property and field maps.
+
+ Review: this is not such a great data structure.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ keyed first on namespace then on type name. The namespace is often a unique key for a given type map.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A little ugly, but the idea is that if a data structure does not
+ contain lazy values then we don't add laziness. So if the thing to map
+ is already evaluated then immediately apply the function.
+
+
+
+
+
+
+
+ Global State. All namespace splits
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Like Fixup but loader may return None, in which case there is no fixup.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Used when generating the secret paths used by FSI file generation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The characters that are allowed to be in an identifier.
+
+
+
+
+ Is this character a part of a long identifier
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Used when generating the secret paths used by FSI file generation
+
+
+
+
+ Used when generating the secret paths used by FSI file generation
+
+
+
+
+ Try to chop "get_" or "set_" from a string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Attrib(kind,unnamedArgs,propVals)
+
+
+
+
+ We keep both source expression and evaluated expression around to help intellisense and signature printing
+
+
+
+
+
+
+
+ AttribNamedArg(name,type,isField,value)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The result of attempting to resolve an assembly name to a full ccu.
+ UnresolvedCcu will contain the name of the assembly that could not be resolved.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Ensure the ccu is derefable in advance. Supply a path to attach to any resulting error message.
+
+
+
+
+
+
+
+
+
+
+ A relinkable handle to the contents of a compilation unit. Relinking is performed by mutation.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The information ILXGEN needs about the location of an item
+
+
+
+
+ Specifies the compiled representations of type and exception definitions.
+ Computed and cached by later phases (never computed type checking). Cached at
+ type and exception definitions. Not pickled.
+
+
+
+
+ Constants in expressions
+
+
+
+
+ Decision trees. Pattern matching has been compiled down to
+ a decision tree by this point. The right-hand-sides (actions) of
+ the decision tree are labelled by integers that are unique for that
+ particular tree.
+
+
+
+
+
+
+
+
+
+
+ A target of a decision tree. Can be thought of as a little function, though is compiled as a local block.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ From TAST TyconRef to IL ILTypeRef
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A named module-or-namespace-fragment definition
+
+
+
+
+ The module_typ is a binder. However it is not used in the ModuleOrNamespaceExpr: it is only referenced from the 'outside'
+ The contents of a module-or-namespace-fragment definition
+
+
+
+
+ A type for a module-or-namespace-fragment and the actual definition of the module-or-namespace-fragment
+
+
+
+
+
+
+
+ note: ModuleOrNamespaceRef and TyconRef are type equivalent
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Namespace or module-compiled-as-type?
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Values, including members in F# types in this module-or-namespace-fragment.
+
+
+
+
+ Type, mapping mangled name to Tycon, e.g.
+
+
+
+
+ Lookup tables keyed the way various clients expect them to be keyed.
+ We attach them here so we don't need to store lookup tables via any other technique
+
+
+
+
+
+
+
+
+
+
+ Mutation used during compilation of FSharp.Core.dll
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Non-local references indirect via a CCU
+ The lookup into the CCU is a NonLocalPath, which is a series of strings
+ We cache the result of dereferencing
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Index into the namespace/module structure of a particular CCU
+
+
+
+
+
+
+
+ A representation of a method in an object expression.
+ Note: Methods associated with types are represented as val declarations
+ Note: We should probably use val_specs for object expressions, as then the treatment of members
+ in object expressions could be more unified with the treatment of members in types
+
+
+
+
+
+
+
+
+
+
+ A public path records where a construct lives within the global namespace
+ of a CCU.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ This ModuleOrNamespace that represents the compilation of a module as a class.
+ The same set of tycons etc. are bound in the ModuleOrNamespace as in the ModuleOrNamespaceExpr
+ This is the body of the module/namespace
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The extra metadata stored about typars for top-level definitions. Any information here is propagated from signature through
+ to the compiled code.
+
+
+
+
+ The extra metadata stored about typars for top-level definitions. Any information here is propagated from signature through
+ to the compiled code.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The specification of a member constraint that must be solved
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The ILX data structure representing the discriminated union.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The type of the value.
+ May be a Type_forall for a generic value.
+ May be a type variable or type containing type variables during type inference.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A unique stamp within the context of this invocation of the compiler process
+
+
+
+
+
+
+
+
+
+
+ The place where the value was defined.
+
+
+
+
+ What is the public path to the value, if any? Should be set if and only if
+ IsMemberOrModuleBinding is set.
+
+
+
+
+
+
+
+ Is this a member, if so some more data about the member.
+
+ Note, the value may still be (a) an extension member or (b) and abtract slot without
+ a true body.
+
+
+
+
+
+
+
+
+
+
+ The internal name the value.
+
+
+
+
+ Was the value inferred to be a method or function that definitely makes no critical tailcalls?
+
+
+
+
+ The value of a value or member marked with [<LiteralAttribute>]
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Is this a member definition or module definition?
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Is this represented as a "top level" static binding (i.e. a static field, static member,
+ instance member), rather than an "inner" binding that may result in a closure.
+
+ This is implied by IsMemberOrModuleBinding, however not vice versa, for two reasons.
+ Some optimizations mutate this value when they decide to change the representation of a
+ binding to be IsCompiledAsTopLevel. Second, even immediately after type checking we expect
+ some non-module, non-member bindings to be marked IsCompiledAsTopLevel, e.g. 'y' in
+ 'let x = let y = 1 in y + y' (NOTE: check this, don't take it as gospel)
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Range of the definition (implementation) of the value, used by Visual Studio
+ Updated by mutation when the implementation is matched against the signature.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The parent type or module, if any (None for expression bindings and parameters)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ References are either local or nonlocal
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The big type of expressions.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The algebra of types
+
+
+
+
+
+
+
+ Unique name generator for stamps attached to lambdas and object expressions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Create a module Tycon based on an existing one using the function 'f'.
+ We require that we be given the parent for the new module.
+ We pass the new module to 'f' in case it needs to reparent the
+ contents of the module.
+
+
+
+
+ Create a tycon based on an existing one using the function 'f'.
+ We require that we be given the new parent for the new tycon.
+ We pass the new tycon to 'f' in case it needs to reparent the
+ contents of the tycon.
+
+
+
+
+ Create a Val based on an existing one using the function 'f'.
+ We require that we be given the parent for the new Val.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Given (newPath,oldPath) replace oldPath by newPath in the TAccess.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Equality on CCUs, implemented as reference equality
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Combine module types when multiple namespace fragments contribute to the
+ same namespace, making new module specs as we go.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Identical to tcref.Deref and deref_tycon, just used to help distinguish what kind of entity we expect here
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Compiler-internal references to items in fslib are generated as Ref_nonlocal even when compiling fslib
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Unique name generator for stamps attached to to val_specs, tycon_specs etc.
+
+
+
+
+
+
+
+
+
+
+ This predicate tests if non-local resolution paths are definitely known to resolve
+ to different entities. All references with different named paths always resolve to
+ different entities. Two references with the same named paths may resolve to the same
+ entities even if they reference through different CCUs, because one reference
+ may be forwarded to another via a .NET TypeForwarder.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ See nlpath_definitely_not_eq
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Equality on type varialbes, implemented as reference equality
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+verboseStamps: print #stamp on each id -- very verbose - but sometimes useful. Turn on using '--stamps'
+
+
+
+
+
+
+
+ Equality on value specs, implemented as reference equality
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Metadata on values (names of arguments etc.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The default location of FSharp.Core.dll and fsc.exe based on the version of fsc.exe that is running
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Plot.Excel.dll b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Plot.Excel.dll
new file mode 100644
index 00000000..9c67c026
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Plot.Excel.dll differ
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Plot.Neutral.dll b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Plot.Neutral.dll
new file mode 100644
index 00000000..5bc82faf
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Plot.Neutral.dll differ
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Plot.XCeed.dll b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Plot.XCeed.dll
new file mode 100644
index 00000000..5ae233a9
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Plot.XCeed.dll differ
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Plot.dll b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Plot.dll
new file mode 100644
index 00000000..5d631dc2
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.Plot.dll differ
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.dll b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.dll
new file mode 100644
index 00000000..7e0d3482
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.dll differ
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.pdb b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.pdb
new file mode 100644
index 00000000..a5effb95
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.pdb differ
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.targets b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.targets
new file mode 100644
index 00000000..12a0fb5d
--- /dev/null
+++ b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.targets
@@ -0,0 +1,86 @@
+
+
+
+
+
+
+
+ CallFsLex;CallFsYacc;$(CompileDependsOn)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ false
+
+
+ false
+
+
+
+
+
+
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.xml b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.xml
new file mode 100644
index 00000000..0a19cbdc
--- /dev/null
+++ b/tools/FSharp_1.9.6.16/bin/FSharp.PowerPack.xml
@@ -0,0 +1,8219 @@
+
+
+FSharp.PowerPack
+
+
+
+
+
+
+ Lookup or set the given element in the table. Set replaces all existing bindings for a value with a single
+ bindings. Raise KeyNotFoundException if the element is not found.
+
+
+
+
+ Lookup or set the given element in the table. Set replaces all existing bindings for a value with a single
+ bindings. Raise KeyNotFoundException if the element is not found.
+
+
+
+
+ The total number of keys in the hash table
+
+
+
+
+ Lookup the given element in the table, returning the result as an Option
+
+
+
+
+ Replace the latest binding (if any) for the given element.
+
+
+
+
+ Remove the latest binding (if any) for the given element from the table
+
+
+
+
+Apply the given function to each binding in the hash table
+
+
+
+
+ Apply the given function to each element in the collection threading the accumulating parameter
+ through the sequence of function applications
+
+
+
+
+ Find all bindings for the given element in the table, if any
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Make a shallow copy of the collection
+
+
+
+
+ Test if the collection contains any bindings for the given element
+
+
+
+
+ Test if the collection contains any bindings for the given element
+
+
+
+
+ Clear all elements from the collection
+
+
+
+
+ Add a binding for the element to the table
+
+
+
+
+ Create a new empty mutable HashMultiMap
+ with key hash/equality based on the F# structural "hash" and (=) functions.
+
+
+
+
+ Create a new empty mutable HashMultiMap with an internal bucket array of the given approximate size
+ and with key hash/equality based on the F# structural "hash" and (=) functions
+
+
+
+
+ Create a new empty mutable HashMultiMap with an internal bucket array of the given approximate size
+ and with the given key hash/equality functions
+
+
+
+
+ Build a map that contains the bindings of the given IEnumerable
+
+
+
+
+ Hash tables, by default based on F# structural "hash" and (=) functions.
+ The table may map a single key to multiple bindings.
+
+
+
+
+ The total number of elements in the set
+
+
+
+
+ Remove the given element from the set
+
+
+
+
+ Apply the given function to each binding in the hash table
+
+
+
+
+ Apply the given function to the set threading the accumulating parameter
+ through the sequence of function applications
+
+
+
+
+ Create a new empty mutable hash set
+ with key hash/equality based on the F# structural "hash" and (=) functions
+
+
+
+
+ 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
+
+
+
+
+ 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
+
+
+
+
+ Create a new mutable hash set containing elements drawn from the given sequence
+
+
+
+
+ Make a shallow copy of the set
+
+
+
+
+ Test if the set contains the given element
+
+
+
+
+ Clear all elements from the set
+
+
+
+
+ Add an element to the collection
+
+
+
+
+ Create a new empty mutable hash set
+ with key hash/equality based on the F# structural "hash" and (=) functions
+
+
+
+
+ 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
+
+
+
+
+ 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
+
+
+
+
+ Create a new mutable hash set containing elements drawn from the given sequence
+
+
+
+
+ Mutable hash sets based by default on F# structural "hash" and (=) functions. Implemented via a hash table and/or Dictionary.
+
+
+
+
+ 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.
+
+
+
+
+
+
+
+
+
+
+ Return the stream which contains on demand the elements of the first stream followed
+ by the elements of the second list
+
+
+
+
+ Return the stream which contains on demand the pair of elements of the first and second list
+
+
+
+
+ Return the stream which contains on demand the list of elements of the list of lazy lists.
+
+
+
+
+ Return a new stream which contains on demand the given item followed by the
+ given stream.
+
+
+
+
+ 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.
+
+
+
+
+ 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.
+
+
+
+
+ Return the stream without the first 'n' elements of the given stream. Does
+ not force the evaluation of any cells in the stream.
+
+
+
+
+ Evaluates to the stream that contains no items
+
+
+
+
+ Return a new collection which on consumption will consist of only the elements of the collection
+ for which the given predicate returns "true"
+
+
+
+
+ Return the first element for which the given function returns true.
+ Raise KeyNotFoundException if no such element exists.
+
+
+
+
+ Apply the given function to successive elements of the list, returning the first
+ result where function returns Some(x) for some x. If the function never returns
+ true, 'None' is returned.
+
+
+
+
+ Return a new stream consisting of the results of applying the given accumulating function
+ to successive elements of the stream
+
+
+
+
+ Get the first cell of the stream.
+
+
+
+
+ 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.
+
+
+
+
+ Build a new collection whose elements are the results of applying the given function
+ to each of the elements of the collection.
+
+
+
+
+ Build a new collection whose elements are the results of applying the given function
+ to the corresponding elements of the two collections pairwise.
+
+
+
+
+ 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.
+
+
+
+
+ Build a collection from the given array. This function will eagerly evaluate all of the
+ stream (and thus may not terminate).
+
+
+
+
+ Build a collection from the given list. This function will eagerly evaluate all of the
+ stream (and thus may not terminate).
+
+
+
+
+ Build a new collection from the given enumerable object
+
+
+
+
+ Return the stream which on consumption will consist of an infinite sequence of the given item
+
+
+
+
+ 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.
+
+
+
+
+ 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.
+
+
+
+
+ Build an array from the given collection
+
+
+
+
+ Build a list from the given collection This function will eagerly evaluate all of the
+ stream (and thus may not terminate).
+
+
+
+
+ Return a view of the collection as an enumerable object
+
+
+
+
+ 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.
+
+
+
+
+
+
+
+
+
+
+Build a new array that contains the elements of the first array followed by the elements of the second array
+
+
+
+
+Read a range of elements from the first array and write them into the second.
+
+
+
+
+Apply the given function to each element of the array. Return
+the array comprised of the results "x" for each element where
+the function returns Some(x)
+
+
+
+
+Combine the two arrays into an array of pairs. The two arrays must have equal lengths.
+
+
+
+
+Build a new array that contains the elements of each of the given list of arrays
+
+
+
+
+Build a new array that contains the elements of the given array
+
+
+
+
+ Create an array whose elements are all initially the given value.
+
+
+
+
+ Test if any element of the array satisfies the given predicate.
+ If the input function is f and the elements are i0...iN
+ then computes p i0 or ... or p iN.
+
+
+
+
+ Test elements of the two arrays pairwise to see if any pair of element satisfies the given predicate.
+ Raise ArgumentException if the arrays have different lengths.
+
+
+
+
+Fill a range of the collection with the given element
+
+
+
+
+Return a new collection containing only the elements of the collection
+for which the given predicate returns true
+
+
+
+
+Return the first element for which the given function returns true.
+Raise KeyNotFoundException if no such element exists.
+
+
+
+
+ Return the index of the first element in the array
+ that satisfies the given predicate. Raise KeyNotFoundException if
+ none of the elements satisy the predicate.
+
+
+
+
+ Return the index of the first element in the array
+ that satisfies the given predicate. Raise KeyNotFoundException if
+ none of the elements satisy the predicate.
+
+
+
+
+Apply the given function to successive elements, returning the first
+result where function returns "Some(x)" for some x.
+
+
+
+
+ Apply a function to each element of the collection, threading an accumulator argument
+ through the computation. If the input function is f and the elements are i0...iN
+ then computes f (... (f s i0)...) iN
+
+
+
+
+ Apply a function to pairs of elements drawn from the two collections,
+ left-to-right, threading an accumulator argument
+ through the computation. The two input
+ arrays must have the same lengths, otherwise an ArgumentException is
+ raised.
+
+
+
+
+ Apply a function to each element of the array, threading an accumulator argument
+ through the computation. If the input function is f and the elements are i0...iN then
+ computes f i0 (...(f iN s)).
+
+
+
+
+ Apply a function to pairs of elements drawn from the two collections, right-to-left,
+ threading an accumulator argument through the computation. The two input
+ arrays must have the same lengths, otherwise an ArgumentException is
+ raised.
+
+
+
+
+ Test if all elements of the array satisfy the given predicate.
+ If the input function is f and the elements are i0...iN and "j0...jN"
+ then computes p i0 && ... && p iN.
+
+
+
+
+ Test elements of the two arrays pairwise to see if all pairs of elements satisfy the given predicate.
+ Raise ArgumentException if the arrays have different lengths.
+
+
+
+
+ Fetch an element from the collection. You can also use the syntax arr.[idx].
+
+
+
+
+ Create an array by calling the given generator on each index.
+
+
+
+
+ Return true if the given array is empty, otherwise false
+
+
+
+
+Apply the given function to each element of the array.
+
+
+
+
+Apply the given function to two arrays simultaneously. The
+two arrays must have the same lengths, otherwise an Invalid_argument exception is
+raised.
+
+
+
+
+Apply the given function to each element of the array. The integer passed to the
+function indicates the index of element.
+
+
+
+
+ Apply the given function to pair of elements drawn from matching indices in two arrays,
+ also passing the index of the elements. The two arrays must have the same lengths,
+ otherwise an ArgumentException is raised.
+
+
+
+
+ Return the length of the collection. You can also use property arr.Length.
+
+
+
+
+Build a new array whose elements are the results of applying the given function
+to each of the elements of the array.
+
+
+
+
+Build a new collection whose elements are the results of applying the given function
+to the corresponding elements of the two collections pairwise. The two input
+arrays must have the same lengths.
+
+
+
+
+Build a new array whose elements are the results of applying the given function
+to each of the elements of the array. The integer index passed to the
+function indicates the index of element being transformed.
+
+
+
+
+ Build a new collection whose elements are the results of applying the given function
+ to the corresponding elements of the two collections pairwise. The two input
+ arrays must have the same lengths, otherwise an ArgumentException is
+ raised.
+
+
+
+
+Build an array from the given list
+
+
+
+
+Split the collection into two collections, containing the
+elements for which the given predicate returns true and false
+respectively
+
+
+
+
+ Apply a function to each element of the array, threading an accumulator argument
+ through the computation. If the input function is f and the elements are i0...iN
+ then computes f (... (f i0 i1)...) iN. Raises ArgumentException if the array has size zero.
+
+
+
+
+ Apply a function to each element of the array, threading an accumulator argument
+ through the computation. If the input function is f and the elements are i0...iN then
+ computes f i0 (...(f iN-1 iN)). Raises ArgumentException if the array has size zero.
+
+
+
+
+Return a new array with the elements in reverse order
+
+
+
+
+ Like fold_left, but return the intermediary and final results
+
+
+
+
+ Like fold_right, but return both the intermediary and final results
+
+
+
+
+ Set the value of an element in the collection. You can also use the syntax arr.[idx] <- e.
+
+
+
+
+ Return an array containing the given element
+
+
+
+
+ Sort the elements using the given comparison function
+
+
+
+
+ Sort the elements using the key extractor and generic comparison on the keys
+
+
+
+
+Split a list of pairs into two lists
+
+
+
+
+Build a new array that contains the given subrange specified by
+starting index and length.
+
+
+
+
+Build a list from the given array
+
+
+
+
+ Return a view of the array as an enumerable object
+
+
+
+
+Return the first element for which the given function returns true.
+Return None if no such element exists.
+
+
+
+
+ Return the index of the first element in the array
+ that satisfies the given predicate.
+
+
+
+
+ Return the index of the first element in the array
+ that satisfies the given predicate.
+
+
+
+
+ Split an array of pairs into two arrays
+
+
+
+
+ Combine the two arrays into an array of pairs. The two arrays must have equal lengths, otherwise an ArgumentException is
+ raised..
+
+
+
+
+ Generic operations on the type System.Collections.Generic.List, which is called ResizeArray in the F# libraries.
+
+
+
+
+
+
+
+ Lookup or set the given element in the table. Raise KeyNotFoundException if the element is not found.
+
+
+
+
+ Lookup or set the given element in the table. Raise KeyNotFoundException if the element is not found.
+
+
+
+
+ The number of bindings in the hash table
+
+
+
+
+ Lookup the given element in the table, returning the result as an Option
+
+
+
+
+ Replace the latest binding (if any) for the given element.
+
+
+
+
+ Remove the latest binding (if any) for the given element from the table
+
+
+
+
+ Apply the given function to each binding in the hash table
+
+
+
+
+ Apply the given function to each element in the collection threading the accumulating parameter
+ through the sequence of function applications
+
+
+
+
+ Find all bindings for the given element in the table, if any
+
+
+
+
+ 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
+
+
+
+
+ Make a shallow copy of the collection
+
+
+
+
+ Test if the collection contains any bindings for the given element
+
+
+
+
+ Test if the collection contains any bindings for the given element
+
+
+
+
+ Clear all elements from the collection
+
+
+
+
+ Add a binding for the element to the table
+
+
+
+
+ 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.
+
+
+
+
+
+
+
+ The number of elements in the set
+
+
+
+
+ Remove the given element from the set
+
+
+
+
+ Apply the given function to each binding in the hash table
+
+
+
+
+ Apply the given function to the set threading the accumulating parameter
+ through the sequence of function applications
+
+
+
+
+ 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
+
+
+
+
+ Make a shallow copy of the set
+
+
+
+
+ Test if the set contains the given element
+
+
+
+
+ Clear all elements from the set
+
+
+
+
+ Add an element to the collection
+
+
+
+
+ Mutable hash sets based on F# structural "hash" and (=) functions. Implemented via a hash table and/or Dictionary.
+ 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.
+
+
+
+
+ Immutable maps. Keys are ordered by construction function specified
+ when creating empty maps or by F# structural comparison if no
+ construction function is specified.
+
+
+ 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.
+
+
+
+
+
+ Lookup an element in the map. Raise KeyNotFoundException if no binding
+ exists in the map.
+
+
+
+
+ Return true if there are no bindings in the map.
+
+
+
+
+ The number of bindings in the map
+
+
+
+
+ Lookup an element in the map, returning a Some value if the element is in the domain
+ of the map and None if not.
+
+
+
+
+ The elements of the set as a list.
+
+
+
+
+ The elements of the set as an array
+
+
+
+
+ Remove an element from the domain of the map. No exception is raised if the element is not present.
+
+
+
+
+ Build two new maps, one containing the bindings for which the given predicate returns 'true',
+ and the other the remaining bindings.
+
+
+
+
+ Build a new collection whose elements are the results of applying the given function
+ to each of the elements of the collection.
+
+
+
+
+ Build a new collection whose elements are the results of applying the given function
+ to each of the elements of the collection. The index passed to the
+ function indicates the index of element being transformed.
+
+
+
+
+ Apply the given function to each binding in the dictionary
+
+
+
+
+
+
+
+ Return true if the given predicate returns true for all of the
+ bindings in the map. Always returns true if the map is empty.
+
+
+
+
+ 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).
+
+
+
+
+ Fold over the bindings in the map.
+
+
+
+
+ Fold over the bindings in the map.
+
+
+
+
+ Search the map looking for the first element where the given function returns a Some value
+
+
+
+
+ Build a new map containing the bindings for which the given predicate returns 'true'.
+
+
+
+
+ Return true if the given predicate returns true for one of the
+ bindings in the map. Always returns false if the map is empty.
+
+
+
+
+
+
+
+ The empty map, and use the given comparer comparison function for all operations associated
+ with any maps built from this map.
+
+
+
+
+ Build a map that contains the bindings of the given IEnumerable
+ and where comparison of elements is based on the given comparison function
+
+
+
+
+ Test is an element is in the domain of the map
+
+
+
+
+ Return a new map with the binding added to the given map.
+
+
+
+
+ Immutable maps. A constraint tag carries information about the class of key-comparers being used.
+
+
+
+
+ Immutable sets based on binary trees, default tag
+
+
+
+
+ Return a new set with the elements of the second set removed from the first.
+
+
+
+
+ Compute the union of the two sets.
+
+
+
+
+ Returns the lowest element in the set according to the ordering being used for the set
+
+
+
+
+ Returns the highest element in the set according to the ordering being used for the set
+
+
+
+
+ A useful shortcut for Set.is_empty. See the Set module for further operations on sets.
+
+
+
+
+ Return the number of elements in the set
+
+
+
+
+ The number of elements in the set
+
+
+
+
+ Compute the union of the two sets.
+
+
+
+
+ The elements of the set as a list.
+
+
+
+
+ The elements of the set as an array.
+
+
+
+
+ A singleton set based on the given comparison operator
+
+
+
+
+ A useful shortcut for Set.remove. Note this operation produces a new set
+ and does not mutate the original set. The new set will share many storage
+ nodes with the original. See the Set module for further operations on sets.
+
+
+
+
+ Build two new sets, one containing the elements for which the given predicate returns 'true',
+ and the other the remaining elements.
+
+
+
+
+ Apply the given function to each binding in the collection
+
+
+
+
+ Evaluates to "true" if all elements of the first set are in the second
+
+
+
+
+ Evaluates to "true" if all elements of the second set are in the first
+
+
+
+
+ Compute the intersection of the two sets.
+
+
+
+
+ Test if all elements of the collection satisfy the given predicate.
+ If the input function is f and the elements are i0...iN and j0...jN then
+ computes p i0 && ... && p iN.
+
+
+
+
+ Apply the given accumulating function to all the elements of the set
+
+
+
+
+ Return a new collection containing only the elements of the collection
+ for which the given predicate returns "true"
+
+
+
+
+ Test if any element of the collection satisfies the given predicate.
+ If the input function is f and the elements are i0...iN then computes
+ p i0 or ... or p iN.
+
+
+
+
+
+
+
+ Compares two sets and returns true if they are equal or false otherwise
+
+
+
+
+ The empty set based on the given comparer
+
+
+
+
+ Return a new set with the elements of the second set removed from the first.
+
+
+
+
+ A set based on the given comparer containing the given initial elements
+
+
+
+
+ A useful shortcut for Set.mem. See the Set module for further operations on sets.
+
+
+
+
+ Compares a and b and returns 1 if a > b, -1 if b < a and 0 if a = b
+
+
+
+
+ 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.
+
+
+
+
+ Immutable sets where a constraint tag carries information about the class of key-comparer being used.
+
+
+
+
+
+
+
+
+
+
+ The spec value describes the action of the argument,
+ and whether it expects a following parameter.
+
+
+
+
+ "parse specs f use" parses the arguments given by Sys.argv
+ according to the argument processing specifications "specs".
+ Arguments begin with "-". Non-arguments are passed to "f" in
+ order. "use" is printed as part of the usage line if an error occurs.
+
+ Permitted arguments are specified using triples: (arg, action, help).
+ Actions are:
+ Unit(f): call f, no subseq. arg
+ Set(br): set ref to 'true', no subseq. arg.
+ Clear(br): set ref to 'false, no subseq. arg.
+ String(f): pass the subseq. arg to f
+ Int(f): pass the subseq. arg to f
+ Float(f): pass the subseq. arg to f
+ Rest(f): pass all subseq. args to f in order
+
+
+
+
+
+
+
+ "usage specs use" prints the help for each argument.
+
+
+
+
+
+
+
+
+
+
+ A simple command-line argument processor.
+
+
+
+
+ Is an element in the array, uses (=) equality.
+
+
+
+
+ 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 Array2D module and
+ types such as "int[,]".
+
+
+
+
+
+
+
+ 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 Array2D module and
+ types such as "int[,]".
+
+
+
+
+
+
+
+ Return true if the list is not empty.
+
+
+
+
+ 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.
+
+
+
+
+ As for Array.pin, except that the caller is responsible for calling Free on the returned GCHandle in order
+ to release the pin.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Like reduce, but return both the intermediary and final results
+
+
+
+
+ Like reduceBack, but return both the intermediary and final results
+
+
+
+
+ Compatibility operations on arrays.
+
+
+
+
+ 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.
+
+
+
+
+ As for Array2D.pin, except that the caller is responsible for calling Free on the returned GCHandle in order
+ to release the pin.
+
+
+
+
+
+
+
+
+
+
+ Returns the sum of a and b
+
+
+
+
+ Compares a and b and returns 1 if a > b, -1 if b < a and 0 if a = b
+
+
+
+
+ Returns a divided by b
+
+
+
+
+ Combines the binary representation of a and b by bitwise and
+
+
+
+
+ Returns the bitwise logical negation of a
+
+
+
+
+ Combines the binary representation of a and b by bitwise or
+
+
+
+
+ Combines the binary representation of a and b by bitwise xor
+
+
+
+
+ Returns a multiplied by b
+
+
+
+
+ Converts a char to a byte
+
+
+
+
+ Converts a 32-bit integer to a byte
+
+
+
+
+ Converts a 32-bit integer to a byte
+
+
+
+
+ Converts a string to a byte
+
+
+
+
+ Converts a 16-bit integer to a byte
+
+
+
+
+ Converts an unsigned 32-bit integer to a byte
+
+
+
+
+ The value one as a System.Byte
+
+
+
+
+ Returns the predeccessor of the argument wrapped around 0uy
+
+
+
+
+ Returns the remainder of a divided by b
+
+
+
+
+ Shifts the binary representation a by n bits to the left
+
+
+
+
+ Shifts the binary representation a by n bits to the right
+
+
+
+
+ Returns a minus b
+
+
+
+
+ Returns the successor of the argument wrapped around 255uy
+
+
+
+
+ Converts a byte to a char
+
+
+
+
+ Converts a byte to a 32-bit integer
+
+
+
+
+ Converts a byte to a 32-bit integer
+
+
+
+
+ Converts a byte to a string
+
+
+
+
+ Converts a byte to a 16-bit integer
+
+
+
+
+ Converts a byte to an unsigned 32-bit integer
+
+
+
+
+ The value zero as a System.Byte
+
+
+
+
+ Byte (8-bit) operations.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Apply a function to each element of the collection, threading an accumulator argument
+ through the computation. If the input function is f and the elements are i0...iN
+ then computes f (... (f s i0)...) iN
+
+
+
+
+ Apply a function to each element of the collection, threading an accumulator argument
+ through the computation. If the input function is f and the elements are i0...iN
+ then computes f i0 (...(f iN s)).
+
+
+
+
+
+
+
+
+
+
+ Apply the given function to each element of the collection.
+
+
+
+
+ Apply the given function to each element of the collection. The integer passed to the
+ function indicates the index of element.
+
+
+
+
+
+
+
+
+
+
+ Build a new collection whose elements are the results of applying the given function
+ to each of the elements of the collection.
+
+
+
+
+ Build a new collection whose elements are the results of applying the given function
+ to each of the elements of the collection. The integer index passed to the
+ function indicates the index of element being transformed.
+
+
+
+
+Build a collection from the given list
+
+
+
+
+
+
+
+
+
+
+
+
+
+Build a list from the given collection
+
+
+
+
+
+
+
+ Byte arrays. Arrays of bytes type-compatible with the C# byte[] type
+
+
+
+
+ Converts the value of the specified 32-bit signed integer to its equivalent Unicode character
+
+
+
+
+ Converts the value of the specified Unicode character to the equivalent 32-bit signed integer
+
+
+
+
+ Compares a and b and returns 1 if a > b, -1 if b < a and 0 if a = b
+
+
+
+
+ Converts the value of a Unicode character to its lowercase equivalent
+
+
+
+
+ Converts the value of a Unicode character to its uppercase equivalent
+
+
+
+
+ Unicode characters, i.e. the System.Char type. see also the operations
+ in System.Char and the System.Text.Encoding interfaces if necessary.
+
+
+
+
+ Combine enum values using 'logical or'. The relevant enumeration type is inferred from context.
+
+
+
+
+ Convert an integer to an enumeration value. The result type is inferred from context.
+
+
+
+
+ Test if an enumeration value has a particular flag set, using 'logical and'.
+ The relevant enumeration type is inferred from context.
+
+
+
+
+ Convert an enumeration value to an integer. The argument type is inferred from context.
+
+
+
+
+ Simple operations to convert between .NET enuemration types and integers
+
+
+
+
+ Returns the sum of a and b
+
+
+
+
+ Compares a and b and returns 1 if a > b, -1 if b < a and 0 if a = b
+
+
+
+
+ Returns a divided by b
+
+
+
+
+ Returns a multiplied by b
+
+
+
+
+ Returns -a
+
+
+
+
+ Converts a raw 32-bit representation to a 32-bit float
+
+
+
+
+ Converts a 64-bit float to a 32-bit float
+
+
+
+
+ Converts a 32-bit integer to a 32-bit float
+
+
+
+
+ Converts a 32-bit integer to a 32-bit float
+
+
+
+
+ Converts a 64-bit integer to a 32-bit float
+
+
+
+
+ Converts a string to a 32-bit float
+
+
+
+
+ Returns a minus b
+
+
+
+
+ Converts a 32-bit float to raw 32-bit representation
+
+
+
+
+ Converts a 32-bit float to a 64-bit float
+
+
+
+
+ Converts a 32-bit float to a 32-bit integer
+
+
+
+
+ Converts a 32-bit float to a 32-bit integer
+
+
+
+
+ Converts a 32-bit float to a 64-bit integer
+
+
+
+
+ Converts a 32-bit float to a string
+
+
+
+
+ ML-like operations on 32-bit System.Single floating point numbers.
+
+
+
+
+ Returns the sum of a and b
+
+
+
+
+ Compares a and b and returns 1 if a > b, -1 if b < a and 0 if a = b
+
+
+
+
+ Returns a divided by b
+
+
+
+
+ Returns a multiplied by b
+
+
+
+
+ Returns -a
+
+
+
+
+ Converts a raw 64-bit representation to a 64-bit float
+
+
+
+
+ Converts a 32-bit float to a 64-bit float
+
+
+
+
+ Converts a 32-bit integer to a 64-bit float
+
+
+
+
+ Converts a 32-bit integer to a 64-bit float
+
+
+
+
+ Converts a 64-bit integer to a 64-bit float
+
+
+
+
+ Converts a string to a 64-bit float
+
+
+
+
+ Returns a minus b
+
+
+
+
+ Converts a 64-bit float to raw 64-bit representation
+
+
+
+
+ Converts a 64-bit float to a 32-bit float
+
+
+
+
+ Converts a 64-bit float to a 32-bit integer
+
+
+
+
+ Converts a 64-bit float to a 32-bit integer
+
+
+
+
+ Converts a 64-bit float to a 64-bit integer
+
+
+
+
+ Converts a 64-bit float to a string
+
+
+
+
+ ML-like operations on 64-bit System.Double floating point numbers.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the absolute value of the argument
+
+
+
+
+ Returns the sum of a and b
+
+
+
+
+ Converts a 64-bit float to a raw 32-bit representation
+
+
+
+
+ Converts a 32-bit float to a raw 32-bit representation
+
+
+
+
+ Compares a and b and returns 1 if a > b, -1 if b < a and 0 if a = b
+
+
+
+
+ Returns a divided by b
+
+
+
+
+ Converts a raw 32-bit representation to a 32-bit float
+
+
+
+
+ Converts a raw 32-bit representation to a 64-bit float
+
+
+
+
+ Combines the binary representation of a and b by bitwise and
+
+
+
+
+ Returns the bitwise logical negation of a
+
+
+
+
+ Combines the binary representation of a and b by bitwise or
+
+
+
+
+ Combines the binary representation of a and b by bitwise xor
+
+
+
+
+ Returns the largest 32-bit signed integer
+
+
+
+
+ Returns the smallest 32-bit signed integer
+
+
+
+
+ The value minus one as a System.Int32
+
+
+
+
+ Returns a multiplied by b
+
+
+
+
+ Returns -a
+
+
+
+
+ Converts a 64-bit float to a 32-bit integer
+
+
+
+
+ Converts a 32-bit float to a 32-bit integer
+
+
+
+
+ Converts a 32-bit integer to a 32-bit integer (included for ML compatability)
+
+
+
+
+ Converts a 64-bit unsigned integer to a 32-bit integer
+
+
+
+
+ Converts a 32-bit unsigned integer to a 32-bit integer
+
+
+
+
+ Converts a string to a 32-bit integer
+
+
+
+
+ Converts a 32-bit unsigned integer to a 32-bit integer
+
+
+
+
+ The value one as a System.Int32
+
+
+
+
+ Returns the predeccessor of the argument
+
+
+
+
+ Returns the remainder of a divided by b
+
+
+
+
+ Shifts the binary representation a by n bits to the left
+
+
+
+
+ Shifts the binary representation a by n bits to the right; high-order empty bits are set to the sign bit
+
+
+
+
+ Shifts the binary representation a by n bits to the right; high-order bits are zero-filled
+
+
+
+
+ Returns a minus b
+
+
+
+
+ Returns the successor of the argument
+
+
+
+
+ Converts a 32-bit integer to a 64-bit float
+
+
+
+
+ Converts a 32-bit integer to a 32-bit float
+
+
+
+
+ Converts a 32-bit integer to a 32-bit integer (included for ML compatability)
+
+
+
+
+ Converts a 32-bit unsigned integer to a 64-bit integer
+
+
+
+
+ Converts a 32-bit unsigned integer to a 32-bit integer
+
+
+
+
+ Converts a 32-bit integer to a string
+
+
+
+
+ Converts a 32-bit integer to a 32-bit unsigned integer
+
+
+
+
+ The value zero as a System.Int32
+
+
+
+
+ Basic operations on 32-bit integers. The type int32 is identical to System.Int32.
+
+
+
+
+ Returns the absolute value of the argument
+
+
+
+
+ Returns the sum of a and b
+
+
+
+
+ Converts a 64-bit float to a raw 64-bit representation
+
+
+
+
+ Compares a and b and returns 1 if a > b, -1 if b < a and 0 if a = b
+
+
+
+
+ Returns a divided by b
+
+
+
+
+ Converts a raw 64-bit representation to a 64-bit float
+
+
+
+
+ Combines the binary representation of a and b by bitwise and
+
+
+
+
+ Returns the bitwise logical negation of a
+
+
+
+
+ Combines the binary representation of a and b by bitwise or
+
+
+
+
+ Combines the binary representation of a and b by bitwise xor
+
+
+
+
+ Returns the largest 64-bit signed integer
+
+
+
+
+ Returns the smallest 64-bit signed integer
+
+
+
+
+ The value minus one as a System.Int64
+
+
+
+
+ Returns a multiplied by b
+
+
+
+
+ Returns -a
+
+
+
+
+ Converts a 64-bit float to a 64-bit integer
+
+
+
+
+ Converts a 32-bit float to a 64-bit integer
+
+
+
+
+ Converts a 32-bit integer to a 64-bit integer
+
+
+
+
+ Converts a 32-bit integer to a 64-bit integer
+
+
+
+
+ Converts a native integer to a 64-bit integer
+
+
+
+
+ Converts a string to a 64-bit integer
+
+
+
+
+ Converts an unsigned 64-bit integer to a 64-bit integer
+
+
+
+
+ The value one as a System.Int64
+
+
+
+
+ Returns the predeccessor of the argument
+
+
+
+
+ Returns the remainder of a divided by b
+
+
+
+
+ Shifts the binary representation a by n bits to the left
+
+
+
+
+ Shifts the binary representation a by n bits to the right; high-order empty bits are set to the sign bit
+
+
+
+
+ Shifts the binary representation a by n bits to the right; high-order bits are zero-filled
+
+
+
+
+ Returns a minus b
+
+
+
+
+ Returns the successor of the argument
+
+
+
+
+ Converts a 64-bit integer to a 64-bit float
+
+
+
+
+ Converts a 64-bit integer to a 32-bit float
+
+
+
+
+ Converts a 64-bit integer to a 32-bit integer
+
+
+
+
+ Converts a 64-bit integer to a 32-bit integer
+
+
+
+
+ Converts a 64-bit integer to a native integer
+
+
+
+
+ Converts a 64-bit integer to a string
+
+
+
+
+ Converts a 64-bit integer to an unsigned 64-bit integer
+
+
+
+
+ The value zero as a System.Int64
+
+
+
+
+ Basic operations on 64-bit integers. The type int64 is identical to System.Int64.
+
+
+
+
+
+
+
+ Build a lazy (delayed) value from the given computation
+
+
+
+
+ See Lazy.Force
+
+
+
+
+ See Lazy.Force.
+
+
+
+
+ See Lazy.SynchronizedForce.
+
+
+
+
+ See Lazy.UnsynchronizedForce
+
+
+
+
+ Build a lazy (delayed) value from the given computation
+
+
+
+
+ Build a lazy (delayed) value from the given pre-computed value.
+
+
+
+
+ Check if a lazy (delayed) value has already been computed
+
+
+
+
+
+
+
+
+
+
+ Lookup key's data in association list, uses (=) equality.
+ Raise System.IndexOutOfRangeException exception if key not found, in which case you should typically use try_assoc instead.
+
+
+
+
+ See assoc, but uses the physical equality operator (==) for equality tests
+
+
+
+
+ Is an element in the list. Elements are compared using generic equality.
+
+
+
+
+
+
+
+ Is an element in the list. Elements are compared using generic equality.
+
+
+
+
+ Does the key have pair in the association list?
+
+
+
+
+ See mem_assoc, but uses the physical equality operator (==) for equality tests.
+
+
+
+
+ See mem, but uses the physical equality operator (==) for equality tests.
+
+
+
+
+ Return true if the list is not empty.
+
+
+
+
+ Remove pair for key from the association list (if it's there).
+
+
+
+
+ See remove_assoc, but uses the physical equality operator (==) for equality tests.
+
+
+
+
+ "rev_append l1 l2" evaluates to "append (rev l1) l2"
+
+
+
+
+ "rev_map f l1" evaluates to "map f (rev l1)"
+
+
+
+
+ "rev_map2 f l1 l2" evaluates to "map2 f (rev l1) (rev l2)"
+
+
+
+
+
+
+
+
+
+
+ Like reduce_left, but return both the intermediary and final results
+
+
+
+
+ Like reduce_right, but return both the intermediary and final results
+
+
+
+
+ Lookup key's data in association list, uses (=) equality,
+ returning "Some data" or "None".
+
+
+
+
+ See try_assoc, but uses the physical equality operator (==) for equality tests.
+
+
+
+
+
+
+
+ Compatibility operations on lists.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 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.
+
+
+
+
+ For use when not opening the Map module, e.g. Map.t
+
+
+
+
+
+
+
+ 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<string> with
+ member self.Compare(x,y) = ...
+
+ let MyStringMapProvider : Map.Provider < string,int > = Map.MakeTagged(new MyComparer())
+
+
+
+
+ Fold over the bindings in the map
+
+
+
+
+ Extension functionality for maps using structural comparison
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Big_int compatability module for arbitrary sized integers.
+
+
+
+
+
+
+
+ Add second buffer to the first.
+
+
+
+
+ Read the given number of bytes as ASCII and add the resulting string
+ to the buffer. Warning: this assumes an ASCII encoding for the I/O channel, i.e. it uses
+ Pervasives.really_input and then use ascii_to_string to produce the string
+ to add.
+
+
+
+
+ Add character to the buffer.
+
+
+
+
+ Add string to the buffer.
+
+
+
+
+ Given a string, start position and length add that substring to the buffer.
+
+
+
+
+ Clears the buffer.
+
+
+
+
+ Gets the string built from the buffer.
+
+
+
+
+ Create a buffer with suggested size.
+
+
+
+
+ Number of characters in the buffer.
+
+
+
+
+
+
+
+ Clears the buffer (same as Buffer.clear).
+
+
+
+
+ Imperative buffers for building strings, a shallow interface to System.Text.StringBuilder
+
+
+
+
+ "dirname" and "basename" decompose a filename into a directory name
+ and a filename, i.e. "concat (dirname s) (basename s) = s"
+
+
+
+
+ "check_suffix f s" returns true if filename "f" ends in suffix "s",
+ e.g. check_suffix "abc.fs" ".fs" returns true.
+
+
+
+
+ "chop_extension f" removes the extension from the given
+ filename. Raises ArgumentException if no extension is present.
+
+
+
+
+ Assuming "check_suffix f s" holds, "chop_suffix f s" returns the
+ filename "f" with the suffix "s" removed.
+
+
+
+
+ "concat a b" returns System.IO.Path.Combine(a,b), i.e. the
+ two names conjoined by the appropriate directory separator character
+ for this architecture.
+
+
+
+
+ The name used for the current directory on this OS.
+
+
+
+
+ "dirname" and "basename" decompose a filename into a directory name
+ and a filename, i.e. "concat (dirname s) (basename s) = s"
+
+
+
+
+ Return true if the filename has a "." extension
+
+
+
+
+ Returns true if the path is relative to the current directory but does not begin with
+ an explicit "." or ".."
+
+
+
+
+ Is the path is relative to the current directory or absolute.
+
+
+
+
+ "parent_dir_name" returns the name for the directory above the current directory on
+ this OS.
+
+
+
+
+ "quote s" is designed for use to quote a filename when using it
+ for a system command. It returns ("\'" ^ s ^ "\'").
+
+
+
+
+ "temp_file f s" returns a hitherto unused new file name. "f" and "s"
+ are hints as to a suitable file name and suffix for the file.
+
+
+
+
+ Common filename operations. This module is included to make it possible to cross-compile
+ code with other ML compilers. See also System.IO.Path
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+A collection of operations for creating and using hash tables based on particular type-tracked hash/equality functions.
+Generated by the Hashtbl.Make and Hashtbl.MakeTagged functors. This type is for use when you wish to
+specify a comparison function once and carry around an object that is a provider of (i.e. a factory for) hashtables
+that utilize that comparison function.
+
+The 'Tag' type parameter is used to track information about the comparison function, which helps ensure
+that you don't mixup maps created with different comparison functions
+
+
+
+
+ OCaml compatible type name, for use when not opening module, e.g. Hashtbl.t
+
+
+
+
+ Build a collection of operations for creating and using
+ hashtables based on the given hash/equality functions. This returns a record
+ that contains the functions you use to create and manipulate tables of
+ this kind. The returned value is much like an ML module. You should call Make once for
+ each new pair of key/value types. You may need to constrain the result
+ to be an instantiation of Provider.
+
+ let MyStringHashProvider : Provider<string,int> = Hashtbl.Make(myStringHash,myStringEq)
+
+
+
+
+ Same as Make, except track the comparison function being used through an additional type parameter.
+
+ To use this function accurately you need to define a new named class that implements IEqualityComparer and
+ pass an instance of that class as the first argument. For example:
+ type MyHasher =
+ class
+ new() = { }
+ interface IEqualityComparer<string> with
+ member self.GetHashCode(x) = ...
+ member self.Equals(x,y) = ...
+ end
+ end
+
+ let MyStringHashProvider : Hashtbl.Provider<string,int> = Hashtbl.MakeTagged(new MyStringHasher())
+
+
+
+
+ Add key and data to the table.
+
+
+
+
+ Empty the table.
+
+
+
+
+ Create a copy of the table. Remember they are imperative and get mutated.
+
+
+
+
+ Create a hash table with the suggested initial size.
+
+ Inlined to enable generation of efficient hash routines for the key type in the common case.
+
+
+
+
+ Lookup key's data in the table.
+ Raises exception is key not in table, if this could happen you should be using tryfind.
+
+
+
+
+ Return all bindings for the given key
+
+
+
+
+ Fold over all bindings
+
+
+
+
+ Hash on the structure of a value according to the F# structural hashing
+ conventions. See Pervasives.hash
+
+
+
+
+ Hash on the identity of an object. See Pervasives.hashq.
+
+
+
+
+Apply the given function to each binding in the hash table
+
+
+
+
+ Test for the existence of any bindings for the given key
+
+
+
+
+ Create a hash table using the given data
+
+
+
+
+ Create hash table using the given data
+
+ Inlined to enable generation of efficient hash routines for the key type in the common case.
+
+
+
+
+ Remove the latest binding for the given key
+
+
+
+
+ Replace the latest binding for the given key
+
+
+
+
+ Lookup the key's data in the table
+
+
+
+
+ Multi-entry hash tables using the structural "hash" and "equals" functions.
+
+These tables can be used with keys of any type, but you should check that
+structural hashing and equality are correct for your key type.
+Structural hashing is efficient but not a suitable choice in all circumstances,
+e.g. may not hash efficiently on non-reference types and deeply-structured types.
+Better efficiency is typically achieved if key types are F#-generated
+types.
+
+These hash tables may map items to multiple keys (see find_all).
+
+The implementations are not safe for concurrent reading/writing,
+and so users of these tables should take an appropriate lock
+before reading/writing if used in a concurrent setting.
+
+
+
+
+ ASCII LexBuffers
+
+ The type "lexbuf" is opaque, but has an internal position information field
+ that can be updated by setting "lexbuf.EndPos", for example if you wish
+ to update the other fields in that position data before or during
+ lexing. You will need to do this if you wish to maintain accurate
+ line-count information. If you do this and wish to maintain strict
+ cross-compiling compatibility with OCamlLex and other tools you may need code
+ to conditionally use lexbuf_set_curr_p when compiling F# code.
+
+
+
+
+
+
+
+ Remove all input, though don't discard the except the current lexeme
+
+
+
+
+ Fuel a lexer using the given BinaryReader.
+
+
+
+
+ Fuel a lexer from an array of bytes
+
+
+
+
+ Fuel a lexer using the given in_channel. The bytes are read using Pervasives.input.
+ If the in_channel is a textual channel the bytes are
+ presented to the lexer by decoding the characters using System.Text.Encoding.ASCII.
+
+
+
+
+ Fuel a lexer from function that fills an array of bytes up to the given length, returning the
+ number of bytes filled.
+
+
+
+
+ Fuel a lexer from a string, converted to ascii using System.Text.Encoding.ASCII.GetBytes
+
+
+
+
+ Fuel a lexer using the given TextReader or StreamReader.
+ The characters read are decoded to bytes using the given encoding (e.g. System.Text.Encoding.ASCII)
+ and the bytes presented to the lexer. The encoding used to decode the characters
+ is associated with the expectations of the lexer (e.g. a lexer may be constructed to accept only
+ ASCII or pseudo-UTF8 bytes) and will typically be different to
+ the encoding used to decode the file.
+
+
+
+
+ same as lexeme_end_p
+
+
+
+
+
+
+
+
+
+
+ Return the matched string
+
+
+
+
+ Return the bytes for the matched string
+
+
+
+
+ Return a character from the matched string, innterpreting the bytes using an ASCII encoding
+
+
+
+
+ Return absolute positions into the entire stream of characters
+
+
+
+
+ Return the positions stored in the lexbuf for the matched string
+
+
+
+
+ Return absolute positions into the entire stream of characters
+
+
+
+
+ Return the positions stored in the lexbuf for the matched string
+
+
+
+
+ Return the matched string interpreting the bytes using the given Unicode text encoding
+
+
+
+
+ Lexing: ML-like lexing support
+
+ This file maintains rough compatibility for lexbuffers used by some ML
+ laxer generators. The lexbuf carries an associated pair of positions.
+ Beware that only the "cnum" (absolute character number) field is automatically
+ updated as each lexeme is matched. Upon each successful match the prior end
+ position is transferred to be the start position and a new start position
+ is allocated with an updated pos_cnum field.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ See Microsoft.FSharp.Core.LanguagePrimitives.PhysicalEquality
+
+
+
+
+
+
+
+ Negation of Obj.eq (i.e. reference/physical inequality)
+
+
+
+
+
+
+
+ See Microsoft.FSharp.Core.Operators.unbox
+
+
+
+
+ See Microsoft.FSharp.Core.Operators.box
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ You can initialize error recovery by raising the Parse_error exception.
+
+
+
+
+ Parsing: parser support for parsers produced by fsyacc.
+
+ Parsers generated by fsyacc provide location information within parser
+ actions. However that information is not available globally, but
+ rather is accessed via the functions available on the following local
+ variable which is available in all parser actions:
+
+ parseState : 'a Microsoft.FSharp.Text.Parsing.IParseState
+
+ However, this is not compatible with the parser specifications used
+ with ocamlyacc and similar tools, which make a single parser state available
+ globally. If you wish to use a global parser state (e.g. so your code will
+ cross-compile with OCaml) then you can use the functions in this file.
+ You will need to either generate the parser with '--ml-compatibility' option
+ or add the code
+
+ Parsing.set_parse_state parseState;
+
+ at the start of each action of your grammar. The functions below
+ simply report the results of corresponding calls to the latest object
+ specified by a call to set_parse_state.
+
+ Note that there could be unprotected multi-threaded concurrent access for the
+ parser information, so you should not in general use these
+ functions if there may be more than one parser active, and
+ should instead use the functions directly available from the parseState
+ object.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A pseudo-abstraction over binary and textual input channels.
+ OCaml-compatible channels conflate binary and text IO, and for this reasons their
+ use from F# is somewhat deprecated (direct use of System.IO StreamReader, TextReader and
+ BinaryReader objects is preferred, e.g. see System.IO.File.OpenText).
+ Well-written OCaml-compatible code that simply opens either a channel in text or binary
+ mode and then does text or binary I/O using the OCaml-compatible functions below
+ will work, though care must be taken with regard to end-of-line characters (see
+ input_char below).
+
+ This library pretends that an in_channel is just a System.IO.TextReader. Channel values
+ created using open_in_bin maintain a private System.IO.BinaryReader, which will be used whenever
+ you do I/O using this channel.
+
+ InChannel.of_BinaryReader and InChannel.of_StreamReader allow you to build input
+ channels out of the corresponding .NET abstractions.
+
+
+
+
+ This type is present primarily for compatibility with other versions of ML. When
+ not cross-compiling we recommend using the .NET I/O libraries
+
+
+
+
+ An pseudo-abstraction over binary and textual output channels.
+ OCaml-compatible channels conflate binary and text IO, and for this reasons their
+ use from F# is somewhat deprecated The direct use of System.IO StreamWriter, TextWriter and
+ BinaryWriter objects is preferred, e.g. see System.IO.File.CreateText). Well-written OCaml code
+ that simply opens either a channel in text or binary mode and then does text
+ or binary I/O using the OCaml functions will work, though care must
+ be taken with regard to end-of-line characters (see output_char below).
+
+ This library pretends that an out_channel is just a System.IO.TextWriter. Channels
+ created using open_out_bin maintain a private System.IO.BinaryWriter, which will be used whenever
+ do I/O using this channel.
+
+
+
+
+ The exception thrown by invalid_arg and misues of F# library functions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Close the channel
+
+
+
+
+ Close the given output channel
+
+
+
+
+ This value is present primarily for compatibility with other versions of ML
+ The smallest value that when added to 1.0 gives a different value to 1.0
+
+
+
+
+
+
+
+
+
+
+ Flush all pending output on the channel to the physical
+ output device.
+
+
+
+
+ Return the length of the input channel
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Attempt to input the given number of bytes from the channel, writing them into the
+ buffer at the given start position. Does not block if the bytes are not available.
+
+ The use of this function with a channel performing byte-to-character translation (e.g. one
+ created with open_in, open_in_utf8 or open_in_encoded, or one
+ or built from a StreamReader or TextReader) is not recommended.
+ Instead, open the channel using open_in_bin or InChannel.of_BinaryReader.
+
+ If used with a StreamReader channel, i.e. one created using
+ open_in, open_in_utf8 or open_in_encoded, or one
+ or built from a StreamReader, this function reads bytes directly from the underlying
+ BaseStream. This may not be appropriate if any other input techniques are being
+ used on the channel.
+
+ If used with a TextReader channel (e.g. stdin), this function reads characters from the
+ stream and then fills some of the byte array with the decoding of these into
+ bytes, where the decoding is performed using the System.Text.Encoding.Default encoding
+
+ Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached.
+
+
+
+
+ Input a binary integer from a binary channel. Compatible with output_binary_int.
+
+
+
+
+ Input a single byte.
+ For text channels this only accepts characters with a UTF16 encoding that fits in a byte, e.g. ASCII.
+ Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached.
+
+
+
+
+ Input a single character. Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached.
+
+
+
+
+ Attempt to input characters from a channel. Does not block if inpout is not available.
+ Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached.
+
+ No CRLF translation is done on input, even in text mode. That is, if an input file
+ has '\r\n' (CRLF) line terminators both characters will be seen in the input.
+
+
+
+
+ Input a single line. Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached.
+
+
+
+
+ Input a single serialized value from a binary stream. Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached.
+
+
+
+
+ Negation on integers of the 'int' type
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Throw an Invalid_argument exception
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ This value is present primarily for compatibility with other versions of ML
+ The highest representable positive value in the 'float' type
+
+
+
+
+ The highest representable value in the 'int' type
+
+
+
+
+ This value is present primarily for compatibility with other versions of ML
+ The lowest non-denormalized positive IEEE64 float
+
+
+
+
+ The lowest representable value in the 'int' type
+
+
+
+
+
+
+
+ This value is present primarily for compatibility with other versions of ML
+
+
+
+
+ This value is present primarily for compatibility with other versions of ML
+
+
+
+
+ This value is present primarily for compatibility with other versions of ML
+
+
+
+
+ 1D Array element set-accessor ('setter')
+
+
+
+
+ 1D Array element get-accessor ('getter')
+
+
+
+
+ Negation of the '==' operator, see also Obj.eq
+
+
+
+
+ This value is present primarily for compatibility with other versions of ML. In F#
+ the overloaded operators may be used.
+
+
+
+
+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.
+
+In normal use on reference types or non-mutable value types this function
+has the following properties:
+ - returns 'true' for two F# values where mutation of data
+ in mutable fields of one affects mutation of data in the other
+ - will return 'true' if (=) returns true
+ - hashq will return equal hashes if (==) returns 'true'
+
+The use on mutable value types is not recommended.
+
+
+
+
+ This value is present primarily for compatibility with other versions of ML. In F#
+ the overloaded operators may be used.
+
+
+
+
+ This value is present primarily for compatibility with other versions of ML
+
+
+
+
+ This value is present primarily for compatibility with other versions of ML. In F#
+ the overloaded operators may be used.
+
+
+
+
+ This value is present primarily for compatibility with other versions of ML. In F#
+ the overloaded operators may be used.
+
+
+
+
+ This value is present primarily for compatibility with other versions of ML. In F#
+ the overloaded operators may be used.
+
+
+
+
+ Open the given file to read.
+
+In the absence of an explicit encoding (e.g. using Open_encoding) open_in
+uses the default text encoding (System.Text.Encoding.Default). If you want to read a file
+regardless of encoding then you should use binary modes. Note that .NET's
+"new StreamReader" function defaults to use a utf8 encoding, and also attempts
+to determine an automatic encoding by looking for "byteorder-marks" at the head
+of a text file. This function does not do this.
+
+ No CR-LF translation is done on input.
+
+
+
+
+ Open the given file to read in binary-mode
+
+
+
+
+ Open the given file in the mode specified by the given flags
+
+
+
+
+ Open the given file to read in text-mode using the UTF8 encoding
+
+
+
+
+ Open the given file to write in text-mode using the
+ System.Text.Encoding.Default encoding
+
+ See output_char for a description of CR-LF translation
+ done on output.
+
+
+
+
+ Open the given file to write in binary-mode
+
+
+
+
+ Open the given file to write in text-mode using the given encoding
+
+
+
+
+ Open the given file to write in the mode according to the specified flags
+
+
+
+
+ Open the given file to write in text-mode using the UTF8 encoding
+
+
+
+
+ Return the length of the output channel.
+ Raise an exception if not an app
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Write the given range of bytes to the output channel.
+
+
+
+
+ Write the given integer to the output channel in binary format.
+ Only valid on binary channels.
+
+
+
+
+ Write the given byte to the output channel. No CRLF translation is
+ performed.
+
+
+
+
+ Write all the given bytes to the output channel. No CRLF translation is
+ performed.
+
+
+
+
+ Write the given Unicode character to the output channel.
+
+ If the output channel is a binary stream and the UTF-16 value of the Unicode character is greater
+ than 255 then ArgumentException is thrown.
+
+ No CRLF translation is done on output. That is, if the output character is
+ '\n' (LF) characters they will not be written as '\r\n' (CRLF) characters, regardless
+ of whether the underlying operating system or output stream uses CRLF as the default
+ line-feed character.
+
+
+
+
+ Write the given Unicode string to the output channel. See output_char for the treatment of
+ '\n' characters within the string.
+
+
+
+
+ Serialize the given value to the output channel.
+
+
+
+
+ Report the current position in the input channel
+
+
+
+
+ Return the current position in the output channel, measured from the
+ start of the channel. Not valid on all channels.
+
+
+
+
+ n-1 (no overflow checking)
+
+
+
+
+ Print a character to the stderr stream
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Read a floating point number from the console.
+
+
+
+
+Read an integer from the console.
+
+
+
+
+Read a line from the console, without the end-of-line character.
+
+
+
+
+ Reads bytes from the channel. Blocks if the bytes are not available.
+ See 'input' for treatment of text channels.
+ Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached.
+
+
+
+
+ Reads bytes from the channel. Blocks if the bytes are not available.
+ For text channels this only accepts UTF-16 bytes with an encoding less than 256.
+ Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached.
+
+
+
+
+ Set the current position in the output channel, measured from the
+ start of the channel.
+
+
+
+
+ Set the binary mode to true or false. If the binary mode is changed from "true" to
+ "false" then a StreamReader is created to read the binary stream. The StreamReader uses
+ the default text encoding System.Text.Encoding.Default
+
+
+
+
+ Set the binary mode. If the binary mode is changed from "true" to
+ "false" then a StreamWriter is created to write the binary stream. The StreamWriter uses
+ the default text encoding System.Text.Encoding.Default.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ n+1 (no overflow checking)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The exception thrown by 'assert' failures.
+ A future release of F# may map this exception to a corresponding .NET exception.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Non-exhaustive match failures will raise Match failures
+ A future release of F# may map this exception to a corresponding .NET exception.
+
+
+
+
+
+
+
+
+
+
+Link .NET IO with the out_channel/in_channel model
+
+
+
+
+ Wrap a stream by creating a StreamReader for the
+ stream and then wrapping is as an input channel.
+ A text encoding must be given, e.g. System.Text.Encoding.UTF8
+
+
+
+
+Link .NET IO with the out_channel/in_channel model
+
+
+
+
+Link .NET IO with the out_channel/in_channel model
+
+
+
+
+ Access the underlying stream-based objects for the channel
+
+
+
+
+Link .NET IO with the out_channel/in_channel model
+
+
+
+
+ Access the underlying stream-based objects for the channel
+
+
+
+
+ Access the underlying stream-based objects for the channel
+
+
+
+
+
+
+
+Link .NET IO with the out_channel/in_channel model
+
+
+
+
+ Wrap a stream by creating a StreamWriter for the
+ stream and then wrapping is as an output channel.
+ A text encoding must be given, e.g. System.Text.Encoding.UTF8
+
+
+
+
+Link .NET IO with the out_channel/in_channel model
+
+
+
+
+Link .NET IO with the out_channel/in_channel model
+
+
+
+
+ Access the underlying stream-based objects for the channel
+
+
+
+
+ Access the underlying stream-based objects for the channel
+
+
+
+
+ Access the underlying stream-based objects for the channel
+
+
+
+
+ Access the underlying stream-based objects for the channel
+
+
+
+
+
+
+
+
+
+
+The type of simple immutable lists
+
+
+
+
+The type of None/Some options
+
+
+
+
+The type of pointers to mutable reference cells
+
+
+
+
+Absolute value of the given integer
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Structural comparison
+
+
+
+
+
+
+
+
+
+
+Decrement a mutable reference cell containing an integer
+
+
+
+
+Exit the current hardware isolated process, if security settings permit,
+otherwise raise an exception. Calls System.Environment.Exit.
+
+
+
+
+
+
+
+ Throw a 'Failure' exception
+
+
+
+
+
+
+
+
+
+
+
+
+
+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).
+
+
+
+
+
+
+
+Increment a mutable reference cell containing an integer
+
+
+
+
+
+
+
+
+
+
+
+
+
+Maximum based on structural comparison
+
+
+
+
+Minimum based on structural comparison
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Concatenate two lists.
+
+
+
+
+Assign to a mutable reference cell
+
+
+
+
+ Concatenate two strings. The overlaoded operator '+' may also be used.
+
+
+
+
+Dereference a mutable reference cell
+
+
+
+
+
+
+
+Structural equality
+
+
+
+
+
+
+
+Structural greater-than
+
+
+
+
+Structural greater-than-or-equal
+
+
+
+
+Structural inequality
+
+
+
+
+Structural less-than comparison
+
+
+
+
+Structural less-than-or-equal comparison
+
+
+
+
+
+
+
+
+
+
+ Throw an exception
+
+
+
+
+Create a mutable reference cell
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The exception thrown by failure and many other F# functions
+ A future release of F# may map this exception to a corresponding .NET exception.
+
+
+
+
+
+
+
+Pervasives: Additional OCaml-compatible bindings
+
+
+
+
+
+
+
+
+
+
+ Compatibility module to display data about exceptions.
+
+
+
+
+ The array of command line options. Gives the command line arguments
+ as returned by System.Environment.GetCommandLineArgs.
+
+
+
+
+ Sets the current working directory for the process using System.IO.Directory.SetCurrentDirectory
+
+
+
+
+ Run the command and return it's exit code.
+
+ Warning: 'command' currently attempts to execute the string using
+ the 'cmd.exe' shell processor. If it is not present on the system
+ then the operation will fail. Use System.Diagnostics.Process
+ directly to run commands in a portable way, which involves specifying
+ the program to run and the arguments independently.
+
+
+
+
+ Path of the current executable, using
+ System.IO.Path.Combine(System.AppDomain.CurrentDomain.BaseDirectory,System.AppDomain.CurrentDomain.FriendlyName)
+
+
+
+
+ Returns true if a file currently exists, using System.IO.File.Exists(s).
+
+
+
+
+ Returns the current working directory for the process using System.IO.Directory.GetCurrentDirectory
+
+
+
+
+ Call System.Environment.GetEnvironmentVariable. Raise KeyNotFoundException if the variable is not defined.
+
+
+
+
+ Deletes a file using System.IO.File.Delete.
+
+
+
+
+ Rename a file on disk using System.IO.File.Move
+
+
+
+
+ Time consumed by the main thread. (for approximate timings).
+ Generally returns only the processor time used by the main
+ thread of the application.
+
+
+
+
+ The number of bits in the "int" type.
+
+
+
+
+ Sys: Basic system operations (for ML compatibility)
+
+ This module is only included to make it possible to cross-compile
+ code with other ML compilers. It may be deprecated and/or removed in
+ a future release. You may wish to use .NET functions directly instead.
+
+
+
+
+ The identity permutation over any size
+
+
+
+
+
+
+
+ Create a permutation by specifying the result of permuting [| 0 .. n-1 |]. For example,
+ Permutation.of_array [| 1;2;0 |] specifies a permutation that rotates all elements right one place.
+
+
+
+
+ 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.
+
+
+
+
+ Return a permutation that, when applied, maps index 0 to size-1, size-1 to 0 etc.
+
+
+
+
+ Return a permutation that rotates right by the given distance. If the distance
+ is negative then a left rotation results.
+
+
+
+
+ Return a swaps the given two elements over any size
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Simple operations on signed bytes
+
+
+
+
+ A synonym for Seq.zip
+
+
+
+
+ Return an IEnumerable that when iterated yields
+ the given item followed by the items in the given sequence
+
+
+
+
+
+
+
+
+
+
+ Return true if the IEnumerable is not empty.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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.
+
+
+
+
+ For use when not opening the Set module, e.g. Set.t
+
+
+
+
+ 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.
+
+
+
+
+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<string> with
+ member self.Compare(x,y) = ...
+
+ let MyStringSetProvider = Set.MakeTagged(new MyComparer())
+
+
+
+
+
+
+
+The elements of the set as a list.
+
+
+
+
+Compute the intersection of the two sets.
+
+
+
+
+ Immutable sets implemented via binary trees
+
+
+
+
+ Return a string with the first character converted to uppercase.
+
+
+
+
+ Compare the given strings using ordinal comparison
+
+
+
+
+ Return true is the given string contains the given character
+
+
+
+
+ Return true is the given string contains the given character in the
+ range specified by the given start index and the given length
+
+
+
+
+ Return true is the given string contains the given character in the
+ range from the given start index to the end of the string.
+
+
+
+
+ Returns the character at the specified position in the string
+
+
+
+
+ Return the first index of the given character in the
+ string. Raise KeyNotFoundException if
+ the string does not contain the given character.
+
+
+
+
+ Return the first index of the given character in the
+ range from the given start position to the end of the string.
+ Raise KeyNotFoundException if
+ the string does not contain the given character.
+
+
+
+
+ Return a new string with all characters converted to lowercase
+
+
+
+
+ Return a string of the given length containing repetitions of the given character
+
+
+
+
+ Return s string of length 1 containing the given character
+
+
+
+
+ Return true if the string contains the given character prior to the given index
+
+
+
+
+ Return the index of the first occurrence of the given character
+ from the end of the string proceeding backwards
+
+
+
+
+ Return the index of the first occurrence of the given character
+ starting from the given index proceeding backwards.
+
+
+
+
+ Split the string using the given list of separator characters.
+ Trimming is also performed at both ends of the string and any empty
+ strings that result from the split are discarded.
+
+
+
+
+ Return a substring of length 'length' starting index 'start'.
+
+
+
+
+ Removes all occurrences of a set of characters specified in a
+ list from the beginning and end of this instance.
+
+
+
+
+ Return a string with the first character converted to lowercase.
+
+
+
+
+ Return a string with all characters converted to uppercase.
+
+
+
+
+ Compatibility module for string processing. Richer string operations
+ are available via the member functions on strings and other functionality in
+ the System.String type
+ and the System.Text.RegularExpressions namespace.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ UInt32: ML-like operations on 32-bit System.UInt32 numbers.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ UInt64: basic operations on 64-bit System.UInt64 numbers.
+
+
+
+
+ Wait for the result and commit it
+
+
+
+
+ Record the result in the AsyncResultCell.
+ Subsequent sets of the result are ignored. This can happen,
+ e.g. for a race between a cancellation and a success.
+
+
+
+
+ Create a new result cell
+
+
+
+
+ A helper type to store a single result from an asynchronous computation and asynchronously
+ access its result.
+
+ When using .NET 4.0 you can often use Task<'T> instead of this type
+
+
+
+
+ Return an asynchronous computation that, when run, either returns a value, raises an exception
+ of cancels according to the value of the asynchronous result.
+
+
+
+
+ Represents the reified result of an asynchronous computation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Extensions to the F# Microsoft.FSharp.Control.Async module
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The type of floating-point matrices. See Microsoft.FSharp.Math
+
+
+
+
+ The type of floating-point row vectors. See Microsoft.FSharp.Math
+
+
+
+
+ The type of floating-point vectors. See Microsoft.FSharp.Math
+
+
+
+
+ Constructs a complex number from both the real and imaginary part.
+
+
+
+
+
+
+
+ Builds a matrix from a sequence of sequence of floats.
+
+
+
+
+ Builds a (row) vector from a sequence of floats.
+
+
+
+
+ Builds a (column) vector from a sequence of floats.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Return the given rational number
+
+
+
+
+ Return the negation of a rational number
+
+
+
+
+ Return the difference of two rational numbers
+
+
+
+
+ Return the product of two rational numbers
+
+
+
+
+ This operator is for use from other .NET languages
+
+
+
+
+ This operator is for use from other .NET languages
+
+
+
+
+ This operator is for use from other .NET languages
+
+
+
+
+ This operator is for use from other .NET languages
+
+
+
+
+ This operator is for use from other .NET languages
+
+
+
+
+ This operator is for use from other .NET languages
+
+
+
+
+ Return the ratio of two rational numbers
+
+
+
+
+ Return the sum of two rational numbers
+
+
+
+
+ Get zero as a rational number
+
+
+
+
+ Return the sign of a rational number; 0, +1 or -1
+
+
+
+
+ Get one as a rational number
+
+
+
+
+ Return the numerator of the normalized rational number
+
+
+
+
+ Return a boolean indicating if this rational number is strictly positive
+
+
+
+
+ Return a boolean indicating if this rational number is strictly negative
+
+
+
+
+ Return the denominator of the normalized rational number
+
+
+
+
+
+
+
+ Return the result of converting the given rational number to an integer
+
+
+
+
+ Return the result of converting the given rational number to a floating point number
+
+
+
+
+ Return the result of converting the given rational number to a big integer
+
+
+
+
+ Return the result of raising the given rational number to the given power
+
+
+
+
+ Return the result of converting the string to a rational number
+
+
+
+
+
+
+
+ Return the result of converting the given integer to a rational number
+
+
+
+
+ Return the result of converting the given big integer to a rational number
+
+
+
+
+ Return the absolute value of a rational number
+
+
+
+
+ The type of arbitrary-sized rational numbers
+
+
+
+
+
+
+
+ Unary negation of a complex number
+
+
+
+
+ Subtract one complex number from another
+
+
+
+
+ Multiply two complex numbers
+
+
+
+
+ Multiply a scalar by a complex number
+
+
+
+
+ Multiply a complex number by a scalar
+
+
+
+
+ Complex division of two complex numbers
+
+
+
+
+ Add two complex numbers
+
+
+
+
+ The real part of a complex number
+
+
+
+
+ The imaginary part of a complex number
+
+
+
+
+ The complex number 0+0i
+
+
+
+
+ The real part of a complex number
+
+
+
+
+ The polar-coordinate phase of a complex number
+
+
+
+
+ The complex number 0+1i
+
+
+
+
+ The complex number 1+0i
+
+
+
+
+ The polar-coordinate magnitude of a complex number
+
+
+
+
+ The imaginary part of a complex number
+
+
+
+
+ The conjugate of a complex number, i.e. x-yi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Create a complex number using magnitude/phase polar coordinates
+
+
+
+
+ Create a complex number x+ij using rectangular coordinates
+
+
+
+
+
+
+
+ Computes the absolute value of a complex number: e.g. Abs x+iy = sqrt(x**2.0 + y**2.0.)
+ Note: Complex.Abs(z) is the same as z.Magnitude
+
+
+
+
+ The type of complex numbers stored as pairs of 64-bit floating point numbers in rectangular coordinates
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Get the item at the given position in the matrix
+
+
+
+
+ Prefix '+' operator. A nop.
+
+
+
+
+ Matrix negation.
+
+
+
+
+ Point-wise subtraction of two matrices. An InvalidArgument exception will be
+ raised if the dimensions do not match.
+
+
+
+
+ Matrix multiplication. An InvalidArgument exception will be
+ raised if the dimensions do not match.
+
+
+
+
+ Matrix-vector multiplication.
+
+
+
+
+ Multiply each element of a matrix by the given scalar value
+
+
+
+
+ Multiply each element of a matrix by the given scalar value
+
+
+
+
+ Pointwise matrix multiplication. An InvalidArgument exception will be
+ raised if the dimensions do not match.
+
+
+
+
+ Point-wise addition of two matrices. An InvalidArgument exception will be
+ raised if the dimensions do not match.
+
+
+
+
+ Get the transpose of the matrix.
+
+
+
+
+ Get the number of rows in the matrix
+
+
+
+
+ Get the number of columns in the matrix
+
+
+
+
+ Returns sqrt(sum(norm(x)*(norm(x))) of all the elements of a matrix.
+ The element type of the matrix must have an associated instance of INormFloat<'T> (see GlobalAssociations) ((else NotSupportedException)).
+
+
+
+
+ Return the non-zero entries of a sparse or dense matrix
+
+
+
+
+ Get the item at the given position in the matrix
+
+
+
+
+ Indicates if the matrix uses the sparse representation.
+
+
+
+
+ Indicates if the matrix uses the dense representation.
+
+
+
+
+ Get the internal array of values for a sparse matrix. This property
+ should only be used when interoperating with other matrix libraries.
+
+
+
+
+ Get the internal array of row offsets for a sparse matrix. This property
+ should only be used when interoperating with other matrix libraries.
+
+
+
+
+ Get the internal array of column values for a sparse matrix. This property
+ should only be used when interoperating with other matrix libraries.
+
+
+
+
+ Get the internal array of values for a dense matrix. This property
+ should only be used when interoperating with other matrix libraries.
+
+
+
+
+ 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.
+
+
+
+
+ Get the number of (rows,columns) in the matrix
+
+
+
+
+ Get the main diagonal of a matrix, as a vector
+
+
+
+
+ Convert the matrix to a column vector
+
+
+
+
+ Convert the matrix to a row vector
+
+
+
+
+ Return a new array containing the elements of the given matrix
+
+
+
+
+ Supports the slicing syntax 'A.[idx1..idx2,idx1..idx2] <- B'
+
+
+
+
+ Select a range of rows from a matrix
+
+
+
+
+ Select a row from a matrix
+
+
+
+
+ Select a region from a matrix
+
+
+
+
+ Permutes the rows of the matrix.
+
+
+
+
+ Permutes the columns of the matrix.
+
+
+
+
+ Supports the slicing syntax 'A.[idx1..idx2,idx1..idx2]'
+
+
+
+
+
+
+
+ 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.
+
+
+
+
+
+
+
+ Create a new matrix that is a copy of the given array
+
+
+
+
+ Select a range of columns from a matrix
+
+
+
+
+ Select a column from a matrix
+
+
+
+
+ The type of matrices. The arithmetic operations on the element type are determined by inspection on the element type itself.
+ Two representations are supported: sparse and dense.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Get the transpose of the row vector.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Get the underlying internal array of values for the vector. This property
+ should only be used when interoperating with other matrix libraries.
+
+
+
+
+
+
+
+ Return a new array containing a copy of the elements of the given vector
+
+
+
+
+ Supports the slicing syntax 'rv.[idx1..idx2] <- rv2'
+
+
+
+
+ Permute the elements of the row vector.
+
+
+
+
+ Supports the slicing syntax 'rv.[idx1..idx2]'
+
+
+
+
+
+
+
+
+
+
+ Create a new matrix that is a copy of the given array
+
+
+
+
+ The type of row vectors.
+
+
+
+
+ Gets an item from the the vector
+
+
+
+
+ Return the input vector
+
+
+
+
+ Negate a vector
+
+
+
+
+ Subtract two vectors, pointwise
+
+
+
+
+ Multiply each element of a vector by the given scalar value.
+
+
+
+
+ Multiply a column vector and a row vector to produce a matrix
+
+
+
+
+ Multiply a vector by a scalar
+
+
+
+
+ Pointwise multiplication of two vectors.
+
+
+
+
+ Add two vectors, pointwise
+
+
+
+
+ Get the transpose of the vector.
+
+
+
+
+ Gets the number of rows in the vector
+
+
+
+
+ Computes the 2-norm of a vector: sqrt(x.Transpose*x).
+
+
+
+
+ Gets the number of entries in the vector
+
+
+
+
+ Gets an item from the the vector
+
+
+
+
+ Get the underlying internal array of values for the vector. This property
+ should only be used when interoperating with other matrix libraries.
+
+
+
+
+ Gets the element operations for the element type of the vector, if any
+
+
+
+
+ Return a new array containing a copy of the elements of the given vector
+
+
+
+
+ Supports the slicing syntax 'v.[idx1..idx2] <- v2'
+
+
+
+
+ Permute the elements of the vector.
+
+
+
+
+ Supports the slicing syntax 'v.[idx1..idx2]'
+
+
+
+
+
+
+
+
+
+
+ Create a new matrix that is a copy of the given array
+
+
+
+
+ The type of column vectors. The arithmetic operations on the element type are determined by inspection
+ on the element type itself
+
+
+
+
+
+
+
+ The type of complex numbers
+
+
+
+
+ The type of floating point matrices
+
+
+
+
+ The type of floating point row vectors
+
+
+
+
+ The type of floating point column vectors
+
+
+
+
+ Add two complex numbers
+
+
+
+
+ A complex of magnitude 1 and the given phase and , i.e. cis x = mkPolar 1.0 x
+
+
+
+
+ The conjugate of a complex number, i.e. x-yi
+
+
+
+
+ Cosine
+
+
+
+
+ Complex division of two complex numbers
+
+
+
+
+ exp(x) = e^x
+
+
+
+
+ The imaginary part of a complex number
+
+
+
+
+ log(x) is natural log (base e)
+
+
+
+
+ The polar-coordinate magnitude of a complex number
+
+
+
+
+ Create a complex number using magnitude/phase polar coordinates
+
+
+
+
+
+
+
+ Multiply two complex numbers
+
+
+
+
+ Multiply a complex number by a scalar
+
+
+
+
+ Unary negation of a complex number
+
+
+
+
+ The complex number 1+0i
+
+
+
+
+ The complex number 0+1i
+
+
+
+
+ The polar-coordinate phase of a complex number
+
+
+
+
+ pi
+
+
+
+
+ The real part of a complex number
+
+
+
+
+ Sine
+
+
+
+
+ Multiply a scalar by a complex number
+
+
+
+
+ sqrt(x) and 0 <= phase(x) < pi
+
+
+
+
+ Subtract one complex number from another
+
+
+
+
+ Tagent
+
+
+
+
+ The complex number 0+0i
+
+
+
+
+
+
+
+ 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.
+
+
+
+
+ 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.
+
+
+
+
+
+
+
+ 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.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Add two matrices (operator +)
+
+
+
+
+
+
+
+ Create a new matrix that is a copy of the given array
+
+
+
+
+Point-wise maximum element of two matrices
+
+
+
+
+Point-wise minimum element of two matrices
+
+
+
+
+
+
+
+Pointwise exponential of a matrix.
+
+
+
+
+ Create a matrix with all entries the given constant
+
+
+
+
+
+
+
+Dot product
+
+
+
+
+ Check if a predicate holds for at least one element of a matrix
+
+
+
+
+ Check if a predicate holds for at least one element of a matrix
+
+
+
+
+ Fold the given function over all elements of a matrix
+
+
+
+
+ Fold the given function down each column of a matrix
+
+
+
+
+ Fold the given function along each row of a matrix
+
+
+
+
+ Fold the given function along a particular column of a matrix
+
+
+
+
+ Fold the given function down a particular row of a matrix
+
+
+
+
+ Fold the given function over all elements of a matrix
+
+
+
+
+ Check if a predicate holds for all elements of a matrix
+
+
+
+
+ Check if a predicate holds for all elements of a matrix
+
+
+
+
+ Get an element of a matrix
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Create a square matrix with the constant 1.0 lying on diagonal
+
+
+
+
+
+
+
+ Create a dense representation matrix with the given entries.
+
+
+
+
+ Create a square matrix with the given vector lying on diagonal
+
+
+
+
+ Create a sparse representation matrix with the given entries. Not all
+ operations are available for sparse matrices, and mutation is not permitted.
+ If an operation on sparse matrices raises a runtime exception then consider
+ converting to a dense matrix using to_dense.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ In-place addition mutates first matrix argument.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ In-place subtraction mutates first matrix argument.
+
+
+
+
+ Map the given function over each element of the matrix, producing a new matrix
+
+
+
+
+ Map the given indexed function over each element of the matrix, producing a new matrix
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+sqrt(sum(x*x)) of all the elements of a matrix
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Multiply all the elements of the matrix
+
+
+
+
+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.
+
+
+
+
+
+
+
+ Set an element of a matrix
+
+
+
+
+
+
+
+Sum all the elements of a matrix
+
+
+
+
+
+
+
+ Ensure that a matrix uses dense representation. See init_sparse
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Sum of the diagonal elements of the matrix
+
+
+
+
+Transpose of a matrix. Use also m.Transpose
+
+
+
+
+ Create a matrix with all entries zero
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Create a new matrix that is a copy of the given array
+
+
+
+
+Take the pointwise maximum of two matrices
+
+
+
+
+Take the pointwise maximum of two matrices
+
+
+
+
+
+
+
+ Create a matrix containing the given value at every element.
+
+
+
+
+
+
+
+ Sum of the point-wise multiple of the two matrices.
+ The element type of the matrix must have an associated instance of INumeric<'T> (see GlobalAssociations) ((else NotSupportedException)).
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Get an element from a matrix. The indexes are given in row/column order.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Create a square matrix with the one for the element type lying on diagonal
+ The element type of the matrix must have an associated instance of INumeric<'T> (see GlobalAssociations) ((else NotSupportedException)).
+
+
+
+
+ Create a matrix using the given function to compute the item at each index.
+
+
+
+
+
+
+
+ Create a matrix containing the given vector along the diagonal.
+ The element type of the matrix must have an associated instance of INumeric<'T> (see GlobalAssociations) ((else NotSupportedException)).
+
+
+
+
+ Create a matrix using the given function to compute the item at each index.
+ The element type of the matrix must have an associated instance of INumeric<'T> (see GlobalAssociations) ((else NotSupportedException)).
+ The function is passed the dictionary of associated operations in addition to the index pair.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns sqrt(sum(norm(x)*(norm(x))) of all the elements of a matrix.
+ The element type of the matrix must have an associated instance of INormFloat<'T> (see GlobalAssociations) ((else NotSupportedException)).
+
+
+
+
+ Create a matrix from the given (usually constant) data
+
+
+
+
+ Create a matrix from the given (usually constant) data
+
+
+
+
+
+
+
+ Create a 1x1 matrix containing the given value
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Set an element in a matrix. The indexes are given in row/column order.
+
+
+
+
+
+
+
+
+
+
+ Return a new array containing the elements of the given matrix
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Return a new matrix which is the transpose of the input matrix
+
+
+
+
+ Create a matrix containing the zero element at each index.
+ The element type of the matrix must have an associated instance of INumeric<'T> (see GlobalAssociations) ((else NotSupportedException)).
+
+
+
+
+ Operations to manipulate matrix types carrying
+ arbitrary element types. The names and types of the operations match those
+ in the containing module Math.Matrix.
+
+ The numeric operations on the element type (add, zero etc.) are inferred from the type
+ argument itself. That is, for some operations
+ the element type of the matrix must have an associated instance of INumeric<'T>
+ or some more specific numeric association (see GlobalAssociations) ((else NotSupportedException)).
+
+
+
+
+ Operations to manipulate floating
+ point matrices. The submodule Matrix.Generic contains a
+ matching set of operations to manipulate matrix types carrying
+ arbitrary element types.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Faraday constant
+
+
+
+
+ Newtonian constant of gravitation
+
+
+
+
+ Conductance quantum 2e^2/h
+
+
+
+
+ Avogadro constant
+
+
+
+
+ Magnetic flux quantum h/2e
+
+
+
+
+ Molar gas constant
+
+
+
+
+ Rydberg constant
+
+
+
+
+ Fine-structure constant
+
+
+
+
+ speed of light in vacuum
+
+
+
+
+ Elementary charge
+
+
+
+
+ Electron volt
+
+
+
+
+ electric constant = 1/(mu0 c^2)
+
+
+
+
+ Planck constant
+
+
+
+
+ Dirac constant, also known as the reduced Planck constant = h/2pi
+
+
+
+
+ Boltzmann constant R/N_A
+
+
+
+
+ Electron mass
+
+
+
+
+ Proton mass
+
+
+
+
+ magnetic constant
+
+
+
+
+ Stefan-Boltzmann constant
+
+
+
+
+ Unified atomic mass unit
+
+
+
+
+ Fundamental physical constants, with units-of-measure
+
+
+
+
+
+
+
+ Create by constant initialization
+
+
+
+
+ Get an element of a column vector
+
+
+
+
+ Create by comprehension
+
+
+
+
+ Get the dimensions (number of rows) of a column rowvec.
+
+
+
+
+ Create a vector from an array of double precision floats
+
+
+
+
+ Create a vector from a list of numbers
+
+
+
+
+
+
+
+ Set an element of a column rowvec
+
+
+
+
+ Return a new array containing a copy of the elements of the given vector
+
+
+
+
+
+
+
+ Return a vector of the given length where every entry is zero.
+
+
+
+
+
+
+
+ Create by constant initialization
+
+
+
+
+ Get an element from a column vector.
+
+
+
+
+ Create by comprehension
+
+
+
+
+ Get the number of rows in a column vector.
+
+
+
+
+ Create a row vector from an array of elements
+
+
+
+
+ Create a row vector from a list of elements
+
+
+
+
+ Create a row vector from a sequence of elements
+
+
+
+
+ Set an element in a column vector.
+
+
+
+
+ Return a new array containing a copy of the elements of the given vector
+
+
+
+
+ Transpose the row vector
+
+
+
+
+ Return a vector of the given length where every entry is zero.
+
+
+
+
+ Operations to manipulate row vectors types carrying
+ arbitrary element types.
+
+
+
+
+ Operations to manipulate floating
+ point row vectors. These are included for completeness and are
+ nearly always transposed to column vectors.
+
+
+
+
+ ampere, SI unit of electric current
+
+
+
+
+ becquerel, SI unit of activity referred to a radionuclide
+
+
+
+
+ coulomb, SI unit of electric charge, amount of electricity
+
+
+
+
+ farad, SI unit of capacitance
+
+
+
+
+ gray, SI unit of absorbed dose
+
+
+
+
+ henry, SI unit of inductance
+
+
+
+
+ hertz, SI unit of frequency
+
+
+
+
+ joule, SI unit of energy, work, amount of heat
+
+
+
+
+ kelvin, SI unit of thermodynamic temperature
+
+
+
+
+ newton, SI unit of force
+
+
+
+
+ pascal, SI unit of pressure, stress
+
+
+
+
+ siemens, SI unit of electric conductance
+
+
+
+
+ sievert, SI unit of does equivalent
+
+
+
+
+ tesla, SI unit of magnetic flux density
+
+
+
+
+ volt, SI unit of electric potential difference, electromotive force
+
+
+
+
+ watt, SI unit of power, radiant flux
+
+
+
+
+ weber, SI unit of magnetic flux
+
+
+
+
+ candela, SI unit of luminous intensity
+
+
+
+
+ katal, SI unit of catalytic activity
+
+
+
+
+ kilogram, SI unit of mass
+
+
+
+
+ lumen, SI unit of luminous flux
+
+
+
+
+ lux, SI unit of illuminance
+
+
+
+
+ metre (or meter), SI unit of length
+
+
+
+
+ mole, SI unit of amount of substance
+
+
+
+
+ ohm, SI unit of electric resistance
+
+
+
+
+ second, SI unit of time
+
+
+
+
+ The International System of Units (SI)
+
+
+
+
+
+
+
+
+
+
+
+
+
+Pointwise exponential of a vector.
+
+
+
+
+ Generate a vector of the given length where each entry contains the given value
+
+
+
+
+Dot product
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Get an element of a column vector
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Get the dimensions (number of rows) of a column vector. Identical to nrows
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Computes the 2-norm of a vector: sqrt(x.Transpose*x).
+
+
+
+
+ Create a vector from an array of double precision floats
+
+
+
+
+ Create a vector from a list of numbers
+
+
+
+
+ Create a 1-element vector
+
+
+
+
+
+
+
+Multiply all the elements of the matrix
+
+
+
+
+ Create a vector that represents a integral mesh over the given range
+ e.g. range 1 5 = vector [ 1.;2.;3.;4.;5. ]
+
+
+
+
+ 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]
+
+
+
+
+
+
+
+ Set an element of a column vector
+
+
+
+
+
+
+
+Sum all the elements of a vector
+
+
+
+
+ Return a new array containing a copy of the elements of the given vector
+
+
+
+
+Transpose of a matrix. Use also m.Transpose
+
+
+
+
+ Return a vector of the given length where every entry is zero.
+
+
+
+
+Add two vectors (operator +)
+
+
+
+
+
+
+
+Take the pointwise maximum of two vectors
+
+
+
+
+Take the pointwise minimum of two vectors
+
+
+
+
+Point-wise multiplication of two vectors (operator .*)
+
+
+
+
+ Generate a vector of the given length where each entry contains the given value
+
+
+
+
+Dot product
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Get an element of a column vector
+
+
+
+
+ Creation: general
+
+
+
+
+ Creation: useful when the element type has associated operations.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Get the dimensions (number of rows) of a column vector. Identical to nrows
+
+
+
+
+
+
+
+
+
+
+Negation of the vector (each element is negated) (unary operator -)
+
+
+
+
+ Computes the 2-norm of a vector: sqrt(x.Transpose*x).
+
+
+
+
+ Create a vector from an array of elements
+
+
+
+
+ Create a vector from a list of numbers
+
+
+
+
+ Create a 1-element vector
+
+
+
+
+ Create a vector from a sequence of numbers
+
+
+
+
+Multiply all the elements of the matrix
+
+
+
+
+Pointwise multiplication of a matrix by a scalar
+
+
+
+
+ Set an element of a column vector
+
+
+
+
+Subtract one vector from another (operator -)
+
+
+
+
+Sum all the elements of a vector
+
+
+
+
+ Return a new array containing a copy of the elements of the given vector
+
+
+
+
+Transpose of a matrix. Use also m.Transpose
+
+
+
+
+ Return a vector of the given length where every entry is zero.
+
+
+
+
+ Operations to manipulate column vectors carrying
+ arbitrary element types.
+
+
+
+
+ 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.
+
+
+
+
+ See NativeArray2
+
+
+
+
+ WARNING: use of this function may lead to unverifiable or invalid code
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 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.
+
+
+
+
+ WARNING: use of this function may lead to unverifiable or invalid code
+
+
+
+
+
+
+
+ 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 'T. 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.
+
+
+
+
+ WARNING: use of this function may lead to unverifiable or invalid code
+
+
+
+
+ Pointer to the C-style row major two-dimensional array
+
+
+
+
+ Number of rows of the native array
+
+
+
+
+ Number of columns of the native array
+
+
+
+
+ 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.
+
+
+
+
+ WARNING: use of this function may lead to unverifiable or invalid code
+
+
+
+
+ Creates a C-style row major two-dimensional array from a native pointer, the number of rows and the number of columns.
+ Nothing is actually copied.
+
+
+
+
+ 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 'T. 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.
+
+
+
+
+ WARNING: use of this function may lead to unverifiable or invalid code
+
+
+
+
+ Pointer to the C-style one-dimensional array
+
+
+
+
+ Length of the C-style one-dimensional array
+
+
+
+
+ WARNING: use of this function may lead to unverifiable or invalid code
+
+
+
+
+ Creates a C-style one dimensional array from a native pointer and the length of the array
+ Nothing is actually copied.
+
+
+
+
+ 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 'T. 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.
+
+
+
+
+ For native interop. Pin the given object
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Represents a pinned handle to a structure with an underlying 2D array, i.e. an underlying NativeArray2.
+ Used when interfacing with native code math libraries such as LAPACK.
+
+
+
+
+ For native interop. Pin the given object
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Represents a pinned handle to a structure with an underlying 1D array, i.e. an underlying NativeArray.
+ Used when interfacing with native code math libraries such as LAPACK.
+
+
+
+
+
+
+
+ Pin the given ref for the duration of a single call to the given function. A native pointer to
+ the contents of the ref is passed to the given function. Cleanup the GCHandle associated with the
+ pin when the function completes, even if an exception is raised.
+
+ This function should only be used if 'T is a simple blittable type
+ such as "int" that does not contain any further heap references.
+
+ WARNING: use of this function may lead to unverifiable or invalid code
+
+
+
+
+
+
+
+ Interpret tables for an ascii lexer generated by fslex.
+
+
+
+
+
+
+
+ Interpret tables for an ascii lexer generated by fslex, processing input asynchronously
+
+
+
+
+ The type of tables for an ascii lexer generated by fslex.
+
+
+
+
+ The start position for the lexeme
+
+
+
+
+ True if the refill of the buffer ever failed , or if explicitly set to true.
+
+
+
+
+ The end position for the lexeme
+
+
+
+
+ The start position for the lexeme
+
+
+
+
+ The length of the matched string
+
+
+
+
+ The matched string
+
+
+
+
+ True if the refill of the buffer ever failed , or if explicitly set to true.
+
+
+
+
+ The end position for the lexeme
+
+
+
+
+ Dynamically typed, non-lexically scoped parameter table
+
+
+
+
+ Fast helper to turn the matched characters into a string, avoiding an intermediate array
+
+
+
+
+ Fetch a particular character in the matched string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Adjust the start position associated with the lexbuf
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Remove all input, though don't discard the current lexeme
+
+
+
+
+
+
+
+ Return absolute offset of the start of the line marked by the position
+
+
+
+
+
+
+
+ The line number in the input stream, assuming fresh positions have been updated
+ using AsNewLinePos() and by modifying the EndPos property of the LexBuffer.
+
+
+
+
+ The file name associated with the input stream.
+
+
+
+
+ Get an arbitrary position, with the empty string as filename, and
+
+
+
+
+ Return the column number marked by the position, i.e. the difference between the AbsoluteOffset and the StartOfLineAbsoluteOffset
+
+
+
+
+
+
+
+ The character number in the input stream
+
+
+
+
+ Gives a position shifted by specified number of characters
+
+
+
+
+ Get a position corresponding to the first line (line number 1) in a given file
+
+
+
+
+ Given a position at the start of a token of length n, return a position just beyond the end of the token
+
+
+
+
+
+
+
+ Position information stored for lexing tokens
+
+
+
+
+ Interpret tables for a unicode lexer generated by fslex.
+
+
+
+
+
+
+
+ Interpret tables for a unicode lexer generated by fslex, processing input asynchronously
+
+
+
+
+ The type of tables for an unicode lexer generated by fslex.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Parsers generated by FsPars provide information from within parser
+ actions. This is accessed via the functions available on the local
+ variable parseState within parser actions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Tables generated by fsyacc
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A record of options to control structural formatting.
+ For F# Interactive properties matching those of this value can be accessed via the 'fsi'
+ value.
+
+ Floating Point format given in the same format accepted by System.Double.ToString,
+ e.g. f6 or g15.
+
+ If ShowProperties is set the printing process will evaluate properties of the values being
+ displayed. This may cause additional computation.
+
+ The ShowIEnumerable is set the printing process will force the evalution of IEnumerable objects
+ to a small, finite depth, as determined by the printing parameters.
+ This may lead to additional computation being performed during printing.
+
+
+ From F# Interactive the default settings can be adjusted using, for example,
+
+ open Microsoft.FSharp.Compiler.Interactive.Settings;;
+ setPrintWidth 120;;
+
+
+
+
+
+
+ The maximum number of rows for which to generate layout for table-like
+ structures. -1 if no maximum.
+
+
+
+
+ The maximum number of elements for which to generate layout for
+ list-like structures, or columns in table-like
+ structures. -1 if no maximum.
+
+
+
+
+ Return to the layout-generation
+ environment to layout any otherwise uninterpreted object
+
+
+
+
+
+
+
+ Data representing structured layouts of terms.
+
+
+
+
+
+
+
+ Convert any value to a string using a standard formatter
+ Data is typically formatted in a structured format, e.g.
+ lists are formatted using the "[1;2]" notation.
+ The details of the format are not specified and may change
+ from version to version and according to the flags given
+ to the F# compiler. The format is intended to be human-readable,
+ not machine readable. If alternative generic formats are required
+ you should develop your own formatter, using the code in the
+ implementation of this file as a starting point.
+
+ Data from other .NET languages is formatted using a virtual
+ call to Object.ToString() on the boxed version of the input.
+
+
+
+
+
+
+
+ Convert any value to a layout using the given formatting options. The
+ layout can then be processed using formatting display engines such as
+ those in the LayoutOps module. any_to_string and output_any are
+ built using any_to_layout with default format options.
+
+
+
+
+ Ouput any value to a channel using the same set of formatting rules
+ as any_to_string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Layout two vertically.
+
+
+
+
+ Layout list vertically.
+
+
+
+
+ Wrap braces around layout.
+
+
+
+
+ Wrap round brackets around Layout.
+
+
+
+
+ Join layouts into a comma separated list.
+
+
+
+
+ The empty layout
+
+
+
+
+ Is it the empty layout?
+
+
+
+
+ An string which is left parenthesis (no space on the right).
+
+
+
+
+ Layout like an F# list.
+
+
+
+
+ An uninterpreted leaf, to be interpreted into a string
+ by the layout engine. This allows leaf layouts for numbers, strings and
+ other atoms to be customized according to culture.
+
+
+
+
+ Join broken with ident=0
+
+
+
+
+ Join broken with ident=1
+
+
+
+
+ Join broken with ident=2
+
+
+
+
+ Join, unbreakable.
+
+
+
+
+ Join, possible break with indent=1
+
+
+
+
+ Join, possible break with indent=2
+
+
+
+
+ Join, possible break with indent=0
+
+
+
+
+ Layout like an F# option.
+
+
+
+
+ An string which is right parenthesis (no space on it's left).
+
+
+
+
+ Join layouts into a semi-colon separated list.
+
+
+
+
+ An string which requires no spaces either side.
+
+
+
+
+ Join layouts into a list separated using the given Layout.
+
+
+
+
+ Join layouts into a space separated list.
+
+
+
+
+ Wrap square brackets around layout.
+
+
+
+
+ See tagL
+
+
+
+
+ Form tuple of layouts.
+
+
+
+
+ For limitting layout of list-like sequences (lists,arrays,etc).
+ unfold a list of items using (project and z) making layout list via itemL.
+ If reach maxLength (before exhausting) then truncate.
+
+
+
+
+ An string leaf
+
+
+
+
+ A layout is a sequence of strings which have been joined together.
+ The strings are classified as words, separators and left and right parenthesis.
+ This classification determines where spaces are inserted.
+ A joint is either unbreakable, breakable or broken.
+ If a joint is broken the RHS layout occurs on the next line with optional indentation.
+ A layout can be squashed to for given width which forces breaks as required.
+
+
+
+
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.ProjectSystem.Base.dll b/tools/FSharp_1.9.6.16/bin/FSharp.ProjectSystem.Base.dll
new file mode 100644
index 00000000..fdb51bf7
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/FSharp.ProjectSystem.Base.dll differ
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.ProjectSystem.FSharp.dll b/tools/FSharp_1.9.6.16/bin/FSharp.ProjectSystem.FSharp.dll
new file mode 100644
index 00000000..786b8fe1
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/FSharp.ProjectSystem.FSharp.dll differ
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.ProjectSystem.PropertyPages.dll b/tools/FSharp_1.9.6.16/bin/FSharp.ProjectSystem.PropertyPages.dll
new file mode 100644
index 00000000..42926c7a
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/FSharp.ProjectSystem.PropertyPages.dll differ
diff --git a/tools/FSharp_1.9.6.16/bin/FSharp.VS.FSI.dll b/tools/FSharp_1.9.6.16/bin/FSharp.VS.FSI.dll
new file mode 100644
index 00000000..5f3b1b18
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/FSharp.VS.FSI.dll differ
diff --git a/tools/FSharp_1.9.6.16/bin/Microsoft.FSharp.targets b/tools/FSharp_1.9.6.16/bin/Microsoft.FSharp.targets
new file mode 100644
index 00000000..5357e34d
--- /dev/null
+++ b/tools/FSharp_1.9.6.16/bin/Microsoft.FSharp.targets
@@ -0,0 +1,177 @@
+
+
+
+
+
+
+
+
+
+ $(MSBuildExtensionsPath)\FSharp\1.0\
+ $(MSBuildAllProjects);$(FSharpTargetsDir)\Microsoft.FSharp.targets
+ .fs
+ F#
+
+ $(Optimize)
+
+
+
+
+
+
+
+
+
+ <_Temporary Remove="@(_Temporary)" />
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ <_Temporary Remove="@(_Temporary)" />
+
+
+
+
+
+ <_DebugSymbolsIntermediatePathTemporary Include="$(PdbFile)"/>
+
+ <_DebugSymbolsIntermediatePath Include="@(_DebugSymbolsIntermediatePathTemporary->'%(RootDir)%(Directory)%(Filename).pdb')"/>
+
+
+
+
+ false
+ _ComputeNonExistentFileProperty
+ $(WarningsAsErrors)
+
+
+
+
+
+
+
+
+
+ <_CoreCompileResourceInputs Remove="@(_CoreCompileResourceInputs)" />
+
+
+
+
+
+
+
+
diff --git a/tools/FSharp_1.9.6.16/bin/fsc.exe b/tools/FSharp_1.9.6.16/bin/fsc.exe
new file mode 100644
index 00000000..67166806
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/fsc.exe differ
diff --git a/tools/FSharp_1.9.6.16/bin/fsi.exe b/tools/FSharp_1.9.6.16/bin/fsi.exe
new file mode 100644
index 00000000..dbceba82
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/fsi.exe differ
diff --git a/tools/FSharp_1.9.6.16/bin/fslex.exe b/tools/FSharp_1.9.6.16/bin/fslex.exe
new file mode 100644
index 00000000..2ad6604d
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/fslex.exe differ
diff --git a/tools/FSharp_1.9.6.16/bin/fsyacc.exe b/tools/FSharp_1.9.6.16/bin/fsyacc.exe
new file mode 100644
index 00000000..710aae35
Binary files /dev/null and b/tools/FSharp_1.9.6.16/bin/fsyacc.exe differ