Skip to content

Instantly share code, notes, and snippets.

@ctaggart

ctaggart/3.0.fsi

Last active August 29, 2015 14:12
Show Gist options
  • Save ctaggart/cd3f74cf366f2759311d to your computer and use it in GitHub Desktop.
Save ctaggart/cd3f74cf366f2759311d to your computer and use it in GitHub Desktop.
Download ZIP
FSharp.Core Surface Area
Raw
3.0.fsi
namespace Microsoft.FSharp.Reflection
/// Represents a case of a discriminated union type
[<Sealed>]
[<Class>]
type UnionCaseInfo =
/// The type in which the case occurs.
member DeclaringType : Type
/// Returns the custom attributes associated with the case.
member GetCustomAttributes : unit -> obj []
/// Returns the custom attributes associated with the case matching the given attribute type.
member GetCustomAttributes : attributeType:Type -> obj []
/// Returns the custom attributes data associated with the case.
member GetCustomAttributesData : unit -> Collections.Generic.IList<Reflection.CustomAttributeData>
/// The fields associated with the case, represented by a PropertyInfo.
member GetFields : unit -> Reflection.PropertyInfo []
/// The name of the case.
member Name : string
/// The integer tag for the case.
member Tag : int
namespace Microsoft.FSharp.Reflection
/// Contains operations associated with constructing and analyzing values associated with F# types
/// such as records, unions and tuples.
[<AbstractClass>]
[<Sealed>]
type FSharpValue =
/// Reads all the fields from a value built using an instance of an F# exception declaration
static member GetExceptionFields : exn:obj * ?bindingFlags:Reflection.BindingFlags -> obj []
/// Reads a field from a record value.
static member GetRecordField : record:obj * info:Reflection.PropertyInfo -> obj
/// Reads all the fields from a record value.
static member GetRecordFields : record:obj * ?bindingFlags:Reflection.BindingFlags -> obj []
/// Reads a field from a tuple value.
static member GetTupleField : tuple:obj * index:int -> obj
/// Reads all fields from a tuple.
static member GetTupleFields : tuple:obj -> obj []
/// Identify the union case and its fields for an object
static member GetUnionFields : value:obj * unionType:Type * ?bindingFlags:Reflection.BindingFlags -> Reflection.UnionCaseInfo * obj []
/// Builds a typed function from object from a dynamic function implementation
static member MakeFunction : functionType:Type * implementation:(obj -> obj) -> obj
/// Creates an instance of a record type.
static member MakeRecord : recordType:Type * values:obj [] * ?bindingFlags:Reflection.BindingFlags -> obj
/// Creates an instance of a tuple type
static member MakeTuple : tupleElements:obj [] * tupleType:Type -> obj
/// Create a union case value.
static member MakeUnion : unionCase:Reflection.UnionCaseInfo * args:obj [] * ?bindingFlags:Reflection.BindingFlags -> obj
/// Precompute a function for constructing a record value.
static member PreComputeRecordConstructor : recordType:Type * ?bindingFlags:Reflection.BindingFlags -> obj [] -> obj
/// Get a ConstructorInfo for a record type
static member PreComputeRecordConstructorInfo : recordType:Type * ?bindingFlags:Reflection.BindingFlags -> Reflection.ConstructorInfo
/// 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.
static member PreComputeRecordFieldReader : info:Reflection.PropertyInfo -> obj -> obj
/// 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.
static member PreComputeRecordReader : recordType:Type * ?bindingFlags:Reflection.BindingFlags -> obj -> obj []
/// Precomputes a function for reading the values of a particular tuple type
static member PreComputeTupleConstructor : tupleType:Type -> obj [] -> obj
/// Gets a method that constructs objects of the given tuple type.
/// For small tuples, no additional type will be returned.
static member PreComputeTupleConstructorInfo : tupleType:Type -> Reflection.ConstructorInfo * Type option
/// Gets information that indicates how to read a field of a tuple
static member PreComputeTuplePropertyInfo : tupleType:Type * index:int -> Reflection.PropertyInfo * (Type * int) option
/// Precomputes a function for reading the values of a particular tuple type
static member PreComputeTupleReader : tupleType:Type -> obj -> obj []
/// Precomputes a function for constructing a discriminated union value for a particular union case.
static member PreComputeUnionConstructor : unionCase:Reflection.UnionCaseInfo * ?bindingFlags:Reflection.BindingFlags -> obj [] -> obj
/// A method that constructs objects of the given case
static member PreComputeUnionConstructorInfo : unionCase:Reflection.UnionCaseInfo * ?bindingFlags:Reflection.BindingFlags -> Reflection.MethodInfo
/// Precomputes a function for reading all the fields for a particular discriminator case of a union type
static member PreComputeUnionReader : unionCase:Reflection.UnionCaseInfo * ?bindingFlags:Reflection.BindingFlags -> obj -> obj []
/// Precompute a property or static method for reading an integer representing the case tag of a union type.
static member PreComputeUnionTagMemberInfo : unionType:Type * ?bindingFlags:Reflection.BindingFlags -> Reflection.MemberInfo
/// Assumes the given type is a union type.
/// If not, ArgumentException is raised during pre-computation.
static member PreComputeUnionTagReader : unionType:Type * ?bindingFlags:Reflection.BindingFlags -> obj -> int
namespace Microsoft.FSharp.Reflection
/// Contains operations associated with constructing and analyzing F# types such as records, unions and tuples
[<AbstractClass>]
[<Sealed>]
type FSharpType =
/// Reads all the fields from an F# exception declaration, in declaration order
static member GetExceptionFields : exceptionType:Type * ?bindingFlags:Reflection.BindingFlags -> Reflection.PropertyInfo []
/// Gets the domain and range types from an F# function type or from the runtime type of a closure implementing an F# type
static member GetFunctionElements : functionType:Type -> Type * Type
/// Reads all the fields from a record value, in declaration order
static member GetRecordFields : recordType:Type * ?bindingFlags:Reflection.BindingFlags -> Reflection.PropertyInfo []
/// Gets the tuple elements from the representation of an F# tuple type.
static member GetTupleElements : tupleType:Type -> Type []
/// Gets the cases of a union type.
static member GetUnionCases : unionType:Type * ?bindingFlags:Reflection.BindingFlags -> Reflection.UnionCaseInfo []
/// Returns true if the typ is a representation of an F# exception declaration
static member IsExceptionRepresentation : exceptionType:Type * ?bindingFlags:Reflection.BindingFlags -> bool
/// 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
static member IsFunction : typ:Type -> bool
/// Return true if the typ is a System.Type value corresponding to the compiled form of an F# module
static member IsModule : typ:Type -> bool
/// Return true if the typ is a representation of an F# record type
static member IsRecord : typ:Type * ?bindingFlags:Reflection.BindingFlags -> bool
/// Return true if the typ is a representation of an F# tuple type
static member IsTuple : typ:Type -> bool
/// Returns true if the typ is a representation of an F# union type or the runtime type of a value of that type
static member IsUnion : typ:Type * ?bindingFlags:Reflection.BindingFlags -> bool
/// Returns a System.Type representing the F# function type with the given domain and range
static member MakeFunctionType : domain:Type * range:Type -> Type
/// Returns a System.Type representing an F# tuple type with the given element types
static member MakeTupleType : types:Type [] -> Type
namespace Microsoft.FSharp.Quotations
/// Information at the binding site of a variable
[<Sealed>]
[<CompiledName("FSharpVar")>]
type Var =
/// Creates a new variable with the given name, type and mutability
new : name:string * typ:Type * ?isMutable:bool -> Var
/// Indicates if the variable represents a mutable storage location
member IsMutable : bool
/// The declared name of the variable
member Name : string
/// The type associated with the variable
member Type : Type
/// Fetches or create a new variable with the given name and type from a global pool of shared variables
/// indexed by name and type
static member Global : name:string * typ:Type -> Quotations.Var
namespace Microsoft.FSharp.Quotations
/// Quoted expressions annotated with System.Type values.
[<CompiledName("FSharpExpr")>]
[<Class>]
type Expr =
/// Returns the custom attributes of an expression.
member CustomAttributes : Quotations.Expr list
override Equals : obj:obj -> bool
/// Gets the free expression variables of an expression as a list.
member GetFreeVars : unit -> seq<Quotations.Var>
/// Substitutes 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.
member Substitute : substitution:(Quotations.Var -> Quotations.Expr option) -> Quotations.Expr
/// Format the expression as a string
member ToString : full:bool -> string
/// Returns type of an expression.
member Type : Type
/// Builds an expression that represents getting the address of a value.
static member AddressOf : target:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents setting the value held at a particular address.
static member AddressSet : target:Quotations.Expr * value:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents the application of a first class function value to a single argument.
static member Application : functionExpr:Quotations.Expr * argument:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents the application of a first class function value to multiple arguments
static member Applications : functionExpr:Quotations.Expr * arguments:Quotations.Expr list list -> Quotations.Expr
/// Builds an expression that represents a call to an static method or module-bound function
static member Call : methodInfo:Reflection.MethodInfo * arguments:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents a call to an instance method associated with an object
static member Call : obj:Quotations.Expr * methodInfo:Reflection.MethodInfo * arguments:Quotations.Expr list -> Quotations.Expr
/// Returns 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.
static member Cast : source:Quotations.Expr -> Quotations.Expr<'T>
/// Builds an expression that represents the coercion of an expression to a type
static member Coerce : source:Quotations.Expr * target:Type -> Quotations.Expr
/// Builds an expression that represents the invocation of a default object constructor
static member DefaultValue : expressionType:Type -> Quotations.Expr
/// 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 quoted 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.
static member Deserialize : qualifyingType:Type * spliceTypes:Type list * spliceExprs:Quotations.Expr list * bytes:byte [] -> Quotations.Expr
/// Builds an expression that represents the access of a static field
static member FieldGet : fieldInfo:Reflection.FieldInfo -> Quotations.Expr
/// Builds an expression that represents the access of a field of an object
static member FieldGet : obj:Quotations.Expr * fieldInfo:Reflection.FieldInfo -> Quotations.Expr
/// Builds an expression that represents writing to a static field
static member FieldSet : fieldInfo:Reflection.FieldInfo * value:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents writing to a field of an object
static member FieldSet : obj:Quotations.Expr * fieldInfo:Reflection.FieldInfo * value:Quotations.Expr -> Quotations.Expr
/// Builds a 'for i = ... to ... do ...' expression that represent loops over integer ranges
static member ForIntegerRangeLoop : loopVariable:Quotations.Var * start:Quotations.Expr * endExpr:Quotations.Expr * body:Quotations.Expr -> Quotations.Expr
/// Fetches or creates 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
static member GlobalVar : name:string -> Quotations.Expr<'T>
/// Builds 'if ... then ... else' expressions.
static member IfThenElse : guard:Quotations.Expr * thenExpr:Quotations.Expr * elseExpr:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents the constrution of an F# function value
static member Lambda : parameter:Quotations.Var * body:Quotations.Expr -> Quotations.Expr
/// Builds expressions associated with 'let' constructs
static member Let : letVariable:Quotations.Var * letExpr:Quotations.Expr * body:Quotations.Expr -> Quotations.Expr
/// Builds recursives expressions associated with 'let rec' constructs
static member LetRecursive : bindings:(Quotations.Var * Quotations.Expr) list * body:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents the creation of an array value initialized with the given elements
static member NewArray : elementType:Type * elements:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents the creation of a delegate value for the given type
static member NewDelegate : delegateType:Type * parameters:Quotations.Var list * body:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents the invocation of an object constructor
static member NewObject : constructorInfo:Reflection.ConstructorInfo * arguments:Quotations.Expr list -> Quotations.Expr
/// Builds record-construction expressions
static member NewRecord : recordType:Type * elements:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents the creation of an F# tuple value
static member NewTuple : elements:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents the creation of a union case value
static member NewUnionCase : unionCase:Reflection.UnionCaseInfo * arguments:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents reading a property of an object
static member PropertyGet : obj:Quotations.Expr * property:Reflection.PropertyInfo * ?indexerArgs:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents reading a static property
static member PropertyGet : property:Reflection.PropertyInfo * ?indexerArgs:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents writing to a property of an object
static member PropertySet : obj:Quotations.Expr * property:Reflection.PropertyInfo * value:Quotations.Expr * ?indexerArgs:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents writing to a static property
static member PropertySet : property:Reflection.PropertyInfo * value:Quotations.Expr * ?indexerArgs:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents a nested quotation literal
static member Quote : inner:Quotations.Expr -> Quotations.Expr
/// Permits 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.
static member RegisterReflectedDefinitions : assembly:Reflection.Assembly * resource:string * serializedValue:byte [] -> unit
/// Builds an expression that represents the sequential execution of one expression followed by another
static member Sequential : first:Quotations.Expr * second:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents a try/finally construct
static member TryFinally : body:Quotations.Expr * compensation:Quotations.Expr -> Quotations.Expr
/// 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.
static member TryGetReflectedDefinition : methodBase:Reflection.MethodBase -> Quotations.Expr option
/// Builds an expression that represents a try/with construct for exception filtering and catching.
static member TryWith : body:Quotations.Expr * filterVar:Quotations.Var * filterBody:Quotations.Expr * catchVar:Quotations.Var * catchBody:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents getting a field of a tuple
static member TupleGet : tuple:Quotations.Expr * index:int -> Quotations.Expr
/// Builds an expression that represents a type test.
static member TypeTest : source:Quotations.Expr * target:Type -> Quotations.Expr
/// Builds an expression that represents a test of a value is of a particular union case
static member UnionCaseTest : source:Quotations.Expr * unionCase:Reflection.UnionCaseInfo -> Quotations.Expr
/// Builds an expression that represents a constant value of a particular type
static member Value : value:obj * expressionType:Type -> Quotations.Expr
/// Builds an expression that represents a constant value
static member Value : value:'T -> Quotations.Expr
/// Builds an expression that represents a variable
static member Var : variable:Quotations.Var -> Quotations.Expr
/// Builds an expression that represents setting a mutable variable
static member VarSet : variable:Quotations.Var * value:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents a while loop
static member WhileLoop : guard:Quotations.Expr * body:Quotations.Expr -> Quotations.Expr
namespace Microsoft.FSharp.Quotations
/// Type-carrying quoted expressions. Expressions are generated either
/// by quotations in source text or programatically
[<CompiledName("FSharpExpr`1")>]
[<Class>]
type Expr<'T> =
inherit Quotations.Expr
/// Gets the raw expression associated with this type-carrying expression
member Raw : Quotations.Expr
/// Contains a set of primitive F# active patterns to analyze F# expression objects
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
module Microsoft.FSharp.Quotations.Patterns
/// An active pattern to recognize expressions that represent getting the address of a value
val (|AddressOf|_|) : input:Quotations.Expr -> Quotations.Expr option
/// An active pattern to recognize expressions that represent setting the value held at an address
val (|AddressSet|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions that represent applications of first class function values
val (|Application|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions that represent calls to static and instance methods, and functions defined in modules
val (|Call|_|) : input:Quotations.Expr -> (Quotations.Expr option * Reflection.MethodInfo * Quotations.Expr list) option
/// An active pattern to recognize expressions that represent coercions from one type to another
val (|Coerce|_|) : input:Quotations.Expr -> (Quotations.Expr * Type) option
/// An active pattern to recognize expressions that represent getting a static or instance field
val (|FieldGet|_|) : input:Quotations.Expr -> (Quotations.Expr option * Reflection.FieldInfo) option
/// An active pattern to recognize expressions that represent setting a static or instance field
val (|FieldSet|_|) : input:Quotations.Expr -> (Quotations.Expr option * Reflection.FieldInfo * Quotations.Expr) option
/// An active pattern to recognize expressions that represent loops over integer ranges
val (|ForIntegerRangeLoop|_|) : input:Quotations.Expr -> (Quotations.Var * Quotations.Expr * Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions that represent while loops
val (|WhileLoop|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions that represent conditionals
val (|IfThenElse|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions that represent first class function values
val (|Lambda|_|) : input:Quotations.Expr -> (Quotations.Var * Quotations.Expr) option
/// An active pattern to recognize expressions that represent let bindings
val (|Let|_|) : input:Quotations.Expr -> (Quotations.Var * Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions that represent recursive let bindings of one or more variables
val (|LetRecursive|_|) : input:Quotations.Expr -> ((Quotations.Var * Quotations.Expr) list * Quotations.Expr) option
/// An active pattern to recognize expressions that represent the construction of arrays
val (|NewArray|_|) : input:Quotations.Expr -> (Type * Quotations.Expr list) option
/// An active pattern to recognize expressions that represent invocations of a default constructor of a struct
val (|DefaultValue|_|) : input:Quotations.Expr -> Type option
/// An active pattern to recognize expressions that represent construction of delegate values
val (|NewDelegate|_|) : input:Quotations.Expr -> (Type * Quotations.Var list * Quotations.Expr) option
/// An active pattern to recognize expressions that represent invocation of object constructors
val (|NewObject|_|) : input:Quotations.Expr -> (Reflection.ConstructorInfo * Quotations.Expr list) option
/// An active pattern to recognize expressions that represent construction of record values
val (|NewRecord|_|) : input:Quotations.Expr -> (Type * Quotations.Expr list) option
/// An active pattern to recognize expressions that represent construction of particular union case values
val (|NewUnionCase|_|) : input:Quotations.Expr -> (Reflection.UnionCaseInfo * Quotations.Expr list) option
/// An active pattern to recognize expressions that represent construction of tuple values
val (|NewTuple|_|) : input:Quotations.Expr -> Quotations.Expr list option
/// 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
val (|PropertyGet|_|) : input:Quotations.Expr -> (Quotations.Expr option * Reflection.PropertyInfo * Quotations.Expr list) option
/// An active pattern to recognize expressions that represent setting a static or instance property, or a non-function value declared in a module
val (|PropertySet|_|) : input:Quotations.Expr -> (Quotations.Expr option * Reflection.PropertyInfo * Quotations.Expr list * Quotations.Expr) option
/// An active pattern to recognize expressions that represent a nested quotation literal
val (|Quote|_|) : input:Quotations.Expr -> Quotations.Expr option
/// An active pattern to recognize expressions that represent sequential exeuction of one expression followed by another
val (|Sequential|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions that represent a try/with construct for exception filtering and catching
val (|TryWith|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Var * Quotations.Expr * Quotations.Var * Quotations.Expr) option
/// An active pattern to recognize expressions that represent a try/finally construct
val (|TryFinally|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions that represent getting a tuple field
val (|TupleGet|_|) : input:Quotations.Expr -> (Quotations.Expr * int) option
/// An active pattern to recognize expressions that represent a dynamic type test
val (|TypeTest|_|) : input:Quotations.Expr -> (Quotations.Expr * Type) option
/// An active pattern to recognize expressions that represent a test if a value is of a particular union case
val (|UnionCaseTest|_|) : input:Quotations.Expr -> (Quotations.Expr * Reflection.UnionCaseInfo) option
/// An active pattern to recognize expressions that represent a constant value
val (|Value|_|) : input:Quotations.Expr -> (obj * Type) option
/// An active pattern to recognize expressions that represent a variable
val (|Var|_|) : input:Quotations.Expr -> Quotations.Var option
/// An active pattern to recognize expressions that represent setting a mutable variable
val (|VarSet|_|) : input:Quotations.Expr -> (Quotations.Var * Quotations.Expr) option
/// Contains a set of derived F# active patterns to analyze F# expression objects
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
module Microsoft.FSharp.Quotations.DerivedPatterns
/// An active pattern to recognize expressions that represent a (possibly curried or tupled) first class function value
val (|Lambdas|_|) : input:Quotations.Expr -> (Quotations.Var list list * Quotations.Expr) option
/// An active pattern to recognize expressions that represent the application of a (possibly curried or tupled) first class function value
val (|Applications|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr list list) option
/// An active pattern to recognize expressions of the form a && b
val (|AndAlso|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions of the form a || b
val (|OrElse|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize () constant expressions
val (|Unit|_|) : input:Quotations.Expr -> unit option
/// An active pattern to recognize constant boolean expressions
val (|Bool|_|) : input:Quotations.Expr -> bool option
/// An active pattern to recognize constant string expressions
val (|String|_|) : input:Quotations.Expr -> string option
/// An active pattern to recognize constant 32-bit floating point number expressions
val (|Single|_|) : input:Quotations.Expr -> float32 option
/// An active pattern to recognize constant 64-bit floating point number expressions
val (|Double|_|) : input:Quotations.Expr -> float option
/// An active pattern to recognize constant unicode character expressions
val (|Char|_|) : input:Quotations.Expr -> char option
/// An active pattern to recognize constant signed byte expressions
val (|SByte|_|) : input:Quotations.Expr -> sbyte option
/// An active pattern to recognize constant byte expressions
val (|Byte|_|) : input:Quotations.Expr -> byte option
/// An active pattern to recognize constant int16 expressions
val (|Int16|_|) : input:Quotations.Expr -> int16 option
/// An active pattern to recognize constant unsigned int16 expressions
val (|UInt16|_|) : input:Quotations.Expr -> uint16 option
/// An active pattern to recognize constant int32 expressions
val (|Int32|_|) : input:Quotations.Expr -> int32 option
/// An active pattern to recognize constant unsigned int32 expressions
val (|UInt32|_|) : input:Quotations.Expr -> uint32 option
/// An active pattern to recognize constant int64 expressions
val (|Int64|_|) : input:Quotations.Expr -> int64 option
/// An active pattern to recognize constant unsigned int64 expressions
val (|UInt64|_|) : input:Quotations.Expr -> uint64 option
/// A parameterized active pattern to recognize calls to a specified function or method.
/// The returned elements are the optional target object (present if the target is an
/// instance method), the generic type instantation (non-empty if the target is a generic
/// instantiation), and the arguments to the function or method.
val (|SpecificCall|_|) : templateParameter:Quotations.Expr -> Quotations.Expr -> (Quotations.Expr option * Type list * Quotations.Expr list) option
/// An active pattern to recognize methods that have an associated ReflectedDefinition
val (|MethodWithReflectedDefinition|_|) : methodBase:Reflection.MethodBase -> Quotations.Expr option
/// An active pattern to recognize property getters or values in modules that have an associated ReflectedDefinition
val (|PropertyGetterWithReflectedDefinition|_|) : propertyInfo:Reflection.PropertyInfo -> Quotations.Expr option
/// An active pattern to recognize property setters that have an associated ReflectedDefinition
val (|PropertySetterWithReflectedDefinition|_|) : propertyInfo:Reflection.PropertyInfo -> Quotations.Expr option
/// Active patterns for traversing, visiting, rebuilding and tranforming expressions in a generic way
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
module Microsoft.FSharp.Quotations.ExprShape
/// An active pattern that performs a complete decomposition viewing the expression tree as a binding structure
val (|ShapeVar|ShapeLambda|ShapeCombination|) : input:Quotations.Expr -> Choice<Quotations.Var,(Quotations.Var * Quotations.Expr),(obj * Quotations.Expr list)>
/// Re-build combination expressions. The first parameter should be an object
/// returned by the ShapeCombination case of the active pattern in this module.
val RebuildShapeCombination : shape:obj * arguments:Quotations.Expr list -> Quotations.Expr
/// Contains operations on native pointers. Use of these operators may
/// result in the generation of unverifiable code.
[<RequireQualifiedAccess>]
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
module Microsoft.FSharp.NativeInterop.NativePtr
/// Returns a typed native pointer for a given machine address.
val inline ofNativeInt : address:nativeint -> nativeptr<'T> when 'T : unmanaged
/// Returns a machine address for a given typed native pointer.
val inline toNativeInt : address:nativeptr<'T> -> nativeint when 'T : unmanaged
/// Returns a typed native pointer by adding index * sizeof<'T> to the
/// given input pointer.
val inline add : address:nativeptr<'T> -> index:int -> nativeptr<'T> when 'T : unmanaged
/// Dereferences the typed native pointer computed by adding index * sizeof<'T> to the
/// given input pointer.
val inline get : address:nativeptr<'T> -> index:int -> 'T when 'T : unmanaged
/// Dereferences the given typed native pointer.
val inline read : address:nativeptr<'T> -> 'T when 'T : unmanaged
/// Assigns the value into the memory location referenced by the given typed native pointer.
val inline write : address:nativeptr<'T> -> value:'T -> unit when 'T : unmanaged
/// Assigns the value into the memory location referenced by the typed native
/// pointer computed by adding index * sizeof<'T> to the given input pointer.
val inline set : address:nativeptr<'T> -> index:int -> value:'T -> unit when 'T : unmanaged
/// Allocates a region of memory on the stack.
val inline stackalloc : count:int -> nativeptr<'T> when 'T : unmanaged
module Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter
/// When used in a quotation, this function indicates a specific conversion
/// should be performed when converting the quotation to a LINQ expression.
///
/// This function should not be called directly.
val ImplicitExpressionConversionHelper : 'T -> Linq.Expressions.Expression<'T>
/// When used in a quotation, this function indicates a specific conversion
/// should be performed when converting the quotation to a LINQ expression.
///
/// This function should not be called directly.
val MemberInitializationHelper : 'T -> 'T
/// When used in a quotation, this function indicates a specific conversion
/// should be performed when converting the quotation to a LINQ expression.
///
/// This function should not be called directly.
val NewAnonymousObjectHelper : 'T -> 'T
/// Converts a subset of F# quotations to a LINQ expression, for the subset of LINQ expressions represented by the
/// expression syntax in the C# language.
val QuotationToExpression : Quotations.Expr -> Linq.Expressions.Expression
/// Converts a subset of F# quotations to a LINQ expression, for the subset of LINQ expressions represented by the
/// expression syntax in the C# language.
val QuotationToLambdaExpression : Quotations.Expr<'T> -> Linq.Expressions.Expression<'T>
/// Evaluates a subset of F# quotations by first converting to a LINQ expression, for the subset of LINQ expressions represented by the
/// expression syntax in the C# language.
val EvaluateQuotation : Quotations.Expr -> obj
/// A runtime helper used to evaluate nested quotation literals.
val SubstHelper : Quotations.Expr * Quotations.Var [] * obj [] -> Quotations.Expr<'T>
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// A type used to reconstruct a grouping after applying a mutable->immutable mapping transformation
/// on a result of a query.
type Grouping<'K, 'T> =
interface System.Collections.Generic.IEnumerable<'T>
interface System.Collections.IEnumerable
interface System.Linq.IGrouping<'K,'T>
new : key:'K * values:seq<'T> -> Grouping<'K, 'T>
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// This type shouldn't be used directly from user code.
type AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8> =
new : Item1:'T1 * Item2:'T2 * Item3:'T3 * Item4:'T4 * Item5:'T5 * Item6:'T6 * Item7:'T7 * Item8:'T8 -> AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8>
member Item1 : 'T1
member Item2 : 'T2
member Item3 : 'T3
member Item4 : 'T4
member Item5 : 'T5
member Item6 : 'T6
member Item7 : 'T7
member Item8 : 'T8
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// This type shouldn't be used directly from user code.
type AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7> =
new : Item1:'T1 * Item2:'T2 * Item3:'T3 * Item4:'T4 * Item5:'T5 * Item6:'T6 * Item7:'T7 -> AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7>
member Item1 : 'T1
member Item2 : 'T2
member Item3 : 'T3
member Item4 : 'T4
member Item5 : 'T5
member Item6 : 'T6
member Item7 : 'T7
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// This type shouldn't be used directly from user code.
type AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5, 'T6> =
new : Item1:'T1 * Item2:'T2 * Item3:'T3 * Item4:'T4 * Item5:'T5 * Item6:'T6 -> AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5, 'T6>
member Item1 : 'T1
member Item2 : 'T2
member Item3 : 'T3
member Item4 : 'T4
member Item5 : 'T5
member Item6 : 'T6
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// This type shouldn't be used directly from user code.
type AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5> =
new : Item1:'T1 * Item2:'T2 * Item3:'T3 * Item4:'T4 * Item5:'T5 -> AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5>
member Item1 : 'T1
member Item2 : 'T2
member Item3 : 'T3
member Item4 : 'T4
member Item5 : 'T5
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// This type shouldn't be used directly from user code.
type AnonymousObject<'T1, 'T2, 'T3, 'T4> =
new : Item1:'T1 * Item2:'T2 * Item3:'T3 * Item4:'T4 -> AnonymousObject<'T1, 'T2, 'T3, 'T4>
member Item1 : 'T1
member Item2 : 'T2
member Item3 : 'T3
member Item4 : 'T4
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// This type shouldn't be used directly from user code.
type AnonymousObject<'T1, 'T2, 'T3> =
new : Item1:'T1 * Item2:'T2 * Item3:'T3 -> AnonymousObject<'T1, 'T2, 'T3>
member Item1 : 'T1
member Item2 : 'T2
member Item3 : 'T3
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// This type shouldn't be used directly from user code.
type AnonymousObject<'T1, 'T2> =
new : Item1:'T1 * Item2:'T2 -> AnonymousObject<'T1, 'T2>
member Item1 : 'T1
member Item2 : 'T2
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// This type shouldn't be used directly from user code.
type AnonymousObject<'T1> =
new : Item1:'T1 -> AnonymousObject<'T1>
member Item1 : 'T1
namespace Microsoft.FSharp.Linq
/// A partial input or result in an F# query. This type is used to support the F# query syntax.
[<NoComparison>]
[<NoEquality>]
[<Sealed>]
type QuerySource<'T, 'Q> =
/// A method used to support the F# query syntax.
new : seq<'T> -> QuerySource<'T, 'Q>
/// A property used to support the F# query syntax.
member Source : seq<'T>
module Microsoft.FSharp.Linq.QueryRunExtensions.LowPriority
/// A method used to support the F# query syntax. Runs the given quotation as a query using LINQ rules.
val Run : Quotations.Expr<'T> -> 'T
module Microsoft.FSharp.Linq.QueryRunExtensions.HighPriority
/// A method used to support the F# query syntax. Runs the given quotation as a query using LINQ IEnumerable rules.
val Run : Quotations.Expr<Linq.QuerySource<'T,Collections.IEnumerable>> -> seq<'T>
namespace Microsoft.FSharp.Linq
/// The type used to support the F# query syntax. Use 'query { ... }' to use the query syntax.
[<Class>]
type QueryBuilder =
/// Create an instance of this builder. Use 'query { ... }' to use the query syntax.
new : unit -> QueryBuilder
/// A query operator that determines whether all elements selected so far satisfies a condition.
[<CustomOperation("all")>]
member All : source:Linq.QuerySource<'T,'Q> * predicate:('T -> bool) -> bool
/// A query operator that selects a value for each element selected so far and returns the average of these values.
[<CustomOperation("averageBy")>]
member inline AverageBy : source:Linq.QuerySource<'T,'Q> * projection:('T -> ^Value) -> ^Value when ^Value : (static member ( + ) : ^Value * ^Value -> ^Value) and ^Value : (static member DivideByInt : ^Value * int -> ^Value) and ^Value : (static member Zero : ^Value)
/// A query operator that selects a nullable value for each element selected so far and returns the average of these values.
/// If any nullable does not have a value, it is ignored.
[<CustomOperation("averageByNullable")>]
member inline AverageByNullable : source:Linq.QuerySource<'T,'Q> * projection:('T -> Nullable< ^Value>) -> Nullable< ^Value> when ^Value : (static member ( + ) : ^Value * ^Value -> ^Value) and ^Value : (static member DivideByInt : ^Value * int -> ^Value) and ^Value : (static member Zero : ^Value) and ^Value : (new : unit -> ^Value) and ^Value : struct and ^Value :> ValueType
/// A query operator that determines whether the selected elements contains a specified element.
[<CustomOperation("contains")>]
member Contains : source:Linq.QuerySource<'T,'Q> * key:'T -> bool
/// A query operator that returns the number of selected elements.
[<CustomOperation("count")>]
member Count : source:Linq.QuerySource<'T,'Q> -> int
/// A query operator that selects distinct elements from the elements selected so far.
[<CustomOperation("distinct")>]
member Distinct : source:Linq.QuerySource<'T,'Q> -> Linq.QuerySource<'T,'Q> when 'T : equality
/// A query operator that selects the single, specific element selected so far
[<CustomOperation("exactlyOne")>]
member ExactlyOne : source:Linq.QuerySource<'T,'Q> -> 'T
/// A query operator that selects the single, specific element of those selected so far, or a default value if that element is not found.
[<CustomOperation("exactlyOneOrDefault")>]
member ExactlyOneOrDefault : source:Linq.QuerySource<'T,'Q> -> 'T
/// A query operator that determines whether any element selected so far satisfies a condition.
[<CustomOperation("exists")>]
member Exists : source:Linq.QuerySource<'T,'Q> * predicate:('T -> bool) -> bool
/// A query operator that selects the first element selected so far that satisfies a specified condition.
[<CustomOperation("find")>]
member Find : source:Linq.QuerySource<'T,'Q> * predicate:('T -> bool) -> 'T
/// A method used to support the F# query syntax. Projects each element of a sequence to another sequence and combines the resulting sequences into one sequence.
member For : source:Linq.QuerySource<'T,'Q> * body:('T -> Linq.QuerySource<'Result,'Q2>) -> Linq.QuerySource<'Result,'Q>
/// A query operator that groups the elements selected so far according to a specified key selector.
[<CustomOperation("groupBy")>]
member GroupBy : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> 'Key) -> Linq.QuerySource<Linq.IGrouping<'Key,'T>,'Q> when 'Key : equality
/// A query operator that correlates two sets of selected values based on matching keys and groups the results.
/// Normal usage is 'groupJoin y in elements2 on (key1 = key2) into group'.
[<CustomOperation("groupJoin")>]
member GroupJoin : outerSource:Linq.QuerySource<'Outer,'Q> * innerSource:Linq.QuerySource<'Inner,'Q> * outerKeySelector:('Outer -> 'Key) * innerKeySelector:('Inner -> 'Key) * resultSelector:('Outer -> seq<'Inner> -> 'Result) -> Linq.QuerySource<'Result,'Q>
/// A query operator that selects a value for each element selected so far and groups the elements by the given key.
[<CustomOperation("groupValBy")>]
member GroupValBy : source:Linq.QuerySource<'T,'Q> * resultSelector:('T -> 'Value) * keySelector:('T -> 'Key) -> Linq.QuerySource<Linq.IGrouping<'Key,'Value>,'Q> when 'Key : equality
/// A query operator that selects the first element from those selected so far.
[<CustomOperation("head")>]
member Head : source:Linq.QuerySource<'T,'Q> -> 'T
/// A query operator that selects the first element of those selected so far, or a default value if the sequence contains no elements.
[<CustomOperation("headOrDefault")>]
member HeadOrDefault : source:Linq.QuerySource<'T,'Q> -> 'T
/// A query operator that correlates two sets of selected values based on matching keys.
/// Normal usage is 'join y in elements2 on (key1 = key2)'.
[<CustomOperation("join")>]
member Join : outerSource:Linq.QuerySource<'Outer,'Q> * innerSource:Linq.QuerySource<'Inner,'Q> * outerKeySelector:('Outer -> 'Key) * innerKeySelector:('Inner -> 'Key) * resultSelector:('Outer -> 'Inner -> 'Result) -> Linq.QuerySource<'Result,'Q>
/// A query operator that selects the last element of those selected so far.
[<CustomOperation("last")>]
member Last : source:Linq.QuerySource<'T,'Q> -> 'T
/// A query operator that selects the last element of those selected so far, or a default value if no element is found.
[<CustomOperation("lastOrDefault")>]
member LastOrDefault : source:Linq.QuerySource<'T,'Q> -> 'T
/// A query operator that correlates two sets of selected values based on matching keys and groups the results.
/// If any group is empty, a group with a single default value is used instead.
/// Normal usage is 'leftOuterJoin y in elements2 on (key1 = key2) into group'.
[<CustomOperation("leftOuterJoin")>]
member LeftOuterJoin : outerSource:Linq.QuerySource<'Outer,'Q> * innerSource:Linq.QuerySource<'Inner,'Q> * outerKeySelector:('Outer -> 'Key) * innerKeySelector:('Inner -> 'Key) * resultSelector:('Outer -> seq<'Inner> -> 'Result) -> Linq.QuerySource<'Result,'Q>
/// A query operator that selects a value for each element selected so far and returns the maximum resulting value.
[<CustomOperation("maxBy")>]
member MaxBy : source:Linq.QuerySource<'T,'Q> * valueSelector:('T -> 'Value) -> 'Value when 'Value : comparison
/// A query operator that selects a nullable value for each element selected so far and returns the maximum of these values.
/// If any nullable does not have a value, it is ignored.
[<CustomOperation("maxByNullable")>]
member MaxByNullable : source:Linq.QuerySource<'T,'Q> * valueSelector:('T -> Nullable<'Value>) -> Nullable<'Value> when 'Value : comparison and 'Value : (new : unit -> 'Value) and 'Value : struct and 'Value :> ValueType
/// A query operator that selects a value for each element selected so far and returns the minimum resulting value.
[<CustomOperation("minBy")>]
member MinBy : source:Linq.QuerySource<'T,'Q> * valueSelector:('T -> 'Value) -> 'Value when 'Value : comparison
/// A query operator that selects a nullable value for each element selected so far and returns the minimum of these values.
/// If any nullable does not have a value, it is ignored.
[<CustomOperation("minByNullable")>]
member MinByNullable : source:Linq.QuerySource<'T,'Q> * valueSelector:('T -> Nullable<'Value>) -> Nullable<'Value> when 'Value : comparison and 'Value : (new : unit -> 'Value) and 'Value : struct and 'Value :> ValueType
/// A query operator that selects the element at a specified index amongst those selected so far.
[<CustomOperation("nth")>]
member Nth : source:Linq.QuerySource<'T,'Q> * index:int -> 'T
/// A method used to support the F# query syntax. Indicates that the query should be passed as a quotation to the Run method.
member Quote : Quotations.Expr<'T> -> Quotations.Expr<'T>
/// A method used to support the F# query syntax. Runs the given quotation as a query using LINQ IQueryable rules.
member Run : Quotations.Expr<Linq.QuerySource<'T,Linq.IQueryable>> -> Linq.IQueryable<'T>
/// A query operator that projects each of the elements selected so far.
[<CustomOperation("select")>]
member Select : source:Linq.QuerySource<'T,'Q> * projection:('T -> 'Result) -> Linq.QuerySource<'Result,'Q>
/// A query operator that bypasses a specified number of the elements selected so far and selects the remaining elements.
[<CustomOperation("skip")>]
member Skip : source:Linq.QuerySource<'T,'Q> * count:int -> Linq.QuerySource<'T,'Q>
/// A query operator that bypasses elements in a sequence as long as a specified condition is true and then selects the remaining elements.
[<CustomOperation("skipWhile")>]
member SkipWhile : source:Linq.QuerySource<'T,'Q> * predicate:('T -> bool) -> Linq.QuerySource<'T,'Q>
/// A query operator that sorts the elements selected so far in ascending order by the given sorting key.
[<CustomOperation("sortBy")>]
member SortBy : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> 'Key) -> Linq.QuerySource<'T,'Q> when 'Key : comparison
/// A query operator that sorts the elements selected so far in descending order by the given sorting key.
[<CustomOperation("sortByDescending")>]
member SortByDescending : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> 'Key) -> Linq.QuerySource<'T,'Q> when 'Key : comparison
/// A query operator that sorts the elements selected so far in ascending order by the given nullable sorting key.
[<CustomOperation("sortByNullable")>]
member SortByNullable : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> Nullable<'Key>) -> Linq.QuerySource<'T,'Q> when 'Key : comparison and 'Key : (new : unit -> 'Key) and 'Key : struct and 'Key :> ValueType
/// A query operator that sorts the elements selected so far in descending order by the given nullable sorting key.
[<CustomOperation("sortByNullableDescending")>]
member SortByNullableDescending : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> Nullable<'Key>) -> Linq.QuerySource<'T,'Q> when 'Key : comparison and 'Key : (new : unit -> 'Key) and 'Key : struct and 'Key :> ValueType
/// A method used to support the F# query syntax. Inputs to queries are implicitly wrapped by a call to one of the overloads of this method.
member Source : source:Linq.IQueryable<'T> -> Linq.QuerySource<'T,'Q>
/// A method used to support the F# query syntax. Inputs to queries are implicitly wrapped by a call to one of the overloads of this method.
member Source : source:Collections.Generic.IEnumerable<'T> -> Linq.QuerySource<'T,Collections.IEnumerable>
/// A query operator that selects a value for each element selected so far and returns the sum of these values.
[<CustomOperation("sumBy")>]
member inline SumBy : source:Linq.QuerySource<'T,'Q> * projection:('T -> ^Value) -> ^Value when ^Value : (static member ( + ) : ^Value * ^Value -> ^Value) and ^Value : (static member Zero : ^Value)
/// A query operator that selects a nullable value for each element selected so far and returns the sum of these values.
/// If any nullable does not have a value, it is ignored.
[<CustomOperation("sumByNullable")>]
member inline SumByNullable : source:Linq.QuerySource<'T,'Q> * valueSelector:('T -> Nullable< ^Value>) -> Nullable< ^Value> when ^Value : (static member ( + ) : ^Value * ^Value -> ^Value) and ^Value : (static member Zero : ^Value) and ^Value : (new : unit -> ^Value) and ^Value : struct and ^Value :> ValueType
/// A query operator that selects a specified number of contiguous elements from those selected so far.
[<CustomOperation("take")>]
member Take : source:Linq.QuerySource<'T,'Q> * count:int -> Linq.QuerySource<'T,'Q>
/// A query operator that selects elements from a sequence as long as a specified condition is true, and then skips the remaining elements.
[<CustomOperation("takeWhile")>]
member TakeWhile : source:Linq.QuerySource<'T,'Q> * predicate:('T -> bool) -> Linq.QuerySource<'T,'Q>
/// A query operator that performs a subsequent ordering of the elements selected so far in ascending order by the given sorting key.
/// This operator may only be used immediately after a 'sortBy', 'sortByDescending', 'thenBy' or 'thenByDescending', or their nullable variants.
[<CustomOperation("thenBy")>]
member ThenBy : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> 'Key) -> Linq.QuerySource<'T,'Q> when 'Key : comparison
/// A query operator that performs a subsequent ordering of the elements selected so far in descending order by the given sorting key.
/// This operator may only be used immediately after a 'sortBy', 'sortByDescending', 'thenBy' or 'thenByDescending', or their nullable variants.
[<CustomOperation("thenByDescending")>]
member ThenByDescending : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> 'Key) -> Linq.QuerySource<'T,'Q> when 'Key : comparison
/// A query operator that performs a subsequent ordering of the elements selected so far in ascending order by the given nullable sorting key.
/// This operator may only be used immediately after a 'sortBy', 'sortByDescending', 'thenBy' or 'thenByDescending', or their nullable variants.
[<CustomOperation("thenByNullable")>]
member ThenByNullable : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> Nullable<'Key>) -> Linq.QuerySource<'T,'Q> when 'Key : comparison and 'Key : (new : unit -> 'Key) and 'Key : struct and 'Key :> ValueType
/// A query operator that performs a subsequent ordering of the elements selected so far in descending order by the given nullable sorting key.
/// This operator may only be used immediately after a 'sortBy', 'sortByDescending', 'thenBy' or 'thenByDescending', or their nullable variants.
[<CustomOperation("thenByNullableDescending")>]
member ThenByNullableDescending : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> Nullable<'Key>) -> Linq.QuerySource<'T,'Q> when 'Key : comparison and 'Key : (new : unit -> 'Key) and 'Key : struct and 'Key :> ValueType
/// A query operator that selects those elements based on a specified predicate.
[<CustomOperation("where")>]
member Where : source:Linq.QuerySource<'T,'Q> * predicate:('T -> bool) -> Linq.QuerySource<'T,'Q>
/// A method used to support the F# query syntax. Returns a sequence of length one that contains the specified value.
member Yield : value:'T -> Linq.QuerySource<'T,'Q>
/// A method used to support the F# query syntax. Returns a sequence that contains the specified values.
member YieldFrom : computation:Linq.QuerySource<'T,'Q> -> Linq.QuerySource<'T,'Q>
/// A method used to support the F# query syntax. Returns an empty sequence that has the specified type argument.
member Zero : unit -> Linq.QuerySource<'T,'Q>
/// Operators for working with nullable values
[<AutoOpen>]
module Microsoft.FSharp.Linq.NullableOperators
/// The '>=' operator where a nullable value appears on the left
val ( ?>= ) : Nullable<'T> -> 'T -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '>' operator where a nullable value appears on the left
val ( ?> ) : Nullable<'T> -> 'T -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<=' operator where a nullable value appears on the left
val ( ?<= ) : Nullable<'T> -> 'T -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<' operator where a nullable value appears on the left
val ( ?< ) : Nullable<'T> -> 'T -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '=' operator where a nullable value appears on the left
val ( ?= ) : Nullable<'T> -> 'T -> bool when 'T : equality and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<>' operator where a nullable value appears on the left
val ( ?<> ) : Nullable<'T> -> 'T -> bool when 'T : equality and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '>=' operator where a nullable value appears on the right
val ( >=? ) : 'T -> Nullable<'T> -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '>' operator where a nullable value appears on the right
val ( >? ) : 'T -> Nullable<'T> -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<=' operator where a nullable value appears on the right
val ( <=? ) : 'T -> Nullable<'T> -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<' operator where a nullable value appears on the right
val ( <? ) : 'T -> Nullable<'T> -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '=' operator where a nullable value appears on the right
val ( =? ) : 'T -> Nullable<'T> -> bool when 'T : equality and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<>' operator where a nullable value appears on the right
val ( <>? ) : 'T -> Nullable<'T> -> bool when 'T : equality and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '>=' operator where a nullable value appears on both left and right sides
val ( ?>=? ) : Nullable<'T> -> Nullable<'T> -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '>' operator where a nullable value appears on both left and right sides
val ( ?>? ) : Nullable<'T> -> Nullable<'T> -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<=' operator where a nullable value appears on both left and right sides
val ( ?<=? ) : Nullable<'T> -> Nullable<'T> -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<' operator where a nullable value appears on both left and right sides
val ( ?<? ) : Nullable<'T> -> Nullable<'T> -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '=' operator where a nullable value appears on both left and right sides
val ( ?=? ) : Nullable<'T> -> Nullable<'T> -> bool when 'T : equality and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<>' operator where a nullable value appears on both left and right sides
val ( ?<>? ) : Nullable<'T> -> Nullable<'T> -> bool when 'T : equality and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The addition operator where a nullable value appears on the left
val inline ( ?+ ) : Nullable< ^T1> -> ^T2 -> Nullable< ^T3> when ^T1 : (static member ( + ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( + ) : ^T1 * ^T2 -> ^T3) and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The addition operator where a nullable value appears on the right
val inline ( +? ) : ^T1 -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( + ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( + ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The addition operator where a nullable value appears on both left and right sides
val inline ( ?+? ) : Nullable< ^T1> -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( + ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( + ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The subtraction operator where a nullable value appears on the left
val inline ( ?- ) : Nullable< ^T1> -> ^T2 -> Nullable< ^T3> when ^T1 : (static member ( - ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( - ) : ^T1 * ^T2 -> ^T3) and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The subtraction operator where a nullable value appears on the right
val inline ( -? ) : ^T1 -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( - ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( - ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The subtraction operator where a nullable value appears on both left and right sides
val inline ( ?-? ) : Nullable< ^T1> -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( - ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( - ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The multiplication operator where a nullable value appears on the left
val inline ( ?* ) : Nullable< ^T1> -> ^T2 -> Nullable< ^T3> when ^T1 : (static member ( * ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( * ) : ^T1 * ^T2 -> ^T3) and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The multiplication operator where a nullable value appears on the right
val inline ( *? ) : ^T1 -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( * ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( * ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The multiplication operator where a nullable value appears on both left and right sides
val inline ( ?*? ) : Nullable< ^T1> -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( * ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( * ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The modulus operator where a nullable value appears on the left
val inline ( ?% ) : Nullable< ^T1> -> ^T2 -> Nullable< ^T3> when ^T1 : (static member ( % ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( % ) : ^T1 * ^T2 -> ^T3) and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The modulus operator where a nullable value appears on the right
val inline ( %? ) : ^T1 -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( % ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( % ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The modulus operator where a nullable value appears on both left and right sides
val inline ( ?%? ) : Nullable< ^T1> -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( % ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( % ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The division operator where a nullable value appears on the left
val inline ( ?/ ) : Nullable< ^T1> -> ^T2 -> Nullable< ^T3> when ^T1 : (static member ( / ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( / ) : ^T1 * ^T2 -> ^T3) and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The division operator where a nullable value appears on the right
val inline ( /? ) : ^T1 -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( / ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( / ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The division operator where a nullable value appears on both left and right sides
val inline ( ?/? ) : Nullable< ^T1> -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( / ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( / ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// Functions for converting nullable values
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Linq.Nullable
/// Converts the argument to byte. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline byte : value:Nullable< ^T> -> Nullable<byte> when ^T : (static member op_Explicit : unit -> byte) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to signed byte. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline sbyte : value:Nullable< ^T> -> Nullable<sbyte> when ^T : (static member op_Explicit : unit -> sbyte) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to signed 16-bit integer. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline int16 : value:Nullable< ^T> -> Nullable<int16> when ^T : (static member op_Explicit : unit -> int16) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to unsigned 16-bit integer. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline uint16 : value:Nullable< ^T> -> Nullable<uint16> when ^T : (static member op_Explicit : unit -> uint16) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to signed 32-bit integer. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline int : value:Nullable< ^T> -> Nullable<int> when ^T : (static member op_Explicit : unit -> int) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to a particular enum type.
val inline enum : value:Nullable<int32> -> Nullable< ^U> when 'U : enum<int32> and 'U : (new : unit -> 'U) and 'U : struct and 'U :> ValueType
/// Converts the argument to signed 32-bit integer. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline int32 : value:Nullable< ^T> -> Nullable<int32> when ^T : (static member op_Explicit : unit -> int32) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to unsigned 32-bit integer. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline uint32 : value:Nullable< ^T> -> Nullable<uint32> when ^T : (static member op_Explicit : unit -> uint32) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to signed 64-bit integer. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline int64 : value:Nullable< ^T> -> Nullable<int64> when ^T : (static member op_Explicit : unit -> int64) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to unsigned 64-bit integer. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline uint64 : value:Nullable< ^T> -> Nullable<uint64> when ^T : (static member op_Explicit : unit -> uint64) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to 32-bit float. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline float32 : value:Nullable< ^T> -> Nullable<float32> when ^T : (static member op_Explicit : unit -> float32) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to 64-bit float. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline float : value:Nullable< ^T> -> Nullable<float> when ^T : (static member op_Explicit : unit -> float) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to signed native integer. This is a direct conversion for all
/// primitive numeric types. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline nativeint : value:Nullable< ^T> -> Nullable<nativeint> when ^T : (static member op_Explicit : unit -> nativeint) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to unsigned native integer using a direct conversion for all
/// primitive numeric types. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline unativeint : value:Nullable< ^T> -> Nullable<unativeint> when ^T : (static member op_Explicit : unit -> unativeint) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to System.Decimal using a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline decimal : value:Nullable< ^T> -> Nullable<decimal> when ^T : (static member op_Explicit : unit -> decimal) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to character. Numeric inputs are converted according to the UTF-16
/// encoding for characters. The operation requires an appropriate static conversion method on the input type.
val inline char : value:Nullable< ^T> -> Nullable<char> when ^T : (static member op_Explicit : unit -> char) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for Metre, the SI unit of length
type m = Data.UnitSystems.SI.UnitNames.metre
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for kilogram, the SI unit of mass
type kg = Data.UnitSystems.SI.UnitNames.kilogram
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for second, the SI unit of time
type s = Data.UnitSystems.SI.UnitNames.second
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for ampere, the SI unit of electric current
type A = Data.UnitSystems.SI.UnitNames.ampere
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for kelvin, the SI unit of thermodynamic temperature
type K = Data.UnitSystems.SI.UnitNames.kelvin
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for mole, the SI unit of amount of substance
type mol = Data.UnitSystems.SI.UnitNames.mole
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for candela, the SI unit of luminous intensity
type cd = Data.UnitSystems.SI.UnitNames.candela
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for hertz, the SI unit of frequency
type Hz = Data.UnitSystems.SI.UnitNames.hertz
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for newton, the SI unit of force
type N = Data.UnitSystems.SI.UnitNames.newton
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for pascal, the SI unit of pressure, stress
type Pa = Data.UnitSystems.SI.UnitNames.pascal
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for joule, the SI unit of energy, work, amount of heat
type J = Data.UnitSystems.SI.UnitNames.joule
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for watt, the SI unit of power, radiant flux
type W = Data.UnitSystems.SI.UnitNames.watt
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for coulomb, the SI unit of electric charge, amount of electricity
type C = Data.UnitSystems.SI.UnitNames.coulomb
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for volt, the SI unit of electric potential difference, electromotive force
type V = Data.UnitSystems.SI.UnitNames.volt
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for farad, the SI unit of capacitance
type F = Data.UnitSystems.SI.UnitNames.farad
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for siemens, the SI unit of electric conductance
type S = Data.UnitSystems.SI.UnitNames.siemens
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for UnitNames.ohm, the SI unit of electric resistance.
type ohm = Data.UnitSystems.SI.UnitNames.ohm
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for weber, the SI unit of magnetic flux
type Wb = Data.UnitSystems.SI.UnitNames.weber
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for tesla, the SI unit of magnetic flux density
type T = Data.UnitSystems.SI.UnitNames.tesla
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for lumen, the SI unit of luminous flux
type lm = Data.UnitSystems.SI.UnitNames.lumen
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for lux, the SI unit of illuminance
type lx = Data.UnitSystems.SI.UnitNames.lux
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for becquerel, the SI unit of activity referred to a radionuclide
type Bq = Data.UnitSystems.SI.UnitNames.becquerel
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for gray, the SI unit of absorbed dose
type Gy = Data.UnitSystems.SI.UnitNames.gray
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for sievert, the SI unit of does equivalent
type Sv = Data.UnitSystems.SI.UnitNames.sievert
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for katal, the SI unit of catalytic activity
type kat = Data.UnitSystems.SI.UnitNames.katal
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for henry, the SI unit of inductance
type H = Data.UnitSystems.SI.UnitNames.henry
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of length
[<Measure>]
type metre =
class
end
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of length
type meter = Data.UnitSystems.SI.UnitNames.metre
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of mass
[<Measure>]
type kilogram =
class
end
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of time
[<Measure>]
type second =
class
end
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of electric current
[<Measure>]
type ampere =
class
end
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of thermodynamic temperature
[<Measure>]
type kelvin =
class
end
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of amount of substance
[<Measure>]
type mole =
class
end
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of luminous intensity
[<Measure>]
type candela =
class
end
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of frequency
type hertz = /Data.UnitSystems.SI.UnitNames.second
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of force
type newton = Data.UnitSystems.SI.UnitNames.kilogram Data.UnitSystems.SI.UnitNames.metre/Data.UnitSystems.SI.UnitNames.second ^ 2
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of pressure, stress
type pascal = Data.UnitSystems.SI.UnitNames.newton/Data.UnitSystems.SI.UnitNames.metre ^ 2
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of energy, work, amount of heat
type joule = Data.UnitSystems.SI.UnitNames.metre Data.UnitSystems.SI.UnitNames.newton
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of power, radiant flux
type watt = Data.UnitSystems.SI.UnitNames.joule/Data.UnitSystems.SI.UnitNames.second
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of electric charge, amount of electricity
type coulomb = Data.UnitSystems.SI.UnitNames.ampere Data.UnitSystems.SI.UnitNames.second
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of electric potential difference, electromotive force
type volt = Data.UnitSystems.SI.UnitNames.watt/Data.UnitSystems.SI.UnitNames.ampere
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of capacitance
type farad = Data.UnitSystems.SI.UnitNames.coulomb/Data.UnitSystems.SI.UnitNames.volt
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of electric resistance
type ohm = Data.UnitSystems.SI.UnitNames.volt/Data.UnitSystems.SI.UnitNames.ampere
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of electric conductance
type siemens = Data.UnitSystems.SI.UnitNames.ampere/Data.UnitSystems.SI.UnitNames.volt
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of magnetic flux
type weber = Data.UnitSystems.SI.UnitNames.second Data.UnitSystems.SI.UnitNames.volt
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of magnetic flux density
type tesla = Data.UnitSystems.SI.UnitNames.weber/Data.UnitSystems.SI.UnitNames.metre ^ 2
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of inductance
type henry = Data.UnitSystems.SI.UnitNames.weber/Data.UnitSystems.SI.UnitNames.ampere
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of luminous flux
type lumen = Data.UnitSystems.SI.UnitNames.candela
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of illuminance
type lux = Data.UnitSystems.SI.UnitNames.lumen/Data.UnitSystems.SI.UnitNames.metre ^ 2
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of activity referred to a radionuclide
type becquerel = /Data.UnitSystems.SI.UnitNames.second
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of absorbed dose
type gray = Data.UnitSystems.SI.UnitNames.joule/Data.UnitSystems.SI.UnitNames.kilogram
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of does equivalent
type sievert = Data.UnitSystems.SI.UnitNames.joule/Data.UnitSystems.SI.UnitNames.kilogram
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of catalytic activity
type katal = Data.UnitSystems.SI.UnitNames.mole/Data.UnitSystems.SI.UnitNames.second
namespace Microsoft.FSharp.Core
/// The type 'unit', which has only one value "()". This value is special and
/// always uses the representation 'null'.
type unit = Unit
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.UIntPtr.
type unativeint = UIntPtr
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Byte.
type uint8 = Byte
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.UInt64.
type uint64 = UInt64
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.UInt32.
type uint32 = UInt32
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.UInt16.
type uint16 = UInt16
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.String.
type string = String
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Single.
type single = Single
namespace Microsoft.FSharp.Core
/// 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.
[<MeasureAnnotatedAbbreviation>]
[<Class>]
type sbyte<'Measure> =
inherit System.ValueType
interface System.IConvertible
interface System.IFormattable
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.SByte.
type sbyte = SByte
namespace Microsoft.FSharp.Core
/// The type of mutable references. Use the functions [:=] and [!] to get and
/// set values of this type.
type ref<'T> = Ref<'T>
namespace Microsoft.FSharp.Core
/// The type of optional values. When used from other CLI languages the
/// empty option is the null value.
type option<'T> = Option<'T>
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Object.
type obj = Object
namespace Microsoft.FSharp.Core
/// Represents an unmanaged pointer in F# code.
[<Class>]
type nativeptr<'T when 'T : unmanaged> =
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.IntPtr.
type nativeint = IntPtr
namespace Microsoft.FSharp.Core
/// 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.
[<MeasureAnnotatedAbbreviation>]
[<Class>]
type int<'Measure> =
inherit System.ValueType
interface System.IConvertible
interface System.IFormattable
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.SByte.
type int8 = SByte
namespace Microsoft.FSharp.Core
/// 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.
[<MeasureAnnotatedAbbreviation>]
[<Class>]
type int64<'Measure> =
inherit System.ValueType
interface System.IConvertible
interface System.IFormattable
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Int64.
type int64 = Int64
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Int32.
type int32 = Int32
namespace Microsoft.FSharp.Core
/// 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.
[<MeasureAnnotatedAbbreviation>]
[<Class>]
type int16<'Measure> =
inherit System.ValueType
interface System.IConvertible
interface System.IFormattable
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Int16.
type int16 = Int16
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Int32.
type int = int32
namespace Microsoft.FSharp.Core
/// This type is for internal use by the F# code generator.
[<Class>]
type ilsigptr<'T> =
namespace Microsoft.FSharp.Core
/// 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.
[<MeasureAnnotatedAbbreviation>]
[<Class>]
type float<'Measure> =
inherit System.ValueType
interface System.IConvertible
interface System.IFormattable
namespace Microsoft.FSharp.Core
/// 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.
[<MeasureAnnotatedAbbreviation>]
[<Class>]
type float32<'Measure> =
inherit System.ValueType
interface System.IConvertible
interface System.IFormattable
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Single.
type float32 = Single
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Double.
type float = Double
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Exception.
type exn = Exception
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Double.
type double = Double
namespace Microsoft.FSharp.Core
/// 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.
[<MeasureAnnotatedAbbreviation>]
[<Class>]
type decimal<'Measure> =
inherit System.ValueType
interface System.IConvertible
interface System.Runtime.Serialization.IDeserializationCallback
interface System.IFormattable
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Decimal.
type decimal = Decimal
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Char.
type char = Char
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Byte.
type byte = Byte
namespace Microsoft.FSharp.Core
/// Represents a managed pointer in F# code.
[<Class>]
type byref<'T> =
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Boolean.
type bool = Boolean
namespace Microsoft.FSharp.Core
type bigint = Numerics.BigInteger
namespace Microsoft.FSharp.Core
/// Single dimensional, zero-based arrays, written int[], string[] etc.
type array<'T> = 'T []
namespace Microsoft.FSharp.Core
/// Single dimensional, zero-based arrays, written int[], string[] etc.
[<Class>]
type ``[]``<'T> =
namespace Microsoft.FSharp.Core
/// Two dimensional arrays, typically zero-based.
[<Class>]
type ``[,]``<'T> =
namespace Microsoft.FSharp.Core
/// Three dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Four dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Adding this attribute to an F# mutable binding causes the "volatile"
/// prefix to be used for all accesses to the field.
[<Sealed>]
type VolatileFieldAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> VolatileFieldAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type UnverifiableAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> UnverifiableAttribute
namespace Microsoft.FSharp.Core
/// The type 'unit', which has only one value "()". This value is special and
/// always uses the representation 'null'.
[<Class>]
type Unit =
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type StructuredFormatDisplayAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : value:string -> StructuredFormatDisplayAttribute
/// 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.
member Value : string
namespace Microsoft.FSharp.Core
/// Adding this attribute to a record, union or struct type confirms the automatic
/// generation of overrides for 'System.Object.Equals(obj)' and
/// 'System.Object.GetHashCode()' for the type.
[<Sealed>]
type StructuralEqualityAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> StructuralEqualityAttribute
namespace Microsoft.FSharp.Core
/// Adding this attribute to a record, union, exception, or struct type confirms the
/// automatic generation of implementations for 'System.IComparable' for the type.
[<Sealed>]
type StructuralComparisonAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> StructuralComparisonAttribute
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type causes it to be represented using a CLI struct.
[<Sealed>]
type StructAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> StructAttribute
/// 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.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Core.String
/// Returns a new string made by concatenating the given strings
/// with separator sep, that is a1 + sep + ... + sep + aN.
val concat : sep:string -> strings:seq<string> -> string
/// Applies the function action to each character in the string.
val iter : action:(char -> unit) -> str:string -> unit
/// Applies the function action to the index of each character in the string and the
/// character itself.
val iteri : action:(int -> char -> unit) -> str:string -> unit
/// Builds a new string whose characters are the results of applying the function mapping
/// to each of the characters of the input string.
val map : mapping:(char -> char) -> str:string -> string
/// Builds a new string whose characters are the results of applying the function mapping
/// to each character and index of the input string.
val mapi : mapping:(int -> char -> char) -> str:string -> string
/// Builds 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.
val collect : mapping:(char -> string) -> str:string -> string
/// Builds 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.
val init : count:int -> initializer:(int -> string) -> string
/// Tests if all characters in the string satisfy the given predicate.
val forall : predicate:(char -> bool) -> str:string -> bool
/// Tests if any character of the string satisfies the given predicate.
val exists : predicate:(char -> bool) -> str:string -> bool
/// Returns a string by concatenating count instances of str.
val replicate : count:int -> str:string -> string
/// Returns the length of the string.
val length : str:string -> int
namespace Microsoft.FSharp.Core
/// Indicates the relationship between a compiled entity in a CLI binary and an element in F# source code.
type SourceConstructFlags =
/// Indicates that the compiled entity has no relationship to an element in F# source code.
| None = 0
/// Indicates that the compiled entity is part of the representation of an F# union type declaration.
| SumType = 1
/// Indicates that the compiled entity is part of the representation of an F# record type declaration.
| RecordType = 2
/// Indicates that the compiled entity is part of the representation of an F# class or other object type declaration.
| ObjectType = 3
/// Indicates that the compiled entity is part of the representation of an F# record or union case field declaration.
| Field = 4
/// Indicates that the compiled entity is part of the representation of an F# exception declaration.
| Exception = 5
/// Indicates that the compiled entity is part of the representation of an F# closure.
| Closure = 6
/// Indicates that the compiled entity is part of the representation of an F# module declaration.
| Module = 7
/// Indicates that the compiled entity is part of the representation of an F# union case declaration.
| UnionCase = 8
/// Indicates that the compiled entity is part of the representation of an F# value declaration.
| Value = 9
/// The mask of values related to the kind of the compiled entity.
| KindMask = 31
/// Indicates that the compiled entity had private or internal representation in F# source code.
| NonPublicRepresentation = 32
namespace Microsoft.FSharp.Core
/// Adding this attribute to class definition makes it sealed, which means it may not
/// be extended or implemented.
type SealedAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : value:bool -> SealedAttribute
/// Creates an instance of the attribute.
new : unit -> SealedAttribute
/// The value of the attribute, indicating whether the type is sealed or not.
member Value : bool
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type, value or member requires that
/// uses of the construct must explicitly instantiate any generic type parameters.
[<Sealed>]
type RequiresExplicitTypeArgumentsAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> RequiresExplicitTypeArgumentsAttribute
namespace Microsoft.FSharp.Core
/// This attribute is used to indicate that references to the elements of a module, record or union
/// type require explicit qualified access.
[<Sealed>]
type RequireQualifiedAccessAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> RequireQualifiedAccessAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type ReflectedDefinitionAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> ReflectedDefinitionAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type ReferenceEqualityAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> ReferenceEqualityAttribute
namespace Microsoft.FSharp.Core
/// The type of mutable references. Use the functions [:=] and [!] to get and
/// set values of this type.
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpRef`1")>]
type Ref<'T> =
{
/// The current value of the reference cell
contents: 'T
}
/// The current value of the reference cell
member Value : 'T with get, set
namespace Microsoft.FSharp.Core
/// Indicates that, when a custom operator is used in a computation expression,
/// a parameter is automatically parameterized by the variable space of the computation expression
[<Sealed>]
type ProjectionParameterAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> ProjectionParameterAttribute
/// Extensible printf-style formatting for numbers and other datatypes
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
module Microsoft.FSharp.Core.Printf
/// Print to a System.Text.StringBuilder
val bprintf : builder:Text.StringBuilder -> format:Printf.BuilderFormat<'T> -> 'T
/// Print to a text writer.
val fprintf : textWriter:IO.TextWriter -> format:Printf.TextWriterFormat<'T> -> 'T
/// Print to a text writer, adding a newline
val fprintfn : textWriter:IO.TextWriter -> format:Printf.TextWriterFormat<'T> -> 'T
/// Formatted printing to stderr
val eprintf : format:Printf.TextWriterFormat<'T> -> 'T
/// Formatted printing to stderr, adding a newline
val eprintfn : format:Printf.TextWriterFormat<'T> -> 'T
/// Formatted printing to stdout
val printf : format:Printf.TextWriterFormat<'T> -> 'T
/// Formatted printing to stdout, adding a newline.
val printfn : format:Printf.TextWriterFormat<'T> -> 'T
/// Print to a string via an internal string buffer and return
/// the result as a string. Helper printers must return strings.
val sprintf : format:Printf.StringFormat<'T> -> 'T
/// bprintf, but call the given 'final' function to generate the result.
/// See kprintf.
val kbprintf : continutation:(unit -> 'Result) -> builder:Text.StringBuilder -> format:Printf.BuilderFormat<'T,'Result> -> 'T
/// fprintf, but call the given 'final' function to generate the result.
/// See kprintf.
val kfprintf : continutation:(unit -> 'Result) -> textWriter:IO.TextWriter -> format:Printf.TextWriterFormat<'T,'Result> -> 'T
/// 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.
val kprintf : continutation:(string -> 'Result) -> format:Printf.StringFormat<'T,'Result> -> 'T
/// sprintf, but call the given 'final' function to generate the result.
/// See kprintf.
val ksprintf : continutation:(string -> 'Result) -> format:Printf.StringFormat<'T,'Result> -> 'T
/// Print to a string buffer and raise an exception with the given
/// result. Helper printers must return strings.
val failwithf : format:Printf.StringFormat<'T,'Result> -> 'T
/// 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.
type BuilderFormat<'T, 'Result> = Format<'T,Text.StringBuilder,unit,'Result>
/// 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.
type StringFormat<'T, 'Result> = Format<'T,unit,string,'Result>
/// 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.
type TextWriterFormat<'T, 'Result> = Format<'T,IO.TextWriter,unit,'Result>
/// 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.
type BuilderFormat<'T> = Printf.BuilderFormat<'T,unit>
/// Represents a statically-analyzed format when formatting builds a string. The type parameter indicates the
/// arguments and return type of the format operation.
type StringFormat<'T> = Printf.StringFormat<'T,string>
/// 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.
type TextWriterFormat<'T> = Printf.TextWriterFormat<'T,unit>
namespace Microsoft.FSharp.Core
/// Type of a formatting expression.
type PrintfFormat<'Printer, 'State, 'Residue, 'Result, 'Tuple> =
inherit PrintfFormat<'Printer,'State,'Residue,'Result>
/// Construct a format string
new : value:string -> PrintfFormat<'Printer, 'State, 'Residue, 'Result, 'Tuple>
namespace Microsoft.FSharp.Core
/// Type of a formatting expression.
type PrintfFormat<'Printer, 'State, 'Residue, 'Result> =
/// Construct a format string
new : value:string -> PrintfFormat<'Printer, 'State, 'Residue, 'Result>
/// The raw text of the format string.
member Value : string
namespace Microsoft.FSharp.Core
/// This attribute is added automatically for all optional arguments.
[<Sealed>]
type OptionalArgumentAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> OptionalArgumentAttribute
namespace Microsoft.FSharp.Core
/// The type of optional values. When used from other CLI languages the
/// empty option is the null value.
[<DefaultAugmentation(false)>]
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (8))>]
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpOption`1")>]
type Option<'T> =
/// The representation of "No value"
| None
/// The representation of "Value of type 'T"
| Some of Value: 'T
/// Return 'true' if the option is a 'None' value.
member IsNone : bool
/// Return 'true' if the option is a 'Some' value.
member IsSome : bool
/// Get the value of a 'Some' option. A NullReferenceException is raised if the option is 'None'.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (2))>]
member Value : 'T
/// Create an option value that is a 'None' value.
static member None : 'T option
/// Create an option value that is a 'Some' value.
static member Some : value:'T -> 'T option
/// Basic operations on options.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
module Microsoft.FSharp.Core.Option
/// Returns true if the option is not None.
val isSome : option:'T option -> bool
/// Returns true if the option is None.
val isNone : option:'T option -> bool
/// Gets the value associated with the option.
val get : option:'T option -> 'T
/// count inp evaluates to match inp with None -> 0 | Some _ -> 1.
val count : option:'T option -> int
/// fold f s inp evaluates to match inp with None -> s | Some x -> f s x.
val fold : folder:('State -> 'T -> 'State) -> state:'State -> option:'T option -> 'State
/// fold f inp s evaluates to match inp with None -> s | Some x -> f x s.
val foldBack : folder:('T -> 'State -> 'State) -> option:'T option -> state:'State -> 'State
/// exists p inp evaluates to match inp with None -> false | Some x -> p x.
val exists : predicate:('T -> bool) -> option:'T option -> bool
/// forall p inp evaluates to match inp with None -> true | Some x -> p x.
val forall : predicate:('T -> bool) -> option:'T option -> bool
/// iter f inp executes match inp with None -> () | Some x -> f x.
val iter : action:('T -> unit) -> option:'T option -> unit
/// map f inp evaluates to match inp with None -> None | Some x -> Some (f x).
val map : mapping:('T -> 'U) -> option:'T option -> 'U option
/// bind f inp evaluates to match inp with None -> None | Some x -> f x
val bind : binder:('T -> 'U option) -> option:'T option -> 'U option
/// Convert the option to an array of length 0 or 1.
val toArray : option:'T option -> 'T []
/// Convert the option to a list of length 0 or 1.
val toList : option:'T option -> 'T list
/// An implementation module used to hold some private implementations of function
/// value invocation.
module Microsoft.FSharp.Core.OptimizedClosures
/// The CLI 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 CLI languages.
[<AbstractClass>]
type FSharpFunc<'T1, 'T2, 'U> =
inherit Microsoft.FSharp.Core.FSharpFunc<'T1,('T2 -> 'U)>
/// Construct an optimized function value that can accept two curried
/// arguments without intervening execution.
new : unit -> FSharpFunc<'T1, 'T2, 'U>
/// Invoke the optimized function value with two curried arguments
abstract member Invoke : arg1:'T1 * arg2:'T2 -> 'U
/// Adapt an F# first class function value to be an optimized function value that can
/// accept two curried arguments without intervening execution.
static member Adapt : func:('T1 -> 'T2 -> 'U) -> OptimizedClosures.FSharpFunc<'T1,'T2,'U>
/// The CLI 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 CLI languages.
[<AbstractClass>]
type FSharpFunc<'T1, 'T2, 'T3, 'U> =
inherit Microsoft.FSharp.Core.FSharpFunc<'T1,('T2 -> 'T3 -> 'U)>
/// Construct an optimized function value that can accept three curried
/// arguments without intervening execution.
new : unit -> FSharpFunc<'T1, 'T2, 'T3, 'U>
/// Invoke an F# first class function value that accepts three curried arguments
/// without intervening execution
abstract member Invoke : arg1:'T1 * arg2:'T2 * arg3:'T3 -> 'U
/// Adapt an F# first class function value to be an optimized function value that can
/// accept three curried arguments without intervening execution.
static member Adapt : func:('T1 -> 'T2 -> 'T3 -> 'U) -> OptimizedClosures.FSharpFunc<'T1,'T2,'T3,'U>
/// The CLI type used to represent F# function values that accept four curried arguments
/// without intervening execution. This type should not typically used directly from
/// either F# code or from other CLI languages.
[<AbstractClass>]
type FSharpFunc<'T1, 'T2, 'T3, 'T4, 'U> =
inherit Microsoft.FSharp.Core.FSharpFunc<'T1,('T2 -> 'T3 -> 'T4 -> 'U)>
/// Construct an optimized function value that can accept four curried
/// arguments without intervening execution.
new : unit -> FSharpFunc<'T1, 'T2, 'T3, 'T4, 'U>
/// Invoke an F# first class function value that accepts four curried arguments
/// without intervening execution
abstract member Invoke : arg1:'T1 * arg2:'T2 * arg3:'T3 * arg4:'T4 -> 'U
/// Adapt an F# first class function value to be an optimized function value that can
/// accept four curried arguments without intervening execution.
static member Adapt : func:('T1 -> 'T2 -> 'T3 -> 'T4 -> 'U) -> OptimizedClosures.FSharpFunc<'T1,'T2,'T3,'T4,'U>
/// The CLI type used to represent F# function values that accept five curried arguments
/// without intervening execution. This type should not typically used directly from
/// either F# code or from other CLI languages.
[<AbstractClass>]
type FSharpFunc<'T1, 'T2, 'T3, 'T4, 'T5, 'U> =
inherit Microsoft.FSharp.Core.FSharpFunc<'T1,('T2 -> 'T3 -> 'T4 -> 'T5 -> 'U)>
/// Construct an optimized function value that can accept five curried
/// arguments without intervening execution.
new : unit -> FSharpFunc<'T1, 'T2, 'T3, 'T4, 'T5, 'U>
/// Invoke an F# first class function value that accepts five curried arguments
/// without intervening execution
abstract member Invoke : arg1:'T1 * arg2:'T2 * arg3:'T3 * arg4:'T4 * arg5:'T5 -> 'U
/// Adapt an F# first class function value to be an optimized function value that can
/// accept five curried arguments without intervening execution.
static member Adapt : func:('T1 -> 'T2 -> 'T3 -> 'T4 -> 'T5 -> 'U) -> OptimizedClosures.FSharpFunc<'T1,'T2,'T3,'T4,'T5,'U>
/// Basic F# Operators. This module is automatically opened in all F# code.
[<AutoOpen>]
module Microsoft.FSharp.Core.Operators
/// Overloaded unary negation.
val inline ( ~- ) : n: ^T -> ^T when ^T : (static member ( ~- ) : unit -> ^T)
/// Overloaded addition operator
val inline ( + ) : x: ^T1 -> y: ^T2 -> ^T3 when ^T1 : (static member ( + ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( + ) : ^T1 * ^T2 -> ^T3)
/// Overloaded subtraction operator
val inline ( - ) : x: ^T1 -> y: ^T2 -> ^T3 when ^T1 : (static member ( - ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( - ) : ^T1 * ^T2 -> ^T3)
/// Overloaded multiplication operator
val inline ( * ) : x: ^T1 -> y: ^T2 -> ^T3 when ^T1 : (static member ( * ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( * ) : ^T1 * ^T2 -> ^T3)
/// Overloaded division operator
val inline ( / ) : x: ^T1 -> y: ^T2 -> ^T3 when ^T1 : (static member ( / ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( / ) : ^T1 * ^T2 -> ^T3)
/// Overloaded modulo operator
val inline ( % ) : x: ^T1 -> y: ^T2 -> ^T3 when ^T1 : (static member ( % ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( % ) : ^T1 * ^T2 -> ^T3)
/// Overloaded logical-AND operator
val inline ( &&& ) : x: ^T -> y: ^T -> ^T when ^T : (static member ( &&& ) : ^T * ^T -> ^T)
/// Overloaded logical-OR operator
val inline ( ||| ) : x: ^T -> y: ^T -> ^T when ^T : (static member ( ||| ) : ^T * ^T -> ^T)
/// Overloaded logical-XOR operator
val inline ( ^^^ ) : x: ^T -> y: ^T -> ^T when ^T : (static member ( ^^^ ) : ^T * ^T -> ^T)
/// Overloaded byte-shift left operator by a specified number of bits
val inline ( <<< ) : value: ^T -> shift:int32 -> ^T when ^T : (static member ( <<< ) : ^T * int32 -> ^T)
/// Overloaded byte-shift right operator by a specified number of bits
val inline ( >>> ) : value: ^T -> shift:int32 -> ^T when ^T : (static member ( >>> ) : ^T * int32 -> ^T)
/// Overloaded logical-NOT operator
val inline ( ~~~ ) : value: ^T -> ^T when ^T : (static member ( ~~~ ) : unit -> ^T)
/// Overloaded prefix=plus operator
val inline ( ~+ ) : value: ^T -> ^T when ^T : (static member ( ~+ ) : unit -> ^T)
/// Structural less-than comparison
val inline ( < ) : x:'T -> y:'T -> bool when 'T : comparison
/// Structural greater-than
val inline ( > ) : x:'T -> y:'T -> bool when 'T : comparison
/// Structural greater-than-or-equal
val inline ( >= ) : x:'T -> y:'T -> bool when 'T : comparison
/// Structural less-than-or-equal comparison
val inline ( <= ) : x:'T -> y:'T -> bool when 'T : comparison
/// Structural equality
val inline ( = ) : x:'T -> y:'T -> bool when 'T : equality
/// Structural inequality
val inline ( <> ) : x:'T -> y:'T -> bool when 'T : equality
/// Compose two functions, the function on the left being applied first
val inline ( >> ) : func1:('T1 -> 'T2) -> func2:('T2 -> 'T3) -> 'T1 -> 'T3
/// Compose two functions, the function on the right being applied first
val inline ( << ) : func2:('T2 -> 'T3) -> func1:('T1 -> 'T2) -> 'T1 -> 'T3
/// Apply a function to a value, the value being on the left, the function on the right
val inline ( |> ) : arg:'T1 -> func:('T1 -> 'U) -> 'U
/// Apply a function to two values, the values being a pair on the left, the function on the right
val inline ( ||> ) : arg1:'T1 * arg2:'T2 -> func:('T1 -> 'T2 -> 'U) -> 'U
/// Apply a function to three values, the values being a triple on the left, the function on the right
val inline ( |||> ) : arg1:'T1 * arg2:'T2 * arg3:'T3 -> func:('T1 -> 'T2 -> 'T3 -> 'U) -> 'U
/// Apply a function to a value, the value being on the right, the function on the left
val inline ( <| ) : func:('T -> 'U) -> arg1:'T -> 'U
/// Apply a function to two values, the values being a pair on the right, the function on the left
val inline ( <|| ) : func:('T1 -> 'T2 -> 'U) -> arg1:'T1 * arg2:'T2 -> 'U
/// Apply a function to three values, the values being a triple on the right, the function on the left
val inline ( <||| ) : func:('T1 -> 'T2 -> 'T3 -> 'U) -> arg1:'T1 * arg2:'T2 * arg3:'T3 -> 'U
/// Used to specify a default value for an optional argument in the implementation of a function
val defaultArg : arg:'T option -> defaultValue:'T -> 'T
/// Concatenate two strings. The operator '+' may also be used.
val ( ^ ) : s1:string -> s2:string -> string
/// Raises an exception
val raise : exn:Exception -> 'T
/// Rethrows an exception. This should only be used when handling an exception
val inline rethrow : unit -> 'T
/// Rethrows an exception. This should only be used when handling an exception
val inline reraise : unit -> 'T
/// Builds a System.Exception object.
val Failure : message:string -> exn
/// Matches System.Exception objects whose runtime type is precisely System.Exception
val (|Failure|_|) : error:exn -> string option
/// Return the first element of a tuple, fst (a,b) = a.
val fst : tuple:('T1 * 'T2) -> 'T1
/// Return the second element of a tuple, snd (a,b) = b.
val snd : tuple:('T1 * 'T2) -> 'T2
/// Generic comparison.
val inline compare : e1:'T -> e2:'T -> int when 'T : comparison
/// Maximum based on generic comparison
val inline max : e1:'T -> e2:'T -> 'T when 'T : comparison
/// Minimum based on generic comparison
val inline min : e1:'T -> e2:'T -> 'T when 'T : comparison
/// Ignore the passed value. This is often used to throw away results of a computation.
val inline ignore : value:'T -> unit
/// Unboxes a strongly typed value. This is the inverse of box, unbox<t>(box<t> a) equals a.
val inline unbox : value:obj -> 'T
/// Boxes a strongly typed value.
val inline box : value:'T -> obj
/// Throw a System.Exception exception.
val failwith : message:string -> 'T
/// Throw a System.ArgumentException exception with
/// the given argument name and message.
val inline invalidArg : argumentName:string -> message:string -> 'T
/// Throw a System.ArgumentNullException exception
val inline nullArg : argumentName:string -> 'T
/// Throw a System.InvalidOperationException exception
val inline invalidOp : message:string -> 'T
/// The identity function
val id : x:'T -> 'T
/// Create a mutable reference cell
val ref : value:'T -> 'T ref
/// Assign to a mutable reference cell
val ( := ) : cell:'T ref -> value:'T -> unit
/// Dereference a mutable reference cell
val ( ! ) : cell:'T ref -> 'T
/// Decrement a mutable reference cell containing an integer
val decr : cell:int ref -> unit
/// Increment a mutable reference cell containing an integer
val incr : cell:int ref -> unit
/// Concatenate two lists.
val ( @ ) : list1:'T list -> list2:'T list -> 'T list
/// Negate a logical value. not true equals false and not false equals true
val inline not : value:bool -> bool
/// Builds a sequence using sequence expression syntax
val seq : sequence:seq<'T> -> seq<'T>
/// Exit the current hardware isolated process, if security settings permit,
/// otherwise raise an exception. Calls System.Environment.Exit.
val exit : exitcode:int -> 'T
/// Equivalent to System.Double.PositiveInfinity
val infinity : float
/// Equivalent to System.Double.NaN
val nan : float
/// Equivalent to System.Single.PositiveInfinity
val infinityf : float32
/// Equivalent to System.Single.NaN
val nanf : float32
/// Reads the value of the property System.Console.In.
val stdin : IO.TextReader
/// Reads the value of the property System.Console.Error.
val stderr : IO.TextWriter
/// Reads the value of the property System.Console.Out.
val stdout : IO.TextWriter
/// The standard overloaded range operator, e.g. [n..m] for lists, seq {n..m} for sequences
val inline ( .. ) : start: ^T -> finish: ^T -> seq< ^T> when ^T : (static member ( + ) : ^T * ^T -> ^T) and ^T : (static member One : ^T) and ^T : comparison
/// The standard overloaded skip range operator, e.g. [n..skip..m] for lists, seq {n..skip..m} for sequences
val inline ( .. .. ) : start: ^T -> step: ^Step -> finish: ^T -> seq< ^T> when ^T : (static member ( + ) : ^T * ^Step -> ^T) and ^T : comparison and ^Step : (static member ( + ) : ^T * ^Step -> ^T) and ^Step : (static member Zero : ^Step)
/// Execute the function as a mutual-exclusion region using the input value as a lock.
val inline lock : lockObject:'Lock -> action:(unit -> 'T) -> 'T when 'Lock : not struct
/// 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.
val using : resource:'T -> action:('T -> 'U) -> 'U when 'T :> IDisposable
/// Generate a System.Type runtime representation of a static type.
/// The static type is still maintained on the value returned.
val typeof : Type
/// 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.
val typedefof : Type
/// Returns the internal size of a type in bytes. For example, sizeof<int> returns 4.
val sizeof : int
/// 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.
val inline hash : obj:'T -> int when 'T : equality
/// 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.
val inline limitedHash : limit:int -> obj:'T -> int when 'T : equality
/// Absolute value of the given number.
val inline abs : value: ^T -> ^T when ^T : (static member Abs : unit -> ^T)
/// Inverse cosine of the given number
val inline acos : value: ^T -> ^T when ^T : (static member Acos : unit -> ^T)
/// Inverse sine of the given number
val inline asin : value: ^T -> ^T when ^T : (static member Asin : unit -> ^T)
/// Inverse tangent of the given number
val inline atan : value: ^T -> ^T when ^T : (static member Atan : unit -> ^T)
/// Inverse tangent of x/y where x and y are specified separately
val inline atan2 : y: ^T1 -> x: ^T1 -> 'T2 when ^T1 : (static member Atan2 : ^T1 * ^T1 -> 'T2)
/// Ceiling of the given number
val inline ceil : value: ^T -> ^T when ^T : (static member Ceiling : unit -> ^T)
/// Exponential of the given number
val inline exp : value: ^T -> ^T when ^T : (static member Exp : unit -> ^T)
/// Floor of the given number
val inline floor : value: ^T -> ^T when ^T : (static member Floor : unit -> ^T)
/// Sign of the given number
val inline sign : value: ^T -> int when ^T : (member Sign : int)
/// Round the given number
val inline round : value: ^T -> ^T when ^T : (static member Round : unit -> ^T)
/// Natural logarithm of the given number
val inline log : value: ^T -> ^T when ^T : (static member Log : unit -> ^T)
/// Logarithm to base 10 of the given number
val inline log10 : value: ^T -> ^T when ^T : (static member Log10 : unit -> ^T)
/// Square root of the given number
val inline sqrt : value: ^T -> ^U when ^T : (static member Sqrt : unit -> ^U)
/// Cosine of the given number
val inline cos : value: ^T -> ^T when ^T : (static member Cos : unit -> ^T)
/// Hyperbolic cosine of the given number
val inline cosh : value: ^T -> ^T when ^T : (static member Cosh : unit -> ^T)
/// Sine of the given number
val inline sin : value: ^T -> ^T when ^T : (static member Sin : unit -> ^T)
/// Hyperbolic sine of the given number
val inline sinh : value: ^T -> ^T when ^T : (static member Sinh : unit -> ^T)
/// Tangent of the given number
val inline tan : value: ^T -> ^T when ^T : (static member Tan : unit -> ^T)
/// Hyperbolic tangent of the given number
val inline tanh : value: ^T -> ^T when ^T : (static member Tanh : unit -> ^T)
/// Overloaded truncate operator.
val inline truncate : value: ^T -> ^T when ^T : (static member Truncate : unit -> ^T)
/// Overloaded power operator.
val inline ( ** ) : x: ^T -> y: ^U -> ^T when ^T : (static member Pow : ^T * ^U -> ^T)
/// Overloaded power operator. If n > 0 then equivalent to x*...*x for n occurrences of x.
val inline pown : x: ^T -> n:int -> ^T when ^T : (static member One : ^T) and ^T : (static member ( * ) : ^T * ^T -> ^T) and ^T : (static member ( / ) : ^T * ^T -> ^T)
/// Converts the argument to byte. This is a direct conversion for all
/// primitive numeric types. For strings, the input is converted using Byte.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline byte : value: ^T -> byte when ^T : (static member op_Explicit : unit -> byte)
/// 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 an appropriate
/// static conversion method on the input type.
val inline sbyte : value: ^T -> sbyte when ^T : (static member op_Explicit : unit -> sbyte)
/// 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 an appropriate
/// static conversion method on the input type.
val inline int16 : value: ^T -> int16 when ^T : (static member op_Explicit : unit -> int16)
/// 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 an appropriate
/// static conversion method on the input type.
val inline uint16 : value: ^T -> uint16 when ^T : (static member op_Explicit : unit -> uint16)
/// 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 an appropriate
/// static conversion method on the input type.
val inline int : value: ^T -> int when ^T : (static member op_Explicit : unit -> int)
/// Converts the argument to a particular enum type.
val inline enum : value:int32 -> ^U when 'U : enum<int32>
/// 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 an appropriate
/// static conversion method on the input type.
val inline int32 : value: ^T -> int32 when ^T : (static member op_Explicit : unit -> int32)
/// 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 an appropriate
/// static conversion method on the input type.
val inline uint32 : value: ^T -> uint32 when ^T : (static member op_Explicit : unit -> uint32)
/// 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 an appropriate
/// static conversion method on the input type.
val inline int64 : value: ^T -> int64 when ^T : (static member op_Explicit : unit -> int64)
/// 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 an appropriate
/// static conversion method on the input type.
val inline uint64 : value: ^T -> uint64 when ^T : (static member op_Explicit : unit -> uint64)
/// 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 an appropriate
/// static conversion method on the input type.
val inline float32 : value: ^T -> float32 when ^T : (static member op_Explicit : unit -> float32)
/// 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 an appropriate
/// static conversion method on the input type.
val inline float : value: ^T -> float when ^T : (static member op_Explicit : unit -> float)
/// Converts the argument to signed native integer. This is a direct conversion for all
/// primitive numeric types. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline nativeint : value: ^T -> nativeint when ^T : (static member op_Explicit : unit -> nativeint)
/// Converts the argument to unsigned native integer using a direct conversion for all
/// primitive numeric types. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline unativeint : value: ^T -> unativeint when ^T : (static member op_Explicit : unit -> unativeint)
/// Converts the argument to a string using ToString.
val inline string : value: ^T -> string
/// Converts the argument to System.Decimal using a direct conversion for all
/// primitive numeric types. For strings, the input is converted using UInt64.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline decimal : value: ^T -> decimal when ^T : (static member op_Explicit : unit -> decimal)
/// 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
/// input types the operation requires an appropriate static conversion method on the input type.
val inline char : value: ^T -> char when ^T : (static member op_Explicit : unit -> char)
/// An active pattern to match values of type System.Collections.Generic.KeyValuePair
val (|KeyValue|) : keyValuePair:Collections.Generic.KeyValuePair<'Key,'Value> -> 'Key * 'Value
/// A module of compiler intrinsic functions for efficient implementations of F# integer ranges
/// and dynamic invocations of other F# operators
module OperatorIntrinsics =
/// Gets a slice of an array
val inline GetArraySlice : source:'T [] -> start:int option -> finish:int option -> 'T []
/// Sets a slice of an array
val inline SetArraySlice : target:'T [] -> start:int option -> finish:int option -> source:'T [] -> unit
/// Gets a slice of an array
val GetArraySlice2D : source:'T [,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> 'T [,]
/// Sets a slice of an array
val SetArraySlice2D : target:'T [,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> source:'T [,] -> unit
/// Gets a slice of an array
val GetArraySlice3D : source:'T [,,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> start3:int option -> finish3:int option -> 'T [,,]
/// Sets a slice of an array
val SetArraySlice3D : target:'T [,,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> start3:int option -> finish3:int option -> source:'T [,,] -> unit
/// Gets a slice of an array
val GetArraySlice4D : source:'T [,,,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> start3:int option -> finish3:int option -> start4:int option -> finish4:int option -> 'T [,,,]
/// Sets a slice of an array
val SetArraySlice4D : target:'T [,,,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> start3:int option -> finish3:int option -> start4:int option -> finish4:int option -> source:'T [,,,] -> unit
/// Gets a slice from a string
val inline GetStringSlice : source:string -> start:int option -> finish:int option -> string
/// Generate a range of integers
val RangeInt32 : start:int -> step:int -> stop:int -> seq<int>
/// Generate a range of float values
val RangeDouble : start:float -> step:float -> stop:float -> seq<float>
/// Generate a range of float32 values
val RangeSingle : start:float32 -> step:float32 -> stop:float32 -> seq<float32>
/// Generate a range of int64 values
val RangeInt64 : start:int64 -> step:int64 -> stop:int64 -> seq<int64>
/// Generate a range of uint64 values
val RangeUInt64 : start:uint64 -> step:uint64 -> stop:uint64 -> seq<uint64>
/// Generate a range of uint32 values
val RangeUInt32 : start:uint32 -> step:uint32 -> stop:uint32 -> seq<uint32>
/// Generate a range of nativeint values
val RangeIntPtr : start:nativeint -> step:nativeint -> stop:nativeint -> seq<nativeint>
/// Generate a range of unativeint values
val RangeUIntPtr : start:unativeint -> step:unativeint -> stop:unativeint -> seq<unativeint>
/// Generate a range of int16 values
val RangeInt16 : start:int16 -> step:int16 -> stop:int16 -> seq<int16>
/// Generate a range of uint16 values
val RangeUInt16 : start:uint16 -> step:uint16 -> stop:uint16 -> seq<uint16>
/// Generate a range of sbyte values
val RangeSByte : start:sbyte -> step:sbyte -> stop:sbyte -> seq<sbyte>
/// Generate a range of byte values
val RangeByte : start:byte -> step:byte -> stop:byte -> seq<byte>
/// Generate a range of char values
val RangeChar : start:char -> stop:char -> seq<char>
/// Generate a range of values using the given zero, add, start, step and stop values
val RangeGeneric : one:'T -> add:('T -> 'T -> 'T) -> start:'T -> stop:'T -> seq<'T>
/// Generate a range of values using the given zero, add, start, step and stop values
val RangeStepGeneric : zero:'Step -> add:('T -> 'Step -> 'T) -> start:'T -> step:'Step -> stop:'T -> seq<'T>
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val AbsDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val AcosDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val AsinDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val AtanDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val Atan2Dynamic : y:'T1 -> x:'T1 -> 'T2
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val CeilingDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val ExpDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val FloorDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val TruncateDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val RoundDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val SignDynamic : 'T -> int
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val LogDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val Log10Dynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val SqrtDynamic : 'T1 -> 'T2
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val CosDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val CoshDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val SinDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val SinhDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val TanDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val TanhDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val PowDynamic : x:'T -> y:'U -> 'T
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'byte'
val PowByte : x:byte -> n:int -> byte
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'sbyte'
val PowSByte : x:sbyte -> n:int -> sbyte
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'int16'
val PowInt16 : x:int16 -> n:int -> int16
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'uint16'
val PowUInt16 : x:uint16 -> n:int -> uint16
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'int32'
val PowInt32 : x:int32 -> n:int -> int32
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'uint32'
val PowUInt32 : x:uint32 -> n:int -> uint32
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'int64'
val PowInt64 : x:int64 -> n:int -> int64
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'uint64'
val PowUInt64 : x:uint64 -> n:int -> uint64
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'nativeint'
val PowIntPtr : x:nativeint -> n:int -> nativeint
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'unativeint'
val PowUIntPtr : x:unativeint -> n:int -> unativeint
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'float32'
val PowSingle : x:float32 -> n:int -> float32
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'float'
val PowDouble : x:float -> n:int -> float
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'decimal'
val PowDecimal : x:decimal -> n:int -> decimal
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator
val PowGeneric : one:'T * mul:('T -> 'T -> 'T) * value:'T * exponent:int -> 'T
/// This module contains basic operations which do not apply runtime and/or static checks
module Unchecked =
/// Unboxes a strongly typed value. This is the inverse of box, unbox<t>(box<t> a) equals a.
val inline unbox : obj -> 'T
/// Generate a default 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.
val defaultof : 'T
/// Perform generic comparison on two values where the type of the values is not
/// statically required to have the 'comparison' constraint.
val inline compare : 'T -> 'T -> int
/// Perform generic equality on two values where the type of the values is not
/// statically required to satisfy the 'equality' constraint.
val inline equals : 'T -> 'T -> bool
/// Perform generic hashing on a value where the type of the value is not
/// statically required to satisfy the 'equality' constraint.
val inline hash : 'T -> int
/// This module contains the basic arithmetic operations with overflow checks.
module Checked =
/// Overloaded unary negation (checks for overflow)
val inline ( ~- ) : value: ^T -> ^T when ^T : (static member ( ~- ) : unit -> ^T)
/// Overloaded subtraction operator (checks for overflow)
val inline ( - ) : x: ^T1 -> y: ^T2 -> ^T3 when ^T1 : (static member ( - ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( - ) : ^T1 * ^T2 -> ^T3)
/// Overloaded addition operator (checks for overflow)
val inline ( + ) : x: ^T1 -> y: ^T2 -> ^T3 when ^T1 : (static member ( + ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( + ) : ^T1 * ^T2 -> ^T3)
/// Overloaded multiplication operator (checks for overflow)
val inline ( * ) : x: ^T1 -> y: ^T2 -> ^T3 when ^T1 : (static member ( * ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( * ) : ^T1 * ^T2 -> ^T3)
/// Converts the argument to byte. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.Byte.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline byte : value: ^T -> byte when ^T : (static member op_Explicit : unit -> byte)
/// Converts the argument to sbyte. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.SByte.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline sbyte : value: ^T -> sbyte when ^T : (static member op_Explicit : unit -> sbyte)
/// Converts the argument to int16. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.Int16.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline int16 : value: ^T -> int16 when ^T : (static member op_Explicit : unit -> int16)
/// Converts the argument to uint16. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.UInt16.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline uint16 : value: ^T -> uint16 when ^T : (static member op_Explicit : unit -> uint16)
/// Converts the argument to int. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.Int32.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline int : value: ^T -> int when ^T : (static member op_Explicit : unit -> int)
/// Converts the argument to int32. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.Int32.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline int32 : value: ^T -> int32 when ^T : (static member op_Explicit : unit -> int32)
/// Converts the argument to uint32. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.UInt32.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline uint32 : value: ^T -> uint32 when ^T : (static member op_Explicit : unit -> uint32)
/// Converts the argument to int64. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.Int64.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline int64 : value: ^T -> int64 when ^T : (static member op_Explicit : unit -> int64)
/// Converts the argument to uint64. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.UInt64.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline uint64 : value: ^T -> uint64 when ^T : (static member op_Explicit : unit -> uint64)
/// Converts the argument to nativeint. This is a direct, checked conversion for all
/// primitive numeric types. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline nativeint : value: ^T -> nativeint when ^T : (static member op_Explicit : unit -> nativeint)
/// Converts the argument to unativeint. This is a direct, checked conversion for all
/// primitive numeric types. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline unativeint : value: ^T -> unativeint when ^T : (static member op_Explicit : unit -> unativeint)
/// Converts the argument to char. Numeric inputs are converted using a checked
/// conversion according to the UTF-16 encoding for characters. String inputs must
/// be exactly one character long. For other input types the operation requires an
/// appropriate static conversion method on the input type.
val inline char : value: ^T -> char when ^T : (static member op_Explicit : unit -> char)
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
[<AutoOpen>]
module Microsoft.FSharp.Core.NumericLiterals
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
module NumericLiteralI =
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
val FromZero : unit -> 'T
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
val FromOne : unit -> 'T
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
val FromInt32 : value:int32 -> 'T
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
val FromInt64 : value:int64 -> 'T
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
val FromString : text:string -> 'T
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
val FromInt64Dynamic : value:int64 -> obj
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
val FromStringDynamic : text:string -> obj
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type indicates it is a type where equality is an abnormal operation.
/// This means that the type does not satisfy the F# 'equality' constraint. Within the bounds of the
/// F# type system, this helps ensure that the F# generic equality function is not instantiated directly
/// at this type. The attribute and checking does not constrain the use of comparison with base or child
/// types of this type.
[<Sealed>]
type NoEqualityAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> NoEqualityAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type NoDynamicInvocationAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> NoDynamicInvocationAttribute
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type indicates it is a type where comparison is an abnormal operation.
/// This means that the type does not satisfy the F# 'comparison' constraint. Within the bounds of the
/// F# type system, this helps ensure that the F# generic comparison function is not instantiated directly
/// at this type. The attribute and checking does not constrain the use of comparison with base or child
/// types of this type.
[<Sealed>]
type NoComparisonAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> NoComparisonAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type MeasureAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> MeasureAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type MeasureAnnotatedAbbreviationAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> MeasureAnnotatedAbbreviationAttribute
namespace Microsoft.FSharp.Core
/// Non-exhaustive match failures will raise the MatchFailureException exception
exception MatchFailureException of string * int * int
namespace Microsoft.FSharp.Core
/// Adding this attribute to a value causes it to be compiled as a CLI constant literal.
[<Sealed>]
type LiteralAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> LiteralAttribute
/// Language primitives associated with the F# language
module Microsoft.FSharp.Core.LanguagePrimitives
/// Compare two values for equality using partial equivalence relation semantics ([nan] <> [nan])
val inline GenericEquality : e1:'T -> e2:'T -> bool when 'T : equality
/// Compare two values for equality using equivalence relation semantics ([nan] = [nan])
val inline GenericEqualityER : e1:'T -> e2:'T -> bool when 'T : equality
/// Compare two values for equality
val inline GenericEqualityWithComparer : comp:Collections.IEqualityComparer -> e1:'T -> e2:'T -> bool when 'T : equality
/// Compare two values
val inline GenericComparison : e1:'T -> e2:'T -> int when 'T : comparison
/// Compare two values. May be called as a recursive case from an implementation of System.IComparable to
/// ensure consistent NaN comparison semantics.
val inline GenericComparisonWithComparer : comp:Collections.IComparer -> e1:'T -> e2:'T -> int when 'T : comparison
/// Compare two values
val inline GenericLessThan : e1:'T -> e2:'T -> bool when 'T : comparison
/// Compare two values
val inline GenericGreaterThan : e1:'T -> e2:'T -> bool when 'T : comparison
/// Compare two values
val inline GenericLessOrEqual : e1:'T -> e2:'T -> bool when 'T : comparison
/// Compare two values
val inline GenericGreaterOrEqual : e1:'T -> e2:'T -> bool when 'T : comparison
/// Take the minimum of two values structurally according to the order given by GenericComparison
val inline GenericMinimum : e1:'T -> e2:'T -> 'T when 'T : comparison
/// Take the maximum of two values structurally according to the order given by GenericComparison
val inline GenericMaximum : e1:'T -> e2:'T -> 'T when 'T : comparison
/// Reference/physical equality.
/// True if the inputs are reference-equal, false otherwise.
val inline PhysicalEquality : e1:'T -> e2:'T -> bool when 'T : not struct
/// The physical hash. Hashes on the object identity, except for value types,
/// where we hash on the contents.
val inline PhysicalHash : obj:'T -> int when 'T : not struct
/// 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.
val GenericEqualityComparer : Collections.IEqualityComparer
/// 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. This equality comparer has equivalence
/// relation semantics ([nan] = [nan]).
val GenericEqualityERComparer : Collections.IEqualityComparer
/// A static F# comparer object
val GenericComparer : Collections.IComparer
/// Make an F# comparer object for the given type
val FastGenericComparer : Collections.Generic.IComparer<'T> when 'T : comparison
/// Make an F# hash/equality object for the given type
val FastGenericEqualityComparer : Collections.Generic.IEqualityComparer<'T> when 'T : equality
/// Make an F# hash/equality object for the given type using node-limited hashing when hashing F#
/// records, lists and union types.
val inline FastLimitedGenericEqualityComparer : limit:int -> Collections.Generic.IEqualityComparer<'T> when 'T : equality
/// 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.
val inline GenericHash : obj:'T -> int
/// Hash a value according to its structure. Use the given limit to restrict the hash when hashing F#
/// records, lists and union types.
val inline GenericLimitedHash : limit:int -> obj:'T -> int
/// Recursively hash a part of a value according to its structure.
val inline GenericHashWithComparer : comparer:Collections.IEqualityComparer -> obj:'T -> int
/// Build an enum value from an underlying value
val inline EnumOfValue : value:'T -> 'Enum when 'Enum : enum<'T>
/// Get the underlying value for an enum value
val inline EnumToValue : enum:'Enum -> 'T when 'Enum : enum<'T>
/// Creates a float value with units-of-measure
val inline FloatWithMeasure : float -> float<'Measure>
/// Creates a float32 value with units-of-measure
val inline Float32WithMeasure : float32 -> float32<'Measure>
/// Creates a decimal value with units-of-measure
val inline DecimalWithMeasure : decimal -> decimal<'Measure>
/// Creates an int32 value with units-of-measure
val inline Int32WithMeasure : int -> int<'Measure>
/// Creates an int64 value with units-of-measure
val inline Int64WithMeasure : int64 -> int64<'Measure>
/// Creates an int16 value with units-of-measure
val inline Int16WithMeasure : int16 -> int16<'Measure>
/// Creates an sbyte value with units-of-measure
val inline SByteWithMeasure : sbyte -> sbyte<'Measure>
/// Parse an int32 according to the rules used by the overloaded 'int32' conversion operator when applied to strings
val ParseInt32 : s:string -> int32
/// Parse an uint32 according to the rules used by the overloaded 'uint32' conversion operator when applied to strings
val ParseUInt32 : s:string -> uint32
/// Parse an int64 according to the rules used by the overloaded 'int64' conversion operator when applied to strings
val ParseInt64 : s:string -> int64
/// Parse an uint64 according to the rules used by the overloaded 'uint64' conversion operator when applied to strings
val ParseUInt64 : s:string -> uint64
/// Resolves to the zero value for any primitive numeric type or any type with a static member called 'Zero'.
val GenericZeroDynamic : unit -> 'T
/// Resolves to the value 'one' for any primitive numeric type or any type with a static member called 'One'.
val GenericOneDynamic : unit -> 'T
/// A compiler intrinsic that implements dynamic invocations to the '+' operator.
val AdditionDynamic : x:'T1 -> y:'T2 -> 'U
/// A compiler intrinsic that implements dynamic invocations to the checked '+' operator.
val CheckedAdditionDynamic : x:'T1 -> y:'T2 -> 'U
/// A compiler intrinsic that implements dynamic invocations to the '*' operator.
val MultiplyDynamic : x:'T1 -> y:'T2 -> 'U
/// A compiler intrinsic that implements dynamic invocations to the checked '*' operator.
val CheckedMultiplyDynamic : x:'T1 -> y:'T2 -> 'U
/// A compiler intrinsic that implements dynamic invocations for the DivideByInt primitive.
val DivideByIntDynamic : x:'T -> y:int -> 'T
/// Resolves to the zero value for any primitive numeric type or any type with a static member called 'Zero'
val GenericZero : ^T when ^T : (static member Zero : ^T)
/// Resolves to the value 'one' for any primitive numeric type or any type with a static member called 'One'
val GenericOne : ^T when ^T : (static member One : ^T)
/// Divides a value by an integer.
val inline DivideByInt : x: ^T -> y:int -> ^T when ^T : (static member DivideByInt : ^T * int -> ^T)
/// For internal use only
module ErrorStrings =
val InputSequenceEmptyString : string
val InputArrayEmptyString : string
val AddressOpNotFirstClassString : string
val NoNegateMinValueString : string
val InputMustBeNonNegativeString : string
/// The F# compiler emits calls to some of the functions in this module as part of the compiled form of some language constructs
module IntrinsicOperators =
/// Binary 'and'. When used as a binary operator the right hand value is evaluated only on demand.
val ( & ) : e1:bool -> e2:bool -> bool
/// Binary 'and'. When used as a binary operator the right hand value is evaluated only on demand
val ( && ) : e1:bool -> e2:bool -> bool
/// Binary 'or'. When used as a binary operator the right hand value is evaluated only on demand.
val ``or`` : e1:bool -> e2:bool -> bool
/// Binary 'or'. When used as a binary operator the right hand value is evaluated only on demand
val ( || ) : e1:bool -> e2:bool -> bool
/// Address-of. Uses of this value may result in the generation of unverifiable code.
val inline ( ~& ) : obj:'T -> byref<'T>
/// Address-of. Uses of this value may result in the generation of unverifiable code.
val inline ( ~&& ) : obj:'T -> nativeptr<'T> when 'T : unmanaged
/// The F# compiler emits calls to some of the functions in this module as part of the compiled form of some language constructs
module IntrinsicFunctions =
/// A compiler intrinsic that implements the ':?>' operator
val UnboxGeneric : source:obj -> 'T
/// A compiler intrinsic that implements the ':?>' operator
val inline UnboxFast : source:obj -> 'T
/// A compiler intrinsic that implements the ':?' operator
val TypeTestGeneric : source:obj -> bool
/// A compiler intrinsic that implements the ':?' operator
val inline TypeTestFast : source:obj -> bool
/// Primitive used by pattern match compilation
val inline GetString : source:string -> index:int -> char
/// This function implements calls to default constructors
/// acccessed by 'new' constraints.
val inline CreateInstance : unit -> 'T when 'T : (new : unit -> 'T)
/// This function implements parsing of decimal constants
val inline MakeDecimal : low:int -> medium:int -> high:int -> isNegative:bool -> scale:byte -> decimal
/// A compiler intrinsic for the efficient compilation of sequence expressions
val Dispose : resource:'T -> unit when 'T :> IDisposable
/// A compiler intrinsic for checking initialization soundness of recursive bindings
val FailInit : unit -> unit
/// A compiler intrinsic for checking initialization soundness of recursive static bindings
val FailStaticInit : unit -> unit
/// A compiler intrinsic for checking initialization soundness of recursive bindings
val CheckThis : 'T -> 'T when 'T : not struct
/// The standard overloaded associative (indexed) lookup operator
val inline GetArray : source:'T [] -> index:int -> 'T
/// The standard overloaded associative (2-indexed) lookup operator
val inline GetArray2D : source:'T [,] -> index1:int -> index2:int -> 'T
/// The standard overloaded associative (3-indexed) lookup operator
val inline GetArray3D : source:'T [,,] -> index1:int -> index2:int -> index3:int -> 'T
/// The standard overloaded associative (4-indexed) lookup operator
val inline GetArray4D : source:'T [,,,] -> index1:int -> index2:int -> index3:int -> index4:int -> 'T
/// The standard overloaded associative (indexed) mutation operator
val inline SetArray : target:'T [] -> index:int -> value:'T -> unit
/// The standard overloaded associative (2-indexed) mutation operator
val inline SetArray2D : target:'T [,] -> index1:int -> index2:int -> value:'T -> unit
/// The standard overloaded associative (3-indexed) mutation operator
val inline SetArray3D : target:'T [,,] -> index1:int -> index2:int -> index3:int -> value:'T -> unit
/// The standard overloaded associative (4-indexed) mutation operator
val inline SetArray4D : target:'T [,,,] -> index1:int -> index2:int -> index3:int -> index4:int -> value:'T -> unit
/// The F# compiler emits calls to some of the functions in this module as part of the compiled form of some language constructs
module HashCompare =
/// A primitive entry point used by the F# compiler for optimization purposes.
val PhysicalHashIntrinsic : input:'T -> int when 'T : not struct
/// A primitive entry point used by the F# compiler for optimization purposes.
val PhysicalEqualityIntrinsic : x:'T -> y:'T -> bool when 'T : not struct
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericHashIntrinsic : input:'T -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val LimitedGenericHashIntrinsic : limit:int -> input:'T -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericHashWithComparerIntrinsic : comp:Collections.IEqualityComparer -> input:'T -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericComparisonWithComparerIntrinsic : comp:Collections.IComparer -> x:'T -> y:'T -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericComparisonIntrinsic : x:'T -> y:'T -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericEqualityIntrinsic : x:'T -> y:'T -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericEqualityERIntrinsic : x:'T -> y:'T -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericEqualityWithComparerIntrinsic : comp:Collections.IEqualityComparer -> x:'T -> y:'T -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericLessThanIntrinsic : x:'T -> y:'T -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericGreaterThanIntrinsic : x:'T -> y:'T -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericGreaterOrEqualIntrinsic : x:'T -> y:'T -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericLessOrEqualIntrinsic : x:'T -> y:'T -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastHashTuple2 : comparer:Collections.IEqualityComparer -> tuple:('T1 * 'T2) -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastHashTuple3 : comparer:Collections.IEqualityComparer -> tuple:('T1 * 'T2 * 'T3) -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastHashTuple4 : comparer:Collections.IEqualityComparer -> tuple:('T1 * 'T2 * 'T3 * 'T4) -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastHashTuple5 : comparer:Collections.IEqualityComparer -> tuple:('T1 * 'T2 * 'T3 * 'T4 * 'T5) -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastEqualsTuple2 : comparer:Collections.IEqualityComparer -> tuple1:('T1 * 'T2) -> tuple2:('T1 * 'T2) -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastEqualsTuple3 : comparer:Collections.IEqualityComparer -> tuple1:('T1 * 'T2 * 'T3) -> tuple2:('T1 * 'T2 * 'T3) -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastEqualsTuple4 : comparer:Collections.IEqualityComparer -> tuple1:('T1 * 'T2 * 'T3 * 'T4) -> tuple2:('T1 * 'T2 * 'T3 * 'T4) -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastEqualsTuple5 : comparer:Collections.IEqualityComparer -> tuple1:('T1 * 'T2 * 'T3 * 'T4 * 'T5) -> tuple2:('T1 * 'T2 * 'T3 * 'T4 * 'T5) -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastCompareTuple2 : comparer:Collections.IComparer -> tuple1:('T1 * 'T2) -> tuple2:('T1 * 'T2) -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastCompareTuple3 : comparer:Collections.IComparer -> tuple1:('T1 * 'T2 * 'T3) -> tuple2:('T1 * 'T2 * 'T3) -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastCompareTuple4 : comparer:Collections.IComparer -> tuple1:('T1 * 'T2 * 'T3 * 'T4) -> tuple2:('T1 * 'T2 * 'T3 * 'T4) -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastCompareTuple5 : comparer:Collections.IComparer -> tuple1:('T1 * 'T2 * 'T3 * 'T4 * 'T5) -> tuple2:('T1 * 'T2 * 'T3 * 'T4 * 'T5) -> int
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type causes it to be represented using a CLI interface.
[<Sealed>]
type InterfaceAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> InterfaceAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type GeneralizableValueAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> GeneralizableValueAttribute
namespace Microsoft.FSharp.Core
/// Helper functions for converting F# first class function values to and from CLI representaions
/// of functions using delegates.
[<AbstractClass>]
[<Sealed>]
type FuncConvert =
/// A utility function to convert function values from tupled to curried form
static member FuncFromTupled : func:('T1 * 'T2 * 'T3 -> 'U) -> 'T1 -> 'T2 -> 'T3 -> 'U
/// A utility function to convert function values from tupled to curried form
static member FuncFromTupled : func:('T1 * 'T2 -> 'U) -> 'T1 -> 'T2 -> 'U
/// A utility function to convert function values from tupled to curried form
static member FuncFromTupled : func:('T1 * 'T2 * 'T3 * 'T4 * 'T5 -> 'U) -> 'T1 -> 'T2 -> 'T3 -> 'T4 -> 'T5 -> 'U
/// A utility function to convert function values from tupled to curried form
static member FuncFromTupled : func:('T1 * 'T2 * 'T3 * 'T4 -> 'U) -> 'T1 -> 'T2 -> 'T3 -> 'T4 -> 'U
/// Convert the given Action delegate object to an F# function value
static member ToFSharpFunc : action:Action<'T> -> 'T -> unit
/// Convert the given Converter delegate object to an F# function value
static member ToFSharpFunc : converter:Converter<'T,'U> -> 'T -> 'U
namespace Microsoft.FSharp.Core
/// Type of a formatting expression.
type Format<'Printer, 'State, 'Residue, 'Result, 'Tuple> = PrintfFormat<'Printer,'State,'Residue,'Result,'Tuple>
namespace Microsoft.FSharp.Core
/// Type of a formatting expression.
type Format<'Printer, 'State, 'Residue, 'Result> = PrintfFormat<'Printer,'State,'Residue,'Result>
namespace Microsoft.FSharp.Core
/// The CLI type used to represent F# first-class type function values. This type is for use
/// by compiled F# code.
[<AbstractClass>]
type FSharpTypeFunc =
/// Construct an instance of an F# first class type function value
new : unit -> FSharpTypeFunc
/// Specialize the type function at a given type
abstract member Specialize : unit -> obj
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type FSharpInterfaceDataVersionAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : major:int * minor:int * release:int -> FSharpInterfaceDataVersionAttribute
/// The major version number of the F# version associated with the attribute
member Major : int
/// The minor version number of the F# version associated with the attribute
member Minor : int
/// The release number of the F# version associated with the attribute
member Release : int
namespace Microsoft.FSharp.Core
/// The CLI type used to represent F# function values. This type is not
/// typically used directly, though may be used from other CLI languages.
[<AbstractClass>]
type FSharpFunc<'T, 'U> =
/// Construct an instance of an F# first class function value
new : unit -> FSharpFunc<'T, 'U>
/// Invoke an F# first class function value with one argument
abstract member Invoke : func:'T -> 'U
/// Convert an value of type System.Converter to a F# first class function value
static member FromConverter : converter:Converter<'T,'U> -> 'T -> 'U
/// 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.
static member InvokeFast : func:FSharpFunc<'T,('U -> 'V -> 'W -> 'X)> * arg1:'T * arg2:'U * arg3:'V * arg4:'W -> 'X
/// 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.
static member InvokeFast : func:FSharpFunc<'T,('U -> 'V -> 'W -> 'X -> 'Y)> * arg1:'T * arg2:'U * arg3:'V * arg4:'W * arg5:'X -> 'Y
/// 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.
static member InvokeFast : func:FSharpFunc<'T,('U -> 'V)> * arg1:'T * arg2:'U -> 'V
/// 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.
static member InvokeFast : func:FSharpFunc<'T,('U -> 'V -> 'W)> * arg1:'T * arg2:'U * arg3:'V -> 'W
/// Convert an value of type System.Converter to a F# first class function value
static member op_Implicit : converter:Converter<'T,'U> -> 'T -> 'U
/// Convert an F# first class function value to a value of type System.Converter
static member op_Implicit : func:('T -> 'U) -> Converter<'T,'U>
/// Convert an F# first class function value to a value of type System.Converter
static member ToConverter : func:('T -> 'U) -> Converter<'T,'U>
[<AutoOpen>]
module Microsoft.FSharp.Core.ExtraTopLevelOperators
/// Print to stdout using the given format.
val printf : format:Printf.TextWriterFormat<'T> -> 'T
/// Print to stdout using the given format, and add a newline.
val printfn : format:Printf.TextWriterFormat<'T> -> 'T
/// Print to stderr using the given format.
val eprintf : format:Printf.TextWriterFormat<'T> -> 'T
/// Print to stderr using the given format, and add a newline.
val eprintfn : format:Printf.TextWriterFormat<'T> -> 'T
/// Print to a string using the given format.
val sprintf : format:Printf.StringFormat<'T> -> 'T
/// Print to a string buffer and raise an exception with the given
/// result. Helper printers must return strings.
val failwithf : format:Printf.StringFormat<'T,'Result> -> 'T
/// Print to a file using the given format.
val fprintf : textWriter:IO.TextWriter -> format:Printf.TextWriterFormat<'T> -> 'T
/// Print to a file using the given format, and add a newline.
val fprintfn : textWriter:IO.TextWriter -> format:Printf.TextWriterFormat<'T> -> 'T
/// Builds a set from a sequence of objects. The objects are indexed using generic comparison.
val set : elements:seq<'T> -> Set<'T> when 'T : comparison
/// Builds an aysnchronous workflow using computation expression syntax.
val async : AsyncBuilder
/// Converts the argument to 32-bit float.
val inline single : value: ^T -> single when ^T : (static member op_Explicit : unit -> single)
/// Converts the argument to 64-bit float.
val inline double : value: ^T -> float when ^T : (static member op_Explicit : unit -> double)
/// Converts the argument to byte.
val inline uint8 : value: ^T -> byte when ^T : (static member op_Explicit : unit -> byte)
/// Converts the argument to signed byte.
val inline int8 : value: ^T -> sbyte when ^T : (static member op_Explicit : unit -> sbyte)
/// Builds a read-only lookup table from a sequence of key/value pairs. The key objects are indexed using generic hashing and equality.
val dict : keyValuePairs:seq<'Key * 'Value> -> Collections.Generic.IDictionary<'Key,'Value> when 'Key : equality
/// Builds a 2D array from a sequence of sequences of elements.
val array2D : rows:seq<'T3196> -> 'T [,] when 'T3196 :> seq<'T>
/// Special prefix operator for splicing typed expressions into quotation holes.
val ( ~% ) : expression:Quotations.Expr<'T> -> 'T
/// Special prefix operator for splicing untyped expressions into quotation holes.
val ( ~%% ) : expression:Quotations.Expr -> 'T
/// An active pattern to force the execution of values of type Lazy<_>.
val (|Lazy|) : input:Lazy<'T> -> 'T
/// Builds a query using query syntax and operators.
val query : Linq.QueryBuilder
namespace Microsoft.FSharp.Core
/// This attribute is used to tag values that are part of an experimental library
/// feature.
[<Sealed>]
type ExperimentalAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : message:string -> ExperimentalAttribute
/// Indicates the warning message to be emitted when F# source code uses this construct
member Message : string
namespace Microsoft.FSharp.Core
/// This attribute is used to indicate a generic container type satisfies the F# 'equality'
/// constraint only if a generic argument also satisfies this constraint. For example, adding
/// this attribute to parameter 'T on a type definition C<'T> means that a type C<X> only supports
/// equality if the type X also supports equality and all other conditions for C<X> to support
/// equality are also met. The type C<'T> can still be used with other type arguments, but a type such
/// as C<(int -> int)> will not support equality because the type (int -> int) is an F# function type
/// and does not support equality.
[<Sealed>]
type EqualityConditionalOnAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> EqualityConditionalOnAttribute
namespace Microsoft.FSharp.Core
/// Adding this attribute to a function indicates it is the entrypoint for an application.
/// If this attribute is not specified for an EXE then the initialization implicit in the
/// module bindings in the last file in the compilation sequence are used as the entrypoint.
[<Sealed>]
type EntryPointAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> EntryPointAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type DefaultValueAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : check:bool -> DefaultValueAttribute
/// Creates an instance of the attribute
new : unit -> DefaultValueAttribute
/// Indicates if a constraint is asserted that the field type supports 'null'
member Check : bool
namespace Microsoft.FSharp.Core
/// 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 CLI class for that type.
[<Sealed>]
type DefaultAugmentationAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : value:bool -> DefaultAugmentationAttribute
/// The value of the attribute, indicating whether the type has a default augmentation or not
member Value : bool
namespace Microsoft.FSharp.Core
/// Indicates that a member on a computation builder type is a custom query operator,
/// and indicates the name of that operator.
[<Sealed>]
type CustomOperationAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : name:string -> CustomOperationAttribute
/// Indicates if the custom operation supports the use of 'into' immediately after the use of the operation in a query or other computation expression to consume the results of the operation
member AllowIntoPattern : bool with get, set
/// Indicates if the custom operation is an operation similar to a group join in a sequence computation, supporting two inputs and a correlation constraint, and generating a group
member IsLikeGroupJoin : bool with get, set
/// Indicates if the custom operation is an operation similar to a join in a sequence computation, supporting two inputs and a correlation constraint
member IsLikeJoin : bool with get, set
/// Indicates if the custom operation is an operation similar to a zip in a sequence computation, supporting two inputs
member IsLikeZip : bool with get, set
/// Indicates the name used for the 'on' part of the custom query operator for join-like operators
member JoinConditionWord : string with get, set
/// Indicates if the custom operation maintains the variable space of the query of computation expression
member MaintainsVariableSpace : bool with get, set
/// Indicates if the custom operation maintains the variable space of the query of computation expression through the use of a bind operation
member MaintainsVariableSpaceUsingBind : bool with get, set
/// Get the name of the custom operation when used in a query or other computation expression
member Name : string
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type indicates it is a type with a user-defined implementation of equality.
[<Sealed>]
type CustomEqualityAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> CustomEqualityAttribute
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type indicates it is a type with a user-defined implementation of comparison.
[<Sealed>]
type CustomComparisonAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> CustomComparisonAttribute
namespace Microsoft.FSharp.Core.CompilerServices
/// The TypeProviderXmlDocAttribute attribute can be added to types and members.
/// The language service will display the CommentText property from the attribute
/// in the appropriate place when the user hovers over a type or member.
type TypeProviderXmlDocAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : commentText:string -> TypeProviderXmlDocAttribute
member CommentText : string
namespace Microsoft.FSharp.Core.CompilerServices
/// Additional type attribute flags related to provided types
type TypeProviderTypeAttributes =
| SuppressRelocate = -2147483648
| IsErased = 1073741824
namespace Microsoft.FSharp.Core.CompilerServices
/// Indicates that a code editor should hide all System.Object methods from the intellisense menus for instances of a provided type
type TypeProviderEditorHideMethodsAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> TypeProviderEditorHideMethodsAttribute
namespace Microsoft.FSharp.Core.CompilerServices
type TypeProviderDefinitionLocationAttribute =
inherit System.Attribute
new : unit -> TypeProviderDefinitionLocationAttribute
member Column : int with get, set
member FilePath : string with get, set
member Line : int with get, set
namespace Microsoft.FSharp.Core.CompilerServices
/// If the class that implements ITypeProvider has a constructor that accepts TypeProviderConfig
/// then it will be constructed with an instance of TypeProviderConfig.
type TypeProviderConfig =
new : systemRuntimeContainsType:(string -> bool) -> TypeProviderConfig
/// Indicates if the type provider instance is used in an environment which executes provided code such as F# Interactive.
member IsHostedExecution : bool with get, set
/// Indicates if the type provider host responds to invalidation events for type provider instances.
member IsInvalidationSupported : bool with get, set
/// Get the referenced assemblies for the type provider instance.
member ReferencedAssemblies : string [] with get, set
/// Get the full path to use to resolve relative paths in any file name arguments given to the type provider instance.
member ResolutionFolder : string with get, set
/// Get the full path to referenced assembly that caused this type provider instance to be created.
member RuntimeAssembly : string with get, set
/// version of referenced system runtime assembly
member SystemRuntimeAssemblyVersion : Version with get, set
/// Checks if given type exists in target system runtime library
member SystemRuntimeContainsType : string -> bool
/// Get the full path to use for temporary files for the type provider instance.
member TemporaryFolder : string with get, set
namespace Microsoft.FSharp.Core.CompilerServices
/// Place on a class that implements ITypeProvider to extend the compiler
type TypeProviderAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> TypeProviderAttribute
namespace Microsoft.FSharp.Core.CompilerServices
/// Place attribute on runtime assembly to indicate that there is a corresponding design-time
/// assembly that contains a type provider. Runtime and designer assembly may be the same.
type TypeProviderAssemblyAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : assemblyName:string -> TypeProviderAssemblyAttribute
/// Creates an instance of the attribute
new : unit -> TypeProviderAssemblyAttribute
member AssemblyName : string
/// A group of functions used as part of the compiled representation of F# sequence expressions.
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers
/// The F# compiler emits calls to this function to
/// implement the while operator for F# sequence expressions.
val EnumerateWhile : guard:(unit -> bool) -> source:seq<'T> -> seq<'T>
/// The F# compiler emits calls to this function to
/// implement the try/finally operator for F# sequence expressions.
val EnumerateThenFinally : source:seq<'T> -> compensation:(unit -> unit) -> seq<'T>
/// The F# compiler emits calls to this function to implement the compiler-intrinsic
/// conversions from untyped System.Collections.IEnumerable sequences to typed sequences.
val EnumerateFromFunctions : create:(unit -> 'T) -> moveNext:('T -> bool) -> current:('T -> 'U) -> seq<'U>
/// The F# compiler emits calls to this function to implement the use operator for F# sequence
/// expressions.
val EnumerateUsing : resource:'T -> source:('T -> 'Collection) -> seq<'U> when 'T :> IDisposable and 'Collection :> seq<'U>
/// Creates an anonymous event with the given handlers.
val CreateEvent : addHandler:('Delegate -> unit) -> removeHandler:('Delegate -> unit) -> createHandler:((obj -> 'Args -> unit) -> 'Delegate) -> IEvent<'Delegate,'Args> when 'Delegate : delegate<'Args, unit> and 'Delegate :> Delegate
namespace Microsoft.FSharp.Core.CompilerServices
/// Represents the product of two measure expressions when returned as a generic argument of a provided type.
[<Class>]
type MeasureProduct<'Measure1, 'Measure2> =
namespace Microsoft.FSharp.Core.CompilerServices
/// Represents the '1' measure expression when returned as a generic argument of a provided type.
[<Class>]
type MeasureOne =
namespace Microsoft.FSharp.Core.CompilerServices
/// Represents the inverse of a measure expressions when returned as a generic argument of a provided type.
[<Class>]
type MeasureInverse<'Measure> =
namespace Microsoft.FSharp.Core.CompilerServices
[<Interface>]
type ITypeProvider =
inherit System.IDisposable
/// Triggered when an assumption changes that invalidates the resolutions so far reported by the provider
[<CLIEvent>]
abstract member add_Invalidate : EventHandler -> unit
/// Apply static arguments to a provided type that accepts static arguments.
abstract member ApplyStaticArguments : typeWithoutArguments:Type * typePathWithArguments:string [] * staticArguments:obj [] -> Type
/// Get the physical contents of the given logical provided assembly.
abstract member GetGeneratedAssemblyContents : assembly:Reflection.Assembly -> byte []
/// Called by the compiler to ask for an Expression tree to replace the given MethodBase with.
abstract member GetInvokerExpression : syntheticMethodBase:Reflection.MethodBase * parameters:Quotations.Expr [] -> Quotations.Expr
/// Namespace name the this TypeProvider injects types into.
abstract member GetNamespaces : unit -> CompilerServices.IProvidedNamespace []
/// Get the static parameters for a provided type.
abstract member GetStaticParameters : typeWithoutArguments:Type -> Reflection.ParameterInfo []
/// Triggered when an assumption changes that invalidates the resolutions so far reported by the provider
[<CLIEvent>]
abstract member Invalidate : IEvent<EventHandler,EventArgs>
/// Triggered when an assumption changes that invalidates the resolutions so far reported by the provider
[<CLIEvent>]
abstract member remove_Invalidate : EventHandler -> unit
namespace Microsoft.FSharp.Core.CompilerServices
[<Interface>]
type IProvidedNamespace =
/// The sub-namespaces in this namespace. An optional member to prevent generation of namespaces until an outer namespace is explored.
abstract member GetNestedNamespaces : unit -> CompilerServices.IProvidedNamespace []
/// The top-level types
abstract member GetTypes : unit -> Type []
/// Namespace name the provider injects types into.
abstract member NamespaceName : string
/// Compilers call this method to query a type provider for a type name.
abstract member ResolveTypeName : typeName:string -> Type
namespace Microsoft.FSharp.Core.CompilerServices
/// The F# compiler emits implementations of this type for compiled sequence expressions.
[<AbstractClass>]
type GeneratedSequenceBase<'T> =
interface System.Collections.IEnumerable
interface System.Collections.Generic.IEnumerable<'T>
interface System.Collections.IEnumerator
interface System.Collections.Generic.IEnumerator<'T>
/// The F# compiler emits implementations of this type for compiled sequence expressions.
new : unit -> GeneratedSequenceBase<'T>
/// The F# compiler emits implementations of this type for compiled sequence expressions.
abstract member CheckClose : bool
/// The F# compiler emits implementations of this type for compiled sequence expressions.
abstract member Close : unit -> unit
/// The F# compiler emits implementations of this type for compiled sequence expressions.
abstract member GenerateNext : result:byref<Collections.Generic.IEnumerable<'T>> -> int
/// The F# compiler emits implementations of this type for compiled sequence expressions.
abstract member GetFreshEnumerator : unit -> Collections.Generic.IEnumerator<'T>
/// The F# compiler emits implementations of this type for compiled sequence expressions.
abstract member LastGenerated : 'T
namespace Microsoft.FSharp.Core
/// Indicates that a message should be emitted when F# source code uses this construct.
[<Sealed>]
type CompilerMessageAttribute =
inherit System.Attribute
/// Creates an instance of the attribute.
new : message:string * messageNumber:int -> CompilerMessageAttribute
/// Indicates if the message should indicate a compiler error. Error numbers less than
/// 10000 are considered reserved for use by the F# compiler and libraries.
member IsError : bool with get, set
/// Indicates if the construct should always be hidden in an editing environment.
member IsHidden : bool with get, set
/// Indicates the warning message to be emitted when F# source code uses this construct
member Message : string
/// Indicates the number associated with the message.
member MessageNumber : int
namespace Microsoft.FSharp.Core
/// Adding this attribute to a value or function definition in an F# module changes the name used
/// for the value in compiled CLI code.
[<Sealed>]
type CompiledNameAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : compiledName:string -> CompiledNameAttribute
/// The name of the value as it appears in compiled code
member CompiledName : string
namespace Microsoft.FSharp.Core
/// This attribute is inserted automatically by the F# compiler to tag
/// methods which are given the 'CompiledName' attribute. It is not intended
/// for use from user code.
[<Sealed>]
type CompilationSourceNameAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : sourceName:string -> CompilationSourceNameAttribute
/// Indicates the name of the entity in F# source code
member SourceName : string
namespace Microsoft.FSharp.Core
/// Indicates one or more adjustments to the compiled representation of an F# type or member.
[<Flags ()>]
type CompilationRepresentationFlags =
/// No special compilation representation.
| None = 0
/// Compile an instance member as 'static' .
| Static = 1
/// Compile a member as 'instance' even if null is used as a representation for this type.
| Instance = 2
/// append 'Module' to the end of a module whose name clashes with a type name in the same namespace.
| ModuleSuffix = 4
/// Permit the use of null as a representation for nullary discriminators in a discriminated union.
| UseNullAsTrueValue = 8
/// Compile a property as a CLI event.
| Event = 16
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type CompilationRepresentationAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : flags:CompilationRepresentationFlags -> CompilationRepresentationAttribute
/// Indicates one or more adjustments to the compiled representation of an F# type or member
member Flags : CompilationRepresentationFlags
namespace Microsoft.FSharp.Core
/// This attribute is inserted automatically by the F# compiler to tag types
/// and methods in the generated CLI code with flags indicating the correspondence
/// with original source constructs. It is used by the functions in the
/// Microsoft.FSharp.Reflection namespace to reverse-map compiled constructs to
/// their original forms. It is not intended for use from user code.
[<Sealed>]
type CompilationMappingAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : sourceConstructFlags:SourceConstructFlags * variantNumber:int * sequenceNumber:int -> CompilationMappingAttribute
/// Creates an instance of the attribute
new : sourceConstructFlags:SourceConstructFlags * sequenceNumber:int -> CompilationMappingAttribute
/// Creates an instance of the attribute
new : sourceConstructFlags:SourceConstructFlags -> CompilationMappingAttribute
/// Indicates the sequence number of the entity, if any, in a linear sequence of elements with F# source code
member SequenceNumber : int
/// Indicates the relationship between the compiled entity and F# source code
member SourceConstructFlags : SourceConstructFlags
/// Indicates the variant number of the entity, if any, in a linear sequence of elements with F# source code
member VariantNumber : int
namespace Microsoft.FSharp.Core
/// This attribute is generated automatically by the F# compiler to tag functions and members
/// that accept a partial application of some of their arguments and return a residual function
[<Sealed>]
type CompilationArgumentCountsAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : counts:int [] -> CompilationArgumentCountsAttribute
/// Indicates the number of arguments in each argument group
member Counts : Collections.Generic.IEnumerable<int>
namespace Microsoft.FSharp.Core
/// This attribute is used to indicate a generic container type satisfies the F# 'comparison'
/// constraint only if a generic argument also satisfies this constraint. For example, adding
/// this attribute to parameter 'T on a type definition C<'T> means that a type C<X> only supports
/// comparison if the type X also supports comparison and all other conditions for C<X> to support
/// comparison are also met. The type C<'T> can still be used with other type arguments, but a type such
/// as C<(int -> int)> will not support comparison because the type (int -> int) is an F# function type
/// and does not support comparison.
[<Sealed>]
type ComparisonConditionalOnAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> ComparisonConditionalOnAttribute
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type causes it to be represented using a CLI class.
[<Sealed>]
type ClassAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> ClassAttribute
namespace Microsoft.FSharp.Core
/// Helper types for active patterns with 7 choices.
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpChoice`7")>]
type Choice<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7> =
/// Choice 1 of 7 choices
| Choice1Of7 of 'T1
/// Choice 2 of 7 choices
| Choice2Of7 of 'T2
/// Choice 3 of 7 choices
| Choice3Of7 of 'T3
/// Choice 4 of 7 choices
| Choice4Of7 of 'T4
/// Choice 5 of 7 choices
| Choice5Of7 of 'T5
/// Choice 6 of 7 choices
| Choice6Of7 of 'T6
/// Choice 7 of 7 choices
| Choice7Of7 of 'T7
namespace Microsoft.FSharp.Core
/// Helper types for active patterns with 6 choices.
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpChoice`6")>]
type Choice<'T1, 'T2, 'T3, 'T4, 'T5, 'T6> =
/// Choice 1 of 6 choices
| Choice1Of6 of 'T1
/// Choice 2 of 6 choices
| Choice2Of6 of 'T2
/// Choice 3 of 6 choices
| Choice3Of6 of 'T3
/// Choice 4 of 6 choices
| Choice4Of6 of 'T4
/// Choice 5 of 6 choices
| Choice5Of6 of 'T5
/// Choice 6 of 6 choices
| Choice6Of6 of 'T6
namespace Microsoft.FSharp.Core
/// Helper types for active patterns with 5 choices.
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpChoice`5")>]
type Choice<'T1, 'T2, 'T3, 'T4, 'T5> =
/// Choice 1 of 5 choices
| Choice1Of5 of 'T1
/// Choice 2 of 5 choices
| Choice2Of5 of 'T2
/// Choice 3 of 5 choices
| Choice3Of5 of 'T3
/// Choice 4 of 5 choices
| Choice4Of5 of 'T4
/// Choice 5 of 5 choices
| Choice5Of5 of 'T5
namespace Microsoft.FSharp.Core
/// Helper types for active patterns with 4 choices.
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpChoice`4")>]
type Choice<'T1, 'T2, 'T3, 'T4> =
/// Choice 1 of 4 choices
| Choice1Of4 of 'T1
/// Choice 2 of 4 choices
| Choice2Of4 of 'T2
/// Choice 3 of 4 choices
| Choice3Of4 of 'T3
/// Choice 4 of 4 choices
| Choice4Of4 of 'T4
namespace Microsoft.FSharp.Core
/// Helper types for active patterns with 3 choices.
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpChoice`3")>]
type Choice<'T1, 'T2, 'T3> =
/// Choice 1 of 3 choices
| Choice1Of3 of 'T1
/// Choice 2 of 3 choices
| Choice2Of3 of 'T2
/// Choice 3 of 3 choices
| Choice3Of3 of 'T3
namespace Microsoft.FSharp.Core
/// Helper types for active patterns with 2 choices.
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpChoice`2")>]
type Choice<'T1, 'T2> =
/// Choice 1 of 2 choices
| Choice1Of2 of 'T1
/// Choice 2 of 2 choices
| Choice2Of2 of 'T2
namespace Microsoft.FSharp.Core
/// Adding this attribute to a record type causes it to be compiled to a CLI representation
/// with a default constructor with property getters and setters.
[<Sealed>]
type CLIMutableAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> CLIMutableAttribute
namespace Microsoft.FSharp.Core
/// Adding this attribute to a property with event type causes it to be compiled with as a CLI
/// metadata event, through a syntactic translation to a pair of 'add_EventName' and
/// 'remove_EventName' methods.
[<Sealed>]
type CLIEventAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> CLIEventAttribute
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type with value 'false' disables the behaviour where F# makes the
/// type Serializable by default.
[<Sealed>]
type AutoSerializableAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : value:bool -> AutoSerializableAttribute
/// The value of the attribute, indicating whether the type is automatically marked serializable or not
member Value : bool
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type AutoOpenAttribute =
inherit System.Attribute
/// Creates an attribute used to mark a namespace or module path to be 'automatically opened' when an assembly is referenced
new : path:string -> AutoOpenAttribute
/// Creates an attribute used to mark a module as 'automatically opened' when the enclosing namespace is opened
new : unit -> AutoOpenAttribute
/// Indicates the namespace or module to be automatically opened when an assembly is referenced
/// or an enclosing module opened.
member Path : string
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type lets the 'null' literal be used for the type
/// within F# code. This attribute may only be added to F#-defined class or
/// interface types.
[<Sealed>]
type AllowNullLiteralAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> AllowNullLiteralAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type AbstractClassAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> AbstractClassAttribute
namespace Microsoft.FSharp.Control
type ``lazy``<'T> = Lazy<'T>
/// A module of extension members providing asynchronous operations for some basic Web operations.
[<AutoOpen>]
module Microsoft.FSharp.Control.WebExtensions
/// Returns an asynchronous computation that, when run, will wait for a response to the given WebRequest.
val AsyncGetResponse : unit -> Async<Net.WebResponse>
/// Returns an asynchronous computation that, when run, will wait for the download of the given URI.
val AsyncDownloadString : address:Uri -> Async<string>
/// Basic operations on first class event and other observable objects.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Control.Observable
/// Returns an observable for the merged observations from the sources.
/// The returned object propagates success and error values arising
/// from either source and completes when both the sources have completed.
val merge : source1:IObservable<'T> -> source2:IObservable<'T> -> IObservable<'T>
/// Returns an observable which transforms the observations of the source by the
/// given function. The transformation function is executed once for each
/// subscribed observer. The returned object also propagates error observations
/// arising from the source and completes when the source completes.
val map : mapping:('T -> 'U) -> source:IObservable<'T> -> IObservable<'U>
/// Returns an observable which filters the observations of the source
/// by the given function. The observable will see only those observations
/// for which the predicate returns true. The predicate is executed once for
/// each subscribed observer. The returned object also propagates error
/// observations arising from the source and completes when the source completes.
val filter : predicate:('T -> bool) -> source:IObservable<'T> -> IObservable<'T>
/// Returns two observables which partition the observations of the source by
/// the given function. The first will trigger observations for those values
/// for which the predicate returns true. The second will trigger observations
/// for those values where the predicate returns false. The predicate is
/// executed once for each subscribed observer. Both also propagate all error
/// observations arising from the source and each completes when the source
/// completes.
val partition : predicate:('T -> bool) -> source:IObservable<'T> -> IObservable<'T> * IObservable<'T>
/// Returns two observables which split the observations of the source by the
/// given function. The first will trigger observations x for which the
/// splitter returns Choice1Of2 x. The second will trigger observations
/// y for which the splitter returns Choice2Of2 y The splitter is
/// executed once for each subscribed observer. Both also propagate error
/// observations arising from the source and each completes when the source
/// completes.
val split : splitter:('T -> Choice<'U1,'U2>) -> source:IObservable<'T> -> IObservable<'U1> * IObservable<'U2>
/// Returns an observable which chooses a projection of observations from the source
/// using the given function. The returned object will trigger observations x
/// for which the splitter returns Some x. The returned object also propagates
/// all errors arising from the source and completes when the source completes.
val choose : chooser:('T -> 'U option) -> source:IObservable<'T> -> IObservable<'U>
/// Returns an observable which, for each observer, allocates an item of state
/// and applies the given accumulating function to successive values arising from
/// the input. The returned object will trigger observations for each computed
/// state value, excluding the initial value. The returned object propagates
/// all errors arising from the source and completes when the source completes.
val scan : collector:('U -> 'T -> 'U) -> state:'U -> source:IObservable<'T> -> IObservable<'U>
/// Creates an observer which permanently subscribes to the given observable and which calls
/// the given function for each observation.
val add : callback:('T -> unit) -> source:IObservable<'T> -> unit
/// Creates an observer which subscribes to the given observable and which calls
/// the given function for each observation.
val subscribe : callback:('T -> unit) -> source:IObservable<'T> -> IDisposable
/// Returns a new observable that triggers on the second and subsequent triggerings of the input observable.
/// The Nth triggering of the input observable 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.
val pairwise : source:IObservable<'T> -> IObservable<'T * 'T>
namespace Microsoft.FSharp.Control
/// A message-processing agent which executes an asynchronous computation.
[<Sealed>]
[<AutoSerializable(false)>]
[<CompiledName("FSharpMailboxProcessor`1")>]
type MailboxProcessor<'Msg> =
interface System.IDisposable
/// Creates an agent. The body function is used to generate the asynchronous
/// computation executed by the agent. This function is not executed until
/// Start is called.
new : body:(MailboxProcessor<'Msg> -> Async<unit>) * ?cancellationToken:Threading.CancellationToken -> MailboxProcessor<'Msg>
/// Occurs when the execution of the agent results in an exception.
[<CLIEvent>]
member add_Error : Handler<Exception> -> unit
/// Returns the number of unprocessed messages in the message queue of the agent.
member CurrentQueueLength : int
/// Raises a timeout exception if a message not received in this amount of time. By default
/// no timeout is used.
member DefaultTimeout : int with get, set
/// Occurs when the execution of the agent results in an exception.
[<CLIEvent>]
member Error : IEvent<Exception>
/// Posts a message to the message queue of the MailboxProcessor, asynchronously.
member Post : message:'Msg -> unit
/// Posts a message to an agent and await a reply on the channel, asynchronously.
member PostAndAsyncReply : buildMessage:(AsyncReplyChannel<'Reply> -> 'Msg) * ?timeout:int -> Async<'Reply>
/// Posts a message to an agent and await a reply on the channel, synchronously.
member PostAndReply : buildMessage:(AsyncReplyChannel<'Reply> -> 'Msg) * ?timeout:int -> 'Reply
/// Like AsyncPostAndReply, but returns None if no reply within the timeout period.
member PostAndTryAsyncReply : buildMessage:(AsyncReplyChannel<'Reply> -> 'Msg) * ?timeout:int -> Async<'Reply option>
/// Waits for a message. This will consume the first message in arrival order.
member Receive : ?timeout:int -> Async<'Msg>
/// Occurs when the execution of the agent results in an exception.
[<CLIEvent>]
member remove_Error : Handler<Exception> -> unit
/// Scans for a message by looking through messages in arrival order until scanner
/// returns a Some value. Other messages remain in the queue.
member Scan : scanner:('Msg -> Async<'T> option) * ?timeout:int -> Async<'T>
/// Starts the agent.
member Start : unit -> unit
/// Like PostAndReply, but returns None if no reply within the timeout period.
member TryPostAndReply : buildMessage:(AsyncReplyChannel<'Reply> -> 'Msg) * ?timeout:int -> 'Reply option
/// Waits for a message. This will consume the first message in arrival order.
member TryReceive : ?timeout:int -> Async<'Msg option>
/// Scans for a message by looking through messages in arrival order until scanner
/// returns a Some value. Other messages remain in the queue.
member TryScan : scanner:('Msg -> Async<'T> option) * ?timeout:int -> Async<'T option>
/// Creates and starts an agent. The body function is used to generate the asynchronous
/// computation executed by the agent.
static member Start : body:(MailboxProcessor<'Msg> -> Async<unit>) * ?cancellationToken:Threading.CancellationToken -> MailboxProcessor<'Msg>
namespace Microsoft.FSharp.Control
/// The type of delayed computations.
type Lazy<'T> = Lazy<'T>
/// Extensions related to Lazy values.
[<AutoOpen>]
module Microsoft.FSharp.Control.LazyExtensions
/// Creates a lazy computation that evaluates to the result of the given function when forced.
val Create : creator:(unit -> 'T) -> Lazy<'T>
/// Creates a lazy computation that evaluates to the given value when forced.
val CreateFromValue : value:'T -> Lazy<'T>
/// Forces the execution of this value and return its result. Same as Value. Mutual exclusion is used to
/// prevent other threads also computing the value.
val Force : unit -> 'T
namespace Microsoft.FSharp.Control
/// First class event values for CLI events conforming to CLI Framework standards.
[<Interface>]
type IEvent<'Delegate, 'Args when 'Delegate : delegate<'Args, unit> and 'Delegate :> Delegate> =
interface
inherit IDelegateEvent<'Delegate>
inherit System.IObservable<'Args>
end
namespace Microsoft.FSharp.Control
/// First-class listening points (i.e. objects that permit you to register a callback
/// activated when the event is triggered).
type IEvent<'T> = IEvent<Handler<'T>,'T>
namespace Microsoft.FSharp.Control
/// First class event values for arbitrary delegate types.
[<Interface>]
type IDelegateEvent<'Delegate when 'Delegate :> Delegate> =
/// 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.
abstract member AddHandler : handler:'Delegate -> unit
/// Remove a listener delegate from an event listener store.
abstract member RemoveHandler : handler:'Delegate -> unit
namespace Microsoft.FSharp.Control
/// A delegate type associated with the F# event type IEvent<_>
type ``Handler`1`` =
delegate of sender:obj * args:'T -> unit
namespace Microsoft.FSharp.Control
/// Event implementations for a delegate types following the standard .NET Framework convention of a first 'sender' argument.
[<CompiledName("FSharpEvent`2")>]
type Event<'Delegate, 'Args when 'Delegate : delegate<'Args, unit> and 'Delegate :> Delegate> =
/// Creates an event object suitable for delegate types following the standard .NET Framework convention of a first 'sender' argument.
new : unit -> Event<'Delegate, 'Args>
/// Publishes the event as a first class event value.
member Publish : IEvent<'Delegate,'Args>
/// Triggers the event using the given sender object and parameters. The sender object may be null.
member Trigger : sender:obj * args:'Args -> unit
namespace Microsoft.FSharp.Control
/// Event implementations for the IEvent<_> type.
[<CompiledName("FSharpEvent`1")>]
type Event<'T> =
/// Creates an observable object.
new : unit -> Event<'T>
/// Publishes an observation as a first class value.
member Publish : IEvent<'T>
/// Triggers an observation using the given parameters.
member Trigger : arg:'T -> unit
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Control.Event
/// Fires the output event when either of the input events fire.
val merge : event1:IEvent<'Del1,'T> -> event2:IEvent<'Del2,'T> -> IEvent<'T> when 'Del1 : delegate<'T, unit> and 'Del1 :> Delegate and 'Del2 : delegate<'T, unit> and 'Del2 :> Delegate
/// Returns a new event that passes values transformed by the given function.
val map : mapping:('T -> 'U) -> sourceEvent:IEvent<'Del,'T> -> IEvent<'U> when 'Del : delegate<'T, unit> and 'Del :> Delegate
/// Returns 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.
val filter : predicate:('T -> bool) -> sourceEvent:IEvent<'Del,'T> -> IEvent<'T> when 'Del : delegate<'T, unit> and 'Del :> Delegate
/// Returns 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.
val partition : predicate:('T -> bool) -> sourceEvent:IEvent<'Del,'T> -> IEvent<'T> * IEvent<'T> when 'Del : delegate<'T, unit> and 'Del :> Delegate
/// Returns 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.
val split : splitter:('T -> Choice<'U1,'U2>) -> sourceEvent:IEvent<'Del,'T> -> IEvent<'U1> * IEvent<'U2> when 'Del : delegate<'T, unit> and 'Del :> Delegate
/// Returns 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.
val choose : chooser:('T -> 'U option) -> sourceEvent:IEvent<'Del,'T> -> IEvent<'U> when 'Del : delegate<'T, unit> and 'Del :> Delegate
/// Returns 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.
val scan : collector:('U -> 'T -> 'U) -> state:'U -> sourceEvent:IEvent<'Del,'T> -> IEvent<'U> when 'Del : delegate<'T, unit> and 'Del :> Delegate
/// Runs the given function each time the given event is triggered.
val add : callback:('T -> unit) -> sourceEvent:IEvent<'Del,'T> -> unit when 'Del : delegate<'T, unit> and 'Del :> Delegate
/// Returns 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.
val pairwise : sourceEvent:IEvent<'Del,'T> -> IEvent<'T * 'T> when 'Del : delegate<'T, unit> and 'Del :> Delegate
namespace Microsoft.FSharp.Control
/// Event implementations for an arbitrary type of delegate.
[<CompiledName("FSharpDelegateEvent`1")>]
type DelegateEvent<'Delegate when 'Delegate :> Delegate> =
/// Creates an event object suitable for implementing an arbitrary type of delegate.
new : unit -> DelegateEvent<'Delegate>
/// Publishes the event as a first class event value.
member Publish : IDelegateEvent<'Delegate>
/// Triggers the event using the given parameters.
member Trigger : args:obj [] -> unit
/// A module of extension members providing asynchronous operations for some basic CLI types related to concurrency and I/O.
[<AutoOpen>]
module Microsoft.FSharp.Control.CommonExtensions
/// Returns an asynchronous computation that will read from the stream into the given buffer.
val AsyncRead : buffer:byte [] * ?offset:int * ?count:int -> Async<int>
/// Returns an asynchronous computation that will read the given number of bytes from the stream.
val AsyncRead : count:int -> Async<byte []>
/// Returns an asynchronous computation that will write the given bytes to the stream.
val AsyncWrite : buffer:byte [] * ?offset:int * ?count:int -> Async<unit>
/// Permanently connects a listener function to the observable. The listener will
/// be invoked for each observation.
val Add : callback:('T -> unit) -> unit
/// Connects a listener function to the observable. The listener will
/// be invoked for each observation. The listener can be removed by
/// calling Dispose on the returned IDisposable object.
val Subscribe : callback:('T -> unit) -> IDisposable
namespace Microsoft.FSharp.Control
/// A compositional asynchronous computation, which, when run, will eventually produce a value
/// of type T, or else raises an exception.
[<Sealed>]
[<NoEquality>]
[<NoComparison>]
[<CompiledName("FSharpAsync`1")>]
[<Class>]
type Async<'T> =
namespace Microsoft.FSharp.Control
/// A handle to a capability to reply to a PostAndReply message.
[<Sealed>]
[<CompiledName("FSharpAsyncReplyChannel`1")>]
[<Class>]
type AsyncReplyChannel<'Reply> =
/// Sends a reply to a PostAndReply message.
member Reply : value:'Reply -> unit
namespace Microsoft.FSharp.Control
/// The type of the async operator, used to build workflows for asynchronous computations.
[<CompiledName("FSharpAsyncBuilder")>]
[<Sealed>]
type AsyncBuilder =
/// Creates an asynchronous computation that runs computation, and when
/// computation generates a result T, runs binder res.
member Bind : computation:Async<'T> * binder:('T -> Async<'U>) -> Async<'U>
/// Creates an asynchronous computation that first runs computation1
/// and then runs computation2, returning the result of computation2.
member Combine : computation1:Async<unit> * computation2:Async<'T> -> Async<'T>
/// Creates an asynchronous computation that runs generator.
member Delay : generator:(unit -> Async<'T>) -> Async<'T>
/// Creates an asynchronous computation that enumerates the sequence seq
/// on demand and runs body for each element.
member For : sequence:seq<'T> * body:('T -> Async<unit>) -> Async<unit>
/// Creates an asynchronous computation that returns the result v.
member Return : value:'T -> Async<'T>
/// Delegates to the input computation.
member ReturnFrom : computation:Async<'T> -> Async<'T>
/// Creates an asynchronous computation that runs computation. The action compensation is executed
/// after computation completes, whether computation exits normally or by an exception. If compensation raises an exception itself
/// the original exception is discarded and the new exception becomes the overall result of the computation.
member TryFinally : computation:Async<'T> * compensation:(unit -> unit) -> Async<'T>
/// Creates an asynchronous computation that runs computation and returns its result.
/// If an exception happens then catchHandler(exn) is called and the resulting computation executed instead.
member TryWith : computation:Async<'T> * catchHandler:(exn -> Async<'T>) -> Async<'T>
/// Creates an asynchronous computation that runs binder(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.
member Using : resource:'T * binder:('T -> Async<'U>) -> Async<'U> when 'T :> IDisposable
/// Creates an asynchronous computation that runs computation repeatedly
/// until guard() becomes false.
member While : guard:(unit -> bool) * computation:Async<unit> -> Async<unit>
/// Creates an asynchronous computation that just returns ().
member Zero : unit -> Async<unit>
namespace Microsoft.FSharp.Control
/// This static class holds members for creating and manipulating asynchronous computations.
[<Sealed>]
[<CompiledName("FSharpAsync")>]
[<Class>]
type Async =
/// Creates three functions that can be used to implement the .NET Asynchronous
/// Programming Model (APM) for a given asynchronous computation.
static member AsBeginEnd : computation:('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit)
/// Creates an asynchronous computation that waits for a single invocation of a CLI
/// event by adding a handler to the event. Once the computation completes or is
/// cancelled, the handler is removed from the event.
static member AwaitEvent : event:IEvent<'Del,'T> * ?cancelAction:(unit -> unit) -> Async<'T> when 'Del : delegate<'T, unit> and 'Del :> Delegate
/// Creates an asynchronous computation that will wait on the IAsyncResult.
static member AwaitIAsyncResult : iar:IAsyncResult * ?millisecondsTimeout:int -> Async<bool>
/// Return an asynchronous computation that will wait for the given task to complete and return
/// its result.
static member AwaitTask : task:Threading.Tasks.Task<'T> -> Async<'T>
/// Creates an asynchronous computation that will wait on the given WaitHandle.
static member AwaitWaitHandle : waitHandle:Threading.WaitHandle * ?millisecondsTimeout:int -> Async<bool>
/// Raises the cancellation condition for the most recent set of asynchronous computations started
/// without any specific CancellationToken. Replaces the global CancellationTokenSource with a new
/// global token source for any asynchronous computations created after this point without any
/// specific CancellationToken.
static member CancelDefaultToken : unit -> unit
/// Creates an asynchronous computation that returns the CancellationToken governing the execution
/// of the computation.
static member CancellationToken : Async<Threading.CancellationToken>
/// Creates an asynchronous computation that executes computation.
/// If this computation completes successfully then return Choice1Of2 with the returned
/// value. If this computation raises an exception before it completes then return Choice2Of2
/// with the raised exception.
static member Catch : computation:Async<'T> -> Async<Choice<'T,exn>>
/// Gets the default cancellation token for executing asynchronous computations.
static member DefaultCancellationToken : Threading.CancellationToken
/// Creates an asynchronous computation in terms of a Begin/End pair of actions in
/// the style used in CLI APIs. This overlaod should be used if the operation is
/// qualified by three arguments. For example,
/// Async.FromBeginEnd(arg1,arg2,arg3,ws.BeginGetWeather,ws.EndGetWeather)
/// When the computation is run, beginFunc is executed, with
/// a callback which represents the continuation of the computation.
/// When the callback is invoked, the overall result is fetched using endFunc.
static member FromBeginEnd : arg1:'Arg1 * arg2:'Arg2 * arg3:'Arg3 * beginAction:('Arg1 * 'Arg2 * 'Arg3 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
/// Creates an asynchronous computation in terms of a Begin/End pair of actions in
/// the style used in CLI APIs. For example,
/// Async.FromBeginEnd(ws.BeginGetWeather,ws.EndGetWeather)
/// When the computation is run, beginFunc is executed, with
/// a callback which represents the continuation of the computation.
/// When the callback is invoked, the overall result is fetched using endFunc.
static member FromBeginEnd : beginAction:(AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
/// Creates an asynchronous computation in terms of a Begin/End pair of actions in
/// the style used in CLI APIs. This overlaod should be used if the operation is
/// qualified by two arguments. For example,
/// Async.FromBeginEnd(arg1,arg2,ws.BeginGetWeather,ws.EndGetWeather)
/// When the computation is run, beginFunc is executed, with
/// a callback which represents the continuation of the computation.
/// When the callback is invoked, the overall result is fetched using endFunc.
static member FromBeginEnd : arg1:'Arg1 * arg2:'Arg2 * beginAction:('Arg1 * 'Arg2 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
/// Creates an asynchronous computation in terms of a Begin/End pair of actions in
/// the style used in CLI APIs. This overlaod should be used if the operation is
/// qualified by one argument. For example,
/// Async.FromBeginEnd(place,ws.BeginGetWeather,ws.EndGetWeather)
/// When the computation is run, beginFunc is executed, with
/// a callback which represents the continuation of the computation.
/// When the callback is invoked, the overall result is fetched using endFunc.
static member FromBeginEnd : arg:'Arg1 * beginAction:('Arg1 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
/// Creates an asynchronous computation that captures the current
/// success, exception and cancellation continuations. The callback must
/// eventually call exactly one of the given continuations.
static member FromContinuations : callback:(('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T>
/// Creates an asynchronous computation that runs the given computation and ignores
/// its result.
static member Ignore : computation:Async<'T> -> Async<unit>
/// Generates a scoped, cooperative cancellation handler for use within an asynchronous workflow.
static member OnCancel : interruption:(unit -> unit) -> Async<IDisposable>
/// Creates an asynchronous computation that executes all the given asynchronous computations,
/// initially queueing each as work items and using a fork/join pattern.
static member Parallel : computations:seq<Async<'T>> -> Async<'T []>
/// Runs the asynchronous computation and await its result.
static member RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:Threading.CancellationToken -> 'T
/// Creates an asynchronous computation that will sleep for the given time. This is scheduled
/// using a System.Threading.Timer object. The operation will not block operating system threads
/// for the duration of the wait.
static member Sleep : millisecondsDueTime:int -> Async<unit>
/// Starts the asynchronous computation in the thread pool. Do not await its result.
static member Start : computation:Async<unit> * ?cancellationToken:Threading.CancellationToken -> unit
/// Executes a computation in the thread pool.
static member StartAsTask : computation:Async<'T> * ?taskCreationOptions:Threading.Tasks.TaskCreationOptions * ?cancellationToken:Threading.CancellationToken -> Threading.Tasks.Task<'T>
/// Starts a child computation within an asynchronous workflow.
/// This allows multiple asynchronous computations to be executed simultaneously.
static member StartChild : computation:Async<'T> * ?millisecondsTimeout:int -> Async<Async<'T>>
/// Creates an asynchronous computation which starts the given computation as a System.Threading.Tasks.Task
static member StartChildAsTask : computation:Async<'T> * ?taskCreationOptions:Threading.Tasks.TaskCreationOptions -> Async<Threading.Tasks.Task<'T>>
/// Runs an asynchronous computation, starting immediately on the current operating system
/// thread.
static member StartImmediate : computation:Async<unit> * ?cancellationToken:Threading.CancellationToken -> unit
/// Runs an asynchronous computation, starting immediately on the current operating system
/// thread. Call one of the three continuations when the operation completes.
static member StartWithContinuations : computation:Async<'T> * continuation:('T -> unit) * exceptionContinuation:(exn -> unit) * cancellationContinuation:(OperationCanceledException -> unit) * ?cancellationToken:Threading.CancellationToken -> unit
/// Creates an asynchronous computation that runs
/// its continuation using syncContext.Post. If syncContext is null
/// then the asynchronous computation is equivalent to SwitchToThreadPool().
static member SwitchToContext : syncContext:Threading.SynchronizationContext -> Async<unit>
/// Creates an asynchronous computation that creates a new thread and runs
/// its continuation in that thread.
static member SwitchToNewThread : unit -> Async<unit>
/// Creates an asynchronous computation that queues a work item that runs
/// its continuation.
static member SwitchToThreadPool : unit -> Async<unit>
/// Creates an asynchronous computation that executes computation.
/// If this computation is cancelled before it completes then the computation generated by
/// running compensation is executed.
static member TryCancelled : computation:Async<'T> * compensation:(OperationCanceledException -> unit) -> Async<'T>
namespace Microsoft.FSharp.Collections
/// An abbreviation for the CLI type System.Collections.Generic.IEnumerable<_>
type seq<'T> = Collections.Generic.IEnumerable<'T>
namespace Microsoft.FSharp.Collections
/// An abbreviation for the type of immutable singly-linked lists.
type list<'T> = List<'T>
namespace Microsoft.FSharp.Collections
/// Immutable sets based on binary trees, where comparison is the
/// F# structural comparison function, potentially using implementations
/// of the IComparable interface on key values.
[<Sealed>]
[<CompiledName("FSharpSet`1")>]
type Set<'T when 'T : comparison> =
interface System.Collections.Generic.ICollection<'T>
interface System.Collections.IEnumerable
interface System.Collections.Generic.IEnumerable<'T>
/// Create a set containing elements drawn from the given sequence.
new : elements:seq<'T> -> Set<'T>
/// 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.
member Add : value:'T -> Set<'T>
/// A useful shortcut for Set.contains. See the Set module for further operations on sets.
member Contains : value:'T -> bool
/// The number of elements in the set
member Count : int
override Equals : obj -> bool
/// A useful shortcut for Set.isEmpty. See the Set module for further operations on sets.
member IsEmpty : bool
/// Evaluates to "true" if all elements of the first set are in the second, and at least
/// one element of the second is not in the first.
member IsProperSubsetOf : otherSet:Set<'T> -> bool
/// Evaluates to "true" if all elements of the second set are in the first, and at least
/// one element of the first is not in the second.
member IsProperSupersetOf : otherSet:Set<'T> -> bool
/// Evaluates to "true" if all elements of the first set are in the second.
member IsSubsetOf : otherSet:Set<'T> -> bool
/// Evaluates to "true" if all elements of the second set are in the first.
member IsSupersetOf : otherSet:Set<'T> -> bool
/// Returns the highest element in the set according to the ordering being used for the set.
member MaximumElement : 'T
/// Returns the lowest element in the set according to the ordering being used for the set.
member MinimumElement : 'T
/// 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.
member Remove : value:'T -> Set<'T>
/// Compute the union of the two sets.
static member op_Addition : set1:Set<'T> * set2:Set<'T> -> Set<'T>
/// Returns a new set with the elements of the second set removed from the first.
static member op_Subtraction : set1:Set<'T> * set2:Set<'T> -> Set<'T>
/// Functional programming operators related to the Set<_> type.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Collections.Set
/// The empty set for the type 'T.
val empty : Set<'T> when 'T : comparison
/// The set containing the given element.
val singleton : value:'T -> Set<'T> when 'T : comparison
/// Returns a new set with an element added to the set. No exception is raised if
/// the set already contains the given element.
val add : value:'T -> set:Set<'T> -> Set<'T> when 'T : comparison
/// Evaluates to "true" if the given element is in the given set.
val contains : element:'T -> set:Set<'T> -> bool when 'T : comparison
/// Evaluates to "true" if all elements of the first set are in the second
val isSubset : set1:Set<'T> -> set2:Set<'T> -> bool when 'T : comparison
/// Evaluates to "true" if all elements of the first set are in the second, and at least
/// one element of the second is not in the first.
val isProperSubset : set1:Set<'T> -> set2:Set<'T> -> bool when 'T : comparison
/// Evaluates to "true" if all elements of the second set are in the first.
val isSuperset : set1:Set<'T> -> set2:Set<'T> -> bool when 'T : comparison
/// Evaluates to "true" if all elements of the second set are in the first, and at least
/// one element of the first is not in the second.
val isProperSuperset : set1:Set<'T> -> set2:Set<'T> -> bool when 'T : comparison
/// Returns the number of elements in the set. Same as size.
val count : set:Set<'T> -> int when 'T : comparison
/// Tests if any element of the collection satisfies the given predicate.
/// If the input function is predicate and the elements are i0...iN
/// then computes p i0 or ... or p iN.
val exists : predicate:('T -> bool) -> set:Set<'T> -> bool when 'T : comparison
/// Returns a new collection containing only the elements of the collection
/// for which the given predicate returns true.
val filter : predicate:('T -> bool) -> set:Set<'T> -> Set<'T> when 'T : comparison
/// Returns a new collection containing the results of applying the
/// given function to each element of the input set.
val map : mapping:('T -> 'U) -> set:Set<'T> -> Set<'U> when 'T : comparison and 'U : comparison
/// Applies the given accumulating function to all the elements of the set
val fold : folder:('State -> 'T -> 'State) -> state:'State -> set:Set<'T> -> 'State when 'T : comparison
/// Applies the given accumulating function to all the elements of the set.
val foldBack : folder:('T -> 'State -> 'State) -> set:Set<'T> -> state:'State -> 'State when 'T : comparison
/// Tests 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.
val forall : predicate:('T -> bool) -> set:Set<'T> -> bool when 'T : comparison
/// Computes the intersection of the two sets.
val intersect : set1:Set<'T> -> set2:Set<'T> -> Set<'T> when 'T : comparison
/// Computes the intersection of a sequence of sets. The sequence must be non-empty.
val intersectMany : sets:seq<Set<'T>> -> Set<'T> when 'T : comparison
/// Computes the union of the two sets.
val union : set1:Set<'T> -> set2:Set<'T> -> Set<'T> when 'T : comparison
/// Computes the union of a sequence of sets.
val unionMany : sets:seq<Set<'T>> -> Set<'T> when 'T : comparison
/// Returns "true" if the set is empty.
val isEmpty : set:Set<'T> -> bool when 'T : comparison
/// Applies the given function to each element of the set, in order according
/// to the comparison function.
val iter : action:('T -> unit) -> set:Set<'T> -> unit when 'T : comparison
/// Splits the set into two sets containing the elements for which the given predicate
/// returns true and false respectively.
val partition : predicate:('T -> bool) -> set:Set<'T> -> Set<'T> * Set<'T> when 'T : comparison
/// Returns a new set with the given element removed. No exception is raised if
/// the set doesn't contain the given element.
val remove : value:'T -> set:Set<'T> -> Set<'T> when 'T : comparison
/// Returns the lowest element in the set according to the ordering being used for the set.
val minElement : set:Set<'T> -> 'T when 'T : comparison
/// Returns the highest element in the set according to the ordering being used for the set.
val maxElement : set:Set<'T> -> 'T when 'T : comparison
/// Builds a set that contains the same elements as the given list.
val ofList : elements:'T list -> Set<'T> when 'T : comparison
/// Builds a list that contains the elements of the set in order.
val toList : set:Set<'T> -> 'T list when 'T : comparison
/// Builds a set that contains the same elements as the given array.
val ofArray : array:'T [] -> Set<'T> when 'T : comparison
/// Builds an array that contains the elements of the set in order.
val toArray : set:Set<'T> -> 'T [] when 'T : comparison
/// Returns an ordered view of the collection as an enumerable object.
val toSeq : set:Set<'T> -> seq<'T> when 'T : comparison
/// Builds a new collection from the given enumerable object.
val ofSeq : elements:seq<'T> -> Set<'T> when 'T : comparison
/// Returns a new set with the elements of the second set removed from the first.
val difference : set1:Set<'T> -> set2:Set<'T> -> Set<'T> when 'T : comparison
/// Basic operations on IEnumerables.
[<RequireQualifiedAccess>]
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
module Microsoft.FSharp.Collections.Seq
/// Wraps the two given enumerations as a single concatenated
/// enumeration.
val append : source1:seq<'T> -> source2:seq<'T> -> seq<'T>
/// Returns the average of the elements in the sequence.
val inline average : source:seq< ^T> -> ^T when ^T : (static member ( + ) : ^T * ^T -> ^T) and ^T : (static member DivideByInt : ^T * int -> ^T) and ^T : (static member Zero : ^T)
/// Returns the average of the results generated by applying the function to each element
/// of the sequence.
val inline averageBy : projection:('T -> ^U) -> source:seq<'T> -> ^U when ^U : (static member ( + ) : ^U * ^U -> ^U) and ^U : (static member DivideByInt : ^U * int -> ^U) and ^U : (static member Zero : ^U)
/// Returns 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. Caching a sequence is typically useful when repeatedly
/// evaluating items in the original sequence is computationally expensive or if
/// iterating the sequence causes side-effects that the user does not want to be
/// repeated multiple times.
///
/// 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.
val cache : source:seq<'T> -> seq<'T>
/// Wraps a loosely-typed System.Collections sequence as a typed sequence.
val cast : source:Collections.IEnumerable -> seq<'T>
/// Applies 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).
val choose : chooser:('T -> 'U option) -> source:seq<'T> -> seq<'U>
/// Applies the given function to each element of the sequence and concatenates all the
/// results.
val collect : mapping:('T -> 'Collection) -> source:seq<'T> -> seq<'U> when 'Collection :> seq<'U>
/// Compares two sequences using the given comparison function, element by element.
/// Returns the first non-zero result from the comparison function. If the end of a sequence
/// is reached it returns a -1 if the first sequence is shorter and a 1 if the second sequence
/// is shorter.
val compareWith : comparer:('T -> 'T -> int) -> source1:seq<'T> -> source2:seq<'T> -> int
/// Combines the given enumeration-of-enumerations as a single concatenated
/// enumeration.
val concat : sources:seq<'Collection> -> seq<'T> when 'Collection :> seq<'T>
/// Applies a key-generating function to each element of a sequence and return a sequence yielding unique
/// keys and their number of occurrences in the original sequence.
val countBy : projection:('T -> 'Key) -> source:seq<'T> -> seq<'Key * int> when 'Key : equality
/// Returns a sequence that is built from the given delayed specification of a
/// sequence.
val delay : generator:(unit -> seq<'T>) -> seq<'T>
/// Returns a sequence that contains no duplicate entries according to generic hash and
/// equality comparisons on the entries.
/// If an element occurs multiple times in the sequence then the later occurrences are discarded.
val distinct : source:seq<'T> -> seq<'T> when 'T : equality
/// Returns a sequence that contains no duplicate entries according to the
/// generic hash and equality comparisons on the keys returned by the given key-generating function.
/// If an element occurs multiple times in the sequence then the later occurrences are discarded.
val distinctBy : projection:('T -> 'Key) -> source:seq<'T> -> seq<'T> when 'Key : equality
/// Creates an empty sequence.
val empty : seq<'T>
/// Tests if any element of the sequence satisfies the given predicate.
val exists : predicate:('T -> bool) -> source:seq<'T> -> bool
/// Tests if any pair of corresponding elements of the input sequences satisfies the given predicate.
val exists2 : predicate:('T1 -> 'T2 -> bool) -> source1:seq<'T1> -> source2:seq<'T2> -> bool
/// Returns a new collection containing only the elements of the collection
/// for which the given predicate returns "true". This is a synonym for Seq.where.
val filter : predicate:('T -> bool) -> source:seq<'T> -> seq<'T>
/// Returns a new collection containing only the elements of the collection
/// for which the given predicate returns "true".
val where : predicate:('T -> bool) -> source:seq<'T> -> seq<'T>
/// Returns the first element for which the given function returns true.
val find : predicate:('T -> bool) -> source:seq<'T> -> 'T
/// Returns the index of the first element for which the given function returns true.
val findIndex : predicate:('T -> bool) -> source:seq<'T> -> int
/// Applies a function to each element of the collection, threading an accumulator argument
/// through the computation. If the input function is f and the elements are i0...iN
/// then computes f (... (f s i0)...) iN
val fold : folder:('State -> 'T -> 'State) -> state:'State -> source:seq<'T> -> 'State
/// Tests if all elements of the sequence satisfy the given predicate.
val forall : predicate:('T -> bool) -> source:seq<'T> -> bool
/// Tests the all pairs of elements drawn from the two sequences satisfy the
/// given predicate. If one sequence is shorter than
/// the other then the remaining elements of the longer sequence are ignored.
val forall2 : predicate:('T1 -> 'T2 -> bool) -> source1:seq<'T1> -> source2:seq<'T2> -> bool
/// Applies a key-generating function to each element of a sequence and yields a sequence of
/// unique keys. Each unique key contains a sequence of all elements that match
/// to this key.
val groupBy : projection:('T -> 'Key) -> source:seq<'T> -> seq<'Key * seq<'T>> when 'Key : equality
/// Returns the first element of the sequence.
val head : source:seq<'T> -> 'T
/// Returns the last element of the sequence.
val last : source:seq<'T> -> 'T
/// Returns the only element of the sequence.
val exactlyOne : source:seq<'T> -> 'T
/// Returns true if the sequence contains no elements, false otherwise.
val isEmpty : source:seq<'T> -> bool
/// Generates a new sequence which, when iterated, will return successive
/// elements by calling the given function, up to the given count. Each element is saved after its
/// initialization. The function is passed the index of the item being
/// generated.
val init : count:int -> initializer:(int -> 'T) -> seq<'T>
/// Generates a new sequence which, when iterated, will return successive
/// elements by calling the given function. The results of calling the function
/// will not be saved, that is the function will be reapplied as necessary to
/// regenerate the elements. The function is passed the index of the item being
/// generated.
val initInfinite : initializer:(int -> 'T) -> seq<'T>
/// Applies the given function to each element of the collection.
val iter : action:('T -> unit) -> source:seq<'T> -> unit
/// Applies the given function to each element of the collection. The integer passed to the
/// function indicates the index of element.
val iteri : action:(int -> 'T -> unit) -> source:seq<'T> -> unit
/// Applies the given function to two collections simultaneously. If one sequence is shorter than
/// the other then the remaining elements of the longer sequence are ignored.
val iter2 : action:('T1 -> 'T2 -> unit) -> source1:seq<'T1> -> source2:seq<'T2> -> unit
/// Returns the length of the sequence
val length : source:seq<'T> -> int
/// Builds 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.
val map : mapping:('T -> 'U) -> source:seq<'T> -> seq<'U>
/// Builds 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.
val map2 : mapping:('T1 -> 'T2 -> 'U) -> source1:seq<'T1> -> source2:seq<'T2> -> seq<'U>
/// Builds 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.
val mapi : mapping:(int -> 'T -> 'U) -> source:seq<'T> -> seq<'U>
/// Returns the greatest of all elements of the sequence, compared via Operators.max
val inline max : source:seq<'T> -> 'T when 'T : comparison
/// Returns the greatest of all elements of the sequence, compared via Operators.max on the function result.
val inline maxBy : projection:('T -> 'U) -> source:seq<'T> -> 'T when 'U : comparison
/// Returns the lowest of all elements of the sequence, compared via Operators.min.
val inline min : source:seq<'T> -> 'T when 'T : comparison
/// Returns the lowest of all elements of the sequence, compared via Operators.min on the function result.
val inline minBy : projection:('T -> 'U) -> source:seq<'T> -> 'T when 'U : comparison
/// Computes the nth element in the collection.
val nth : index:int -> source:seq<'T> -> 'T
/// Views the given array as a sequence.
val ofArray : source:'T [] -> seq<'T>
/// Views the given list as a sequence.
val ofList : source:'T list -> seq<'T>
/// Returns a sequence of each element in the input sequence and its predecessor, with the
/// exception of the first element which is only returned as the predecessor of the second element.
val pairwise : source:seq<'T> -> seq<'T * 'T>
/// Applies the given function to successive elements, returning the first
/// x where the function returns "Some(x)".
val pick : chooser:('T -> 'U option) -> source:seq<'T> -> 'U
/// Builds a new sequence object that delegates to the given sequence object. This ensures
/// the original sequence cannot be rediscovered and mutated by a type cast. For example,
/// if given an array the returned sequence will return the elements of the array, but
/// you cannot cast the returned sequence object to an array.
val readonly : source:seq<'T> -> seq<'T>
/// Applies a function to each element of the sequence, threading an accumulator argument
/// through the computation. Begin by applying the function to the first two elements.
/// Then feed this result into the function along with the third element and so on.
/// Return the final result.
val reduce : reduction:('T -> 'T -> 'T) -> source:seq<'T> -> 'T
/// Like fold, but computes on-demand and returns the sequence of intermediary and final results.
val scan : folder:('State -> 'T -> 'State) -> state:'State -> source:seq<'T> -> seq<'State>
/// Returns a sequence that yields one item only.
val singleton : value:'T -> seq<'T>
/// Returns a sequence that skips N elements of the underlying sequence and then yields the
/// remaining elements of the sequence.
val skip : count:int -> source:seq<'T> -> seq<'T>
/// Returns a sequence that, when iterated, skips elements of the underlying sequence while the
/// given predicate returns true, and then yields the remaining elements of the sequence.
val skipWhile : predicate:('T -> bool) -> source:seq<'T> -> seq<'T>
/// Yields a sequence ordered by keys.
val sort : source:seq<'T> -> seq<'T> when 'T : comparison
/// Applies a key-generating function to each element of a sequence and yield a sequence ordered
/// by keys. The keys are compared using generic comparison as implemented by Operators.compare.
val sortBy : projection:('T -> 'Key) -> source:seq<'T> -> seq<'T> when 'Key : comparison
/// Returns the sum of the elements in the sequence.
val inline sum : source:seq< ^T> -> ^T when ^T : (static member ( + ) : ^T * ^T -> ^T) and ^T : (static member Zero : ^T)
/// Returns the sum of the results generated by applying the function to each element of the sequence.
val inline sumBy : projection:('T -> ^U) -> source:seq<'T> -> ^U when ^U : (static member ( + ) : ^U * ^U -> ^U) and ^U : (static member Zero : ^U)
/// Returns the first N elements of the sequence.
val take : count:int -> source:seq<'T> -> seq<'T>
/// Returns a sequence that, when iterated, yields elements of the underlying sequence while the
/// given predicate returns true, and then returns no further elements.
val takeWhile : predicate:('T -> bool) -> source:seq<'T> -> seq<'T>
/// Builds an array from the given collection.
val toArray : source:seq<'T> -> 'T []
/// Builds a list from the given collection.
val toList : source:seq<'T> -> 'T list
/// Returns the first element for which the given function returns true.
/// Return None if no such element exists.
val tryFind : predicate:('T -> bool) -> source:seq<'T> -> 'T option
/// Returns the index of the first element in the sequence
/// that satisfies the given predicate. Return None if no such element exists.
val tryFindIndex : predicate:('T -> bool) -> source:seq<'T> -> int option
/// Applies the given function to successive elements, returning the first
/// result where the function returns "Some(x)".
val tryPick : chooser:('T -> 'U option) -> source:seq<'T> -> 'U option
/// Returns a sequence that when enumerated returns at most N elements.
val truncate : count:int -> source:seq<'T> -> seq<'T>
/// Returns 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.
val unfold : generator:('State -> ('T * 'State) option) -> state:'State -> seq<'T>
/// Returns a sequence that yields sliding windows of containing elements drawn from the input
/// sequence. Each window is returned as a fresh array.
val windowed : windowSize:int -> source:seq<'T> -> seq<'T []>
/// Combines the two sequences into a list of pairs. The two sequences need not have equal lengths:
/// when one sequence is exhausted any remaining elements in the other
/// sequence are ignored.
val zip : source1:seq<'T1> -> source2:seq<'T2> -> seq<'T1 * 'T2>
/// Combines the three sequences into a list of triples. The sequences need not have equal lengths:
/// when one sequence is exhausted any remaining elements in the other
/// sequences are ignored.
val zip3 : source1:seq<'T1> -> source2:seq<'T2> -> source3:seq<'T3> -> seq<'T1 * 'T2 * 'T3>
namespace Microsoft.FSharp.Collections
/// An abbreviation for the CLI type System.Collections.Generic.List<_>
type ResizeArray<'T> = Collections.Generic.List<'T>
namespace Microsoft.FSharp.Collections
/// Immutable maps. Keys are ordered by F# generic comparison.
[<CompiledName("FSharpMap`2")>]
[<Sealed>]
type Map<'Key, 'Value when 'Key : comparison> =
interface System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<'Key,'Value>>
interface System.Collections.Generic.IDictionary<'Key,'Value>
interface System.Collections.IEnumerable
interface System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<'Key,'Value>>
/// Builds a map that contains the bindings of the given IEnumerable.
new : elements:seq<'Key * 'Value> -> Map<'Key, 'Value>
/// Returns a new map with the binding added to the given map.
member Add : key:'Key * value:'Value -> Map<'Key,'Value>
/// Tests if an element is in the domain of the map.
member ContainsKey : key:'Key -> bool
/// The number of bindings in the map.
member Count : int
override Equals : obj -> bool
/// Returns true if there are no bindings in the map.
member IsEmpty : bool
/// Lookup an element in the map. Raise KeyNotFoundException if no binding
/// exists in the map.
member Item : 'Value
/// Removes an element from the domain of the map. No exception is raised if the element is not present.
member Remove : key:'Key -> Map<'Key,'Value>
/// Lookup an element in the map, returning a Some value if the element is in the domain
/// of the map and None if not.
member TryFind : key:'Key -> 'Value option
/// Functional programming operators related to the Map<_,_> type.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Collections.Map
/// Returns a new map with the binding added to the given map.
val add : key:'Key -> value:'T -> table:Map<'Key,'T> -> Map<'Key,'T> when 'Key : comparison
/// Returns a new map made from the given bindings.
val ofList : elements:('Key * 'T) list -> Map<'Key,'T> when 'Key : comparison
/// Returns a new map made from the given bindings.
val ofArray : elements:('Key * 'T) [] -> Map<'Key,'T> when 'Key : comparison
/// Returns a new map made from the given bindings.
val ofSeq : elements:seq<'Key * 'T> -> Map<'Key,'T> when 'Key : comparison
/// Views the collection as an enumerable sequence of pairs.
/// The sequence will be ordered by the keys of the map.
val toSeq : table:Map<'Key,'T> -> seq<'Key * 'T> when 'Key : comparison
/// Returns a list of all key-value pairs in the mapping.
/// The list will be ordered by the keys of the map.
val toList : table:Map<'Key,'T> -> ('Key * 'T) list when 'Key : comparison
/// Returns an array of all key-value pairs in the mapping.
/// The array will be ordered by the keys of the map.
val toArray : table:Map<'Key,'T> -> ('Key * 'T) [] when 'Key : comparison
/// Is the map empty?
val isEmpty : table:Map<'Key,'T> -> bool when 'Key : comparison
/// The empty map.
val empty : Map<'Key,'T> when 'Key : comparison
/// Lookup an element in the map, raising KeyNotFoundException if no binding
/// exists in the map.
val find : key:'Key -> table:Map<'Key,'T> -> 'T when 'Key : comparison
/// Searches the map looking for the first element where the given function returns a Some value.
val tryPick : chooser:('Key -> 'T -> 'U option) -> table:Map<'Key,'T> -> 'U option when 'Key : comparison
/// Searches the map looking for the first element where the given function returns a Some value
val pick : chooser:('Key -> 'T -> 'U option) -> table:Map<'Key,'T> -> 'U when 'Key : comparison
/// Folds over the bindings in the map.
val foldBack : folder:('Key -> 'T -> 'State -> 'State) -> table:Map<'Key,'T> -> state:'State -> 'State when 'Key : comparison
/// Folds over the bindings in the map
val fold : folder:('State -> 'Key -> 'T -> 'State) -> state:'State -> table:Map<'Key,'T> -> 'State when 'Key : comparison
/// Applies the given function to each binding in the dictionary
val iter : action:('Key -> 'T -> unit) -> table:Map<'Key,'T> -> unit when 'Key : comparison
/// Returns true if the given predicate returns true for one of the
/// bindings in the map.
val exists : predicate:('Key -> 'T -> bool) -> table:Map<'Key,'T> -> bool when 'Key : comparison
/// Builds a new map containing only the bindings for which the given predicate returns 'true'.
val filter : predicate:('Key -> 'T -> bool) -> table:Map<'Key,'T> -> Map<'Key,'T> when 'Key : comparison
/// Returns true if the given predicate returns true for all of the
/// bindings in the map.
val forall : predicate:('Key -> 'T -> bool) -> table:Map<'Key,'T> -> bool when 'Key : comparison
/// Builds a new collection whose elements are the results of applying the given function
/// to each of the elements of the collection. The key passed to the
/// function indicates the key of element being transformed.
val map : mapping:('Key -> 'T -> 'U) -> table:Map<'Key,'T> -> Map<'Key,'U> when 'Key : comparison
/// Tests if an element is in the domain of the map.
val containsKey : key:'Key -> table:Map<'Key,'T> -> bool when 'Key : comparison
/// Builds two new maps, one containing the bindings for which the given predicate returns 'true',
/// and the other the remaining bindings.
val partition : predicate:('Key -> 'T -> bool) -> table:Map<'Key,'T> -> Map<'Key,'T> * Map<'Key,'T> when 'Key : comparison
/// Removes an element from the domain of the map. No exception is raised if the element is not present.
val remove : key:'Key -> table:Map<'Key,'T> -> Map<'Key,'T> when 'Key : comparison
/// Lookup an element in the map, returning a Some value if the element is in the domain
/// of the map and None if not.
val tryFind : key:'Key -> table:Map<'Key,'T> -> 'T option when 'Key : comparison
/// 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.
val findKey : predicate:('Key -> 'T -> bool) -> table:Map<'Key,'T> -> 'Key when 'Key : comparison
/// Returns the key of the first mapping in the collection that satisfies the given predicate.
/// Returns 'None' if no such element exists.
val tryFindKey : predicate:('Key -> 'T -> bool) -> table:Map<'Key,'T> -> 'Key option when 'Key : comparison
namespace Microsoft.FSharp.Collections
/// The type of immutable singly-linked lists.
[<DefaultAugmentation(false)>]
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpList`1")>]
type List<'T> =
| ( [] )
| ( :: ) of Head: 'T * Tail: 'T list
interface System.Collections.IEnumerable
interface System.Collections.Generic.IEnumerable<'T>
/// Gets the first element of the list
member Head : 'T
/// Gets a value indicating if the list contains no entries
member IsEmpty : bool
/// Gets the element of the list at the given position.
member Item : 'T
/// Gets the number of items contained in the list
member Length : int
/// Gets the tail of the list, which is a list containing all the elements of the list, excluding the first element
member Tail : 'T list
/// Returns a list with head as its first element and tail as its subsequent elements
static member Cons : head:'T * tail:'T list -> 'T list
/// Returns an empty list of a particular type
static member Empty : 'T list
/// Basic operations on lists.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Collections.List
/// Returns a new list that contains the elements of the first list
/// followed by elements of the second.
val append : list1:'T list -> list2:'T list -> 'T list
/// Returns the average of the elements in the list.
val inline average : list: ^T list -> ^T when ^T : (static member ( + ) : ^T * ^T -> ^T) and ^T : (static member DivideByInt : ^T * int -> ^T) and ^T : (static member Zero : ^T)
/// Returns the average of the elements generated by applying the function to each element of the list.
val inline averageBy : projection:('T -> ^U) -> list:'T list -> ^U when ^U : (static member ( + ) : ^U * ^U -> ^U) and ^U : (static member DivideByInt : ^U * int -> ^U) and ^U : (static member Zero : ^U)
/// Applies the given function to each element of the list. Returns
/// the list comprised of the results x for each element where
/// the function returns Some(x)
val choose : chooser:('T -> 'U option) -> list:'T list -> 'U list
/// For each element of the list, applies the given function. Concatenates all the results and return the combined list.
val collect : mapping:('T -> 'U list) -> list:'T list -> 'U list
/// Returns a new list that contains the elements of each the lists in order.
val concat : lists:seq<'T list> -> 'T list
/// Returns an empty list of the given type.
val empty : 'T list
/// Tests if any element of the list satisfies the given predicate.
val exists : predicate:('T -> bool) -> list:'T list -> bool
/// Tests if any pair of corresponding elements of the lists satisfies the given predicate.
val exists2 : predicate:('T1 -> 'T2 -> bool) -> list1:'T1 list -> list2:'T2 list -> bool
/// Returns the first element for which the given function returns true.
/// Raises KeyNotFoundException if no such element exists.
val find : predicate:('T -> bool) -> list:'T list -> 'T
/// Returns the index of the first element in the list
/// that satisfies the given predicate.
/// Raises KeyNotFoundException if no such element exists.
val findIndex : predicate:('T -> bool) -> list:'T list -> int
/// Returns a new collection containing only the elements of the collection
/// for which the given predicate returns "true"
val filter : predicate:('T -> bool) -> list:'T list -> 'T list
/// Applies 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.
val fold : folder:('State -> 'T -> 'State) -> state:'State -> list:'T list -> 'State
/// Applies a function to corresponding elements of two collections, threading an accumulator argument
/// through the computation. The collections must have identical sizes.
/// If the input function is f and the elements are i0...iN and j0...jN
/// then computes f (... (f s i0 j0)...) iN jN.
val fold2 : folder:('State -> 'T1 -> 'T2 -> 'State) -> state:'State -> list1:'T1 list -> list2:'T2 list -> 'State
/// Applies a function to each element of the collection, threading an accumulator argument
/// through the computation. If the input function is f and the elements are i0...iN then
/// computes f i0 (...(f iN s)).
val foldBack : folder:('T -> 'State -> 'State) -> list:'T list -> state:'State -> 'State
/// Applies a function to corresponding elements of two collections, threading an accumulator argument
/// through the computation. The collections must have identical sizes.
/// If the input function is f and the elements are i0...iN and j0...jN
/// then computes f i0 j0 (...(f iN jN s)).
val foldBack2 : folder:('T1 -> 'T2 -> 'State -> 'State) -> list1:'T1 list -> list2:'T2 list -> state:'State -> 'State
/// Tests if all elements of the collection satisfy the given predicate.
val forall : predicate:('T -> bool) -> list:'T list -> bool
/// Tests if all corresponding elements of the collection satisfy the given predicate pairwise.
val forall2 : predicate:('T1 -> 'T2 -> bool) -> list1:'T1 list -> list2:'T2 list -> bool
/// Returns the first element of the list.
val head : list:'T list -> 'T
/// Creates a list by calling the given generator on each index.
val init : length:int -> initializer:(int -> 'T) -> 'T list
/// Returns true if the list contains no elements, false otherwise.
val isEmpty : list:'T list -> bool
/// Applies the given function to each element of the collection.
val iter : action:('T -> unit) -> list:'T list -> unit
/// Applies the given function to two collections simultaneously. The
/// collections must have identical size.
val iter2 : action:('T1 -> 'T2 -> unit) -> list1:'T1 list -> list2:'T2 list -> unit
/// Applies the given function to each element of the collection. The integer passed to the
/// function indicates the index of element.
val iteri : action:(int -> 'T -> unit) -> list:'T list -> unit
/// Applies the given function to two collections simultaneously. The
/// collections must have identical size. The integer passed to the
/// function indicates the index of element.
val iteri2 : action:(int -> 'T1 -> 'T2 -> unit) -> list1:'T1 list -> list2:'T2 list -> unit
/// Returns the length of the list.
val length : list:'T list -> int
/// Builds a new collection whose elements are the results of applying the given function
/// to each of the elements of the collection.
val map : mapping:('T -> 'U) -> list:'T list -> 'U list
/// Builds a new collection whose elements are the results of applying the given function
/// to the corresponding elements of the two collections pairwise.
val map2 : mapping:('T1 -> 'T2 -> 'U) -> list1:'T1 list -> list2:'T2 list -> 'U list
/// Builds a new collection whose elements are the results of applying the given function
/// to the corresponding elements of the three collections simultaneously.
val map3 : mapping:('T1 -> 'T2 -> 'T3 -> 'U) -> list1:'T1 list -> list2:'T2 list -> list3:'T3 list -> 'U list
/// Builds 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.
val mapi : mapping:(int -> 'T -> 'U) -> list:'T list -> 'U list
/// Like mapi, but mapping corresponding elements from two lists of equal length.
val mapi2 : mapping:(int -> 'T1 -> 'T2 -> 'U) -> list1:'T1 list -> list2:'T2 list -> 'U list
/// Return the greatest of all elements of the list, compared via Operators.max.
val inline max : list:'T list -> 'T when 'T : comparison
/// Returns the greatest of all elements of the list, compared via Operators.max on the function result.
val inline maxBy : projection:('T -> 'U) -> list:'T list -> 'T when 'U : comparison
/// Returns the lowest of all elements of the list, compared via Operators.min.
val inline min : list:'T list -> 'T when 'T : comparison
/// Returns the lowest of all elements of the list, compared via Operators.min on the function result
val inline minBy : projection:('T -> 'U) -> list:'T list -> 'T when 'U : comparison
/// Indexes into the list. The first element has index 0.
val nth : list:'T list -> index:int -> 'T
/// Builds a list from the given array.
val ofArray : array:'T [] -> 'T list
/// Builds a new list from the given enumerable object.
val ofSeq : source:seq<'T> -> 'T list
/// Splits the collection into two collections, containing the
/// elements for which the given predicate returns true and false
/// respectively. Element order is preserved in both of the created lists.
val partition : predicate:('T -> bool) -> list:'T list -> 'T list * 'T list
/// Applies 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
val pick : chooser:('T -> 'U option) -> list:'T list -> 'U
/// Returns a list with all elements permuted according to the
/// specified permutation.
val permute : indexMap:(int -> int) -> list:'T list -> 'T list
/// 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.
val reduce : reduction:('T -> 'T -> 'T) -> list:'T list -> 'T
/// Applies a function to each element of the collection, threading an accumulator argument
/// through the computation. If the input function is f and the elements are i0...iN then computes
/// f i0 (...(f iN-1 iN)).
val reduceBack : reduction:('T -> 'T -> 'T) -> list:'T list -> 'T
/// Creates a list by calling the given generator on each index.
val replicate : count:int -> initial:'T -> 'T list
/// Returns a new list with the elements in reverse order.
val rev : list:'T list -> 'T list
/// Applies 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. Returns the list of intermediate results and the final result.
val scan : folder:('State -> 'T -> 'State) -> state:'State -> list:'T list -> 'State list
/// Like foldBack, but returns both the intermediary and final results
val scanBack : folder:('T -> 'State -> 'State) -> list:'T list -> state:'State -> 'State list
/// Sorts the given list using the given comparison function.
val sortWith : comparer:('T -> 'T -> int) -> list:'T list -> 'T list
/// Sorts the given list using keys given by the given projection. Keys are compared using Operators.compare.
val sortBy : projection:('T -> 'Key) -> list:'T list -> 'T list when 'Key : comparison
/// Sorts the given list using Operators.compare.
val sort : list:'T list -> 'T list when 'T : comparison
/// Returns the sum of the elements in the list.
val inline sum : list: ^T list -> ^T when ^T : (static member ( + ) : ^T * ^T -> ^T) and ^T : (static member Zero : ^T)
/// Returns the sum of the results generated by applying the function to each element of the list.
val inline sumBy : projection:('T -> ^U) -> list:'T list -> ^U when ^U : (static member ( + ) : ^U * ^U -> ^U) and ^U : (static member Zero : ^U)
/// Returns the list after removing the first element.
val tail : list:'T list -> 'T list
/// Builds an array from the given list.
val toArray : list:'T list -> 'T []
/// Views the given list as a sequence.
val toSeq : list:'T list -> seq<'T>
/// Applies 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.
val tryPick : chooser:('T -> 'U option) -> list:'T list -> 'U option
/// Returns the first element for which the given function returns true..
/// Return None if no such element exists.
val tryFind : predicate:('T -> bool) -> list:'T list -> 'T option
/// Returns the index of the first element in the list
/// that satisfies the given predicate.
/// Return None if no such element exists.
val tryFindIndex : predicate:('T -> bool) -> list:'T list -> int option
/// Splits a list of pairs into two lists.
val unzip : list:('T1 * 'T2) list -> 'T1 list * 'T2 list
/// Splits a list of triples into three lists.
val unzip3 : list:('T1 * 'T2 * 'T3) list -> 'T1 list * 'T2 list * 'T3 list
/// Combines the two lists into a list of pairs. The two lists must have equal lengths.
val zip : list1:'T1 list -> list2:'T2 list -> ('T1 * 'T2) list
/// Combines the three lists into a list of triples. The lists must have equal lengths.
val zip3 : list1:'T1 list -> list2:'T2 list -> list3:'T3 list -> ('T1 * 'T2 * 'T3) list
/// Common notions of value identity used with hash tables.
module Microsoft.FSharp.Collections.HashIdentity
/// Structural hashing. Hash using Operators.(=) and Operators.hash.
val Structural : Collections.Generic.IEqualityComparer<'T> when 'T : equality
val LimitedStructural : limit:int -> Collections.Generic.IEqualityComparer<'T> when 'T : equality
/// 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.
val Reference : Collections.Generic.IEqualityComparer<'T> when 'T : not struct
/// Hash using the given hashing and equality functions.
val inline FromFunctions : hasher:('T -> int) -> equality:('T -> 'T -> bool) -> Collections.Generic.IEqualityComparer<'T>
/// Common notions of comparison identity used with sorted data structures.
module Microsoft.FSharp.Collections.ComparisonIdentity
/// Structural comparison. Compare using Operators.compare.
val Structural : Collections.Generic.IComparer<'T> when 'T : comparison
/// Compare using the given comparer function.
val FromFunction : comparer:('T -> 'T -> int) -> Collections.Generic.IComparer<'T>
/// Basic operations on arrays.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Collections.Array
/// Builds a new array that contains the elements of the first array followed by the elements of the second array.
val append : array1:'T [] -> array2:'T [] -> 'T []
/// Returns the average of the elements in the array.
val inline average : array: ^T [] -> ^T when ^T : (static member ( + ) : ^T * ^T -> ^T) and ^T : (static member DivideByInt : ^T * int -> ^T) and ^T : (static member Zero : ^T)
/// Returns the average of the elements generated by applying the function to each element of the array.
val inline averageBy : projection:('T -> ^U) -> array:'T [] -> ^U when ^U : (static member ( + ) : ^U * ^U -> ^U) and ^U : (static member DivideByInt : ^U * int -> ^U) and ^U : (static member Zero : ^U)
/// Reads a range of elements from the first array and write them into the second.
val blit : source:'T [] -> sourceIndex:int -> target:'T [] -> targetIndex:int -> count:int -> unit
/// For each element of the array, applies the given function. Concatenates all the results and return the combined array.
val collect : mapping:('T -> 'U []) -> array:'T [] -> 'U []
/// Builds a new array that contains the elements of each of the given sequence of arrays.
val concat : arrays:seq<'T []> -> 'T []
/// Builds a new array that contains the elements of the given array.
val copy : array:'T [] -> 'T []
/// Creates an array whose elements are all initially the given value.
val create : count:int -> value:'T -> 'T []
/// Applies 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.
val tryPick : chooser:('T -> 'U option) -> array:'T [] -> 'U option
/// Fills a range of elements of the array with the given value.
val fill : target:'T [] -> targetIndex:int -> count:int -> value:'T -> unit
/// Applies 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.
val pick : chooser:('T -> 'U option) -> array:'T [] -> 'U
/// Applies the given function to each element of the array. Returns
/// the array comprised of the results "x" for each element where
/// the function returns Some(x)
val choose : chooser:('T -> 'U option) -> array:'T [] -> 'U []
/// Returns an empty array of the given type.
val empty : 'T []
/// Tests if any element of the array satisfies the given predicate.
val exists : predicate:('T -> bool) -> array:'T [] -> bool
/// Tests if any pair of corresponding elements of the arrays satisfies the given predicate.
val exists2 : predicate:('T1 -> 'T2 -> bool) -> array1:'T1 [] -> array2:'T2 [] -> bool
/// Returns a new collection containing only the elements of the collection
/// for which the given predicate returns "true".
val filter : predicate:('T -> bool) -> array:'T [] -> 'T []
/// Returns the first element for which the given function returns 'true'.
/// Raise KeyNotFoundException if no such element exists.
val find : predicate:('T -> bool) -> array:'T [] -> 'T
/// Returns the index of the first element in the array
/// that satisfies the given predicate. Raise KeyNotFoundException if
/// none of the elements satisy the predicate.
val findIndex : predicate:('T -> bool) -> array:'T [] -> int
/// Tests if all elements of the array satisfy the given predicate.
val forall : predicate:('T -> bool) -> array:'T [] -> bool
/// Tests if all corresponding elements of the array satisfy the given predicate pairwise.
val forall2 : predicate:('T1 -> 'T2 -> bool) -> array1:'T1 [] -> array2:'T2 [] -> bool
/// Applies a function to each element of the collection, threading an accumulator argument
/// through the computation. If the input function is f and the elements are i0...iN then computes
/// f (... (f s i0)...) iN
val fold : folder:('State -> 'T -> 'State) -> state:'State -> array:'T [] -> 'State
/// Applies 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))
val foldBack : folder:('T -> 'State -> 'State) -> array:'T [] -> state:'State -> 'State
/// Applies 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.
val fold2 : folder:('State -> 'T1 -> 'T2 -> 'State) -> state:'State -> array1:'T1 [] -> array2:'T2 [] -> 'State
/// 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.
val foldBack2 : folder:('T1 -> 'T2 -> 'State -> 'State) -> array1:'T1 [] -> array2:'T2 [] -> state:'State -> 'State
/// Gets an element from an array.
val get : array:'T [] -> index:int -> 'T
/// Creates an array given the dimension and a generator function to compute the elements.
val inline init : count:int -> initializer:(int -> 'T) -> 'T []
/// Creates an array where the entries are initially the default value Unchecked.defaultof<'T>.
val zeroCreate : count:int -> 'T []
/// Returns true if the given array is empty, otherwise false.
val isEmpty : array:'T [] -> bool
/// Applies the given function to each element of the array.
val inline iter : action:('T -> unit) -> array:'T [] -> unit
/// Applies 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.
val iter2 : action:('T1 -> 'T2 -> unit) -> array1:'T1 [] -> array2:'T2 [] -> unit
/// Applies the given function to each element of the array. The integer passed to the
/// function indicates the index of element.
val iteri : action:(int -> 'T -> unit) -> array:'T [] -> unit
/// Applies 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.
val iteri2 : action:(int -> 'T1 -> 'T2 -> unit) -> array1:'T1 [] -> array2:'T2 [] -> unit
/// Returns the length of an array. You can also use property arr.Length.
val length : array:'T [] -> int
/// Builds a new array whose elements are the results of applying the given function
/// to each of the elements of the array.
val inline map : mapping:('T -> 'U) -> array:'T [] -> 'U []
/// Builds 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.
val map2 : mapping:('T1 -> 'T2 -> 'U) -> array1:'T1 [] -> array2:'T2 [] -> 'U []
/// Builds 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.
val mapi2 : mapping:(int -> 'T1 -> 'T2 -> 'U) -> array1:'T1 [] -> array2:'T2 [] -> 'U []
/// Builds 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.
val mapi : mapping:(int -> 'T -> 'U) -> array:'T [] -> 'U []
/// Returns the greatest of all elements of the array, compared via Operators.max on the function result.
val inline max : array:'T [] -> 'T when 'T : comparison
/// Returns the greatest of all elements of the array, compared via Operators.max on the function result.
val inline maxBy : projection:('T -> 'U) -> array:'T [] -> 'T when 'U : comparison
/// Returns the lowest of all elements of the array, compared via Operators.min.
val inline min : array:'T [] -> 'T when 'T : comparison
/// Returns the lowest of all elements of the array, compared via Operators.min on the function result.
val inline minBy : projection:('T -> 'U) -> array:'T [] -> 'T when 'U : comparison
/// Builds an array from the given list.
val ofList : list:'T list -> 'T []
/// Builds a new array from the given enumerable object.
val ofSeq : source:seq<'T> -> 'T []
/// Splits the collection into two collections, containing the
/// elements for which the given predicate returns "true" and "false"
/// respectively.
val partition : predicate:('T -> bool) -> array:'T [] -> 'T [] * 'T []
/// Returns an array with all elements permuted according to the
/// specified permutation.
val permute : indexMap:(int -> int) -> array:'T [] -> 'T []
/// Applies 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.
val reduce : reduction:('T -> 'T -> 'T) -> array:'T [] -> 'T
/// Applies 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.
val reduceBack : reduction:('T -> 'T -> 'T) -> array:'T [] -> 'T
/// Returns a new array with the elements in reverse order.
val rev : array:'T [] -> 'T []
/// Like fold, but return the intermediary and final results.
val scan : folder:('State -> 'T -> 'State) -> state:'State -> array:'T [] -> 'State []
/// Like foldBack, but return both the intermediary and final results.
val scanBack : folder:('T -> 'State -> 'State) -> array:'T [] -> state:'State -> 'State []
/// Sets an element of an array.
val set : array:'T [] -> index:int -> value:'T -> unit
/// Builds a new array that contains the given subrange specified by
/// starting index and length.
val sub : array:'T [] -> startIndex:int -> count:int -> 'T []
/// Sorts the elements of an array, returning a new array. Elements are compared using Operators.compare.
val sort : array:'T [] -> 'T [] when 'T : comparison
/// Sorts the elements of an array, using the given projection for the keys and returning a new array.
/// Elements are compared using Operators.compare.
val sortBy : projection:('T -> 'Key) -> array:'T [] -> 'T [] when 'Key : comparison
/// Sorts the elements of an array, using the given comparison function as the order, returning a new array.
val sortWith : comparer:('T -> 'T -> int) -> array:'T [] -> 'T []
/// Sorts the elements of an array by mutating the array in-place, using the given projection for the keys.
/// Elements are compared using Operators.compare.
val sortInPlaceBy : projection:('T -> 'Key) -> array:'T [] -> unit when 'Key : comparison
/// Sorts the elements of an array by mutating the array in-place, using the given comparison function as the order.
val sortInPlaceWith : comparer:('T -> 'T -> int) -> array:'T [] -> unit
/// Sorts the elements of an array by mutating the array in-place, using the given comparison function.
/// Elements are compared using Operators.compare.
val sortInPlace : array:'T [] -> unit when 'T : comparison
/// Returns the sum of the elements in the array.
val inline sum : array: ^T [] -> ^T when ^T : (static member ( + ) : ^T * ^T -> ^T) and ^T : (static member Zero : ^T)
/// Returns the sum of the results generated by applying the function to each element of the array.
val inline sumBy : projection:('T -> ^U) -> array:'T [] -> ^U when ^U : (static member ( + ) : ^U * ^U -> ^U) and ^U : (static member Zero : ^U)
/// Builds a list from the given array.
val toList : array:'T [] -> 'T list
/// Views the given array as a sequence.
val toSeq : array:'T [] -> seq<'T>
/// Returns the first element for which the given function returns true.
/// Return None if no such element exists.
val tryFind : predicate:('T -> bool) -> array:'T [] -> 'T option
/// Returns the index of the first element in the array
/// that satisfies the given predicate.
val tryFindIndex : predicate:('T -> bool) -> array:'T [] -> int option
/// Splits an array of pairs into two arrays.
val unzip : array:('T1 * 'T2) [] -> 'T1 [] * 'T2 []
/// Splits an array of triples into three arrays.
val unzip3 : array:('T1 * 'T2 * 'T3) [] -> 'T1 [] * 'T2 [] * 'T3 []
/// Combines the two arrays into an array of pairs. The two arrays must have equal lengths, otherwise an ArgumentException is
/// raised.
val zip : array1:'T1 [] -> array2:'T2 [] -> ('T1 * 'T2) []
/// Combines three arrays into an array of pairs. The three arrays must have equal lengths, otherwise an ArgumentException is
/// raised.
val zip3 : array1:'T1 [] -> array2:'T2 [] -> array3:'T3 [] -> ('T1 * 'T2 * 'T3) []
/// Provides parallel operations on arrays
module Parallel =
/// 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).
val choose : chooser:('T -> 'U option) -> array:'T [] -> 'U []
/// For each element of the array, apply the given function. Concatenate all the results and return the combined array.
val collect : mapping:('T -> 'U []) -> array:'T [] -> 'U []
/// Build a new array whose elements are the results of applying the given function
/// to each of the elements of the array.
val map : mapping:('T -> 'U) -> array:'T [] -> 'U []
/// 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.
val mapi : mapping:(int -> 'T -> 'U) -> array:'T [] -> 'U []
/// Apply the given function to each element of the array.
val iter : action:('T -> unit) -> array:'T [] -> unit
/// Apply the given function to each element of the array. The integer passed to the
/// function indicates the index of element.
val iteri : action:(int -> 'T -> unit) -> array:'T [] -> unit
/// Create an array given the dimension and a generator function to compute the elements.
val init : count:int -> initializer:(int -> 'T) -> 'T []
/// Split the collection into two collections, containing the
/// elements for which the given predicate returns "true" and "false"
/// respectively
val partition : predicate:('T -> bool) -> array:'T [] -> 'T [] * 'T []
/// Basic operations on rank 4 arrays.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Collections.Array4D
/// Creates an array whose elements are all initially the given value
val create : length1:int -> length2:int -> length3:int -> length4:int -> initial:'T -> 'T [,,,]
/// Creates an array given the dimensions and a generator function to compute the elements.
val init : length1:int -> length2:int -> length3:int -> length4:int -> initializer:(int -> int -> int -> int -> 'T) -> 'T [,,,]
/// Returns the length of an array in the first dimension
val length1 : array:'T [,,,] -> int
/// Returns the length of an array in the second dimension.
val length2 : array:'T [,,,] -> int
/// Returns the length of an array in the third dimension.
val length3 : array:'T [,,,] -> int
/// Returns the length of an array in the fourth dimension.
val length4 : array:'T [,,,] -> int
/// Creates an array where the entries are initially the "default" value.
val zeroCreate : length1:int -> length2:int -> length3:int -> length4:int -> 'T [,,,]
/// Fetches an element from a 4D array. You can also use the syntax 'array.[index1,index2,index3,index4]'
val get : array:'T [,,,] -> index1:int -> index2:int -> index3:int -> index4:int -> 'T
/// Sets the value of an element in an array. You can also
/// use the syntax 'array.[index1,index2,index3,index4] <- value'.
val set : array:'T [,,,] -> index1:int -> index2:int -> index3:int -> index4:int -> value:'T -> unit
/// Basic operations on rank 3 arrays.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Collections.Array3D
/// Creates an array whose elements are all initially the given value.
val create : length1:int -> length2:int -> length3:int -> initial:'T -> 'T [,,]
/// Creates an array given the dimensions and a generator function to compute the elements.
val init : length1:int -> length2:int -> length3:int -> initializer:(int -> int -> int -> 'T) -> 'T [,,]
/// Fetches an element from a 3D array. You can also use the syntax 'array.[index1,index2,index3]'
val get : array:'T [,,] -> index1:int -> index2:int -> index3:int -> 'T
/// Applies the given function to each element of the array.
val iter : action:('T -> unit) -> array:'T [,,] -> unit
/// Applies the given function to each element of the array. The integer indicies passed to the
/// function indicates the index of element.
val iteri : action:(int -> int -> int -> 'T -> unit) -> array:'T [,,] -> unit
/// Returns the length of an array in the first dimension
val length1 : array:'T [,,] -> int
/// Returns the length of an array in the second dimension.
val length2 : array:'T [,,] -> int
/// Returns the length of an array in the third dimension.
val length3 : array:'T [,,] -> int
/// Builds a new array whose elements are the results of applying the given function
/// to each of the elements of the array.
val map : mapping:('T -> 'U) -> array:'T [,,] -> 'U [,,]
/// Builds 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.
val mapi : mapping:(int -> int -> int -> 'T -> 'U) -> array:'T [,,] -> 'U [,,]
/// Sets the value of an element in an array. You can also
/// use the syntax 'array.[index1,index2,index3] <- value'.
val set : array:'T [,,] -> index1:int -> index2:int -> index3:int -> value:'T -> unit
/// Creates an array where the entries are initially the "default" value.
val zeroCreate : length1:int -> length2:int -> length3:int -> 'T [,,]
/// Basic operations on 2-dimensional arrays.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Collections.Array2D
/// Fetches the base-index for the first dimension of the array.
val base1 : array:'T [,] -> int
/// Fetches the base-index for the second dimension of the array.
val base2 : array:'T [,] -> int
/// Builds a new array whose elements are the same as the input array.
val copy : array:'T [,] -> 'T [,]
/// Reads a range of elements from the first array and write them into the second.
val blit : source:'T [,] -> sourceIndex1:int -> sourceIndex2:int -> target:'T [,] -> targetIndex1:int -> targetIndex2:int -> length1:int -> length2:int -> unit
/// Creates an array given the dimensions and a generator function to compute the elements.
val init : length1:int -> length2:int -> initializer:(int -> int -> 'T) -> 'T [,]
/// Creates an array whose elements are all initially the given value.
val create : length1:int -> length2:int -> value:'T -> 'T [,]
/// Creates an array where the entries are initially Unchecked.defaultof<'T>.
val zeroCreate : length1:int -> length2:int -> 'T [,]
/// Creates a based array given the dimensions and a generator function to compute the elements.
val initBased : base1:int -> base2:int -> length1:int -> length2:int -> initializer:(int -> int -> 'T) -> 'T [,]
/// Creates a based array whose elements are all initially the given value.
val createBased : base1:int -> base2:int -> length1:int -> length2:int -> initial:'T -> 'T [,]
/// Creates a based array where the entries are initially Unchecked.defaultof<'T>.
val zeroCreateBased : base1:int -> base2:int -> length1:int -> length2:int -> 'T [,]
/// Applies the given function to each element of the array.
val iter : action:('T -> unit) -> array:'T [,] -> unit
/// Applies the given function to each element of the array. The integer indices passed to the
/// function indicates the index of element.
val iteri : action:(int -> int -> 'T -> unit) -> array:'T [,] -> unit
/// Returns the length of an array in the first dimension.
val length1 : array:'T [,] -> int
/// Returns the length of an array in the second dimension.
val length2 : array:'T [,] -> int
/// Builds a new array whose elements are the results of applying the given function
/// to each of the elements of the array.
val map : mapping:('T -> 'U) -> array:'T [,] -> 'U [,]
/// Builds 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.
val mapi : mapping:(int -> int -> 'T -> 'U) -> array:'T [,] -> 'U [,]
/// Builds 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.
val rebase : array:'T [,] -> 'T [,]
/// Sets the value of an element in an array. You can also use the syntax array.[index1,index2] <- value.
val set : array:'T [,] -> index1:int -> index2:int -> value:'T -> unit
/// Fetches an element from a 2D array. You can also use the syntax array.[index1,index2].
val get : array:'T [,] -> index1:int -> index2:int -> 'T
Raw
3.1.fsi
namespace Microsoft.FSharp.Reflection
/// Represents a case of a discriminated union type
[<Sealed>]
[<Class>]
type UnionCaseInfo =
/// The type in which the case occurs.
member DeclaringType : Type
/// Returns the custom attributes associated with the case.
member GetCustomAttributes : unit -> obj []
/// Returns the custom attributes associated with the case matching the given attribute type.
member GetCustomAttributes : attributeType:Type -> obj []
/// Returns the custom attributes data associated with the case.
member GetCustomAttributesData : unit -> Collections.Generic.IList<Reflection.CustomAttributeData>
/// The fields associated with the case, represented by a PropertyInfo.
member GetFields : unit -> Reflection.PropertyInfo []
/// The name of the case.
member Name : string
/// The integer tag for the case.
member Tag : int
namespace Microsoft.FSharp.Reflection
/// Contains operations associated with constructing and analyzing values associated with F# types
/// such as records, unions and tuples.
[<AbstractClass>]
[<Sealed>]
type FSharpValue =
/// Reads all the fields from a value built using an instance of an F# exception declaration
static member GetExceptionFields : exn:obj * ?bindingFlags:Reflection.BindingFlags -> obj []
/// Reads a field from a record value.
static member GetRecordField : record:obj * info:Reflection.PropertyInfo -> obj
/// Reads all the fields from a record value.
static member GetRecordFields : record:obj * ?bindingFlags:Reflection.BindingFlags -> obj []
/// Reads a field from a tuple value.
static member GetTupleField : tuple:obj * index:int -> obj
/// Reads all fields from a tuple.
static member GetTupleFields : tuple:obj -> obj []
/// Identify the union case and its fields for an object
static member GetUnionFields : value:obj * unionType:Type * ?bindingFlags:Reflection.BindingFlags -> Reflection.UnionCaseInfo * obj []
/// Builds a typed function from object from a dynamic function implementation
static member MakeFunction : functionType:Type * implementation:(obj -> obj) -> obj
/// Creates an instance of a record type.
static member MakeRecord : recordType:Type * values:obj [] * ?bindingFlags:Reflection.BindingFlags -> obj
/// Creates an instance of a tuple type
static member MakeTuple : tupleElements:obj [] * tupleType:Type -> obj
/// Create a union case value.
static member MakeUnion : unionCase:Reflection.UnionCaseInfo * args:obj [] * ?bindingFlags:Reflection.BindingFlags -> obj
/// Precompute a function for constructing a record value.
static member PreComputeRecordConstructor : recordType:Type * ?bindingFlags:Reflection.BindingFlags -> obj [] -> obj
/// Get a ConstructorInfo for a record type
static member PreComputeRecordConstructorInfo : recordType:Type * ?bindingFlags:Reflection.BindingFlags -> Reflection.ConstructorInfo
/// 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.
static member PreComputeRecordFieldReader : info:Reflection.PropertyInfo -> obj -> obj
/// 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.
static member PreComputeRecordReader : recordType:Type * ?bindingFlags:Reflection.BindingFlags -> obj -> obj []
/// Precomputes a function for reading the values of a particular tuple type
static member PreComputeTupleConstructor : tupleType:Type -> obj [] -> obj
/// Gets a method that constructs objects of the given tuple type.
/// For small tuples, no additional type will be returned.
static member PreComputeTupleConstructorInfo : tupleType:Type -> Reflection.ConstructorInfo * Type option
/// Gets information that indicates how to read a field of a tuple
static member PreComputeTuplePropertyInfo : tupleType:Type * index:int -> Reflection.PropertyInfo * (Type * int) option
/// Precomputes a function for reading the values of a particular tuple type
static member PreComputeTupleReader : tupleType:Type -> obj -> obj []
/// Precomputes a function for constructing a discriminated union value for a particular union case.
static member PreComputeUnionConstructor : unionCase:Reflection.UnionCaseInfo * ?bindingFlags:Reflection.BindingFlags -> obj [] -> obj
/// A method that constructs objects of the given case
static member PreComputeUnionConstructorInfo : unionCase:Reflection.UnionCaseInfo * ?bindingFlags:Reflection.BindingFlags -> Reflection.MethodInfo
/// Precomputes a function for reading all the fields for a particular discriminator case of a union type
static member PreComputeUnionReader : unionCase:Reflection.UnionCaseInfo * ?bindingFlags:Reflection.BindingFlags -> obj -> obj []
/// Precompute a property or static method for reading an integer representing the case tag of a union type.
static member PreComputeUnionTagMemberInfo : unionType:Type * ?bindingFlags:Reflection.BindingFlags -> Reflection.MemberInfo
/// Assumes the given type is a union type.
/// If not, ArgumentException is raised during pre-computation.
static member PreComputeUnionTagReader : unionType:Type * ?bindingFlags:Reflection.BindingFlags -> obj -> int
namespace Microsoft.FSharp.Reflection
/// Contains operations associated with constructing and analyzing F# types such as records, unions and tuples
[<AbstractClass>]
[<Sealed>]
type FSharpType =
/// Reads all the fields from an F# exception declaration, in declaration order
static member GetExceptionFields : exceptionType:Type * ?bindingFlags:Reflection.BindingFlags -> Reflection.PropertyInfo []
/// Gets the domain and range types from an F# function type or from the runtime type of a closure implementing an F# type
static member GetFunctionElements : functionType:Type -> Type * Type
/// Reads all the fields from a record value, in declaration order
static member GetRecordFields : recordType:Type * ?bindingFlags:Reflection.BindingFlags -> Reflection.PropertyInfo []
/// Gets the tuple elements from the representation of an F# tuple type.
static member GetTupleElements : tupleType:Type -> Type []
/// Gets the cases of a union type.
static member GetUnionCases : unionType:Type * ?bindingFlags:Reflection.BindingFlags -> Reflection.UnionCaseInfo []
/// Returns true if the typ is a representation of an F# exception declaration
static member IsExceptionRepresentation : exceptionType:Type * ?bindingFlags:Reflection.BindingFlags -> bool
/// 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
static member IsFunction : typ:Type -> bool
/// Return true if the typ is a System.Type value corresponding to the compiled form of an F# module
static member IsModule : typ:Type -> bool
/// Return true if the typ is a representation of an F# record type
static member IsRecord : typ:Type * ?bindingFlags:Reflection.BindingFlags -> bool
/// Return true if the typ is a representation of an F# tuple type
static member IsTuple : typ:Type -> bool
/// Returns true if the typ is a representation of an F# union type or the runtime type of a value of that type
static member IsUnion : typ:Type * ?bindingFlags:Reflection.BindingFlags -> bool
/// Returns a System.Type representing the F# function type with the given domain and range
static member MakeFunctionType : domain:Type * range:Type -> Type
/// Returns a System.Type representing an F# tuple type with the given element types
static member MakeTupleType : types:Type [] -> Type
[<AutoOpen>]
module Microsoft.FSharp.Reflection.FSharpReflectionExtensions
/// Creates an instance of a record type.
val MakeRecord : recordType:Type * values:obj [] * ?allowAccessToPrivateRepresentation:bool -> obj
/// Reads all the fields from a record value.
val GetRecordFields : record:obj * ?allowAccessToPrivateRepresentation:bool -> obj []
/// 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.
val PreComputeRecordReader : recordType:Type * ?allowAccessToPrivateRepresentation:bool -> obj -> obj []
/// Precompute a function for constructing a record value.
val PreComputeRecordConstructor : recordType:Type * ?allowAccessToPrivateRepresentation:bool -> obj [] -> obj
/// Get a ConstructorInfo for a record type
val PreComputeRecordConstructorInfo : recordType:Type * ?allowAccessToPrivateRepresentation:bool -> Reflection.ConstructorInfo
/// Create a union case value.
val MakeUnion : unionCase:Reflection.UnionCaseInfo * args:obj [] * ?allowAccessToPrivateRepresentation:bool -> obj
/// Identify the union case and its fields for an object
val GetUnionFields : value:obj * unionType:Type * ?allowAccessToPrivateRepresentation:bool -> Reflection.UnionCaseInfo * obj []
/// Assumes the given type is a union type.
/// If not, ArgumentException is raised during pre-computation.
val PreComputeUnionTagReader : unionType:Type * ?allowAccessToPrivateRepresentation:bool -> obj -> int
/// Precompute a property or static method for reading an integer representing the case tag of a union type.
val PreComputeUnionTagMemberInfo : unionType:Type * ?allowAccessToPrivateRepresentation:bool -> Reflection.MemberInfo
/// Precomputes a function for reading all the fields for a particular discriminator case of a union type
val PreComputeUnionReader : unionCase:Reflection.UnionCaseInfo * ?allowAccessToPrivateRepresentation:bool -> obj -> obj []
/// Precomputes a function for constructing a discriminated union value for a particular union case.
val PreComputeUnionConstructor : unionCase:Reflection.UnionCaseInfo * ?allowAccessToPrivateRepresentation:bool -> obj [] -> obj
/// A method that constructs objects of the given case
val PreComputeUnionConstructorInfo : unionCase:Reflection.UnionCaseInfo * ?allowAccessToPrivateRepresentation:bool -> Reflection.MethodInfo
/// Reads all the fields from a value built using an instance of an F# exception declaration
val GetExceptionFields : exn:obj * ?allowAccessToPrivateRepresentation:bool -> obj []
/// Reads all the fields from a record value, in declaration order
val GetRecordFields : recordType:Type * ?allowAccessToPrivateRepresentation:bool -> Reflection.PropertyInfo []
/// Gets the cases of a union type.
val GetUnionCases : unionType:Type * ?allowAccessToPrivateRepresentation:bool -> Reflection.UnionCaseInfo []
/// Return true if the typ is a representation of an F# record type
val IsRecord : typ:Type * ?allowAccessToPrivateRepresentation:bool -> bool
/// Returns true if the typ is a representation of an F# union type or the runtime type of a value of that type
val IsUnion : typ:Type * ?allowAccessToPrivateRepresentation:bool -> bool
/// Reads all the fields from an F# exception declaration, in declaration order
val GetExceptionFields : exceptionType:Type * ?allowAccessToPrivateRepresentation:bool -> Reflection.PropertyInfo []
/// Returns true if the typ is a representation of an F# exception declaration
val IsExceptionRepresentation : exceptionType:Type * ?allowAccessToPrivateRepresentation:bool -> bool
namespace Microsoft.FSharp.Quotations
/// Information at the binding site of a variable
[<Sealed>]
[<CompiledName("FSharpVar")>]
type Var =
/// Creates a new variable with the given name, type and mutability
new : name:string * typ:Type * ?isMutable:bool -> Var
/// Indicates if the variable represents a mutable storage location
member IsMutable : bool
/// The declared name of the variable
member Name : string
/// The type associated with the variable
member Type : Type
/// Fetches or create a new variable with the given name and type from a global pool of shared variables
/// indexed by name and type
static member Global : name:string * typ:Type -> Quotations.Var
namespace Microsoft.FSharp.Quotations
/// Quoted expressions annotated with System.Type values.
[<CompiledName("FSharpExpr")>]
[<Class>]
type Expr =
/// Returns the custom attributes of an expression.
member CustomAttributes : Quotations.Expr list
override Equals : obj:obj -> bool
/// Gets the free expression variables of an expression as a list.
member GetFreeVars : unit -> seq<Quotations.Var>
/// Substitutes 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.
member Substitute : substitution:(Quotations.Var -> Quotations.Expr option) -> Quotations.Expr
/// Format the expression as a string
member ToString : full:bool -> string
/// Returns type of an expression.
member Type : Type
/// Builds an expression that represents getting the address of a value.
static member AddressOf : target:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents setting the value held at a particular address.
static member AddressSet : target:Quotations.Expr * value:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents the application of a first class function value to a single argument.
static member Application : functionExpr:Quotations.Expr * argument:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents the application of a first class function value to multiple arguments
static member Applications : functionExpr:Quotations.Expr * arguments:Quotations.Expr list list -> Quotations.Expr
/// Builds an expression that represents a call to an static method or module-bound function
static member Call : methodInfo:Reflection.MethodInfo * arguments:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents a call to an instance method associated with an object
static member Call : obj:Quotations.Expr * methodInfo:Reflection.MethodInfo * arguments:Quotations.Expr list -> Quotations.Expr
/// Returns 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.
static member Cast : source:Quotations.Expr -> Quotations.Expr<'T>
/// Builds an expression that represents the coercion of an expression to a type
static member Coerce : source:Quotations.Expr * target:Type -> Quotations.Expr
/// Builds an expression that represents the invocation of a default object constructor
static member DefaultValue : expressionType:Type -> Quotations.Expr
/// 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 quoted 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.
static member Deserialize : qualifyingType:Type * spliceTypes:Type list * spliceExprs:Quotations.Expr list * bytes:byte [] -> Quotations.Expr
/// Builds an expression that represents the access of a static field
static member FieldGet : fieldInfo:Reflection.FieldInfo -> Quotations.Expr
/// Builds an expression that represents the access of a field of an object
static member FieldGet : obj:Quotations.Expr * fieldInfo:Reflection.FieldInfo -> Quotations.Expr
/// Builds an expression that represents writing to a static field
static member FieldSet : fieldInfo:Reflection.FieldInfo * value:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents writing to a field of an object
static member FieldSet : obj:Quotations.Expr * fieldInfo:Reflection.FieldInfo * value:Quotations.Expr -> Quotations.Expr
/// Builds a 'for i = ... to ... do ...' expression that represent loops over integer ranges
static member ForIntegerRangeLoop : loopVariable:Quotations.Var * start:Quotations.Expr * endExpr:Quotations.Expr * body:Quotations.Expr -> Quotations.Expr
/// Fetches or creates 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
static member GlobalVar : name:string -> Quotations.Expr<'T>
/// Builds 'if ... then ... else' expressions.
static member IfThenElse : guard:Quotations.Expr * thenExpr:Quotations.Expr * elseExpr:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents the constrution of an F# function value
static member Lambda : parameter:Quotations.Var * body:Quotations.Expr -> Quotations.Expr
/// Builds expressions associated with 'let' constructs
static member Let : letVariable:Quotations.Var * letExpr:Quotations.Expr * body:Quotations.Expr -> Quotations.Expr
/// Builds recursives expressions associated with 'let rec' constructs
static member LetRecursive : bindings:(Quotations.Var * Quotations.Expr) list * body:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents the creation of an array value initialized with the given elements
static member NewArray : elementType:Type * elements:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents the creation of a delegate value for the given type
static member NewDelegate : delegateType:Type * parameters:Quotations.Var list * body:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents the invocation of an object constructor
static member NewObject : constructorInfo:Reflection.ConstructorInfo * arguments:Quotations.Expr list -> Quotations.Expr
/// Builds record-construction expressions
static member NewRecord : recordType:Type * elements:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents the creation of an F# tuple value
static member NewTuple : elements:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents the creation of a union case value
static member NewUnionCase : unionCase:Reflection.UnionCaseInfo * arguments:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents reading a property of an object
static member PropertyGet : obj:Quotations.Expr * property:Reflection.PropertyInfo * ?indexerArgs:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents reading a static property
static member PropertyGet : property:Reflection.PropertyInfo * ?indexerArgs:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents writing to a property of an object
static member PropertySet : obj:Quotations.Expr * property:Reflection.PropertyInfo * value:Quotations.Expr * ?indexerArgs:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents writing to a static property
static member PropertySet : property:Reflection.PropertyInfo * value:Quotations.Expr * ?indexerArgs:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents a nested quotation literal
static member Quote : inner:Quotations.Expr -> Quotations.Expr
/// Permits 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.
static member RegisterReflectedDefinitions : assembly:Reflection.Assembly * resource:string * serializedValue:byte [] -> unit
/// Builds an expression that represents the sequential execution of one expression followed by another
static member Sequential : first:Quotations.Expr * second:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents a try/finally construct
static member TryFinally : body:Quotations.Expr * compensation:Quotations.Expr -> Quotations.Expr
/// 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.
static member TryGetReflectedDefinition : methodBase:Reflection.MethodBase -> Quotations.Expr option
/// Builds an expression that represents a try/with construct for exception filtering and catching.
static member TryWith : body:Quotations.Expr * filterVar:Quotations.Var * filterBody:Quotations.Expr * catchVar:Quotations.Var * catchBody:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents getting a field of a tuple
static member TupleGet : tuple:Quotations.Expr * index:int -> Quotations.Expr
/// Builds an expression that represents a type test.
static member TypeTest : source:Quotations.Expr * target:Type -> Quotations.Expr
/// Builds an expression that represents a test of a value is of a particular union case
static member UnionCaseTest : source:Quotations.Expr * unionCase:Reflection.UnionCaseInfo -> Quotations.Expr
/// Builds an expression that represents a constant value of a particular type
static member Value : value:obj * expressionType:Type -> Quotations.Expr
/// Builds an expression that represents a constant value
static member Value : value:'T -> Quotations.Expr
/// Builds an expression that represents a variable
static member Var : variable:Quotations.Var -> Quotations.Expr
/// Builds an expression that represents setting a mutable variable
static member VarSet : variable:Quotations.Var * value:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents a while loop
static member WhileLoop : guard:Quotations.Expr * body:Quotations.Expr -> Quotations.Expr
namespace Microsoft.FSharp.Quotations
/// Type-carrying quoted expressions. Expressions are generated either
/// by quotations in source text or programatically
[<CompiledName("FSharpExpr`1")>]
[<Class>]
type Expr<'T> =
inherit Quotations.Expr
/// Gets the raw expression associated with this type-carrying expression
member Raw : Quotations.Expr
/// Contains a set of primitive F# active patterns to analyze F# expression objects
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
module Microsoft.FSharp.Quotations.Patterns
/// An active pattern to recognize expressions that represent getting the address of a value
val (|AddressOf|_|) : input:Quotations.Expr -> Quotations.Expr option
/// An active pattern to recognize expressions that represent setting the value held at an address
val (|AddressSet|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions that represent applications of first class function values
val (|Application|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions that represent calls to static and instance methods, and functions defined in modules
val (|Call|_|) : input:Quotations.Expr -> (Quotations.Expr option * Reflection.MethodInfo * Quotations.Expr list) option
/// An active pattern to recognize expressions that represent coercions from one type to another
val (|Coerce|_|) : input:Quotations.Expr -> (Quotations.Expr * Type) option
/// An active pattern to recognize expressions that represent getting a static or instance field
val (|FieldGet|_|) : input:Quotations.Expr -> (Quotations.Expr option * Reflection.FieldInfo) option
/// An active pattern to recognize expressions that represent setting a static or instance field
val (|FieldSet|_|) : input:Quotations.Expr -> (Quotations.Expr option * Reflection.FieldInfo * Quotations.Expr) option
/// An active pattern to recognize expressions that represent loops over integer ranges
val (|ForIntegerRangeLoop|_|) : input:Quotations.Expr -> (Quotations.Var * Quotations.Expr * Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions that represent while loops
val (|WhileLoop|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions that represent conditionals
val (|IfThenElse|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions that represent first class function values
val (|Lambda|_|) : input:Quotations.Expr -> (Quotations.Var * Quotations.Expr) option
/// An active pattern to recognize expressions that represent let bindings
val (|Let|_|) : input:Quotations.Expr -> (Quotations.Var * Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions that represent recursive let bindings of one or more variables
val (|LetRecursive|_|) : input:Quotations.Expr -> ((Quotations.Var * Quotations.Expr) list * Quotations.Expr) option
/// An active pattern to recognize expressions that represent the construction of arrays
val (|NewArray|_|) : input:Quotations.Expr -> (Type * Quotations.Expr list) option
/// An active pattern to recognize expressions that represent invocations of a default constructor of a struct
val (|DefaultValue|_|) : input:Quotations.Expr -> Type option
/// An active pattern to recognize expressions that represent construction of delegate values
val (|NewDelegate|_|) : input:Quotations.Expr -> (Type * Quotations.Var list * Quotations.Expr) option
/// An active pattern to recognize expressions that represent invocation of object constructors
val (|NewObject|_|) : input:Quotations.Expr -> (Reflection.ConstructorInfo * Quotations.Expr list) option
/// An active pattern to recognize expressions that represent construction of record values
val (|NewRecord|_|) : input:Quotations.Expr -> (Type * Quotations.Expr list) option
/// An active pattern to recognize expressions that represent construction of particular union case values
val (|NewUnionCase|_|) : input:Quotations.Expr -> (Reflection.UnionCaseInfo * Quotations.Expr list) option
/// An active pattern to recognize expressions that represent construction of tuple values
val (|NewTuple|_|) : input:Quotations.Expr -> Quotations.Expr list option
/// 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
val (|PropertyGet|_|) : input:Quotations.Expr -> (Quotations.Expr option * Reflection.PropertyInfo * Quotations.Expr list) option
/// An active pattern to recognize expressions that represent setting a static or instance property, or a non-function value declared in a module
val (|PropertySet|_|) : input:Quotations.Expr -> (Quotations.Expr option * Reflection.PropertyInfo * Quotations.Expr list * Quotations.Expr) option
/// An active pattern to recognize expressions that represent a nested quotation literal
val (|Quote|_|) : input:Quotations.Expr -> Quotations.Expr option
/// An active pattern to recognize expressions that represent sequential exeuction of one expression followed by another
val (|Sequential|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions that represent a try/with construct for exception filtering and catching
val (|TryWith|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Var * Quotations.Expr * Quotations.Var * Quotations.Expr) option
/// An active pattern to recognize expressions that represent a try/finally construct
val (|TryFinally|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions that represent getting a tuple field
val (|TupleGet|_|) : input:Quotations.Expr -> (Quotations.Expr * int) option
/// An active pattern to recognize expressions that represent a dynamic type test
val (|TypeTest|_|) : input:Quotations.Expr -> (Quotations.Expr * Type) option
/// An active pattern to recognize expressions that represent a test if a value is of a particular union case
val (|UnionCaseTest|_|) : input:Quotations.Expr -> (Quotations.Expr * Reflection.UnionCaseInfo) option
/// An active pattern to recognize expressions that represent a constant value
val (|Value|_|) : input:Quotations.Expr -> (obj * Type) option
/// An active pattern to recognize expressions that represent a variable
val (|Var|_|) : input:Quotations.Expr -> Quotations.Var option
/// An active pattern to recognize expressions that represent setting a mutable variable
val (|VarSet|_|) : input:Quotations.Expr -> (Quotations.Var * Quotations.Expr) option
/// Contains a set of derived F# active patterns to analyze F# expression objects
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
module Microsoft.FSharp.Quotations.DerivedPatterns
/// An active pattern to recognize expressions that represent a (possibly curried or tupled) first class function value
val (|Lambdas|_|) : input:Quotations.Expr -> (Quotations.Var list list * Quotations.Expr) option
/// An active pattern to recognize expressions that represent the application of a (possibly curried or tupled) first class function value
val (|Applications|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr list list) option
/// An active pattern to recognize expressions of the form a && b
val (|AndAlso|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions of the form a || b
val (|OrElse|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize () constant expressions
val (|Unit|_|) : input:Quotations.Expr -> unit option
/// An active pattern to recognize constant boolean expressions
val (|Bool|_|) : input:Quotations.Expr -> bool option
/// An active pattern to recognize constant string expressions
val (|String|_|) : input:Quotations.Expr -> string option
/// An active pattern to recognize constant 32-bit floating point number expressions
val (|Single|_|) : input:Quotations.Expr -> float32 option
/// An active pattern to recognize constant 64-bit floating point number expressions
val (|Double|_|) : input:Quotations.Expr -> float option
/// An active pattern to recognize constant unicode character expressions
val (|Char|_|) : input:Quotations.Expr -> char option
/// An active pattern to recognize constant signed byte expressions
val (|SByte|_|) : input:Quotations.Expr -> sbyte option
/// An active pattern to recognize constant byte expressions
val (|Byte|_|) : input:Quotations.Expr -> byte option
/// An active pattern to recognize constant int16 expressions
val (|Int16|_|) : input:Quotations.Expr -> int16 option
/// An active pattern to recognize constant unsigned int16 expressions
val (|UInt16|_|) : input:Quotations.Expr -> uint16 option
/// An active pattern to recognize constant int32 expressions
val (|Int32|_|) : input:Quotations.Expr -> int32 option
/// An active pattern to recognize constant unsigned int32 expressions
val (|UInt32|_|) : input:Quotations.Expr -> uint32 option
/// An active pattern to recognize constant int64 expressions
val (|Int64|_|) : input:Quotations.Expr -> int64 option
/// An active pattern to recognize constant unsigned int64 expressions
val (|UInt64|_|) : input:Quotations.Expr -> uint64 option
/// A parameterized active pattern to recognize calls to a specified function or method.
/// The returned elements are the optional target object (present if the target is an
/// instance method), the generic type instantation (non-empty if the target is a generic
/// instantiation), and the arguments to the function or method.
val (|SpecificCall|_|) : templateParameter:Quotations.Expr -> Quotations.Expr -> (Quotations.Expr option * Type list * Quotations.Expr list) option
/// An active pattern to recognize methods that have an associated ReflectedDefinition
val (|MethodWithReflectedDefinition|_|) : methodBase:Reflection.MethodBase -> Quotations.Expr option
/// An active pattern to recognize property getters or values in modules that have an associated ReflectedDefinition
val (|PropertyGetterWithReflectedDefinition|_|) : propertyInfo:Reflection.PropertyInfo -> Quotations.Expr option
/// An active pattern to recognize property setters that have an associated ReflectedDefinition
val (|PropertySetterWithReflectedDefinition|_|) : propertyInfo:Reflection.PropertyInfo -> Quotations.Expr option
/// Active patterns for traversing, visiting, rebuilding and tranforming expressions in a generic way
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
module Microsoft.FSharp.Quotations.ExprShape
/// An active pattern that performs a complete decomposition viewing the expression tree as a binding structure
val (|ShapeVar|ShapeLambda|ShapeCombination|) : input:Quotations.Expr -> Choice<Quotations.Var,(Quotations.Var * Quotations.Expr),(obj * Quotations.Expr list)>
/// Re-build combination expressions. The first parameter should be an object
/// returned by the ShapeCombination case of the active pattern in this module.
val RebuildShapeCombination : shape:obj * arguments:Quotations.Expr list -> Quotations.Expr
/// Contains operations on native pointers. Use of these operators may
/// result in the generation of unverifiable code.
[<RequireQualifiedAccess>]
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
module Microsoft.FSharp.NativeInterop.NativePtr
/// Returns a typed native pointer for a given machine address.
val inline ofNativeInt : address:nativeint -> nativeptr<'T> when 'T : unmanaged
/// Returns a machine address for a given typed native pointer.
val inline toNativeInt : address:nativeptr<'T> -> nativeint when 'T : unmanaged
/// Returns a typed native pointer by adding index * sizeof<'T> to the
/// given input pointer.
val inline add : address:nativeptr<'T> -> index:int -> nativeptr<'T> when 'T : unmanaged
/// Dereferences the typed native pointer computed by adding index * sizeof<'T> to the
/// given input pointer.
val inline get : address:nativeptr<'T> -> index:int -> 'T when 'T : unmanaged
/// Dereferences the given typed native pointer.
val inline read : address:nativeptr<'T> -> 'T when 'T : unmanaged
/// Assigns the value into the memory location referenced by the given typed native pointer.
val inline write : address:nativeptr<'T> -> value:'T -> unit when 'T : unmanaged
/// Assigns the value into the memory location referenced by the typed native
/// pointer computed by adding index * sizeof<'T> to the given input pointer.
val inline set : address:nativeptr<'T> -> index:int -> value:'T -> unit when 'T : unmanaged
/// Allocates a region of memory on the stack.
val inline stackalloc : count:int -> nativeptr<'T> when 'T : unmanaged
module Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter
/// When used in a quotation, this function indicates a specific conversion
/// should be performed when converting the quotation to a LINQ expression.
///
/// This function should not be called directly.
val ImplicitExpressionConversionHelper : 'T -> Linq.Expressions.Expression<'T>
/// When used in a quotation, this function indicates a specific conversion
/// should be performed when converting the quotation to a LINQ expression.
///
/// This function should not be called directly.
val MemberInitializationHelper : 'T -> 'T
/// When used in a quotation, this function indicates a specific conversion
/// should be performed when converting the quotation to a LINQ expression.
///
/// This function should not be called directly.
val NewAnonymousObjectHelper : 'T -> 'T
/// Converts a subset of F# quotations to a LINQ expression, for the subset of LINQ expressions represented by the
/// expression syntax in the C# language.
val QuotationToExpression : Quotations.Expr -> Linq.Expressions.Expression
/// Converts a subset of F# quotations to a LINQ expression, for the subset of LINQ expressions represented by the
/// expression syntax in the C# language.
val QuotationToLambdaExpression : Quotations.Expr<'T> -> Linq.Expressions.Expression<'T>
/// Evaluates a subset of F# quotations by first converting to a LINQ expression, for the subset of LINQ expressions represented by the
/// expression syntax in the C# language.
val EvaluateQuotation : Quotations.Expr -> obj
/// A runtime helper used to evaluate nested quotation literals.
val SubstHelper : Quotations.Expr * Quotations.Var [] * obj [] -> Quotations.Expr<'T>
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// A type used to reconstruct a grouping after applying a mutable->immutable mapping transformation
/// on a result of a query.
type Grouping<'K, 'T> =
interface System.Collections.Generic.IEnumerable<'T>
interface System.Collections.IEnumerable
interface System.Linq.IGrouping<'K,'T>
new : key:'K * values:seq<'T> -> Grouping<'K, 'T>
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// This type shouldn't be used directly from user code.
type AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8> =
new : Item1:'T1 * Item2:'T2 * Item3:'T3 * Item4:'T4 * Item5:'T5 * Item6:'T6 * Item7:'T7 * Item8:'T8 -> AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8>
member Item1 : 'T1
member Item2 : 'T2
member Item3 : 'T3
member Item4 : 'T4
member Item5 : 'T5
member Item6 : 'T6
member Item7 : 'T7
member Item8 : 'T8
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// This type shouldn't be used directly from user code.
type AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7> =
new : Item1:'T1 * Item2:'T2 * Item3:'T3 * Item4:'T4 * Item5:'T5 * Item6:'T6 * Item7:'T7 -> AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7>
member Item1 : 'T1
member Item2 : 'T2
member Item3 : 'T3
member Item4 : 'T4
member Item5 : 'T5
member Item6 : 'T6
member Item7 : 'T7
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// This type shouldn't be used directly from user code.
type AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5, 'T6> =
new : Item1:'T1 * Item2:'T2 * Item3:'T3 * Item4:'T4 * Item5:'T5 * Item6:'T6 -> AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5, 'T6>
member Item1 : 'T1
member Item2 : 'T2
member Item3 : 'T3
member Item4 : 'T4
member Item5 : 'T5
member Item6 : 'T6
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// This type shouldn't be used directly from user code.
type AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5> =
new : Item1:'T1 * Item2:'T2 * Item3:'T3 * Item4:'T4 * Item5:'T5 -> AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5>
member Item1 : 'T1
member Item2 : 'T2
member Item3 : 'T3
member Item4 : 'T4
member Item5 : 'T5
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// This type shouldn't be used directly from user code.
type AnonymousObject<'T1, 'T2, 'T3, 'T4> =
new : Item1:'T1 * Item2:'T2 * Item3:'T3 * Item4:'T4 -> AnonymousObject<'T1, 'T2, 'T3, 'T4>
member Item1 : 'T1
member Item2 : 'T2
member Item3 : 'T3
member Item4 : 'T4
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// This type shouldn't be used directly from user code.
type AnonymousObject<'T1, 'T2, 'T3> =
new : Item1:'T1 * Item2:'T2 * Item3:'T3 -> AnonymousObject<'T1, 'T2, 'T3>
member Item1 : 'T1
member Item2 : 'T2
member Item3 : 'T3
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// This type shouldn't be used directly from user code.
type AnonymousObject<'T1, 'T2> =
new : Item1:'T1 * Item2:'T2 -> AnonymousObject<'T1, 'T2>
member Item1 : 'T1
member Item2 : 'T2
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// This type shouldn't be used directly from user code.
type AnonymousObject<'T1> =
new : Item1:'T1 -> AnonymousObject<'T1>
member Item1 : 'T1
namespace Microsoft.FSharp.Linq
/// A partial input or result in an F# query. This type is used to support the F# query syntax.
[<NoComparison>]
[<NoEquality>]
[<Sealed>]
type QuerySource<'T, 'Q> =
/// A method used to support the F# query syntax.
new : seq<'T> -> QuerySource<'T, 'Q>
/// A property used to support the F# query syntax.
member Source : seq<'T>
module Microsoft.FSharp.Linq.QueryRunExtensions.LowPriority
/// A method used to support the F# query syntax. Runs the given quotation as a query using LINQ rules.
val Run : Quotations.Expr<'T> -> 'T
module Microsoft.FSharp.Linq.QueryRunExtensions.HighPriority
/// A method used to support the F# query syntax. Runs the given quotation as a query using LINQ IEnumerable rules.
val Run : Quotations.Expr<Linq.QuerySource<'T,Collections.IEnumerable>> -> seq<'T>
namespace Microsoft.FSharp.Linq
/// The type used to support the F# query syntax. Use 'query { ... }' to use the query syntax.
[<Class>]
type QueryBuilder =
/// Create an instance of this builder. Use 'query { ... }' to use the query syntax.
new : unit -> QueryBuilder
/// A query operator that determines whether all elements selected so far satisfies a condition.
[<CustomOperation("all")>]
member All : source:Linq.QuerySource<'T,'Q> * predicate:('T -> bool) -> bool
/// A query operator that selects a value for each element selected so far and returns the average of these values.
[<CustomOperation("averageBy")>]
member inline AverageBy : source:Linq.QuerySource<'T,'Q> * projection:('T -> ^Value) -> ^Value when ^Value : (static member ( + ) : ^Value * ^Value -> ^Value) and ^Value : (static member DivideByInt : ^Value * int -> ^Value) and ^Value : (static member Zero : ^Value)
/// A query operator that selects a nullable value for each element selected so far and returns the average of these values.
/// If any nullable does not have a value, it is ignored.
[<CustomOperation("averageByNullable")>]
member inline AverageByNullable : source:Linq.QuerySource<'T,'Q> * projection:('T -> Nullable< ^Value>) -> Nullable< ^Value> when ^Value : (static member ( + ) : ^Value * ^Value -> ^Value) and ^Value : (static member DivideByInt : ^Value * int -> ^Value) and ^Value : (static member Zero : ^Value) and ^Value : (new : unit -> ^Value) and ^Value : struct and ^Value :> ValueType
/// A query operator that determines whether the selected elements contains a specified element.
[<CustomOperation("contains")>]
member Contains : source:Linq.QuerySource<'T,'Q> * key:'T -> bool
/// A query operator that returns the number of selected elements.
[<CustomOperation("count")>]
member Count : source:Linq.QuerySource<'T,'Q> -> int
/// A query operator that selects distinct elements from the elements selected so far.
[<CustomOperation("distinct")>]
member Distinct : source:Linq.QuerySource<'T,'Q> -> Linq.QuerySource<'T,'Q> when 'T : equality
/// A query operator that selects the single, specific element selected so far
[<CustomOperation("exactlyOne")>]
member ExactlyOne : source:Linq.QuerySource<'T,'Q> -> 'T
/// A query operator that selects the single, specific element of those selected so far, or a default value if that element is not found.
[<CustomOperation("exactlyOneOrDefault")>]
member ExactlyOneOrDefault : source:Linq.QuerySource<'T,'Q> -> 'T
/// A query operator that determines whether any element selected so far satisfies a condition.
[<CustomOperation("exists")>]
member Exists : source:Linq.QuerySource<'T,'Q> * predicate:('T -> bool) -> bool
/// A query operator that selects the first element selected so far that satisfies a specified condition.
[<CustomOperation("find")>]
member Find : source:Linq.QuerySource<'T,'Q> * predicate:('T -> bool) -> 'T
/// A method used to support the F# query syntax. Projects each element of a sequence to another sequence and combines the resulting sequences into one sequence.
member For : source:Linq.QuerySource<'T,'Q> * body:('T -> Linq.QuerySource<'Result,'Q2>) -> Linq.QuerySource<'Result,'Q>
/// A query operator that groups the elements selected so far according to a specified key selector.
[<CustomOperation("groupBy")>]
member GroupBy : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> 'Key) -> Linq.QuerySource<Linq.IGrouping<'Key,'T>,'Q> when 'Key : equality
/// A query operator that correlates two sets of selected values based on matching keys and groups the results.
/// Normal usage is 'groupJoin y in elements2 on (key1 = key2) into group'.
[<CustomOperation("groupJoin")>]
member GroupJoin : outerSource:Linq.QuerySource<'Outer,'Q> * innerSource:Linq.QuerySource<'Inner,'Q> * outerKeySelector:('Outer -> 'Key) * innerKeySelector:('Inner -> 'Key) * resultSelector:('Outer -> seq<'Inner> -> 'Result) -> Linq.QuerySource<'Result,'Q>
/// A query operator that selects a value for each element selected so far and groups the elements by the given key.
[<CustomOperation("groupValBy")>]
member GroupValBy : source:Linq.QuerySource<'T,'Q> * resultSelector:('T -> 'Value) * keySelector:('T -> 'Key) -> Linq.QuerySource<Linq.IGrouping<'Key,'Value>,'Q> when 'Key : equality
/// A query operator that selects the first element from those selected so far.
[<CustomOperation("head")>]
member Head : source:Linq.QuerySource<'T,'Q> -> 'T
/// A query operator that selects the first element of those selected so far, or a default value if the sequence contains no elements.
[<CustomOperation("headOrDefault")>]
member HeadOrDefault : source:Linq.QuerySource<'T,'Q> -> 'T
/// A query operator that correlates two sets of selected values based on matching keys.
/// Normal usage is 'join y in elements2 on (key1 = key2)'.
[<CustomOperation("join")>]
member Join : outerSource:Linq.QuerySource<'Outer,'Q> * innerSource:Linq.QuerySource<'Inner,'Q> * outerKeySelector:('Outer -> 'Key) * innerKeySelector:('Inner -> 'Key) * resultSelector:('Outer -> 'Inner -> 'Result) -> Linq.QuerySource<'Result,'Q>
/// A query operator that selects the last element of those selected so far.
[<CustomOperation("last")>]
member Last : source:Linq.QuerySource<'T,'Q> -> 'T
/// A query operator that selects the last element of those selected so far, or a default value if no element is found.
[<CustomOperation("lastOrDefault")>]
member LastOrDefault : source:Linq.QuerySource<'T,'Q> -> 'T
/// A query operator that correlates two sets of selected values based on matching keys and groups the results.
/// If any group is empty, a group with a single default value is used instead.
/// Normal usage is 'leftOuterJoin y in elements2 on (key1 = key2) into group'.
[<CustomOperation("leftOuterJoin")>]
member LeftOuterJoin : outerSource:Linq.QuerySource<'Outer,'Q> * innerSource:Linq.QuerySource<'Inner,'Q> * outerKeySelector:('Outer -> 'Key) * innerKeySelector:('Inner -> 'Key) * resultSelector:('Outer -> seq<'Inner> -> 'Result) -> Linq.QuerySource<'Result,'Q>
/// A query operator that selects a value for each element selected so far and returns the maximum resulting value.
[<CustomOperation("maxBy")>]
member MaxBy : source:Linq.QuerySource<'T,'Q> * valueSelector:('T -> 'Value) -> 'Value when 'Value : comparison
/// A query operator that selects a nullable value for each element selected so far and returns the maximum of these values.
/// If any nullable does not have a value, it is ignored.
[<CustomOperation("maxByNullable")>]
member MaxByNullable : source:Linq.QuerySource<'T,'Q> * valueSelector:('T -> Nullable<'Value>) -> Nullable<'Value> when 'Value : comparison and 'Value : (new : unit -> 'Value) and 'Value : struct and 'Value :> ValueType
/// A query operator that selects a value for each element selected so far and returns the minimum resulting value.
[<CustomOperation("minBy")>]
member MinBy : source:Linq.QuerySource<'T,'Q> * valueSelector:('T -> 'Value) -> 'Value when 'Value : comparison
/// A query operator that selects a nullable value for each element selected so far and returns the minimum of these values.
/// If any nullable does not have a value, it is ignored.
[<CustomOperation("minByNullable")>]
member MinByNullable : source:Linq.QuerySource<'T,'Q> * valueSelector:('T -> Nullable<'Value>) -> Nullable<'Value> when 'Value : comparison and 'Value : (new : unit -> 'Value) and 'Value : struct and 'Value :> ValueType
/// A query operator that selects the element at a specified index amongst those selected so far.
[<CustomOperation("nth")>]
member Nth : source:Linq.QuerySource<'T,'Q> * index:int -> 'T
/// A method used to support the F# query syntax. Indicates that the query should be passed as a quotation to the Run method.
member Quote : Quotations.Expr<'T> -> Quotations.Expr<'T>
/// A method used to support the F# query syntax. Runs the given quotation as a query using LINQ IQueryable rules.
member Run : Quotations.Expr<Linq.QuerySource<'T,Linq.IQueryable>> -> Linq.IQueryable<'T>
/// A query operator that projects each of the elements selected so far.
[<CustomOperation("select")>]
member Select : source:Linq.QuerySource<'T,'Q> * projection:('T -> 'Result) -> Linq.QuerySource<'Result,'Q>
/// A query operator that bypasses a specified number of the elements selected so far and selects the remaining elements.
[<CustomOperation("skip")>]
member Skip : source:Linq.QuerySource<'T,'Q> * count:int -> Linq.QuerySource<'T,'Q>
/// A query operator that bypasses elements in a sequence as long as a specified condition is true and then selects the remaining elements.
[<CustomOperation("skipWhile")>]
member SkipWhile : source:Linq.QuerySource<'T,'Q> * predicate:('T -> bool) -> Linq.QuerySource<'T,'Q>
/// A query operator that sorts the elements selected so far in ascending order by the given sorting key.
[<CustomOperation("sortBy")>]
member SortBy : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> 'Key) -> Linq.QuerySource<'T,'Q> when 'Key : comparison
/// A query operator that sorts the elements selected so far in descending order by the given sorting key.
[<CustomOperation("sortByDescending")>]
member SortByDescending : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> 'Key) -> Linq.QuerySource<'T,'Q> when 'Key : comparison
/// A query operator that sorts the elements selected so far in ascending order by the given nullable sorting key.
[<CustomOperation("sortByNullable")>]
member SortByNullable : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> Nullable<'Key>) -> Linq.QuerySource<'T,'Q> when 'Key : comparison and 'Key : (new : unit -> 'Key) and 'Key : struct and 'Key :> ValueType
/// A query operator that sorts the elements selected so far in descending order by the given nullable sorting key.
[<CustomOperation("sortByNullableDescending")>]
member SortByNullableDescending : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> Nullable<'Key>) -> Linq.QuerySource<'T,'Q> when 'Key : comparison and 'Key : (new : unit -> 'Key) and 'Key : struct and 'Key :> ValueType
/// A method used to support the F# query syntax. Inputs to queries are implicitly wrapped by a call to one of the overloads of this method.
member Source : source:Linq.IQueryable<'T> -> Linq.QuerySource<'T,'Q>
/// A method used to support the F# query syntax. Inputs to queries are implicitly wrapped by a call to one of the overloads of this method.
member Source : source:Collections.Generic.IEnumerable<'T> -> Linq.QuerySource<'T,Collections.IEnumerable>
/// A query operator that selects a value for each element selected so far and returns the sum of these values.
[<CustomOperation("sumBy")>]
member inline SumBy : source:Linq.QuerySource<'T,'Q> * projection:('T -> ^Value) -> ^Value when ^Value : (static member ( + ) : ^Value * ^Value -> ^Value) and ^Value : (static member Zero : ^Value)
/// A query operator that selects a nullable value for each element selected so far and returns the sum of these values.
/// If any nullable does not have a value, it is ignored.
[<CustomOperation("sumByNullable")>]
member inline SumByNullable : source:Linq.QuerySource<'T,'Q> * valueSelector:('T -> Nullable< ^Value>) -> Nullable< ^Value> when ^Value : (static member ( + ) : ^Value * ^Value -> ^Value) and ^Value : (static member Zero : ^Value) and ^Value : (new : unit -> ^Value) and ^Value : struct and ^Value :> ValueType
/// A query operator that selects a specified number of contiguous elements from those selected so far.
[<CustomOperation("take")>]
member Take : source:Linq.QuerySource<'T,'Q> * count:int -> Linq.QuerySource<'T,'Q>
/// A query operator that selects elements from a sequence as long as a specified condition is true, and then skips the remaining elements.
[<CustomOperation("takeWhile")>]
member TakeWhile : source:Linq.QuerySource<'T,'Q> * predicate:('T -> bool) -> Linq.QuerySource<'T,'Q>
/// A query operator that performs a subsequent ordering of the elements selected so far in ascending order by the given sorting key.
/// This operator may only be used immediately after a 'sortBy', 'sortByDescending', 'thenBy' or 'thenByDescending', or their nullable variants.
[<CustomOperation("thenBy")>]
member ThenBy : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> 'Key) -> Linq.QuerySource<'T,'Q> when 'Key : comparison
/// A query operator that performs a subsequent ordering of the elements selected so far in descending order by the given sorting key.
/// This operator may only be used immediately after a 'sortBy', 'sortByDescending', 'thenBy' or 'thenByDescending', or their nullable variants.
[<CustomOperation("thenByDescending")>]
member ThenByDescending : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> 'Key) -> Linq.QuerySource<'T,'Q> when 'Key : comparison
/// A query operator that performs a subsequent ordering of the elements selected so far in ascending order by the given nullable sorting key.
/// This operator may only be used immediately after a 'sortBy', 'sortByDescending', 'thenBy' or 'thenByDescending', or their nullable variants.
[<CustomOperation("thenByNullable")>]
member ThenByNullable : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> Nullable<'Key>) -> Linq.QuerySource<'T,'Q> when 'Key : comparison and 'Key : (new : unit -> 'Key) and 'Key : struct and 'Key :> ValueType
/// A query operator that performs a subsequent ordering of the elements selected so far in descending order by the given nullable sorting key.
/// This operator may only be used immediately after a 'sortBy', 'sortByDescending', 'thenBy' or 'thenByDescending', or their nullable variants.
[<CustomOperation("thenByNullableDescending")>]
member ThenByNullableDescending : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> Nullable<'Key>) -> Linq.QuerySource<'T,'Q> when 'Key : comparison and 'Key : (new : unit -> 'Key) and 'Key : struct and 'Key :> ValueType
/// A query operator that selects those elements based on a specified predicate.
[<CustomOperation("where")>]
member Where : source:Linq.QuerySource<'T,'Q> * predicate:('T -> bool) -> Linq.QuerySource<'T,'Q>
/// A method used to support the F# query syntax. Returns a sequence of length one that contains the specified value.
member Yield : value:'T -> Linq.QuerySource<'T,'Q>
/// A method used to support the F# query syntax. Returns a sequence that contains the specified values.
member YieldFrom : computation:Linq.QuerySource<'T,'Q> -> Linq.QuerySource<'T,'Q>
/// A method used to support the F# query syntax. Returns an empty sequence that has the specified type argument.
member Zero : unit -> Linq.QuerySource<'T,'Q>
/// Operators for working with nullable values
[<AutoOpen>]
module Microsoft.FSharp.Linq.NullableOperators
/// The '>=' operator where a nullable value appears on the left
val ( ?>= ) : Nullable<'T> -> 'T -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '>' operator where a nullable value appears on the left
val ( ?> ) : Nullable<'T> -> 'T -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<=' operator where a nullable value appears on the left
val ( ?<= ) : Nullable<'T> -> 'T -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<' operator where a nullable value appears on the left
val ( ?< ) : Nullable<'T> -> 'T -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '=' operator where a nullable value appears on the left
val ( ?= ) : Nullable<'T> -> 'T -> bool when 'T : equality and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<>' operator where a nullable value appears on the left
val ( ?<> ) : Nullable<'T> -> 'T -> bool when 'T : equality and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '>=' operator where a nullable value appears on the right
val ( >=? ) : 'T -> Nullable<'T> -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '>' operator where a nullable value appears on the right
val ( >? ) : 'T -> Nullable<'T> -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<=' operator where a nullable value appears on the right
val ( <=? ) : 'T -> Nullable<'T> -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<' operator where a nullable value appears on the right
val ( <? ) : 'T -> Nullable<'T> -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '=' operator where a nullable value appears on the right
val ( =? ) : 'T -> Nullable<'T> -> bool when 'T : equality and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<>' operator where a nullable value appears on the right
val ( <>? ) : 'T -> Nullable<'T> -> bool when 'T : equality and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '>=' operator where a nullable value appears on both left and right sides
val ( ?>=? ) : Nullable<'T> -> Nullable<'T> -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '>' operator where a nullable value appears on both left and right sides
val ( ?>? ) : Nullable<'T> -> Nullable<'T> -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<=' operator where a nullable value appears on both left and right sides
val ( ?<=? ) : Nullable<'T> -> Nullable<'T> -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<' operator where a nullable value appears on both left and right sides
val ( ?<? ) : Nullable<'T> -> Nullable<'T> -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '=' operator where a nullable value appears on both left and right sides
val ( ?=? ) : Nullable<'T> -> Nullable<'T> -> bool when 'T : equality and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<>' operator where a nullable value appears on both left and right sides
val ( ?<>? ) : Nullable<'T> -> Nullable<'T> -> bool when 'T : equality and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The addition operator where a nullable value appears on the left
val inline ( ?+ ) : Nullable< ^T1> -> ^T2 -> Nullable< ^T3> when ^T1 : (static member ( + ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( + ) : ^T1 * ^T2 -> ^T3) and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The addition operator where a nullable value appears on the right
val inline ( +? ) : ^T1 -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( + ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( + ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The addition operator where a nullable value appears on both left and right sides
val inline ( ?+? ) : Nullable< ^T1> -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( + ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( + ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The subtraction operator where a nullable value appears on the left
val inline ( ?- ) : Nullable< ^T1> -> ^T2 -> Nullable< ^T3> when ^T1 : (static member ( - ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( - ) : ^T1 * ^T2 -> ^T3) and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The subtraction operator where a nullable value appears on the right
val inline ( -? ) : ^T1 -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( - ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( - ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The subtraction operator where a nullable value appears on both left and right sides
val inline ( ?-? ) : Nullable< ^T1> -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( - ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( - ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The multiplication operator where a nullable value appears on the left
val inline ( ?* ) : Nullable< ^T1> -> ^T2 -> Nullable< ^T3> when ^T1 : (static member ( * ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( * ) : ^T1 * ^T2 -> ^T3) and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The multiplication operator where a nullable value appears on the right
val inline ( *? ) : ^T1 -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( * ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( * ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The multiplication operator where a nullable value appears on both left and right sides
val inline ( ?*? ) : Nullable< ^T1> -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( * ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( * ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The modulus operator where a nullable value appears on the left
val inline ( ?% ) : Nullable< ^T1> -> ^T2 -> Nullable< ^T3> when ^T1 : (static member ( % ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( % ) : ^T1 * ^T2 -> ^T3) and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The modulus operator where a nullable value appears on the right
val inline ( %? ) : ^T1 -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( % ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( % ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The modulus operator where a nullable value appears on both left and right sides
val inline ( ?%? ) : Nullable< ^T1> -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( % ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( % ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The division operator where a nullable value appears on the left
val inline ( ?/ ) : Nullable< ^T1> -> ^T2 -> Nullable< ^T3> when ^T1 : (static member ( / ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( / ) : ^T1 * ^T2 -> ^T3) and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The division operator where a nullable value appears on the right
val inline ( /? ) : ^T1 -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( / ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( / ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The division operator where a nullable value appears on both left and right sides
val inline ( ?/? ) : Nullable< ^T1> -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( / ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( / ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// Functions for converting nullable values
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Linq.Nullable
/// Converts the argument to byte. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline byte : value:Nullable< ^T> -> Nullable<byte> when ^T : (static member op_Explicit : unit -> byte) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to signed byte. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline sbyte : value:Nullable< ^T> -> Nullable<sbyte> when ^T : (static member op_Explicit : unit -> sbyte) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to signed 16-bit integer. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline int16 : value:Nullable< ^T> -> Nullable<int16> when ^T : (static member op_Explicit : unit -> int16) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to unsigned 16-bit integer. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline uint16 : value:Nullable< ^T> -> Nullable<uint16> when ^T : (static member op_Explicit : unit -> uint16) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to signed 32-bit integer. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline int : value:Nullable< ^T> -> Nullable<int> when ^T : (static member op_Explicit : unit -> int) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to a particular enum type.
val inline enum : value:Nullable<int32> -> Nullable< ^U> when 'U : enum<int32> and 'U : (new : unit -> 'U) and 'U : struct and 'U :> ValueType
/// Converts the argument to signed 32-bit integer. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline int32 : value:Nullable< ^T> -> Nullable<int32> when ^T : (static member op_Explicit : unit -> int32) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to unsigned 32-bit integer. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline uint32 : value:Nullable< ^T> -> Nullable<uint32> when ^T : (static member op_Explicit : unit -> uint32) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to signed 64-bit integer. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline int64 : value:Nullable< ^T> -> Nullable<int64> when ^T : (static member op_Explicit : unit -> int64) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to unsigned 64-bit integer. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline uint64 : value:Nullable< ^T> -> Nullable<uint64> when ^T : (static member op_Explicit : unit -> uint64) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to 32-bit float. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline float32 : value:Nullable< ^T> -> Nullable<float32> when ^T : (static member op_Explicit : unit -> float32) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to 64-bit float. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline float : value:Nullable< ^T> -> Nullable<float> when ^T : (static member op_Explicit : unit -> float) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to signed native integer. This is a direct conversion for all
/// primitive numeric types. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline nativeint : value:Nullable< ^T> -> Nullable<nativeint> when ^T : (static member op_Explicit : unit -> nativeint) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to unsigned native integer using a direct conversion for all
/// primitive numeric types. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline unativeint : value:Nullable< ^T> -> Nullable<unativeint> when ^T : (static member op_Explicit : unit -> unativeint) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to System.Decimal using a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline decimal : value:Nullable< ^T> -> Nullable<decimal> when ^T : (static member op_Explicit : unit -> decimal) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to character. Numeric inputs are converted according to the UTF-16
/// encoding for characters. The operation requires an appropriate static conversion method on the input type.
val inline char : value:Nullable< ^T> -> Nullable<char> when ^T : (static member op_Explicit : unit -> char) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for Metre, the SI unit of length
type m = Data.UnitSystems.SI.UnitNames.metre
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for kilogram, the SI unit of mass
type kg = Data.UnitSystems.SI.UnitNames.kilogram
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for second, the SI unit of time
type s = Data.UnitSystems.SI.UnitNames.second
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for ampere, the SI unit of electric current
type A = Data.UnitSystems.SI.UnitNames.ampere
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for kelvin, the SI unit of thermodynamic temperature
type K = Data.UnitSystems.SI.UnitNames.kelvin
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for mole, the SI unit of amount of substance
type mol = Data.UnitSystems.SI.UnitNames.mole
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for candela, the SI unit of luminous intensity
type cd = Data.UnitSystems.SI.UnitNames.candela
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for hertz, the SI unit of frequency
type Hz = Data.UnitSystems.SI.UnitNames.hertz
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for newton, the SI unit of force
type N = Data.UnitSystems.SI.UnitNames.newton
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for pascal, the SI unit of pressure, stress
type Pa = Data.UnitSystems.SI.UnitNames.pascal
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for joule, the SI unit of energy, work, amount of heat
type J = Data.UnitSystems.SI.UnitNames.joule
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for watt, the SI unit of power, radiant flux
type W = Data.UnitSystems.SI.UnitNames.watt
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for coulomb, the SI unit of electric charge, amount of electricity
type C = Data.UnitSystems.SI.UnitNames.coulomb
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for volt, the SI unit of electric potential difference, electromotive force
type V = Data.UnitSystems.SI.UnitNames.volt
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for farad, the SI unit of capacitance
type F = Data.UnitSystems.SI.UnitNames.farad
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for siemens, the SI unit of electric conductance
type S = Data.UnitSystems.SI.UnitNames.siemens
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for UnitNames.ohm, the SI unit of electric resistance.
type ohm = Data.UnitSystems.SI.UnitNames.ohm
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for weber, the SI unit of magnetic flux
type Wb = Data.UnitSystems.SI.UnitNames.weber
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for tesla, the SI unit of magnetic flux density
type T = Data.UnitSystems.SI.UnitNames.tesla
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for lumen, the SI unit of luminous flux
type lm = Data.UnitSystems.SI.UnitNames.lumen
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for lux, the SI unit of illuminance
type lx = Data.UnitSystems.SI.UnitNames.lux
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for becquerel, the SI unit of activity referred to a radionuclide
type Bq = Data.UnitSystems.SI.UnitNames.becquerel
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for gray, the SI unit of absorbed dose
type Gy = Data.UnitSystems.SI.UnitNames.gray
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for sievert, the SI unit of does equivalent
type Sv = Data.UnitSystems.SI.UnitNames.sievert
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for katal, the SI unit of catalytic activity
type kat = Data.UnitSystems.SI.UnitNames.katal
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for henry, the SI unit of inductance
type H = Data.UnitSystems.SI.UnitNames.henry
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of length
[<Measure>]
type metre =
class
end
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of length
type meter = Data.UnitSystems.SI.UnitNames.metre
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of mass
[<Measure>]
type kilogram =
class
end
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of time
[<Measure>]
type second =
class
end
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of electric current
[<Measure>]
type ampere =
class
end
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of thermodynamic temperature
[<Measure>]
type kelvin =
class
end
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of amount of substance
[<Measure>]
type mole =
class
end
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of luminous intensity
[<Measure>]
type candela =
class
end
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of frequency
type hertz = /Data.UnitSystems.SI.UnitNames.second
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of force
type newton = Data.UnitSystems.SI.UnitNames.kilogram Data.UnitSystems.SI.UnitNames.metre/Data.UnitSystems.SI.UnitNames.second ^ 2
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of pressure, stress
type pascal = Data.UnitSystems.SI.UnitNames.newton/Data.UnitSystems.SI.UnitNames.metre ^ 2
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of energy, work, amount of heat
type joule = Data.UnitSystems.SI.UnitNames.metre Data.UnitSystems.SI.UnitNames.newton
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of power, radiant flux
type watt = Data.UnitSystems.SI.UnitNames.joule/Data.UnitSystems.SI.UnitNames.second
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of electric charge, amount of electricity
type coulomb = Data.UnitSystems.SI.UnitNames.ampere Data.UnitSystems.SI.UnitNames.second
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of electric potential difference, electromotive force
type volt = Data.UnitSystems.SI.UnitNames.watt/Data.UnitSystems.SI.UnitNames.ampere
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of capacitance
type farad = Data.UnitSystems.SI.UnitNames.coulomb/Data.UnitSystems.SI.UnitNames.volt
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of electric resistance
type ohm = Data.UnitSystems.SI.UnitNames.volt/Data.UnitSystems.SI.UnitNames.ampere
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of electric conductance
type siemens = Data.UnitSystems.SI.UnitNames.ampere/Data.UnitSystems.SI.UnitNames.volt
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of magnetic flux
type weber = Data.UnitSystems.SI.UnitNames.second Data.UnitSystems.SI.UnitNames.volt
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of magnetic flux density
type tesla = Data.UnitSystems.SI.UnitNames.weber/Data.UnitSystems.SI.UnitNames.metre ^ 2
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of inductance
type henry = Data.UnitSystems.SI.UnitNames.weber/Data.UnitSystems.SI.UnitNames.ampere
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of luminous flux
type lumen = Data.UnitSystems.SI.UnitNames.candela
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of illuminance
type lux = Data.UnitSystems.SI.UnitNames.lumen/Data.UnitSystems.SI.UnitNames.metre ^ 2
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of activity referred to a radionuclide
type becquerel = /Data.UnitSystems.SI.UnitNames.second
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of absorbed dose
type gray = Data.UnitSystems.SI.UnitNames.joule/Data.UnitSystems.SI.UnitNames.kilogram
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of does equivalent
type sievert = Data.UnitSystems.SI.UnitNames.joule/Data.UnitSystems.SI.UnitNames.kilogram
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of catalytic activity
type katal = Data.UnitSystems.SI.UnitNames.mole/Data.UnitSystems.SI.UnitNames.second
namespace Microsoft.FSharp.Core
/// The type 'unit', which has only one value "()". This value is special and
/// always uses the representation 'null'.
type unit = Unit
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.UIntPtr.
type unativeint = UIntPtr
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Byte.
type uint8 = Byte
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.UInt64.
type uint64 = UInt64
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.UInt32.
type uint32 = UInt32
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.UInt16.
type uint16 = UInt16
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.String.
type string = String
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Single.
type single = Single
namespace Microsoft.FSharp.Core
/// 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.
[<MeasureAnnotatedAbbreviation>]
[<Class>]
type sbyte<'Measure> =
inherit System.ValueType
interface System.IConvertible
interface System.IFormattable
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.SByte.
type sbyte = SByte
namespace Microsoft.FSharp.Core
/// The type of mutable references. Use the functions [:=] and [!] to get and
/// set values of this type.
type ref<'T> = Ref<'T>
namespace Microsoft.FSharp.Core
/// The type of optional values. When used from other CLI languages the
/// empty option is the null value.
type option<'T> = Option<'T>
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Object.
type obj = Object
namespace Microsoft.FSharp.Core
/// Represents an unmanaged pointer in F# code.
[<Class>]
type nativeptr<'T when 'T : unmanaged> =
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.IntPtr.
type nativeint = IntPtr
namespace Microsoft.FSharp.Core
/// 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.
[<MeasureAnnotatedAbbreviation>]
[<Class>]
type int<'Measure> =
inherit System.ValueType
interface System.IConvertible
interface System.IFormattable
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.SByte.
type int8 = SByte
namespace Microsoft.FSharp.Core
/// 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.
[<MeasureAnnotatedAbbreviation>]
[<Class>]
type int64<'Measure> =
inherit System.ValueType
interface System.IConvertible
interface System.IFormattable
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Int64.
type int64 = Int64
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Int32.
type int32 = Int32
namespace Microsoft.FSharp.Core
/// 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.
[<MeasureAnnotatedAbbreviation>]
[<Class>]
type int16<'Measure> =
inherit System.ValueType
interface System.IConvertible
interface System.IFormattable
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Int16.
type int16 = Int16
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Int32.
type int = int32
namespace Microsoft.FSharp.Core
/// This type is for internal use by the F# code generator.
[<Class>]
type ilsigptr<'T> =
namespace Microsoft.FSharp.Core
/// 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.
[<MeasureAnnotatedAbbreviation>]
[<Class>]
type float<'Measure> =
inherit System.ValueType
interface System.IConvertible
interface System.IFormattable
namespace Microsoft.FSharp.Core
/// 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.
[<MeasureAnnotatedAbbreviation>]
[<Class>]
type float32<'Measure> =
inherit System.ValueType
interface System.IConvertible
interface System.IFormattable
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Single.
type float32 = Single
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Double.
type float = Double
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Exception.
type exn = Exception
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Double.
type double = Double
namespace Microsoft.FSharp.Core
/// 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.
[<MeasureAnnotatedAbbreviation>]
[<Class>]
type decimal<'Measure> =
inherit System.ValueType
interface System.IConvertible
interface System.Runtime.Serialization.IDeserializationCallback
interface System.IFormattable
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Decimal.
type decimal = Decimal
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Char.
type char = Char
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Byte.
type byte = Byte
namespace Microsoft.FSharp.Core
/// Represents a managed pointer in F# code.
[<Class>]
type byref<'T> =
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Boolean.
type bool = Boolean
namespace Microsoft.FSharp.Core
type bigint = Numerics.BigInteger
namespace Microsoft.FSharp.Core
/// Single dimensional, zero-based arrays, written int[], string[] etc.
type array<'T> = 'T []
namespace Microsoft.FSharp.Core
/// Single dimensional, zero-based arrays, written int[], string[] etc.
[<Class>]
type ``[]``<'T> =
namespace Microsoft.FSharp.Core
/// Two dimensional arrays, typically zero-based.
[<Class>]
type ``[,]``<'T> =
namespace Microsoft.FSharp.Core
/// Three dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Four dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Adding this attribute to an F# mutable binding causes the "volatile"
/// prefix to be used for all accesses to the field.
[<Sealed>]
type VolatileFieldAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> VolatileFieldAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type UnverifiableAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> UnverifiableAttribute
namespace Microsoft.FSharp.Core
/// The type 'unit', which has only one value "()". This value is special and
/// always uses the representation 'null'.
[<Class>]
type Unit =
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type StructuredFormatDisplayAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : value:string -> StructuredFormatDisplayAttribute
/// 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.
member Value : string
namespace Microsoft.FSharp.Core
/// Adding this attribute to a record, union or struct type confirms the automatic
/// generation of overrides for 'System.Object.Equals(obj)' and
/// 'System.Object.GetHashCode()' for the type.
[<Sealed>]
type StructuralEqualityAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> StructuralEqualityAttribute
namespace Microsoft.FSharp.Core
/// Adding this attribute to a record, union, exception, or struct type confirms the
/// automatic generation of implementations for 'System.IComparable' for the type.
[<Sealed>]
type StructuralComparisonAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> StructuralComparisonAttribute
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type causes it to be represented using a CLI struct.
[<Sealed>]
type StructAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> StructAttribute
/// 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.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Core.String
/// Returns a new string made by concatenating the given strings
/// with separator sep, that is a1 + sep + ... + sep + aN.
val concat : sep:string -> strings:seq<string> -> string
/// Applies the function action to each character in the string.
val iter : action:(char -> unit) -> str:string -> unit
/// Applies the function action to the index of each character in the string and the
/// character itself.
val iteri : action:(int -> char -> unit) -> str:string -> unit
/// Builds a new string whose characters are the results of applying the function mapping
/// to each of the characters of the input string.
val map : mapping:(char -> char) -> str:string -> string
/// Builds a new string whose characters are the results of applying the function mapping
/// to each character and index of the input string.
val mapi : mapping:(int -> char -> char) -> str:string -> string
/// Builds 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.
val collect : mapping:(char -> string) -> str:string -> string
/// Builds 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.
val init : count:int -> initializer:(int -> string) -> string
/// Tests if all characters in the string satisfy the given predicate.
val forall : predicate:(char -> bool) -> str:string -> bool
/// Tests if any character of the string satisfies the given predicate.
val exists : predicate:(char -> bool) -> str:string -> bool
/// Returns a string by concatenating count instances of str.
val replicate : count:int -> str:string -> string
/// Returns the length of the string.
val length : str:string -> int
namespace Microsoft.FSharp.Core
/// Indicates the relationship between a compiled entity in a CLI binary and an element in F# source code.
type SourceConstructFlags =
/// Indicates that the compiled entity has no relationship to an element in F# source code.
| None = 0
/// Indicates that the compiled entity is part of the representation of an F# union type declaration.
| SumType = 1
/// Indicates that the compiled entity is part of the representation of an F# record type declaration.
| RecordType = 2
/// Indicates that the compiled entity is part of the representation of an F# class or other object type declaration.
| ObjectType = 3
/// Indicates that the compiled entity is part of the representation of an F# record or union case field declaration.
| Field = 4
/// Indicates that the compiled entity is part of the representation of an F# exception declaration.
| Exception = 5
/// Indicates that the compiled entity is part of the representation of an F# closure.
| Closure = 6
/// Indicates that the compiled entity is part of the representation of an F# module declaration.
| Module = 7
/// Indicates that the compiled entity is part of the representation of an F# union case declaration.
| UnionCase = 8
/// Indicates that the compiled entity is part of the representation of an F# value declaration.
| Value = 9
/// The mask of values related to the kind of the compiled entity.
| KindMask = 31
/// Indicates that the compiled entity had private or internal representation in F# source code.
| NonPublicRepresentation = 32
namespace Microsoft.FSharp.Core
/// Adding this attribute to class definition makes it sealed, which means it may not
/// be extended or implemented.
type SealedAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : value:bool -> SealedAttribute
/// Creates an instance of the attribute.
new : unit -> SealedAttribute
/// The value of the attribute, indicating whether the type is sealed or not.
member Value : bool
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type, value or member requires that
/// uses of the construct must explicitly instantiate any generic type parameters.
[<Sealed>]
type RequiresExplicitTypeArgumentsAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> RequiresExplicitTypeArgumentsAttribute
namespace Microsoft.FSharp.Core
/// This attribute is used to indicate that references to the elements of a module, record or union
/// type require explicit qualified access.
[<Sealed>]
type RequireQualifiedAccessAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> RequireQualifiedAccessAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type ReflectedDefinitionAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> ReflectedDefinitionAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type ReferenceEqualityAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> ReferenceEqualityAttribute
namespace Microsoft.FSharp.Core
/// The type of mutable references. Use the functions [:=] and [!] to get and
/// set values of this type.
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpRef`1")>]
type Ref<'T> =
{
/// The current value of the reference cell
contents: 'T
}
/// The current value of the reference cell
member Value : 'T with get, set
namespace Microsoft.FSharp.Core
/// Indicates that, when a custom operator is used in a computation expression,
/// a parameter is automatically parameterized by the variable space of the computation expression
[<Sealed>]
type ProjectionParameterAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> ProjectionParameterAttribute
/// Extensible printf-style formatting for numbers and other datatypes
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
module Microsoft.FSharp.Core.Printf
/// Print to a System.Text.StringBuilder
val bprintf : builder:Text.StringBuilder -> format:Printf.BuilderFormat<'T> -> 'T
/// Print to a text writer.
val fprintf : textWriter:IO.TextWriter -> format:Printf.TextWriterFormat<'T> -> 'T
/// Print to a text writer, adding a newline
val fprintfn : textWriter:IO.TextWriter -> format:Printf.TextWriterFormat<'T> -> 'T
/// Formatted printing to stderr
val eprintf : format:Printf.TextWriterFormat<'T> -> 'T
/// Formatted printing to stderr, adding a newline
val eprintfn : format:Printf.TextWriterFormat<'T> -> 'T
/// Formatted printing to stdout
val printf : format:Printf.TextWriterFormat<'T> -> 'T
/// Formatted printing to stdout, adding a newline.
val printfn : format:Printf.TextWriterFormat<'T> -> 'T
/// Print to a string via an internal string buffer and return
/// the result as a string. Helper printers must return strings.
val sprintf : format:Printf.StringFormat<'T> -> 'T
/// bprintf, but call the given 'final' function to generate the result.
/// See kprintf.
val kbprintf : continutation:(unit -> 'Result) -> builder:Text.StringBuilder -> format:Printf.BuilderFormat<'T,'Result> -> 'T
/// fprintf, but call the given 'final' function to generate the result.
/// See kprintf.
val kfprintf : continutation:(unit -> 'Result) -> textWriter:IO.TextWriter -> format:Printf.TextWriterFormat<'T,'Result> -> 'T
/// 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.
val kprintf : continutation:(string -> 'Result) -> format:Printf.StringFormat<'T,'Result> -> 'T
/// sprintf, but call the given 'final' function to generate the result.
/// See kprintf.
val ksprintf : continutation:(string -> 'Result) -> format:Printf.StringFormat<'T,'Result> -> 'T
/// Print to a string buffer and raise an exception with the given
/// result. Helper printers must return strings.
val failwithf : format:Printf.StringFormat<'T,'Result> -> 'T
/// 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.
type BuilderFormat<'T, 'Result> = Format<'T,Text.StringBuilder,unit,'Result>
/// 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.
type StringFormat<'T, 'Result> = Format<'T,unit,string,'Result>
/// 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.
type TextWriterFormat<'T, 'Result> = Format<'T,IO.TextWriter,unit,'Result>
/// 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.
type BuilderFormat<'T> = Printf.BuilderFormat<'T,unit>
/// Represents a statically-analyzed format when formatting builds a string. The type parameter indicates the
/// arguments and return type of the format operation.
type StringFormat<'T> = Printf.StringFormat<'T,string>
/// 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.
type TextWriterFormat<'T> = Printf.TextWriterFormat<'T,unit>
namespace Microsoft.FSharp.Core
/// Type of a formatting expression.
type PrintfFormat<'Printer, 'State, 'Residue, 'Result, 'Tuple> =
inherit PrintfFormat<'Printer,'State,'Residue,'Result>
/// Construct a format string
new : value:string -> PrintfFormat<'Printer, 'State, 'Residue, 'Result, 'Tuple>
namespace Microsoft.FSharp.Core
/// Type of a formatting expression.
type PrintfFormat<'Printer, 'State, 'Residue, 'Result> =
/// Construct a format string
new : value:string -> PrintfFormat<'Printer, 'State, 'Residue, 'Result>
/// The raw text of the format string.
member Value : string
namespace Microsoft.FSharp.Core
/// This attribute is added automatically for all optional arguments.
[<Sealed>]
type OptionalArgumentAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> OptionalArgumentAttribute
namespace Microsoft.FSharp.Core
/// The type of optional values. When used from other CLI languages the
/// empty option is the null value.
[<DefaultAugmentation(false)>]
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (8))>]
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpOption`1")>]
type Option<'T> =
/// The representation of "No value"
| None
/// The representation of "Value of type 'T"
| Some of Value: 'T
/// Return 'true' if the option is a 'None' value.
member IsNone : bool
/// Return 'true' if the option is a 'Some' value.
member IsSome : bool
/// Get the value of a 'Some' option. A NullReferenceException is raised if the option is 'None'.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (2))>]
member Value : 'T
/// Create an option value that is a 'None' value.
static member None : 'T option
/// Create an option value that is a 'Some' value.
static member Some : value:'T -> 'T option
/// Basic operations on options.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
module Microsoft.FSharp.Core.Option
/// Returns true if the option is not None.
val isSome : option:'T option -> bool
/// Returns true if the option is None.
val isNone : option:'T option -> bool
/// Gets the value associated with the option.
val get : option:'T option -> 'T
/// count inp evaluates to match inp with None -> 0 | Some _ -> 1.
val count : option:'T option -> int
/// fold f s inp evaluates to match inp with None -> s | Some x -> f s x.
val fold : folder:('State -> 'T -> 'State) -> state:'State -> option:'T option -> 'State
/// fold f inp s evaluates to match inp with None -> s | Some x -> f x s.
val foldBack : folder:('T -> 'State -> 'State) -> option:'T option -> state:'State -> 'State
/// exists p inp evaluates to match inp with None -> false | Some x -> p x.
val exists : predicate:('T -> bool) -> option:'T option -> bool
/// forall p inp evaluates to match inp with None -> true | Some x -> p x.
val forall : predicate:('T -> bool) -> option:'T option -> bool
/// iter f inp executes match inp with None -> () | Some x -> f x.
val iter : action:('T -> unit) -> option:'T option -> unit
/// map f inp evaluates to match inp with None -> None | Some x -> Some (f x).
val map : mapping:('T -> 'U) -> option:'T option -> 'U option
/// bind f inp evaluates to match inp with None -> None | Some x -> f x
val bind : binder:('T -> 'U option) -> option:'T option -> 'U option
/// Convert the option to an array of length 0 or 1.
val toArray : option:'T option -> 'T []
/// Convert the option to a list of length 0 or 1.
val toList : option:'T option -> 'T list
/// An implementation module used to hold some private implementations of function
/// value invocation.
module Microsoft.FSharp.Core.OptimizedClosures
/// The CLI 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 CLI languages.
[<AbstractClass>]
type FSharpFunc<'T1, 'T2, 'U> =
inherit Microsoft.FSharp.Core.FSharpFunc<'T1,('T2 -> 'U)>
/// Construct an optimized function value that can accept two curried
/// arguments without intervening execution.
new : unit -> FSharpFunc<'T1, 'T2, 'U>
/// Invoke the optimized function value with two curried arguments
abstract member Invoke : arg1:'T1 * arg2:'T2 -> 'U
/// Adapt an F# first class function value to be an optimized function value that can
/// accept two curried arguments without intervening execution.
static member Adapt : func:('T1 -> 'T2 -> 'U) -> OptimizedClosures.FSharpFunc<'T1,'T2,'U>
/// The CLI 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 CLI languages.
[<AbstractClass>]
type FSharpFunc<'T1, 'T2, 'T3, 'U> =
inherit Microsoft.FSharp.Core.FSharpFunc<'T1,('T2 -> 'T3 -> 'U)>
/// Construct an optimized function value that can accept three curried
/// arguments without intervening execution.
new : unit -> FSharpFunc<'T1, 'T2, 'T3, 'U>
/// Invoke an F# first class function value that accepts three curried arguments
/// without intervening execution
abstract member Invoke : arg1:'T1 * arg2:'T2 * arg3:'T3 -> 'U
/// Adapt an F# first class function value to be an optimized function value that can
/// accept three curried arguments without intervening execution.
static member Adapt : func:('T1 -> 'T2 -> 'T3 -> 'U) -> OptimizedClosures.FSharpFunc<'T1,'T2,'T3,'U>
/// The CLI type used to represent F# function values that accept four curried arguments
/// without intervening execution. This type should not typically used directly from
/// either F# code or from other CLI languages.
[<AbstractClass>]
type FSharpFunc<'T1, 'T2, 'T3, 'T4, 'U> =
inherit Microsoft.FSharp.Core.FSharpFunc<'T1,('T2 -> 'T3 -> 'T4 -> 'U)>
/// Construct an optimized function value that can accept four curried
/// arguments without intervening execution.
new : unit -> FSharpFunc<'T1, 'T2, 'T3, 'T4, 'U>
/// Invoke an F# first class function value that accepts four curried arguments
/// without intervening execution
abstract member Invoke : arg1:'T1 * arg2:'T2 * arg3:'T3 * arg4:'T4 -> 'U
/// Adapt an F# first class function value to be an optimized function value that can
/// accept four curried arguments without intervening execution.
static member Adapt : func:('T1 -> 'T2 -> 'T3 -> 'T4 -> 'U) -> OptimizedClosures.FSharpFunc<'T1,'T2,'T3,'T4,'U>
/// The CLI type used to represent F# function values that accept five curried arguments
/// without intervening execution. This type should not typically used directly from
/// either F# code or from other CLI languages.
[<AbstractClass>]
type FSharpFunc<'T1, 'T2, 'T3, 'T4, 'T5, 'U> =
inherit Microsoft.FSharp.Core.FSharpFunc<'T1,('T2 -> 'T3 -> 'T4 -> 'T5 -> 'U)>
/// Construct an optimized function value that can accept five curried
/// arguments without intervening execution.
new : unit -> FSharpFunc<'T1, 'T2, 'T3, 'T4, 'T5, 'U>
/// Invoke an F# first class function value that accepts five curried arguments
/// without intervening execution
abstract member Invoke : arg1:'T1 * arg2:'T2 * arg3:'T3 * arg4:'T4 * arg5:'T5 -> 'U
/// Adapt an F# first class function value to be an optimized function value that can
/// accept five curried arguments without intervening execution.
static member Adapt : func:('T1 -> 'T2 -> 'T3 -> 'T4 -> 'T5 -> 'U) -> OptimizedClosures.FSharpFunc<'T1,'T2,'T3,'T4,'T5,'U>
/// Basic F# Operators. This module is automatically opened in all F# code.
[<AutoOpen>]
module Microsoft.FSharp.Core.Operators
/// Overloaded unary negation.
val inline ( ~- ) : n: ^T -> ^T when ^T : (static member ( ~- ) : unit -> ^T)
/// Overloaded addition operator
val inline ( + ) : x: ^T1 -> y: ^T2 -> ^T3 when ^T1 : (static member ( + ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( + ) : ^T1 * ^T2 -> ^T3)
/// Overloaded subtraction operator
val inline ( - ) : x: ^T1 -> y: ^T2 -> ^T3 when ^T1 : (static member ( - ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( - ) : ^T1 * ^T2 -> ^T3)
/// Overloaded multiplication operator
val inline ( * ) : x: ^T1 -> y: ^T2 -> ^T3 when ^T1 : (static member ( * ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( * ) : ^T1 * ^T2 -> ^T3)
/// Overloaded division operator
val inline ( / ) : x: ^T1 -> y: ^T2 -> ^T3 when ^T1 : (static member ( / ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( / ) : ^T1 * ^T2 -> ^T3)
/// Overloaded modulo operator
val inline ( % ) : x: ^T1 -> y: ^T2 -> ^T3 when ^T1 : (static member ( % ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( % ) : ^T1 * ^T2 -> ^T3)
/// Overloaded bitwise-AND operator
val inline ( &&& ) : x: ^T -> y: ^T -> ^T when ^T : (static member ( &&& ) : ^T * ^T -> ^T)
/// Overloaded bitwise-OR operator
val inline ( ||| ) : x: ^T -> y: ^T -> ^T when ^T : (static member ( ||| ) : ^T * ^T -> ^T)
/// Overloaded bitwise-XOR operator
val inline ( ^^^ ) : x: ^T -> y: ^T -> ^T when ^T : (static member ( ^^^ ) : ^T * ^T -> ^T)
/// Overloaded byte-shift left operator by a specified number of bits
val inline ( <<< ) : value: ^T -> shift:int32 -> ^T when ^T : (static member ( <<< ) : ^T * int32 -> ^T)
/// Overloaded byte-shift right operator by a specified number of bits
val inline ( >>> ) : value: ^T -> shift:int32 -> ^T when ^T : (static member ( >>> ) : ^T * int32 -> ^T)
/// Overloaded bitwise-NOT operator
val inline ( ~~~ ) : value: ^T -> ^T when ^T : (static member ( ~~~ ) : unit -> ^T)
/// Overloaded prefix-plus operator
val inline ( ~+ ) : value: ^T -> ^T when ^T : (static member ( ~+ ) : unit -> ^T)
/// Structural less-than comparison
val inline ( < ) : x:'T -> y:'T -> bool when 'T : comparison
/// Structural greater-than
val inline ( > ) : x:'T -> y:'T -> bool when 'T : comparison
/// Structural greater-than-or-equal
val inline ( >= ) : x:'T -> y:'T -> bool when 'T : comparison
/// Structural less-than-or-equal comparison
val inline ( <= ) : x:'T -> y:'T -> bool when 'T : comparison
/// Structural equality
val inline ( = ) : x:'T -> y:'T -> bool when 'T : equality
/// Structural inequality
val inline ( <> ) : x:'T -> y:'T -> bool when 'T : equality
/// Compose two functions, the function on the left being applied first
val inline ( >> ) : func1:('T1 -> 'T2) -> func2:('T2 -> 'T3) -> 'T1 -> 'T3
/// Compose two functions, the function on the right being applied first
val inline ( << ) : func2:('T2 -> 'T3) -> func1:('T1 -> 'T2) -> 'T1 -> 'T3
/// Apply a function to a value, the value being on the left, the function on the right
val inline ( |> ) : arg:'T1 -> func:('T1 -> 'U) -> 'U
/// Apply a function to two values, the values being a pair on the left, the function on the right
val inline ( ||> ) : arg1:'T1 * arg2:'T2 -> func:('T1 -> 'T2 -> 'U) -> 'U
/// Apply a function to three values, the values being a triple on the left, the function on the right
val inline ( |||> ) : arg1:'T1 * arg2:'T2 * arg3:'T3 -> func:('T1 -> 'T2 -> 'T3 -> 'U) -> 'U
/// Apply a function to a value, the value being on the right, the function on the left
val inline ( <| ) : func:('T -> 'U) -> arg1:'T -> 'U
/// Apply a function to two values, the values being a pair on the right, the function on the left
val inline ( <|| ) : func:('T1 -> 'T2 -> 'U) -> arg1:'T1 * arg2:'T2 -> 'U
/// Apply a function to three values, the values being a triple on the right, the function on the left
val inline ( <||| ) : func:('T1 -> 'T2 -> 'T3 -> 'U) -> arg1:'T1 * arg2:'T2 * arg3:'T3 -> 'U
/// Used to specify a default value for an optional argument in the implementation of a function
val defaultArg : arg:'T option -> defaultValue:'T -> 'T
/// Concatenate two strings. The operator '+' may also be used.
val ( ^ ) : s1:string -> s2:string -> string
/// Raises an exception
val raise : exn:Exception -> 'T
/// Rethrows an exception. This should only be used when handling an exception
val inline rethrow : unit -> 'T
/// Rethrows an exception. This should only be used when handling an exception
val inline reraise : unit -> 'T
/// Builds a System.Exception object.
val Failure : message:string -> exn
/// Matches System.Exception objects whose runtime type is precisely System.Exception
val (|Failure|_|) : error:exn -> string option
/// Return the first element of a tuple, fst (a,b) = a.
val fst : tuple:('T1 * 'T2) -> 'T1
/// Return the second element of a tuple, snd (a,b) = b.
val snd : tuple:('T1 * 'T2) -> 'T2
/// Generic comparison.
val inline compare : e1:'T -> e2:'T -> int when 'T : comparison
/// Maximum based on generic comparison
val inline max : e1:'T -> e2:'T -> 'T when 'T : comparison
/// Minimum based on generic comparison
val inline min : e1:'T -> e2:'T -> 'T when 'T : comparison
/// Ignore the passed value. This is often used to throw away results of a computation.
val inline ignore : value:'T -> unit
/// Unboxes a strongly typed value. This is the inverse of box, unbox<t>(box<t> a) equals a.
val inline unbox : value:obj -> 'T
/// Boxes a strongly typed value.
val inline box : value:'T -> obj
/// Throw a System.Exception exception.
val failwith : message:string -> 'T
/// Throw a System.ArgumentException exception with
/// the given argument name and message.
val inline invalidArg : argumentName:string -> message:string -> 'T
/// Throw a System.ArgumentNullException exception
val inline nullArg : argumentName:string -> 'T
/// Throw a System.InvalidOperationException exception
val inline invalidOp : message:string -> 'T
/// The identity function
val id : x:'T -> 'T
/// Create a mutable reference cell
val ref : value:'T -> 'T ref
/// Assign to a mutable reference cell
val ( := ) : cell:'T ref -> value:'T -> unit
/// Dereference a mutable reference cell
val ( ! ) : cell:'T ref -> 'T
/// Decrement a mutable reference cell containing an integer
val decr : cell:int ref -> unit
/// Increment a mutable reference cell containing an integer
val incr : cell:int ref -> unit
/// Concatenate two lists.
val ( @ ) : list1:'T list -> list2:'T list -> 'T list
/// Negate a logical value. not true equals false and not false equals true
val inline not : value:bool -> bool
/// Builds a sequence using sequence expression syntax
val seq : sequence:seq<'T> -> seq<'T>
/// Exit the current hardware isolated process, if security settings permit,
/// otherwise raise an exception. Calls System.Environment.Exit.
val exit : exitcode:int -> 'T
/// Equivalent to System.Double.PositiveInfinity
val infinity : float
/// Equivalent to System.Double.NaN
val nan : float
/// Equivalent to System.Single.PositiveInfinity
val infinityf : float32
/// Equivalent to System.Single.NaN
val nanf : float32
/// Reads the value of the property System.Console.In.
val stdin : IO.TextReader
/// Reads the value of the property System.Console.Error.
val stderr : IO.TextWriter
/// Reads the value of the property System.Console.Out.
val stdout : IO.TextWriter
/// The standard overloaded range operator, e.g. [n..m] for lists, seq {n..m} for sequences
val inline ( .. ) : start: ^T -> finish: ^T -> seq< ^T> when ^T : (static member ( + ) : ^T * ^T -> ^T) and ^T : (static member One : ^T) and ^T : comparison
/// The standard overloaded skip range operator, e.g. [n..skip..m] for lists, seq {n..skip..m} for sequences
val inline ( .. .. ) : start: ^T -> step: ^Step -> finish: ^T -> seq< ^T> when ^T : (static member ( + ) : ^T * ^Step -> ^T) and ^T : comparison and ^Step : (static member ( + ) : ^T * ^Step -> ^T) and ^Step : (static member Zero : ^Step)
/// Execute the function as a mutual-exclusion region using the input value as a lock.
val inline lock : lockObject:'Lock -> action:(unit -> 'T) -> 'T when 'Lock : not struct
/// 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.
val using : resource:'T -> action:('T -> 'U) -> 'U when 'T :> IDisposable
/// Generate a System.Type runtime representation of a static type.
/// The static type is still maintained on the value returned.
val typeof : Type
/// 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.
val typedefof : Type
/// Returns the internal size of a type in bytes. For example, sizeof<int> returns 4.
val sizeof : int
/// 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.
val inline hash : obj:'T -> int when 'T : equality
/// 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.
val inline limitedHash : limit:int -> obj:'T -> int when 'T : equality
/// Absolute value of the given number.
val inline abs : value: ^T -> ^T when ^T : (static member Abs : unit -> ^T)
/// Inverse cosine of the given number
val inline acos : value: ^T -> ^T when ^T : (static member Acos : unit -> ^T)
/// Inverse sine of the given number
val inline asin : value: ^T -> ^T when ^T : (static member Asin : unit -> ^T)
/// Inverse tangent of the given number
val inline atan : value: ^T -> ^T when ^T : (static member Atan : unit -> ^T)
/// Inverse tangent of x/y where x and y are specified separately
val inline atan2 : y: ^T1 -> x: ^T1 -> 'T2 when ^T1 : (static member Atan2 : ^T1 * ^T1 -> 'T2)
/// Ceiling of the given number
val inline ceil : value: ^T -> ^T when ^T : (static member Ceiling : unit -> ^T)
/// Exponential of the given number
val inline exp : value: ^T -> ^T when ^T : (static member Exp : unit -> ^T)
/// Floor of the given number
val inline floor : value: ^T -> ^T when ^T : (static member Floor : unit -> ^T)
/// Sign of the given number
val inline sign : value: ^T -> int when ^T : (member Sign : int)
/// Round the given number
val inline round : value: ^T -> ^T when ^T : (static member Round : unit -> ^T)
/// Natural logarithm of the given number
val inline log : value: ^T -> ^T when ^T : (static member Log : unit -> ^T)
/// Logarithm to base 10 of the given number
val inline log10 : value: ^T -> ^T when ^T : (static member Log10 : unit -> ^T)
/// Square root of the given number
val inline sqrt : value: ^T -> ^U when ^T : (static member Sqrt : unit -> ^U)
/// Cosine of the given number
val inline cos : value: ^T -> ^T when ^T : (static member Cos : unit -> ^T)
/// Hyperbolic cosine of the given number
val inline cosh : value: ^T -> ^T when ^T : (static member Cosh : unit -> ^T)
/// Sine of the given number
val inline sin : value: ^T -> ^T when ^T : (static member Sin : unit -> ^T)
/// Hyperbolic sine of the given number
val inline sinh : value: ^T -> ^T when ^T : (static member Sinh : unit -> ^T)
/// Tangent of the given number
val inline tan : value: ^T -> ^T when ^T : (static member Tan : unit -> ^T)
/// Hyperbolic tangent of the given number
val inline tanh : value: ^T -> ^T when ^T : (static member Tanh : unit -> ^T)
/// Overloaded truncate operator.
val inline truncate : value: ^T -> ^T when ^T : (static member Truncate : unit -> ^T)
/// Overloaded power operator.
val inline ( ** ) : x: ^T -> y: ^U -> ^T when ^T : (static member Pow : ^T * ^U -> ^T)
/// Overloaded power operator. If n > 0 then equivalent to x*...*x for n occurrences of x.
val inline pown : x: ^T -> n:int -> ^T when ^T : (static member One : ^T) and ^T : (static member ( * ) : ^T * ^T -> ^T) and ^T : (static member ( / ) : ^T * ^T -> ^T)
/// Converts the argument to byte. This is a direct conversion for all
/// primitive numeric types. For strings, the input is converted using Byte.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline byte : value: ^T -> byte when ^T : (static member op_Explicit : unit -> byte)
/// 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 an appropriate
/// static conversion method on the input type.
val inline sbyte : value: ^T -> sbyte when ^T : (static member op_Explicit : unit -> sbyte)
/// 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 an appropriate
/// static conversion method on the input type.
val inline int16 : value: ^T -> int16 when ^T : (static member op_Explicit : unit -> int16)
/// 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 an appropriate
/// static conversion method on the input type.
val inline uint16 : value: ^T -> uint16 when ^T : (static member op_Explicit : unit -> uint16)
/// 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 an appropriate
/// static conversion method on the input type.
val inline int : value: ^T -> int when ^T : (static member op_Explicit : unit -> int)
/// Converts the argument to a particular enum type.
val inline enum : value:int32 -> ^U when 'U : enum<int32>
/// 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 an appropriate
/// static conversion method on the input type.
val inline int32 : value: ^T -> int32 when ^T : (static member op_Explicit : unit -> int32)
/// 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 an appropriate
/// static conversion method on the input type.
val inline uint32 : value: ^T -> uint32 when ^T : (static member op_Explicit : unit -> uint32)
/// 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 an appropriate
/// static conversion method on the input type.
val inline int64 : value: ^T -> int64 when ^T : (static member op_Explicit : unit -> int64)
/// 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 an appropriate
/// static conversion method on the input type.
val inline uint64 : value: ^T -> uint64 when ^T : (static member op_Explicit : unit -> uint64)
/// 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 an appropriate
/// static conversion method on the input type.
val inline float32 : value: ^T -> float32 when ^T : (static member op_Explicit : unit -> float32)
/// 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 an appropriate
/// static conversion method on the input type.
val inline float : value: ^T -> float when ^T : (static member op_Explicit : unit -> float)
/// Converts the argument to signed native integer. This is a direct conversion for all
/// primitive numeric types. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline nativeint : value: ^T -> nativeint when ^T : (static member op_Explicit : unit -> nativeint)
/// Converts the argument to unsigned native integer using a direct conversion for all
/// primitive numeric types. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline unativeint : value: ^T -> unativeint when ^T : (static member op_Explicit : unit -> unativeint)
/// Converts the argument to a string using ToString.
val inline string : value: ^T -> string
/// Converts the argument to System.Decimal using a direct conversion for all
/// primitive numeric types. For strings, the input is converted using UInt64.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline decimal : value: ^T -> decimal when ^T : (static member op_Explicit : unit -> decimal)
/// 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
/// input types the operation requires an appropriate static conversion method on the input type.
val inline char : value: ^T -> char when ^T : (static member op_Explicit : unit -> char)
/// An active pattern to match values of type System.Collections.Generic.KeyValuePair
val (|KeyValue|) : keyValuePair:Collections.Generic.KeyValuePair<'Key,'Value> -> 'Key * 'Value
/// A module of compiler intrinsic functions for efficient implementations of F# integer ranges
/// and dynamic invocations of other F# operators
module OperatorIntrinsics =
/// Gets a slice of an array
val inline GetArraySlice : source:'T [] -> start:int option -> finish:int option -> 'T []
/// Sets a slice of an array
val inline SetArraySlice : target:'T [] -> start:int option -> finish:int option -> source:'T [] -> unit
/// Gets a region slice of an array
val GetArraySlice2D : source:'T [,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> 'T [,]
/// Gets a vector slice of a 2D array. The index of the first dimension is fixed.
val inline GetArraySlice2DFixed1 : source:'T [,] -> index1:int -> start2:int option -> finish2:int option -> 'T []
/// Gets a vector slice of a 2D array. The index of the second dimension is fixed.
val inline GetArraySlice2DFixed2 : source:'T [,] -> start1:int option -> finish1:int option -> index2:int -> 'T []
/// Sets a region slice of an array
val SetArraySlice2D : target:'T [,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> source:'T [,] -> unit
/// Sets a vector slice of a 2D array. The index of the first dimension is fixed.
val inline SetArraySlice2DFixed1 : target:'T [,] -> index1:int -> start2:int option -> finish2:int option -> source:'T [] -> unit
/// Sets a vector slice of a 2D array. The index of the second dimension is fixed.
val inline SetArraySlice2DFixed2 : target:'T [,] -> start1:int option -> finish1:int option -> index2:int -> source:'T [] -> unit
/// Gets a slice of an array
val GetArraySlice3D : source:'T [,,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> start3:int option -> finish3:int option -> 'T [,,]
/// Sets a slice of an array
val SetArraySlice3D : target:'T [,,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> start3:int option -> finish3:int option -> source:'T [,,] -> unit
/// Gets a slice of an array
val GetArraySlice4D : source:'T [,,,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> start3:int option -> finish3:int option -> start4:int option -> finish4:int option -> 'T [,,,]
/// Sets a slice of an array
val SetArraySlice4D : target:'T [,,,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> start3:int option -> finish3:int option -> start4:int option -> finish4:int option -> source:'T [,,,] -> unit
/// Gets a slice from a string
val inline GetStringSlice : source:string -> start:int option -> finish:int option -> string
/// Generate a range of integers
val RangeInt32 : start:int -> step:int -> stop:int -> seq<int>
/// Generate a range of float values
val RangeDouble : start:float -> step:float -> stop:float -> seq<float>
/// Generate a range of float32 values
val RangeSingle : start:float32 -> step:float32 -> stop:float32 -> seq<float32>
/// Generate a range of int64 values
val RangeInt64 : start:int64 -> step:int64 -> stop:int64 -> seq<int64>
/// Generate a range of uint64 values
val RangeUInt64 : start:uint64 -> step:uint64 -> stop:uint64 -> seq<uint64>
/// Generate a range of uint32 values
val RangeUInt32 : start:uint32 -> step:uint32 -> stop:uint32 -> seq<uint32>
/// Generate a range of nativeint values
val RangeIntPtr : start:nativeint -> step:nativeint -> stop:nativeint -> seq<nativeint>
/// Generate a range of unativeint values
val RangeUIntPtr : start:unativeint -> step:unativeint -> stop:unativeint -> seq<unativeint>
/// Generate a range of int16 values
val RangeInt16 : start:int16 -> step:int16 -> stop:int16 -> seq<int16>
/// Generate a range of uint16 values
val RangeUInt16 : start:uint16 -> step:uint16 -> stop:uint16 -> seq<uint16>
/// Generate a range of sbyte values
val RangeSByte : start:sbyte -> step:sbyte -> stop:sbyte -> seq<sbyte>
/// Generate a range of byte values
val RangeByte : start:byte -> step:byte -> stop:byte -> seq<byte>
/// Generate a range of char values
val RangeChar : start:char -> stop:char -> seq<char>
/// Generate a range of values using the given zero, add, start, step and stop values
val RangeGeneric : one:'T -> add:('T -> 'T -> 'T) -> start:'T -> stop:'T -> seq<'T>
/// Generate a range of values using the given zero, add, start, step and stop values
val RangeStepGeneric : zero:'Step -> add:('T -> 'Step -> 'T) -> start:'T -> step:'Step -> stop:'T -> seq<'T>
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val AbsDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val AcosDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val AsinDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val AtanDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val Atan2Dynamic : y:'T1 -> x:'T1 -> 'T2
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val CeilingDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val ExpDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val FloorDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val TruncateDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val RoundDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val SignDynamic : 'T -> int
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val LogDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val Log10Dynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val SqrtDynamic : 'T1 -> 'T2
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val CosDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val CoshDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val SinDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val SinhDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val TanDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val TanhDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val PowDynamic : x:'T -> y:'U -> 'T
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'byte'
val PowByte : x:byte -> n:int -> byte
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'sbyte'
val PowSByte : x:sbyte -> n:int -> sbyte
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'int16'
val PowInt16 : x:int16 -> n:int -> int16
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'uint16'
val PowUInt16 : x:uint16 -> n:int -> uint16
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'int32'
val PowInt32 : x:int32 -> n:int -> int32
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'uint32'
val PowUInt32 : x:uint32 -> n:int -> uint32
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'int64'
val PowInt64 : x:int64 -> n:int -> int64
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'uint64'
val PowUInt64 : x:uint64 -> n:int -> uint64
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'nativeint'
val PowIntPtr : x:nativeint -> n:int -> nativeint
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'unativeint'
val PowUIntPtr : x:unativeint -> n:int -> unativeint
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'float32'
val PowSingle : x:float32 -> n:int -> float32
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'float'
val PowDouble : x:float -> n:int -> float
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'decimal'
val PowDecimal : x:decimal -> n:int -> decimal
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator
val PowGeneric : one:'T * mul:('T -> 'T -> 'T) * value:'T * exponent:int -> 'T
/// This module contains basic operations which do not apply runtime and/or static checks
module Unchecked =
/// Unboxes a strongly typed value. This is the inverse of box, unbox<t>(box<t> a) equals a.
val inline unbox : obj -> 'T
/// Generate a default 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.
val defaultof : 'T
/// Perform generic comparison on two values where the type of the values is not
/// statically required to have the 'comparison' constraint.
val inline compare : 'T -> 'T -> int
/// Perform generic equality on two values where the type of the values is not
/// statically required to satisfy the 'equality' constraint.
val inline equals : 'T -> 'T -> bool
/// Perform generic hashing on a value where the type of the value is not
/// statically required to satisfy the 'equality' constraint.
val inline hash : 'T -> int
/// This module contains the basic arithmetic operations with overflow checks.
module Checked =
/// Overloaded unary negation (checks for overflow)
val inline ( ~- ) : value: ^T -> ^T when ^T : (static member ( ~- ) : unit -> ^T)
/// Overloaded subtraction operator (checks for overflow)
val inline ( - ) : x: ^T1 -> y: ^T2 -> ^T3 when ^T1 : (static member ( - ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( - ) : ^T1 * ^T2 -> ^T3)
/// Overloaded addition operator (checks for overflow)
val inline ( + ) : x: ^T1 -> y: ^T2 -> ^T3 when ^T1 : (static member ( + ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( + ) : ^T1 * ^T2 -> ^T3)
/// Overloaded multiplication operator (checks for overflow)
val inline ( * ) : x: ^T1 -> y: ^T2 -> ^T3 when ^T1 : (static member ( * ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( * ) : ^T1 * ^T2 -> ^T3)
/// Converts the argument to byte. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.Byte.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline byte : value: ^T -> byte when ^T : (static member op_Explicit : unit -> byte)
/// Converts the argument to sbyte. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.SByte.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline sbyte : value: ^T -> sbyte when ^T : (static member op_Explicit : unit -> sbyte)
/// Converts the argument to int16. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.Int16.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline int16 : value: ^T -> int16 when ^T : (static member op_Explicit : unit -> int16)
/// Converts the argument to uint16. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.UInt16.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline uint16 : value: ^T -> uint16 when ^T : (static member op_Explicit : unit -> uint16)
/// Converts the argument to int. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.Int32.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline int : value: ^T -> int when ^T : (static member op_Explicit : unit -> int)
/// Converts the argument to int32. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.Int32.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline int32 : value: ^T -> int32 when ^T : (static member op_Explicit : unit -> int32)
/// Converts the argument to uint32. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.UInt32.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline uint32 : value: ^T -> uint32 when ^T : (static member op_Explicit : unit -> uint32)
/// Converts the argument to int64. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.Int64.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline int64 : value: ^T -> int64 when ^T : (static member op_Explicit : unit -> int64)
/// Converts the argument to uint64. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.UInt64.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline uint64 : value: ^T -> uint64 when ^T : (static member op_Explicit : unit -> uint64)
/// Converts the argument to nativeint. This is a direct, checked conversion for all
/// primitive numeric types. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline nativeint : value: ^T -> nativeint when ^T : (static member op_Explicit : unit -> nativeint)
/// Converts the argument to unativeint. This is a direct, checked conversion for all
/// primitive numeric types. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline unativeint : value: ^T -> unativeint when ^T : (static member op_Explicit : unit -> unativeint)
/// Converts the argument to char. Numeric inputs are converted using a checked
/// conversion according to the UTF-16 encoding for characters. String inputs must
/// be exactly one character long. For other input types the operation requires an
/// appropriate static conversion method on the input type.
val inline char : value: ^T -> char when ^T : (static member op_Explicit : unit -> char)
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
[<AutoOpen>]
module Microsoft.FSharp.Core.NumericLiterals
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
module NumericLiteralI =
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
val FromZero : unit -> 'T
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
val FromOne : unit -> 'T
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
val FromInt32 : value:int32 -> 'T
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
val FromInt64 : value:int64 -> 'T
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
val FromString : text:string -> 'T
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
val FromInt64Dynamic : value:int64 -> obj
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
val FromStringDynamic : text:string -> obj
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type indicates it is a type where equality is an abnormal operation.
/// This means that the type does not satisfy the F# 'equality' constraint. Within the bounds of the
/// F# type system, this helps ensure that the F# generic equality function is not instantiated directly
/// at this type. The attribute and checking does not constrain the use of comparison with base or child
/// types of this type.
[<Sealed>]
type NoEqualityAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> NoEqualityAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type NoDynamicInvocationAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> NoDynamicInvocationAttribute
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type indicates it is a type where comparison is an abnormal operation.
/// This means that the type does not satisfy the F# 'comparison' constraint. Within the bounds of the
/// F# type system, this helps ensure that the F# generic comparison function is not instantiated directly
/// at this type. The attribute and checking does not constrain the use of comparison with base or child
/// types of this type.
[<Sealed>]
type NoComparisonAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> NoComparisonAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type MeasureAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> MeasureAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type MeasureAnnotatedAbbreviationAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> MeasureAnnotatedAbbreviationAttribute
namespace Microsoft.FSharp.Core
/// Non-exhaustive match failures will raise the MatchFailureException exception
exception MatchFailureException of string * int * int
namespace Microsoft.FSharp.Core
/// Adding this attribute to a value causes it to be compiled as a CLI constant literal.
[<Sealed>]
type LiteralAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> LiteralAttribute
/// Language primitives associated with the F# language
module Microsoft.FSharp.Core.LanguagePrimitives
/// Compare two values for equality using partial equivalence relation semantics ([nan] <> [nan])
val inline GenericEquality : e1:'T -> e2:'T -> bool when 'T : equality
/// Compare two values for equality using equivalence relation semantics ([nan] = [nan])
val inline GenericEqualityER : e1:'T -> e2:'T -> bool when 'T : equality
/// Compare two values for equality
val inline GenericEqualityWithComparer : comp:Collections.IEqualityComparer -> e1:'T -> e2:'T -> bool when 'T : equality
/// Compare two values
val inline GenericComparison : e1:'T -> e2:'T -> int when 'T : comparison
/// Compare two values. May be called as a recursive case from an implementation of System.IComparable to
/// ensure consistent NaN comparison semantics.
val inline GenericComparisonWithComparer : comp:Collections.IComparer -> e1:'T -> e2:'T -> int when 'T : comparison
/// Compare two values
val inline GenericLessThan : e1:'T -> e2:'T -> bool when 'T : comparison
/// Compare two values
val inline GenericGreaterThan : e1:'T -> e2:'T -> bool when 'T : comparison
/// Compare two values
val inline GenericLessOrEqual : e1:'T -> e2:'T -> bool when 'T : comparison
/// Compare two values
val inline GenericGreaterOrEqual : e1:'T -> e2:'T -> bool when 'T : comparison
/// Take the minimum of two values structurally according to the order given by GenericComparison
val inline GenericMinimum : e1:'T -> e2:'T -> 'T when 'T : comparison
/// Take the maximum of two values structurally according to the order given by GenericComparison
val inline GenericMaximum : e1:'T -> e2:'T -> 'T when 'T : comparison
/// Reference/physical equality.
/// True if the inputs are reference-equal, false otherwise.
val inline PhysicalEquality : e1:'T -> e2:'T -> bool when 'T : not struct
/// The physical hash. Hashes on the object identity, except for value types,
/// where we hash on the contents.
val inline PhysicalHash : obj:'T -> int when 'T : not struct
/// 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.
val GenericEqualityComparer : Collections.IEqualityComparer
/// 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. This equality comparer has equivalence
/// relation semantics ([nan] = [nan]).
val GenericEqualityERComparer : Collections.IEqualityComparer
/// A static F# comparer object
val GenericComparer : Collections.IComparer
/// Make an F# comparer object for the given type
val FastGenericComparer : Collections.Generic.IComparer<'T> when 'T : comparison
/// Make an F# hash/equality object for the given type
val FastGenericEqualityComparer : Collections.Generic.IEqualityComparer<'T> when 'T : equality
/// Make an F# hash/equality object for the given type using node-limited hashing when hashing F#
/// records, lists and union types.
val inline FastLimitedGenericEqualityComparer : limit:int -> Collections.Generic.IEqualityComparer<'T> when 'T : equality
/// 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.
val inline GenericHash : obj:'T -> int
/// Hash a value according to its structure. Use the given limit to restrict the hash when hashing F#
/// records, lists and union types.
val inline GenericLimitedHash : limit:int -> obj:'T -> int
/// Recursively hash a part of a value according to its structure.
val inline GenericHashWithComparer : comparer:Collections.IEqualityComparer -> obj:'T -> int
/// Build an enum value from an underlying value
val inline EnumOfValue : value:'T -> 'Enum when 'Enum : enum<'T>
/// Get the underlying value for an enum value
val inline EnumToValue : enum:'Enum -> 'T when 'Enum : enum<'T>
/// Creates a float value with units-of-measure
val inline FloatWithMeasure : float -> float<'Measure>
/// Creates a float32 value with units-of-measure
val inline Float32WithMeasure : float32 -> float32<'Measure>
/// Creates a decimal value with units-of-measure
val inline DecimalWithMeasure : decimal -> decimal<'Measure>
/// Creates an int32 value with units-of-measure
val inline Int32WithMeasure : int -> int<'Measure>
/// Creates an int64 value with units-of-measure
val inline Int64WithMeasure : int64 -> int64<'Measure>
/// Creates an int16 value with units-of-measure
val inline Int16WithMeasure : int16 -> int16<'Measure>
/// Creates an sbyte value with units-of-measure
val inline SByteWithMeasure : sbyte -> sbyte<'Measure>
/// Parse an int32 according to the rules used by the overloaded 'int32' conversion operator when applied to strings
val ParseInt32 : s:string -> int32
/// Parse an uint32 according to the rules used by the overloaded 'uint32' conversion operator when applied to strings
val ParseUInt32 : s:string -> uint32
/// Parse an int64 according to the rules used by the overloaded 'int64' conversion operator when applied to strings
val ParseInt64 : s:string -> int64
/// Parse an uint64 according to the rules used by the overloaded 'uint64' conversion operator when applied to strings
val ParseUInt64 : s:string -> uint64
/// Resolves to the zero value for any primitive numeric type or any type with a static member called 'Zero'.
val GenericZeroDynamic : unit -> 'T
/// Resolves to the value 'one' for any primitive numeric type or any type with a static member called 'One'.
val GenericOneDynamic : unit -> 'T
/// A compiler intrinsic that implements dynamic invocations to the '+' operator.
val AdditionDynamic : x:'T1 -> y:'T2 -> 'U
/// A compiler intrinsic that implements dynamic invocations to the checked '+' operator.
val CheckedAdditionDynamic : x:'T1 -> y:'T2 -> 'U
/// A compiler intrinsic that implements dynamic invocations to the '*' operator.
val MultiplyDynamic : x:'T1 -> y:'T2 -> 'U
/// A compiler intrinsic that implements dynamic invocations to the checked '*' operator.
val CheckedMultiplyDynamic : x:'T1 -> y:'T2 -> 'U
/// A compiler intrinsic that implements dynamic invocations for the DivideByInt primitive.
val DivideByIntDynamic : x:'T -> y:int -> 'T
/// Resolves to the zero value for any primitive numeric type or any type with a static member called 'Zero'
val GenericZero : ^T when ^T : (static member Zero : ^T)
/// Resolves to the value 'one' for any primitive numeric type or any type with a static member called 'One'
val GenericOne : ^T when ^T : (static member One : ^T)
/// Divides a value by an integer.
val inline DivideByInt : x: ^T -> y:int -> ^T when ^T : (static member DivideByInt : ^T * int -> ^T)
/// For internal use only
module ErrorStrings =
val InputSequenceEmptyString : string
val InputArrayEmptyString : string
val AddressOpNotFirstClassString : string
val NoNegateMinValueString : string
val InputMustBeNonNegativeString : string
/// The F# compiler emits calls to some of the functions in this module as part of the compiled form of some language constructs
module IntrinsicOperators =
/// Binary 'and'. When used as a binary operator the right hand value is evaluated only on demand.
val ( & ) : e1:bool -> e2:bool -> bool
/// Binary 'and'. When used as a binary operator the right hand value is evaluated only on demand
val ( && ) : e1:bool -> e2:bool -> bool
/// Binary 'or'. When used as a binary operator the right hand value is evaluated only on demand.
val ``or`` : e1:bool -> e2:bool -> bool
/// Binary 'or'. When used as a binary operator the right hand value is evaluated only on demand
val ( || ) : e1:bool -> e2:bool -> bool
/// Address-of. Uses of this value may result in the generation of unverifiable code.
val inline ( ~& ) : obj:'T -> byref<'T>
/// Address-of. Uses of this value may result in the generation of unverifiable code.
val inline ( ~&& ) : obj:'T -> nativeptr<'T> when 'T : unmanaged
/// The F# compiler emits calls to some of the functions in this module as part of the compiled form of some language constructs
module IntrinsicFunctions =
/// A compiler intrinsic that implements the ':?>' operator
val UnboxGeneric : source:obj -> 'T
/// A compiler intrinsic that implements the ':?>' operator
val inline UnboxFast : source:obj -> 'T
/// A compiler intrinsic that implements the ':?' operator
val TypeTestGeneric : source:obj -> bool
/// A compiler intrinsic that implements the ':?' operator
val inline TypeTestFast : source:obj -> bool
/// Primitive used by pattern match compilation
val inline GetString : source:string -> index:int -> char
/// This function implements calls to default constructors
/// acccessed by 'new' constraints.
val inline CreateInstance : unit -> 'T when 'T : (new : unit -> 'T)
/// This function implements parsing of decimal constants
val inline MakeDecimal : low:int -> medium:int -> high:int -> isNegative:bool -> scale:byte -> decimal
/// A compiler intrinsic for the efficient compilation of sequence expressions
val Dispose : resource:'T -> unit when 'T :> IDisposable
/// A compiler intrinsic for checking initialization soundness of recursive bindings
val FailInit : unit -> unit
/// A compiler intrinsic for checking initialization soundness of recursive static bindings
val FailStaticInit : unit -> unit
/// A compiler intrinsic for checking initialization soundness of recursive bindings
val CheckThis : 'T -> 'T when 'T : not struct
/// The standard overloaded associative (indexed) lookup operator
val inline GetArray : source:'T [] -> index:int -> 'T
/// The standard overloaded associative (2-indexed) lookup operator
val inline GetArray2D : source:'T [,] -> index1:int -> index2:int -> 'T
/// The standard overloaded associative (3-indexed) lookup operator
val inline GetArray3D : source:'T [,,] -> index1:int -> index2:int -> index3:int -> 'T
/// The standard overloaded associative (4-indexed) lookup operator
val inline GetArray4D : source:'T [,,,] -> index1:int -> index2:int -> index3:int -> index4:int -> 'T
/// The standard overloaded associative (indexed) mutation operator
val inline SetArray : target:'T [] -> index:int -> value:'T -> unit
/// The standard overloaded associative (2-indexed) mutation operator
val inline SetArray2D : target:'T [,] -> index1:int -> index2:int -> value:'T -> unit
/// The standard overloaded associative (3-indexed) mutation operator
val inline SetArray3D : target:'T [,,] -> index1:int -> index2:int -> index3:int -> value:'T -> unit
/// The standard overloaded associative (4-indexed) mutation operator
val inline SetArray4D : target:'T [,,,] -> index1:int -> index2:int -> index3:int -> index4:int -> value:'T -> unit
/// The F# compiler emits calls to some of the functions in this module as part of the compiled form of some language constructs
module HashCompare =
/// A primitive entry point used by the F# compiler for optimization purposes.
val PhysicalHashIntrinsic : input:'T -> int when 'T : not struct
/// A primitive entry point used by the F# compiler for optimization purposes.
val PhysicalEqualityIntrinsic : x:'T -> y:'T -> bool when 'T : not struct
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericHashIntrinsic : input:'T -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val LimitedGenericHashIntrinsic : limit:int -> input:'T -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericHashWithComparerIntrinsic : comp:Collections.IEqualityComparer -> input:'T -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericComparisonWithComparerIntrinsic : comp:Collections.IComparer -> x:'T -> y:'T -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericComparisonIntrinsic : x:'T -> y:'T -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericEqualityIntrinsic : x:'T -> y:'T -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericEqualityERIntrinsic : x:'T -> y:'T -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericEqualityWithComparerIntrinsic : comp:Collections.IEqualityComparer -> x:'T -> y:'T -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericLessThanIntrinsic : x:'T -> y:'T -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericGreaterThanIntrinsic : x:'T -> y:'T -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericGreaterOrEqualIntrinsic : x:'T -> y:'T -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericLessOrEqualIntrinsic : x:'T -> y:'T -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastHashTuple2 : comparer:Collections.IEqualityComparer -> tuple:('T1 * 'T2) -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastHashTuple3 : comparer:Collections.IEqualityComparer -> tuple:('T1 * 'T2 * 'T3) -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastHashTuple4 : comparer:Collections.IEqualityComparer -> tuple:('T1 * 'T2 * 'T3 * 'T4) -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastHashTuple5 : comparer:Collections.IEqualityComparer -> tuple:('T1 * 'T2 * 'T3 * 'T4 * 'T5) -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastEqualsTuple2 : comparer:Collections.IEqualityComparer -> tuple1:('T1 * 'T2) -> tuple2:('T1 * 'T2) -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastEqualsTuple3 : comparer:Collections.IEqualityComparer -> tuple1:('T1 * 'T2 * 'T3) -> tuple2:('T1 * 'T2 * 'T3) -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastEqualsTuple4 : comparer:Collections.IEqualityComparer -> tuple1:('T1 * 'T2 * 'T3 * 'T4) -> tuple2:('T1 * 'T2 * 'T3 * 'T4) -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastEqualsTuple5 : comparer:Collections.IEqualityComparer -> tuple1:('T1 * 'T2 * 'T3 * 'T4 * 'T5) -> tuple2:('T1 * 'T2 * 'T3 * 'T4 * 'T5) -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastCompareTuple2 : comparer:Collections.IComparer -> tuple1:('T1 * 'T2) -> tuple2:('T1 * 'T2) -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastCompareTuple3 : comparer:Collections.IComparer -> tuple1:('T1 * 'T2 * 'T3) -> tuple2:('T1 * 'T2 * 'T3) -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastCompareTuple4 : comparer:Collections.IComparer -> tuple1:('T1 * 'T2 * 'T3 * 'T4) -> tuple2:('T1 * 'T2 * 'T3 * 'T4) -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastCompareTuple5 : comparer:Collections.IComparer -> tuple1:('T1 * 'T2 * 'T3 * 'T4 * 'T5) -> tuple2:('T1 * 'T2 * 'T3 * 'T4 * 'T5) -> int
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type causes it to be represented using a CLI interface.
[<Sealed>]
type InterfaceAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> InterfaceAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type GeneralizableValueAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> GeneralizableValueAttribute
namespace Microsoft.FSharp.Core
/// Helper functions for converting F# first class function values to and from CLI representaions
/// of functions using delegates.
[<AbstractClass>]
[<Sealed>]
type FuncConvert =
/// A utility function to convert function values from tupled to curried form
static member FuncFromTupled : func:('T1 * 'T2 * 'T3 -> 'U) -> 'T1 -> 'T2 -> 'T3 -> 'U
/// A utility function to convert function values from tupled to curried form
static member FuncFromTupled : func:('T1 * 'T2 -> 'U) -> 'T1 -> 'T2 -> 'U
/// A utility function to convert function values from tupled to curried form
static member FuncFromTupled : func:('T1 * 'T2 * 'T3 * 'T4 * 'T5 -> 'U) -> 'T1 -> 'T2 -> 'T3 -> 'T4 -> 'T5 -> 'U
/// A utility function to convert function values from tupled to curried form
static member FuncFromTupled : func:('T1 * 'T2 * 'T3 * 'T4 -> 'U) -> 'T1 -> 'T2 -> 'T3 -> 'T4 -> 'U
/// Convert the given Action delegate object to an F# function value
static member ToFSharpFunc : action:Action<'T> -> 'T -> unit
/// Convert the given Converter delegate object to an F# function value
static member ToFSharpFunc : converter:Converter<'T,'U> -> 'T -> 'U
namespace Microsoft.FSharp.Core
/// Type of a formatting expression.
type Format<'Printer, 'State, 'Residue, 'Result, 'Tuple> = PrintfFormat<'Printer,'State,'Residue,'Result,'Tuple>
namespace Microsoft.FSharp.Core
/// Type of a formatting expression.
type Format<'Printer, 'State, 'Residue, 'Result> = PrintfFormat<'Printer,'State,'Residue,'Result>
namespace Microsoft.FSharp.Core
/// The CLI type used to represent F# first-class type function values. This type is for use
/// by compiled F# code.
[<AbstractClass>]
type FSharpTypeFunc =
/// Construct an instance of an F# first class type function value
new : unit -> FSharpTypeFunc
/// Specialize the type function at a given type
abstract member Specialize : unit -> obj
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type FSharpInterfaceDataVersionAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : major:int * minor:int * release:int -> FSharpInterfaceDataVersionAttribute
/// The major version number of the F# version associated with the attribute
member Major : int
/// The minor version number of the F# version associated with the attribute
member Minor : int
/// The release number of the F# version associated with the attribute
member Release : int
namespace Microsoft.FSharp.Core
/// The CLI type used to represent F# function values. This type is not
/// typically used directly, though may be used from other CLI languages.
[<AbstractClass>]
type FSharpFunc<'T, 'U> =
/// Construct an instance of an F# first class function value
new : unit -> FSharpFunc<'T, 'U>
/// Invoke an F# first class function value with one argument
abstract member Invoke : func:'T -> 'U
/// Convert an value of type System.Converter to a F# first class function value
static member FromConverter : converter:Converter<'T,'U> -> 'T -> 'U
/// 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.
static member InvokeFast : func:FSharpFunc<'T,('U -> 'V -> 'W -> 'X)> * arg1:'T * arg2:'U * arg3:'V * arg4:'W -> 'X
/// 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.
static member InvokeFast : func:FSharpFunc<'T,('U -> 'V -> 'W -> 'X -> 'Y)> * arg1:'T * arg2:'U * arg3:'V * arg4:'W * arg5:'X -> 'Y
/// 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.
static member InvokeFast : func:FSharpFunc<'T,('U -> 'V)> * arg1:'T * arg2:'U -> 'V
/// 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.
static member InvokeFast : func:FSharpFunc<'T,('U -> 'V -> 'W)> * arg1:'T * arg2:'U * arg3:'V -> 'W
/// Convert an value of type System.Converter to a F# first class function value
static member op_Implicit : converter:Converter<'T,'U> -> 'T -> 'U
/// Convert an F# first class function value to a value of type System.Converter
static member op_Implicit : func:('T -> 'U) -> Converter<'T,'U>
/// Convert an F# first class function value to a value of type System.Converter
static member ToConverter : func:('T -> 'U) -> Converter<'T,'U>
[<AutoOpen>]
module Microsoft.FSharp.Core.ExtraTopLevelOperators
/// Print to stdout using the given format.
val printf : format:Printf.TextWriterFormat<'T> -> 'T
/// Print to stdout using the given format, and add a newline.
val printfn : format:Printf.TextWriterFormat<'T> -> 'T
/// Print to stderr using the given format.
val eprintf : format:Printf.TextWriterFormat<'T> -> 'T
/// Print to stderr using the given format, and add a newline.
val eprintfn : format:Printf.TextWriterFormat<'T> -> 'T
/// Print to a string using the given format.
val sprintf : format:Printf.StringFormat<'T> -> 'T
/// Print to a string buffer and raise an exception with the given
/// result. Helper printers must return strings.
val failwithf : format:Printf.StringFormat<'T,'Result> -> 'T
/// Print to a file using the given format.
val fprintf : textWriter:IO.TextWriter -> format:Printf.TextWriterFormat<'T> -> 'T
/// Print to a file using the given format, and add a newline.
val fprintfn : textWriter:IO.TextWriter -> format:Printf.TextWriterFormat<'T> -> 'T
/// Builds a set from a sequence of objects. The objects are indexed using generic comparison.
val set : elements:seq<'T> -> Set<'T> when 'T : comparison
/// Builds an aysnchronous workflow using computation expression syntax.
val async : AsyncBuilder
/// Converts the argument to 32-bit float.
val inline single : value: ^T -> single when ^T : (static member op_Explicit : unit -> single)
/// Converts the argument to 64-bit float.
val inline double : value: ^T -> float when ^T : (static member op_Explicit : unit -> double)
/// Converts the argument to byte.
val inline uint8 : value: ^T -> byte when ^T : (static member op_Explicit : unit -> byte)
/// Converts the argument to signed byte.
val inline int8 : value: ^T -> sbyte when ^T : (static member op_Explicit : unit -> sbyte)
/// Builds a read-only lookup table from a sequence of key/value pairs. The key objects are indexed using generic hashing and equality.
val dict : keyValuePairs:seq<'Key * 'Value> -> Collections.Generic.IDictionary<'Key,'Value> when 'Key : equality
/// Builds a 2D array from a sequence of sequences of elements.
val array2D : rows:seq<'T3227> -> 'T [,] when 'T3227 :> seq<'T>
/// Special prefix operator for splicing typed expressions into quotation holes.
val ( ~% ) : expression:Quotations.Expr<'T> -> 'T
/// Special prefix operator for splicing untyped expressions into quotation holes.
val ( ~%% ) : expression:Quotations.Expr -> 'T
/// An active pattern to force the execution of values of type Lazy<_>.
val (|Lazy|) : input:Lazy<'T> -> 'T
/// Builds a query using query syntax and operators.
val query : Linq.QueryBuilder
namespace Microsoft.FSharp.Core
/// This attribute is used to tag values that are part of an experimental library
/// feature.
[<Sealed>]
type ExperimentalAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : message:string -> ExperimentalAttribute
/// Indicates the warning message to be emitted when F# source code uses this construct
member Message : string
namespace Microsoft.FSharp.Core
/// This attribute is used to indicate a generic container type satisfies the F# 'equality'
/// constraint only if a generic argument also satisfies this constraint. For example, adding
/// this attribute to parameter 'T on a type definition C<'T> means that a type C<X> only supports
/// equality if the type X also supports equality and all other conditions for C<X> to support
/// equality are also met. The type C<'T> can still be used with other type arguments, but a type such
/// as C<(int -> int)> will not support equality because the type (int -> int) is an F# function type
/// and does not support equality.
[<Sealed>]
type EqualityConditionalOnAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> EqualityConditionalOnAttribute
namespace Microsoft.FSharp.Core
/// Adding this attribute to a function indicates it is the entrypoint for an application.
/// If this attribute is not specified for an EXE then the initialization implicit in the
/// module bindings in the last file in the compilation sequence are used as the entrypoint.
[<Sealed>]
type EntryPointAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> EntryPointAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type DefaultValueAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : check:bool -> DefaultValueAttribute
/// Creates an instance of the attribute
new : unit -> DefaultValueAttribute
/// Indicates if a constraint is asserted that the field type supports 'null'
member Check : bool
namespace Microsoft.FSharp.Core
/// 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 CLI class for that type.
[<Sealed>]
type DefaultAugmentationAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : value:bool -> DefaultAugmentationAttribute
/// The value of the attribute, indicating whether the type has a default augmentation or not
member Value : bool
namespace Microsoft.FSharp.Core
/// Indicates that a member on a computation builder type is a custom query operator,
/// and indicates the name of that operator.
[<Sealed>]
type CustomOperationAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : name:string -> CustomOperationAttribute
/// Indicates if the custom operation supports the use of 'into' immediately after the use of the operation in a query or other computation expression to consume the results of the operation
member AllowIntoPattern : bool with get, set
/// Indicates if the custom operation is an operation similar to a group join in a sequence computation, supporting two inputs and a correlation constraint, and generating a group
member IsLikeGroupJoin : bool with get, set
/// Indicates if the custom operation is an operation similar to a join in a sequence computation, supporting two inputs and a correlation constraint
member IsLikeJoin : bool with get, set
/// Indicates if the custom operation is an operation similar to a zip in a sequence computation, supporting two inputs
member IsLikeZip : bool with get, set
/// Indicates the name used for the 'on' part of the custom query operator for join-like operators
member JoinConditionWord : string with get, set
/// Indicates if the custom operation maintains the variable space of the query of computation expression
member MaintainsVariableSpace : bool with get, set
/// Indicates if the custom operation maintains the variable space of the query of computation expression through the use of a bind operation
member MaintainsVariableSpaceUsingBind : bool with get, set
/// Get the name of the custom operation when used in a query or other computation expression
member Name : string
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type indicates it is a type with a user-defined implementation of equality.
[<Sealed>]
type CustomEqualityAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> CustomEqualityAttribute
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type indicates it is a type with a user-defined implementation of comparison.
[<Sealed>]
type CustomComparisonAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> CustomComparisonAttribute
namespace Microsoft.FSharp.Core.CompilerServices
/// The TypeProviderXmlDocAttribute attribute can be added to types and members.
/// The language service will display the CommentText property from the attribute
/// in the appropriate place when the user hovers over a type or member.
type TypeProviderXmlDocAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : commentText:string -> TypeProviderXmlDocAttribute
member CommentText : string
namespace Microsoft.FSharp.Core.CompilerServices
/// Additional type attribute flags related to provided types
type TypeProviderTypeAttributes =
| SuppressRelocate = -2147483648
| IsErased = 1073741824
namespace Microsoft.FSharp.Core.CompilerServices
/// Indicates that a code editor should hide all System.Object methods from the intellisense menus for instances of a provided type
type TypeProviderEditorHideMethodsAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> TypeProviderEditorHideMethodsAttribute
namespace Microsoft.FSharp.Core.CompilerServices
type TypeProviderDefinitionLocationAttribute =
inherit System.Attribute
new : unit -> TypeProviderDefinitionLocationAttribute
member Column : int with get, set
member FilePath : string with get, set
member Line : int with get, set
namespace Microsoft.FSharp.Core.CompilerServices
/// If the class that implements ITypeProvider has a constructor that accepts TypeProviderConfig
/// then it will be constructed with an instance of TypeProviderConfig.
type TypeProviderConfig =
new : systemRuntimeContainsType:(string -> bool) -> TypeProviderConfig
/// Indicates if the type provider instance is used in an environment which executes provided code such as F# Interactive.
member IsHostedExecution : bool with get, set
/// Indicates if the type provider host responds to invalidation events for type provider instances.
member IsInvalidationSupported : bool with get, set
/// Get the referenced assemblies for the type provider instance.
member ReferencedAssemblies : string [] with get, set
/// Get the full path to use to resolve relative paths in any file name arguments given to the type provider instance.
member ResolutionFolder : string with get, set
/// Get the full path to referenced assembly that caused this type provider instance to be created.
member RuntimeAssembly : string with get, set
/// version of referenced system runtime assembly
member SystemRuntimeAssemblyVersion : Version with get, set
/// Checks if given type exists in target system runtime library
member SystemRuntimeContainsType : string -> bool
/// Get the full path to use for temporary files for the type provider instance.
member TemporaryFolder : string with get, set
namespace Microsoft.FSharp.Core.CompilerServices
/// Place on a class that implements ITypeProvider to extend the compiler
type TypeProviderAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> TypeProviderAttribute
namespace Microsoft.FSharp.Core.CompilerServices
/// Place attribute on runtime assembly to indicate that there is a corresponding design-time
/// assembly that contains a type provider. Runtime and designer assembly may be the same.
type TypeProviderAssemblyAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : assemblyName:string -> TypeProviderAssemblyAttribute
/// Creates an instance of the attribute
new : unit -> TypeProviderAssemblyAttribute
member AssemblyName : string
/// A group of functions used as part of the compiled representation of F# sequence expressions.
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers
/// The F# compiler emits calls to this function to
/// implement the while operator for F# sequence expressions.
val EnumerateWhile : guard:(unit -> bool) -> source:seq<'T> -> seq<'T>
/// The F# compiler emits calls to this function to
/// implement the try/finally operator for F# sequence expressions.
val EnumerateThenFinally : source:seq<'T> -> compensation:(unit -> unit) -> seq<'T>
/// The F# compiler emits calls to this function to implement the compiler-intrinsic
/// conversions from untyped System.Collections.IEnumerable sequences to typed sequences.
val EnumerateFromFunctions : create:(unit -> 'T) -> moveNext:('T -> bool) -> current:('T -> 'U) -> seq<'U>
/// The F# compiler emits calls to this function to implement the use operator for F# sequence
/// expressions.
val EnumerateUsing : resource:'T -> source:('T -> 'Collection) -> seq<'U> when 'T :> IDisposable and 'Collection :> seq<'U>
/// Creates an anonymous event with the given handlers.
val CreateEvent : addHandler:('Delegate -> unit) -> removeHandler:('Delegate -> unit) -> createHandler:((obj -> 'Args -> unit) -> 'Delegate) -> IEvent<'Delegate,'Args> when 'Delegate : delegate<'Args, unit> and 'Delegate :> Delegate
namespace Microsoft.FSharp.Core.CompilerServices
/// Represents the product of two measure expressions when returned as a generic argument of a provided type.
[<Class>]
type MeasureProduct<'Measure1, 'Measure2> =
namespace Microsoft.FSharp.Core.CompilerServices
/// Represents the '1' measure expression when returned as a generic argument of a provided type.
[<Class>]
type MeasureOne =
namespace Microsoft.FSharp.Core.CompilerServices
/// Represents the inverse of a measure expressions when returned as a generic argument of a provided type.
[<Class>]
type MeasureInverse<'Measure> =
namespace Microsoft.FSharp.Core.CompilerServices
[<Interface>]
type ITypeProvider =
inherit System.IDisposable
/// Triggered when an assumption changes that invalidates the resolutions so far reported by the provider
[<CLIEvent>]
abstract member add_Invalidate : EventHandler -> unit
/// Apply static arguments to a provided type that accepts static arguments.
abstract member ApplyStaticArguments : typeWithoutArguments:Type * typePathWithArguments:string [] * staticArguments:obj [] -> Type
/// Get the physical contents of the given logical provided assembly.
abstract member GetGeneratedAssemblyContents : assembly:Reflection.Assembly -> byte []
/// Called by the compiler to ask for an Expression tree to replace the given MethodBase with.
abstract member GetInvokerExpression : syntheticMethodBase:Reflection.MethodBase * parameters:Quotations.Expr [] -> Quotations.Expr
/// Namespace name the this TypeProvider injects types into.
abstract member GetNamespaces : unit -> CompilerServices.IProvidedNamespace []
/// Get the static parameters for a provided type.
abstract member GetStaticParameters : typeWithoutArguments:Type -> Reflection.ParameterInfo []
/// Triggered when an assumption changes that invalidates the resolutions so far reported by the provider
[<CLIEvent>]
abstract member Invalidate : IEvent<EventHandler,EventArgs>
/// Triggered when an assumption changes that invalidates the resolutions so far reported by the provider
[<CLIEvent>]
abstract member remove_Invalidate : EventHandler -> unit
namespace Microsoft.FSharp.Core.CompilerServices
[<Interface>]
type IProvidedNamespace =
/// The sub-namespaces in this namespace. An optional member to prevent generation of namespaces until an outer namespace is explored.
abstract member GetNestedNamespaces : unit -> CompilerServices.IProvidedNamespace []
/// The top-level types
abstract member GetTypes : unit -> Type []
/// Namespace name the provider injects types into.
abstract member NamespaceName : string
/// Compilers call this method to query a type provider for a type name.
abstract member ResolveTypeName : typeName:string -> Type
namespace Microsoft.FSharp.Core.CompilerServices
/// The F# compiler emits implementations of this type for compiled sequence expressions.
[<AbstractClass>]
type GeneratedSequenceBase<'T> =
interface System.Collections.IEnumerable
interface System.Collections.Generic.IEnumerable<'T>
interface System.Collections.IEnumerator
interface System.Collections.Generic.IEnumerator<'T>
/// The F# compiler emits implementations of this type for compiled sequence expressions.
new : unit -> GeneratedSequenceBase<'T>
/// The F# compiler emits implementations of this type for compiled sequence expressions.
abstract member CheckClose : bool
/// The F# compiler emits implementations of this type for compiled sequence expressions.
abstract member Close : unit -> unit
/// The F# compiler emits implementations of this type for compiled sequence expressions.
abstract member GenerateNext : result:byref<Collections.Generic.IEnumerable<'T>> -> int
/// The F# compiler emits implementations of this type for compiled sequence expressions.
abstract member GetFreshEnumerator : unit -> Collections.Generic.IEnumerator<'T>
/// The F# compiler emits implementations of this type for compiled sequence expressions.
abstract member LastGenerated : 'T
namespace Microsoft.FSharp.Core
/// Indicates that a message should be emitted when F# source code uses this construct.
[<Sealed>]
type CompilerMessageAttribute =
inherit System.Attribute
/// Creates an instance of the attribute.
new : message:string * messageNumber:int -> CompilerMessageAttribute
/// Indicates if the message should indicate a compiler error. Error numbers less than
/// 10000 are considered reserved for use by the F# compiler and libraries.
member IsError : bool with get, set
/// Indicates if the construct should always be hidden in an editing environment.
member IsHidden : bool with get, set
/// Indicates the warning message to be emitted when F# source code uses this construct
member Message : string
/// Indicates the number associated with the message.
member MessageNumber : int
namespace Microsoft.FSharp.Core
/// Adding this attribute to a value or function definition in an F# module changes the name used
/// for the value in compiled CLI code.
[<Sealed>]
type CompiledNameAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : compiledName:string -> CompiledNameAttribute
/// The name of the value as it appears in compiled code
member CompiledName : string
namespace Microsoft.FSharp.Core
/// This attribute is inserted automatically by the F# compiler to tag
/// methods which are given the 'CompiledName' attribute. It is not intended
/// for use from user code.
[<Sealed>]
type CompilationSourceNameAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : sourceName:string -> CompilationSourceNameAttribute
/// Indicates the name of the entity in F# source code
member SourceName : string
namespace Microsoft.FSharp.Core
/// Indicates one or more adjustments to the compiled representation of an F# type or member.
[<Flags ()>]
type CompilationRepresentationFlags =
/// No special compilation representation.
| None = 0
/// Compile an instance member as 'static' .
| Static = 1
/// Compile a member as 'instance' even if null is used as a representation for this type.
| Instance = 2
/// append 'Module' to the end of a module whose name clashes with a type name in the same namespace.
| ModuleSuffix = 4
/// Permit the use of null as a representation for nullary discriminators in a discriminated union.
| UseNullAsTrueValue = 8
/// Compile a property as a CLI event.
| Event = 16
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type CompilationRepresentationAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : flags:CompilationRepresentationFlags -> CompilationRepresentationAttribute
/// Indicates one or more adjustments to the compiled representation of an F# type or member
member Flags : CompilationRepresentationFlags
namespace Microsoft.FSharp.Core
/// This attribute is inserted automatically by the F# compiler to tag types
/// and methods in the generated CLI code with flags indicating the correspondence
/// with original source constructs. It is used by the functions in the
/// Microsoft.FSharp.Reflection namespace to reverse-map compiled constructs to
/// their original forms. It is not intended for use from user code.
[<Sealed>]
type CompilationMappingAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : sourceConstructFlags:SourceConstructFlags * variantNumber:int * sequenceNumber:int -> CompilationMappingAttribute
/// Creates an instance of the attribute
new : sourceConstructFlags:SourceConstructFlags * sequenceNumber:int -> CompilationMappingAttribute
/// Creates an instance of the attribute
new : sourceConstructFlags:SourceConstructFlags -> CompilationMappingAttribute
/// Indicates the sequence number of the entity, if any, in a linear sequence of elements with F# source code
member SequenceNumber : int
/// Indicates the relationship between the compiled entity and F# source code
member SourceConstructFlags : SourceConstructFlags
/// Indicates the variant number of the entity, if any, in a linear sequence of elements with F# source code
member VariantNumber : int
namespace Microsoft.FSharp.Core
/// This attribute is generated automatically by the F# compiler to tag functions and members
/// that accept a partial application of some of their arguments and return a residual function
[<Sealed>]
type CompilationArgumentCountsAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : counts:int [] -> CompilationArgumentCountsAttribute
/// Indicates the number of arguments in each argument group
member Counts : Collections.Generic.IEnumerable<int>
namespace Microsoft.FSharp.Core
/// This attribute is used to indicate a generic container type satisfies the F# 'comparison'
/// constraint only if a generic argument also satisfies this constraint. For example, adding
/// this attribute to parameter 'T on a type definition C<'T> means that a type C<X> only supports
/// comparison if the type X also supports comparison and all other conditions for C<X> to support
/// comparison are also met. The type C<'T> can still be used with other type arguments, but a type such
/// as C<(int -> int)> will not support comparison because the type (int -> int) is an F# function type
/// and does not support comparison.
[<Sealed>]
type ComparisonConditionalOnAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> ComparisonConditionalOnAttribute
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type causes it to be represented using a CLI class.
[<Sealed>]
type ClassAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> ClassAttribute
namespace Microsoft.FSharp.Core
/// Helper types for active patterns with 7 choices.
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpChoice`7")>]
type Choice<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7> =
/// Choice 1 of 7 choices
| Choice1Of7 of 'T1
/// Choice 2 of 7 choices
| Choice2Of7 of 'T2
/// Choice 3 of 7 choices
| Choice3Of7 of 'T3
/// Choice 4 of 7 choices
| Choice4Of7 of 'T4
/// Choice 5 of 7 choices
| Choice5Of7 of 'T5
/// Choice 6 of 7 choices
| Choice6Of7 of 'T6
/// Choice 7 of 7 choices
| Choice7Of7 of 'T7
namespace Microsoft.FSharp.Core
/// Helper types for active patterns with 6 choices.
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpChoice`6")>]
type Choice<'T1, 'T2, 'T3, 'T4, 'T5, 'T6> =
/// Choice 1 of 6 choices
| Choice1Of6 of 'T1
/// Choice 2 of 6 choices
| Choice2Of6 of 'T2
/// Choice 3 of 6 choices
| Choice3Of6 of 'T3
/// Choice 4 of 6 choices
| Choice4Of6 of 'T4
/// Choice 5 of 6 choices
| Choice5Of6 of 'T5
/// Choice 6 of 6 choices
| Choice6Of6 of 'T6
namespace Microsoft.FSharp.Core
/// Helper types for active patterns with 5 choices.
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpChoice`5")>]
type Choice<'T1, 'T2, 'T3, 'T4, 'T5> =
/// Choice 1 of 5 choices
| Choice1Of5 of 'T1
/// Choice 2 of 5 choices
| Choice2Of5 of 'T2
/// Choice 3 of 5 choices
| Choice3Of5 of 'T3
/// Choice 4 of 5 choices
| Choice4Of5 of 'T4
/// Choice 5 of 5 choices
| Choice5Of5 of 'T5
namespace Microsoft.FSharp.Core
/// Helper types for active patterns with 4 choices.
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpChoice`4")>]
type Choice<'T1, 'T2, 'T3, 'T4> =
/// Choice 1 of 4 choices
| Choice1Of4 of 'T1
/// Choice 2 of 4 choices
| Choice2Of4 of 'T2
/// Choice 3 of 4 choices
| Choice3Of4 of 'T3
/// Choice 4 of 4 choices
| Choice4Of4 of 'T4
namespace Microsoft.FSharp.Core
/// Helper types for active patterns with 3 choices.
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpChoice`3")>]
type Choice<'T1, 'T2, 'T3> =
/// Choice 1 of 3 choices
| Choice1Of3 of 'T1
/// Choice 2 of 3 choices
| Choice2Of3 of 'T2
/// Choice 3 of 3 choices
| Choice3Of3 of 'T3
namespace Microsoft.FSharp.Core
/// Helper types for active patterns with 2 choices.
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpChoice`2")>]
type Choice<'T1, 'T2> =
/// Choice 1 of 2 choices
| Choice1Of2 of 'T1
/// Choice 2 of 2 choices
| Choice2Of2 of 'T2
namespace Microsoft.FSharp.Core
/// Adding this attribute to a record type causes it to be compiled to a CLI representation
/// with a default constructor with property getters and setters.
[<Sealed>]
type CLIMutableAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> CLIMutableAttribute
namespace Microsoft.FSharp.Core
/// Adding this attribute to a property with event type causes it to be compiled with as a CLI
/// metadata event, through a syntactic translation to a pair of 'add_EventName' and
/// 'remove_EventName' methods.
[<Sealed>]
type CLIEventAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> CLIEventAttribute
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type with value 'false' disables the behaviour where F# makes the
/// type Serializable by default.
[<Sealed>]
type AutoSerializableAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : value:bool -> AutoSerializableAttribute
/// The value of the attribute, indicating whether the type is automatically marked serializable or not
member Value : bool
namespace Microsoft.FSharp.Core
/// 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 opened.
[<Sealed>]
type AutoOpenAttribute =
inherit System.Attribute
/// Creates an attribute used to mark a namespace or module path to be 'automatically opened' when an assembly is referenced
new : path:string -> AutoOpenAttribute
/// Creates an attribute used to mark a module as 'automatically opened' when the enclosing namespace is opened
new : unit -> AutoOpenAttribute
/// Indicates the namespace or module to be automatically opened when an assembly is referenced
/// or an enclosing module opened.
member Path : string
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type lets the 'null' literal be used for the type
/// within F# code. This attribute may only be added to F#-defined class or
/// interface types.
[<Sealed>]
type AllowNullLiteralAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> AllowNullLiteralAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type AbstractClassAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> AbstractClassAttribute
namespace Microsoft.FSharp.Control
type ``lazy``<'T> = Lazy<'T>
/// A module of extension members providing asynchronous operations for some basic Web operations.
[<AutoOpen>]
module Microsoft.FSharp.Control.WebExtensions
/// Returns an asynchronous computation that, when run, will wait for a response to the given WebRequest.
val AsyncGetResponse : unit -> Async<Net.WebResponse>
/// Returns an asynchronous computation that, when run, will wait for the download of the given URI.
val AsyncDownloadString : address:Uri -> Async<string>
/// Basic operations on first class event and other observable objects.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Control.Observable
/// Returns an observable for the merged observations from the sources.
/// The returned object propagates success and error values arising
/// from either source and completes when both the sources have completed.
val merge : source1:IObservable<'T> -> source2:IObservable<'T> -> IObservable<'T>
/// Returns an observable which transforms the observations of the source by the
/// given function. The transformation function is executed once for each
/// subscribed observer. The returned object also propagates error observations
/// arising from the source and completes when the source completes.
val map : mapping:('T -> 'U) -> source:IObservable<'T> -> IObservable<'U>
/// Returns an observable which filters the observations of the source
/// by the given function. The observable will see only those observations
/// for which the predicate returns true. The predicate is executed once for
/// each subscribed observer. The returned object also propagates error
/// observations arising from the source and completes when the source completes.
val filter : predicate:('T -> bool) -> source:IObservable<'T> -> IObservable<'T>
/// Returns two observables which partition the observations of the source by
/// the given function. The first will trigger observations for those values
/// for which the predicate returns true. The second will trigger observations
/// for those values where the predicate returns false. The predicate is
/// executed once for each subscribed observer. Both also propagate all error
/// observations arising from the source and each completes when the source
/// completes.
val partition : predicate:('T -> bool) -> source:IObservable<'T> -> IObservable<'T> * IObservable<'T>
/// Returns two observables which split the observations of the source by the
/// given function. The first will trigger observations x for which the
/// splitter returns Choice1Of2 x. The second will trigger observations
/// y for which the splitter returns Choice2Of2 y The splitter is
/// executed once for each subscribed observer. Both also propagate error
/// observations arising from the source and each completes when the source
/// completes.
val split : splitter:('T -> Choice<'U1,'U2>) -> source:IObservable<'T> -> IObservable<'U1> * IObservable<'U2>
/// Returns an observable which chooses a projection of observations from the source
/// using the given function. The returned object will trigger observations x
/// for which the splitter returns Some x. The returned object also propagates
/// all errors arising from the source and completes when the source completes.
val choose : chooser:('T -> 'U option) -> source:IObservable<'T> -> IObservable<'U>
/// Returns an observable which, for each observer, allocates an item of state
/// and applies the given accumulating function to successive values arising from
/// the input. The returned object will trigger observations for each computed
/// state value, excluding the initial value. The returned object propagates
/// all errors arising from the source and completes when the source completes.
val scan : collector:('U -> 'T -> 'U) -> state:'U -> source:IObservable<'T> -> IObservable<'U>
/// Creates an observer which permanently subscribes to the given observable and which calls
/// the given function for each observation.
val add : callback:('T -> unit) -> source:IObservable<'T> -> unit
/// Creates an observer which subscribes to the given observable and which calls
/// the given function for each observation.
val subscribe : callback:('T -> unit) -> source:IObservable<'T> -> IDisposable
/// Returns a new observable that triggers on the second and subsequent triggerings of the input observable.
/// The Nth triggering of the input observable 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.
val pairwise : source:IObservable<'T> -> IObservable<'T * 'T>
namespace Microsoft.FSharp.Control
/// A message-processing agent which executes an asynchronous computation.
[<Sealed>]
[<AutoSerializable(false)>]
[<CompiledName("FSharpMailboxProcessor`1")>]
type MailboxProcessor<'Msg> =
interface System.IDisposable
/// Creates an agent. The body function is used to generate the asynchronous
/// computation executed by the agent. This function is not executed until
/// Start is called.
new : body:(MailboxProcessor<'Msg> -> Async<unit>) * ?cancellationToken:Threading.CancellationToken -> MailboxProcessor<'Msg>
/// Occurs when the execution of the agent results in an exception.
[<CLIEvent>]
member add_Error : Handler<Exception> -> unit
/// Returns the number of unprocessed messages in the message queue of the agent.
member CurrentQueueLength : int
/// Raises a timeout exception if a message not received in this amount of time. By default
/// no timeout is used.
member DefaultTimeout : int with get, set
/// Occurs when the execution of the agent results in an exception.
[<CLIEvent>]
member Error : IEvent<Exception>
/// Posts a message to the message queue of the MailboxProcessor, asynchronously.
member Post : message:'Msg -> unit
/// Posts a message to an agent and await a reply on the channel, asynchronously.
member PostAndAsyncReply : buildMessage:(AsyncReplyChannel<'Reply> -> 'Msg) * ?timeout:int -> Async<'Reply>
/// Posts a message to an agent and await a reply on the channel, synchronously.
member PostAndReply : buildMessage:(AsyncReplyChannel<'Reply> -> 'Msg) * ?timeout:int -> 'Reply
/// Like AsyncPostAndReply, but returns None if no reply within the timeout period.
member PostAndTryAsyncReply : buildMessage:(AsyncReplyChannel<'Reply> -> 'Msg) * ?timeout:int -> Async<'Reply option>
/// Waits for a message. This will consume the first message in arrival order.
member Receive : ?timeout:int -> Async<'Msg>
/// Occurs when the execution of the agent results in an exception.
[<CLIEvent>]
member remove_Error : Handler<Exception> -> unit
/// Scans for a message by looking through messages in arrival order until scanner
/// returns a Some value. Other messages remain in the queue.
member Scan : scanner:('Msg -> Async<'T> option) * ?timeout:int -> Async<'T>
/// Starts the agent.
member Start : unit -> unit
/// Like PostAndReply, but returns None if no reply within the timeout period.
member TryPostAndReply : buildMessage:(AsyncReplyChannel<'Reply> -> 'Msg) * ?timeout:int -> 'Reply option
/// Waits for a message. This will consume the first message in arrival order.
member TryReceive : ?timeout:int -> Async<'Msg option>
/// Scans for a message by looking through messages in arrival order until scanner
/// returns a Some value. Other messages remain in the queue.
member TryScan : scanner:('Msg -> Async<'T> option) * ?timeout:int -> Async<'T option>
/// Creates and starts an agent. The body function is used to generate the asynchronous
/// computation executed by the agent.
static member Start : body:(MailboxProcessor<'Msg> -> Async<unit>) * ?cancellationToken:Threading.CancellationToken -> MailboxProcessor<'Msg>
namespace Microsoft.FSharp.Control
/// The type of delayed computations.
type Lazy<'T> = Lazy<'T>
/// Extensions related to Lazy values.
[<AutoOpen>]
module Microsoft.FSharp.Control.LazyExtensions
/// Creates a lazy computation that evaluates to the result of the given function when forced.
val Create : creator:(unit -> 'T) -> Lazy<'T>
/// Creates a lazy computation that evaluates to the given value when forced.
val CreateFromValue : value:'T -> Lazy<'T>
/// Forces the execution of this value and return its result. Same as Value. Mutual exclusion is used to
/// prevent other threads also computing the value.
val Force : unit -> 'T
namespace Microsoft.FSharp.Control
/// First class event values for CLI events conforming to CLI Framework standards.
[<Interface>]
type IEvent<'Delegate, 'Args when 'Delegate : delegate<'Args, unit> and 'Delegate :> Delegate> =
interface
inherit IDelegateEvent<'Delegate>
inherit System.IObservable<'Args>
end
namespace Microsoft.FSharp.Control
/// First-class listening points (i.e. objects that permit you to register a callback
/// activated when the event is triggered).
type IEvent<'T> = IEvent<Handler<'T>,'T>
namespace Microsoft.FSharp.Control
/// First class event values for arbitrary delegate types.
[<Interface>]
type IDelegateEvent<'Delegate when 'Delegate :> Delegate> =
/// 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.
abstract member AddHandler : handler:'Delegate -> unit
/// Remove a listener delegate from an event listener store.
abstract member RemoveHandler : handler:'Delegate -> unit
namespace Microsoft.FSharp.Control
/// A delegate type associated with the F# event type IEvent<_>
type ``Handler`1`` =
delegate of sender:obj * args:'T -> unit
namespace Microsoft.FSharp.Control
/// Event implementations for a delegate types following the standard .NET Framework convention of a first 'sender' argument.
[<CompiledName("FSharpEvent`2")>]
type Event<'Delegate, 'Args when 'Delegate : delegate<'Args, unit> and 'Delegate :> Delegate> =
/// Creates an event object suitable for delegate types following the standard .NET Framework convention of a first 'sender' argument.
new : unit -> Event<'Delegate, 'Args>
/// Publishes the event as a first class event value.
member Publish : IEvent<'Delegate,'Args>
/// Triggers the event using the given sender object and parameters. The sender object may be null.
member Trigger : sender:obj * args:'Args -> unit
namespace Microsoft.FSharp.Control
/// Event implementations for the IEvent<_> type.
[<CompiledName("FSharpEvent`1")>]
type Event<'T> =
/// Creates an observable object.
new : unit -> Event<'T>
/// Publishes an observation as a first class value.
member Publish : IEvent<'T>
/// Triggers an observation using the given parameters.
member Trigger : arg:'T -> unit
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Control.Event
/// Fires the output event when either of the input events fire.
val merge : event1:IEvent<'Del1,'T> -> event2:IEvent<'Del2,'T> -> IEvent<'T> when 'Del1 : delegate<'T, unit> and 'Del1 :> Delegate and 'Del2 : delegate<'T, unit> and 'Del2 :> Delegate
/// Returns a new event that passes values transformed by the given function.
val map : mapping:('T -> 'U) -> sourceEvent:IEvent<'Del,'T> -> IEvent<'U> when 'Del : delegate<'T, unit> and 'Del :> Delegate
/// Returns 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.
val filter : predicate:('T -> bool) -> sourceEvent:IEvent<'Del,'T> -> IEvent<'T> when 'Del : delegate<'T, unit> and 'Del :> Delegate
/// Returns 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.
val partition : predicate:('T -> bool) -> sourceEvent:IEvent<'Del,'T> -> IEvent<'T> * IEvent<'T> when 'Del : delegate<'T, unit> and 'Del :> Delegate
/// Returns 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.
val split : splitter:('T -> Choice<'U1,'U2>) -> sourceEvent:IEvent<'Del,'T> -> IEvent<'U1> * IEvent<'U2> when 'Del : delegate<'T, unit> and 'Del :> Delegate
/// Returns 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.
val choose : chooser:('T -> 'U option) -> sourceEvent:IEvent<'Del,'T> -> IEvent<'U> when 'Del : delegate<'T, unit> and 'Del :> Delegate
/// Returns 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.
val scan : collector:('U -> 'T -> 'U) -> state:'U -> sourceEvent:IEvent<'Del,'T> -> IEvent<'U> when 'Del : delegate<'T, unit> and 'Del :> Delegate
/// Runs the given function each time the given event is triggered.
val add : callback:('T -> unit) -> sourceEvent:IEvent<'Del,'T> -> unit when 'Del : delegate<'T, unit> and 'Del :> Delegate
/// Returns 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.
val pairwise : sourceEvent:IEvent<'Del,'T> -> IEvent<'T * 'T> when 'Del : delegate<'T, unit> and 'Del :> Delegate
namespace Microsoft.FSharp.Control
/// Event implementations for an arbitrary type of delegate.
[<CompiledName("FSharpDelegateEvent`1")>]
type DelegateEvent<'Delegate when 'Delegate :> Delegate> =
/// Creates an event object suitable for implementing an arbitrary type of delegate.
new : unit -> DelegateEvent<'Delegate>
/// Publishes the event as a first class event value.
member Publish : IDelegateEvent<'Delegate>
/// Triggers the event using the given parameters.
member Trigger : args:obj [] -> unit
/// A module of extension members providing asynchronous operations for some basic CLI types related to concurrency and I/O.
[<AutoOpen>]
module Microsoft.FSharp.Control.CommonExtensions
/// Returns an asynchronous computation that will read from the stream into the given buffer.
val AsyncRead : buffer:byte [] * ?offset:int * ?count:int -> Async<int>
/// Returns an asynchronous computation that will read the given number of bytes from the stream.
val AsyncRead : count:int -> Async<byte []>
/// Returns an asynchronous computation that will write the given bytes to the stream.
val AsyncWrite : buffer:byte [] * ?offset:int * ?count:int -> Async<unit>
/// Permanently connects a listener function to the observable. The listener will
/// be invoked for each observation.
val Add : callback:('T -> unit) -> unit
/// Connects a listener function to the observable. The listener will
/// be invoked for each observation. The listener can be removed by
/// calling Dispose on the returned IDisposable object.
val Subscribe : callback:('T -> unit) -> IDisposable
namespace Microsoft.FSharp.Control
/// A compositional asynchronous computation, which, when run, will eventually produce a value
/// of type T, or else raises an exception.
[<Sealed>]
[<NoEquality>]
[<NoComparison>]
[<CompiledName("FSharpAsync`1")>]
[<Class>]
type Async<'T> =
namespace Microsoft.FSharp.Control
/// A handle to a capability to reply to a PostAndReply message.
[<Sealed>]
[<CompiledName("FSharpAsyncReplyChannel`1")>]
[<Class>]
type AsyncReplyChannel<'Reply> =
/// Sends a reply to a PostAndReply message.
member Reply : value:'Reply -> unit
namespace Microsoft.FSharp.Control
/// The type of the async operator, used to build workflows for asynchronous computations.
[<CompiledName("FSharpAsyncBuilder")>]
[<Sealed>]
type AsyncBuilder =
/// Creates an asynchronous computation that runs computation, and when
/// computation generates a result T, runs binder res.
member Bind : computation:Async<'T> * binder:('T -> Async<'U>) -> Async<'U>
/// Creates an asynchronous computation that first runs computation1
/// and then runs computation2, returning the result of computation2.
member Combine : computation1:Async<unit> * computation2:Async<'T> -> Async<'T>
/// Creates an asynchronous computation that runs generator.
member Delay : generator:(unit -> Async<'T>) -> Async<'T>
/// Creates an asynchronous computation that enumerates the sequence seq
/// on demand and runs body for each element.
member For : sequence:seq<'T> * body:('T -> Async<unit>) -> Async<unit>
/// Creates an asynchronous computation that returns the result v.
member Return : value:'T -> Async<'T>
/// Delegates to the input computation.
member ReturnFrom : computation:Async<'T> -> Async<'T>
/// Creates an asynchronous computation that runs computation. The action compensation is executed
/// after computation completes, whether computation exits normally or by an exception. If compensation raises an exception itself
/// the original exception is discarded and the new exception becomes the overall result of the computation.
member TryFinally : computation:Async<'T> * compensation:(unit -> unit) -> Async<'T>
/// Creates an asynchronous computation that runs computation and returns its result.
/// If an exception happens then catchHandler(exn) is called and the resulting computation executed instead.
member TryWith : computation:Async<'T> * catchHandler:(exn -> Async<'T>) -> Async<'T>
/// Creates an asynchronous computation that runs binder(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.
member Using : resource:'T * binder:('T -> Async<'U>) -> Async<'U> when 'T :> IDisposable
/// Creates an asynchronous computation that runs computation repeatedly
/// until guard() becomes false.
member While : guard:(unit -> bool) * computation:Async<unit> -> Async<unit>
/// Creates an asynchronous computation that just returns ().
member Zero : unit -> Async<unit>
namespace Microsoft.FSharp.Control
/// This static class holds members for creating and manipulating asynchronous computations.
[<Sealed>]
[<CompiledName("FSharpAsync")>]
[<Class>]
type Async =
/// Creates three functions that can be used to implement the .NET Asynchronous
/// Programming Model (APM) for a given asynchronous computation.
static member AsBeginEnd : computation:('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit)
/// Creates an asynchronous computation that waits for a single invocation of a CLI
/// event by adding a handler to the event. Once the computation completes or is
/// cancelled, the handler is removed from the event.
static member AwaitEvent : event:IEvent<'Del,'T> * ?cancelAction:(unit -> unit) -> Async<'T> when 'Del : delegate<'T, unit> and 'Del :> Delegate
/// Creates an asynchronous computation that will wait on the IAsyncResult.
static member AwaitIAsyncResult : iar:IAsyncResult * ?millisecondsTimeout:int -> Async<bool>
/// Return an asynchronous computation that will wait for the given task to complete and return
/// its result.
static member AwaitTask : task:Threading.Tasks.Task<'T> -> Async<'T>
/// Creates an asynchronous computation that will wait on the given WaitHandle.
static member AwaitWaitHandle : waitHandle:Threading.WaitHandle * ?millisecondsTimeout:int -> Async<bool>
/// Raises the cancellation condition for the most recent set of asynchronous computations started
/// without any specific CancellationToken. Replaces the global CancellationTokenSource with a new
/// global token source for any asynchronous computations created after this point without any
/// specific CancellationToken.
static member CancelDefaultToken : unit -> unit
/// Creates an asynchronous computation that returns the CancellationToken governing the execution
/// of the computation.
static member CancellationToken : Async<Threading.CancellationToken>
/// Creates an asynchronous computation that executes computation.
/// If this computation completes successfully then return Choice1Of2 with the returned
/// value. If this computation raises an exception before it completes then return Choice2Of2
/// with the raised exception.
static member Catch : computation:Async<'T> -> Async<Choice<'T,exn>>
/// Gets the default cancellation token for executing asynchronous computations.
static member DefaultCancellationToken : Threading.CancellationToken
/// Creates an asynchronous computation in terms of a Begin/End pair of actions in
/// the style used in CLI APIs. This overlaod should be used if the operation is
/// qualified by three arguments. For example,
/// Async.FromBeginEnd(arg1,arg2,arg3,ws.BeginGetWeather,ws.EndGetWeather)
/// When the computation is run, beginFunc is executed, with
/// a callback which represents the continuation of the computation.
/// When the callback is invoked, the overall result is fetched using endFunc.
static member FromBeginEnd : arg1:'Arg1 * arg2:'Arg2 * arg3:'Arg3 * beginAction:('Arg1 * 'Arg2 * 'Arg3 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
/// Creates an asynchronous computation in terms of a Begin/End pair of actions in
/// the style used in CLI APIs. For example,
/// Async.FromBeginEnd(ws.BeginGetWeather,ws.EndGetWeather)
/// When the computation is run, beginFunc is executed, with
/// a callback which represents the continuation of the computation.
/// When the callback is invoked, the overall result is fetched using endFunc.
static member FromBeginEnd : beginAction:(AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
/// Creates an asynchronous computation in terms of a Begin/End pair of actions in
/// the style used in CLI APIs. This overlaod should be used if the operation is
/// qualified by two arguments. For example,
/// Async.FromBeginEnd(arg1,arg2,ws.BeginGetWeather,ws.EndGetWeather)
/// When the computation is run, beginFunc is executed, with
/// a callback which represents the continuation of the computation.
/// When the callback is invoked, the overall result is fetched using endFunc.
static member FromBeginEnd : arg1:'Arg1 * arg2:'Arg2 * beginAction:('Arg1 * 'Arg2 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
/// Creates an asynchronous computation in terms of a Begin/End pair of actions in
/// the style used in CLI APIs. This overlaod should be used if the operation is
/// qualified by one argument. For example,
/// Async.FromBeginEnd(place,ws.BeginGetWeather,ws.EndGetWeather)
/// When the computation is run, beginFunc is executed, with
/// a callback which represents the continuation of the computation.
/// When the callback is invoked, the overall result is fetched using endFunc.
static member FromBeginEnd : arg:'Arg1 * beginAction:('Arg1 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
/// Creates an asynchronous computation that captures the current
/// success, exception and cancellation continuations. The callback must
/// eventually call exactly one of the given continuations.
static member FromContinuations : callback:(('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T>
/// Creates an asynchronous computation that runs the given computation and ignores
/// its result.
static member Ignore : computation:Async<'T> -> Async<unit>
/// Generates a scoped, cooperative cancellation handler for use within an asynchronous workflow.
static member OnCancel : interruption:(unit -> unit) -> Async<IDisposable>
/// Creates an asynchronous computation that executes all the given asynchronous computations,
/// initially queueing each as work items and using a fork/join pattern.
static member Parallel : computations:seq<Async<'T>> -> Async<'T []>
/// Runs the asynchronous computation and await its result.
static member RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:Threading.CancellationToken -> 'T
/// Creates an asynchronous computation that will sleep for the given time. This is scheduled
/// using a System.Threading.Timer object. The operation will not block operating system threads
/// for the duration of the wait.
static member Sleep : millisecondsDueTime:int -> Async<unit>
/// Starts the asynchronous computation in the thread pool. Do not await its result.
static member Start : computation:Async<unit> * ?cancellationToken:Threading.CancellationToken -> unit
/// Executes a computation in the thread pool.
static member StartAsTask : computation:Async<'T> * ?taskCreationOptions:Threading.Tasks.TaskCreationOptions * ?cancellationToken:Threading.CancellationToken -> Threading.Tasks.Task<'T>
/// Starts a child computation within an asynchronous workflow.
/// This allows multiple asynchronous computations to be executed simultaneously.
static member StartChild : computation:Async<'T> * ?millisecondsTimeout:int -> Async<Async<'T>>
/// Creates an asynchronous computation which starts the given computation as a System.Threading.Tasks.Task
static member StartChildAsTask : computation:Async<'T> * ?taskCreationOptions:Threading.Tasks.TaskCreationOptions -> Async<Threading.Tasks.Task<'T>>
/// Runs an asynchronous computation, starting immediately on the current operating system
/// thread.
static member StartImmediate : computation:Async<unit> * ?cancellationToken:Threading.CancellationToken -> unit
/// Runs an asynchronous computation, starting immediately on the current operating system
/// thread. Call one of the three continuations when the operation completes.
static member StartWithContinuations : computation:Async<'T> * continuation:('T -> unit) * exceptionContinuation:(exn -> unit) * cancellationContinuation:(OperationCanceledException -> unit) * ?cancellationToken:Threading.CancellationToken -> unit
/// Creates an asynchronous computation that runs
/// its continuation using syncContext.Post. If syncContext is null
/// then the asynchronous computation is equivalent to SwitchToThreadPool().
static member SwitchToContext : syncContext:Threading.SynchronizationContext -> Async<unit>
/// Creates an asynchronous computation that creates a new thread and runs
/// its continuation in that thread.
static member SwitchToNewThread : unit -> Async<unit>
/// Creates an asynchronous computation that queues a work item that runs
/// its continuation.
static member SwitchToThreadPool : unit -> Async<unit>
/// Creates an asynchronous computation that executes computation.
/// If this computation is cancelled before it completes then the computation generated by
/// running compensation is executed.
static member TryCancelled : computation:Async<'T> * compensation:(OperationCanceledException -> unit) -> Async<'T>
namespace Microsoft.FSharp.Collections
/// An abbreviation for the CLI type System.Collections.Generic.IEnumerable<_>
type seq<'T> = Collections.Generic.IEnumerable<'T>
namespace Microsoft.FSharp.Collections
/// An abbreviation for the type of immutable singly-linked lists.
type list<'T> = List<'T>
namespace Microsoft.FSharp.Collections
/// Immutable sets based on binary trees, where comparison is the
/// F# structural comparison function, potentially using implementations
/// of the IComparable interface on key values.
[<Sealed>]
[<CompiledName("FSharpSet`1")>]
type Set<'T when 'T : comparison> =
interface System.Collections.Generic.ICollection<'T>
interface System.Collections.IEnumerable
interface System.Collections.Generic.IEnumerable<'T>
/// Create a set containing elements drawn from the given sequence.
new : elements:seq<'T> -> Set<'T>
/// 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.
member Add : value:'T -> Set<'T>
/// A useful shortcut for Set.contains. See the Set module for further operations on sets.
member Contains : value:'T -> bool
/// The number of elements in the set
member Count : int
override Equals : obj -> bool
/// A useful shortcut for Set.isEmpty. See the Set module for further operations on sets.
member IsEmpty : bool
/// Evaluates to "true" if all elements of the first set are in the second, and at least
/// one element of the second is not in the first.
member IsProperSubsetOf : otherSet:Set<'T> -> bool
/// Evaluates to "true" if all elements of the second set are in the first, and at least
/// one element of the first is not in the second.
member IsProperSupersetOf : otherSet:Set<'T> -> bool
/// Evaluates to "true" if all elements of the first set are in the second.
member IsSubsetOf : otherSet:Set<'T> -> bool
/// Evaluates to "true" if all elements of the second set are in the first.
member IsSupersetOf : otherSet:Set<'T> -> bool
/// Returns the highest element in the set according to the ordering being used for the set.
member MaximumElement : 'T
/// Returns the lowest element in the set according to the ordering being used for the set.
member MinimumElement : 'T
/// 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.
member Remove : value:'T -> Set<'T>
/// Compute the union of the two sets.
static member op_Addition : set1:Set<'T> * set2:Set<'T> -> Set<'T>
/// Returns a new set with the elements of the second set removed from the first.
static member op_Subtraction : set1:Set<'T> * set2:Set<'T> -> Set<'T>
/// Functional programming operators related to the Set<_> type.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Collections.Set
/// The empty set for the type 'T.
val empty : Set<'T> when 'T : comparison
/// The set containing the given element.
val singleton : value:'T -> Set<'T> when 'T : comparison
/// Returns a new set with an element added to the set. No exception is raised if
/// the set already contains the given element.
val add : value:'T -> set:Set<'T> -> Set<'T> when 'T : comparison
/// Evaluates to "true" if the given element is in the given set.
val contains : element:'T -> set:Set<'T> -> bool when 'T : comparison
/// Evaluates to "true" if all elements of the first set are in the second
val isSubset : set1:Set<'T> -> set2:Set<'T> -> bool when 'T : comparison
/// Evaluates to "true" if all elements of the first set are in the second, and at least
/// one element of the second is not in the first.
val isProperSubset : set1:Set<'T> -> set2:Set<'T> -> bool when 'T : comparison
/// Evaluates to "true" if all elements of the second set are in the first.
val isSuperset : set1:Set<'T> -> set2:Set<'T> -> bool when 'T : comparison
/// Evaluates to "true" if all elements of the second set are in the first, and at least
/// one element of the first is not in the second.
val isProperSuperset : set1:Set<'T> -> set2:Set<'T> -> bool when 'T : comparison
/// Returns the number of elements in the set. Same as size.
val count : set:Set<'T> -> int when 'T : comparison
/// Tests if any element of the collection satisfies the given predicate.
/// If the input function is predicate and the elements are i0...iN
/// then computes p i0 or ... or p iN.
val exists : predicate:('T -> bool) -> set:Set<'T> -> bool when 'T : comparison
/// Returns a new collection containing only the elements of the collection
/// for which the given predicate returns true.
val filter : predicate:('T -> bool) -> set:Set<'T> -> Set<'T> when 'T : comparison
/// Returns a new collection containing the results of applying the
/// given function to each element of the input set.
val map : mapping:('T -> 'U) -> set:Set<'T> -> Set<'U> when 'T : comparison and 'U : comparison
/// Applies the given accumulating function to all the elements of the set
val fold : folder:('State -> 'T -> 'State) -> state:'State -> set:Set<'T> -> 'State when 'T : comparison
/// Applies the given accumulating function to all the elements of the set.
val foldBack : folder:('T -> 'State -> 'State) -> set:Set<'T> -> state:'State -> 'State when 'T : comparison
/// Tests 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.
val forall : predicate:('T -> bool) -> set:Set<'T> -> bool when 'T : comparison
/// Computes the intersection of the two sets.
val intersect : set1:Set<'T> -> set2:Set<'T> -> Set<'T> when 'T : comparison
/// Computes the intersection of a sequence of sets. The sequence must be non-empty.
val intersectMany : sets:seq<Set<'T>> -> Set<'T> when 'T : comparison
/// Computes the union of the two sets.
val union : set1:Set<'T> -> set2:Set<'T> -> Set<'T> when 'T : comparison
/// Computes the union of a sequence of sets.
val unionMany : sets:seq<Set<'T>> -> Set<'T> when 'T : comparison
/// Returns "true" if the set is empty.
val isEmpty : set:Set<'T> -> bool when 'T : comparison
/// Applies the given function to each element of the set, in order according
/// to the comparison function.
val iter : action:('T -> unit) -> set:Set<'T> -> unit when 'T : comparison
/// Splits the set into two sets containing the elements for which the given predicate
/// returns true and false respectively.
val partition : predicate:('T -> bool) -> set:Set<'T> -> Set<'T> * Set<'T> when 'T : comparison
/// Returns a new set with the given element removed. No exception is raised if
/// the set doesn't contain the given element.
val remove : value:'T -> set:Set<'T> -> Set<'T> when 'T : comparison
/// Returns the lowest element in the set according to the ordering being used for the set.
val minElement : set:Set<'T> -> 'T when 'T : comparison
/// Returns the highest element in the set according to the ordering being used for the set.
val maxElement : set:Set<'T> -> 'T when 'T : comparison
/// Builds a set that contains the same elements as the given list.
val ofList : elements:'T list -> Set<'T> when 'T : comparison
/// Builds a list that contains the elements of the set in order.
val toList : set:Set<'T> -> 'T list when 'T : comparison
/// Builds a set that contains the same elements as the given array.
val ofArray : array:'T [] -> Set<'T> when 'T : comparison
/// Builds an array that contains the elements of the set in order.
val toArray : set:Set<'T> -> 'T [] when 'T : comparison
/// Returns an ordered view of the collection as an enumerable object.
val toSeq : set:Set<'T> -> seq<'T> when 'T : comparison
/// Builds a new collection from the given enumerable object.
val ofSeq : elements:seq<'T> -> Set<'T> when 'T : comparison
/// Returns a new set with the elements of the second set removed from the first.
val difference : set1:Set<'T> -> set2:Set<'T> -> Set<'T> when 'T : comparison
/// Basic operations on IEnumerables.
[<RequireQualifiedAccess>]
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
module Microsoft.FSharp.Collections.Seq
/// Wraps the two given enumerations as a single concatenated
/// enumeration.
val append : source1:seq<'T> -> source2:seq<'T> -> seq<'T>
/// Returns the average of the elements in the sequence.
val inline average : source:seq< ^T> -> ^T when ^T : (static member ( + ) : ^T * ^T -> ^T) and ^T : (static member DivideByInt : ^T * int -> ^T) and ^T : (static member Zero : ^T)
/// Returns the average of the results generated by applying the function to each element
/// of the sequence.
val inline averageBy : projection:('T -> ^U) -> source:seq<'T> -> ^U when ^U : (static member ( + ) : ^U * ^U -> ^U) and ^U : (static member DivideByInt : ^U * int -> ^U) and ^U : (static member Zero : ^U)
/// Returns 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. Caching a sequence is typically useful when repeatedly
/// evaluating items in the original sequence is computationally expensive or if
/// iterating the sequence causes side-effects that the user does not want to be
/// repeated multiple times.
///
/// 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.
val cache : source:seq<'T> -> seq<'T>
/// Wraps a loosely-typed System.Collections sequence as a typed sequence.
val cast : source:Collections.IEnumerable -> seq<'T>
/// Applies 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).
val choose : chooser:('T -> 'U option) -> source:seq<'T> -> seq<'U>
/// Applies the given function to each element of the sequence and concatenates all the
/// results.
val collect : mapping:('T -> 'Collection) -> source:seq<'T> -> seq<'U> when 'Collection :> seq<'U>
/// Compares two sequences using the given comparison function, element by element.
/// Returns the first non-zero result from the comparison function. If the end of a sequence
/// is reached it returns a -1 if the first sequence is shorter and a 1 if the second sequence
/// is shorter.
val compareWith : comparer:('T -> 'T -> int) -> source1:seq<'T> -> source2:seq<'T> -> int
/// Combines the given enumeration-of-enumerations as a single concatenated
/// enumeration.
val concat : sources:seq<'Collection> -> seq<'T> when 'Collection :> seq<'T>
/// Applies a key-generating function to each element of a sequence and return a sequence yielding unique
/// keys and their number of occurrences in the original sequence.
val countBy : projection:('T -> 'Key) -> source:seq<'T> -> seq<'Key * int> when 'Key : equality
/// Returns a sequence that is built from the given delayed specification of a
/// sequence.
val delay : generator:(unit -> seq<'T>) -> seq<'T>
/// Returns a sequence that contains no duplicate entries according to generic hash and
/// equality comparisons on the entries.
/// If an element occurs multiple times in the sequence then the later occurrences are discarded.
val distinct : source:seq<'T> -> seq<'T> when 'T : equality
/// Returns a sequence that contains no duplicate entries according to the
/// generic hash and equality comparisons on the keys returned by the given key-generating function.
/// If an element occurs multiple times in the sequence then the later occurrences are discarded.
val distinctBy : projection:('T -> 'Key) -> source:seq<'T> -> seq<'T> when 'Key : equality
/// Creates an empty sequence.
val empty : seq<'T>
/// Tests if any element of the sequence satisfies the given predicate.
val exists : predicate:('T -> bool) -> source:seq<'T> -> bool
/// Tests if any pair of corresponding elements of the input sequences satisfies the given predicate.
val exists2 : predicate:('T1 -> 'T2 -> bool) -> source1:seq<'T1> -> source2:seq<'T2> -> bool
/// Returns a new collection containing only the elements of the collection
/// for which the given predicate returns "true". This is a synonym for Seq.where.
val filter : predicate:('T -> bool) -> source:seq<'T> -> seq<'T>
/// Returns a new collection containing only the elements of the collection
/// for which the given predicate returns "true".
val where : predicate:('T -> bool) -> source:seq<'T> -> seq<'T>
/// Returns the first element for which the given function returns true.
val find : predicate:('T -> bool) -> source:seq<'T> -> 'T
/// Returns the index of the first element for which the given function returns true.
val findIndex : predicate:('T -> bool) -> source:seq<'T> -> int
/// Applies a function to each element of the collection, threading an accumulator argument
/// through the computation. If the input function is f and the elements are i0...iN
/// then computes f (... (f s i0)...) iN
val fold : folder:('State -> 'T -> 'State) -> state:'State -> source:seq<'T> -> 'State
/// Tests if all elements of the sequence satisfy the given predicate.
val forall : predicate:('T -> bool) -> source:seq<'T> -> bool
/// Tests the all pairs of elements drawn from the two sequences satisfy the
/// given predicate. If one sequence is shorter than
/// the other then the remaining elements of the longer sequence are ignored.
val forall2 : predicate:('T1 -> 'T2 -> bool) -> source1:seq<'T1> -> source2:seq<'T2> -> bool
/// Applies a key-generating function to each element of a sequence and yields a sequence of
/// unique keys. Each unique key contains a sequence of all elements that match
/// to this key.
val groupBy : projection:('T -> 'Key) -> source:seq<'T> -> seq<'Key * seq<'T>> when 'Key : equality
/// Returns the first element of the sequence.
val head : source:seq<'T> -> 'T
/// Returns the last element of the sequence.
val last : source:seq<'T> -> 'T
/// Returns the only element of the sequence.
val exactlyOne : source:seq<'T> -> 'T
/// Returns true if the sequence contains no elements, false otherwise.
val isEmpty : source:seq<'T> -> bool
/// Generates a new sequence which, when iterated, will return successive
/// elements by calling the given function, up to the given count. Each element is saved after its
/// initialization. The function is passed the index of the item being
/// generated.
val init : count:int -> initializer:(int -> 'T) -> seq<'T>
/// Generates a new sequence which, when iterated, will return successive
/// elements by calling the given function. The results of calling the function
/// will not be saved, that is the function will be reapplied as necessary to
/// regenerate the elements. The function is passed the index of the item being
/// generated.
val initInfinite : initializer:(int -> 'T) -> seq<'T>
/// Applies the given function to each element of the collection.
val iter : action:('T -> unit) -> source:seq<'T> -> unit
/// Applies the given function to each element of the collection. The integer passed to the
/// function indicates the index of element.
val iteri : action:(int -> 'T -> unit) -> source:seq<'T> -> unit
/// Applies the given function to two collections simultaneously. If one sequence is shorter than
/// the other then the remaining elements of the longer sequence are ignored.
val iter2 : action:('T1 -> 'T2 -> unit) -> source1:seq<'T1> -> source2:seq<'T2> -> unit
/// Returns the length of the sequence
val length : source:seq<'T> -> int
/// Builds 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.
val map : mapping:('T -> 'U) -> source:seq<'T> -> seq<'U>
/// Builds 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.
val map2 : mapping:('T1 -> 'T2 -> 'U) -> source1:seq<'T1> -> source2:seq<'T2> -> seq<'U>
/// Builds 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.
val mapi : mapping:(int -> 'T -> 'U) -> source:seq<'T> -> seq<'U>
/// Returns the greatest of all elements of the sequence, compared via Operators.max
val inline max : source:seq<'T> -> 'T when 'T : comparison
/// Returns the greatest of all elements of the sequence, compared via Operators.max on the function result.
val inline maxBy : projection:('T -> 'U) -> source:seq<'T> -> 'T when 'U : comparison
/// Returns the lowest of all elements of the sequence, compared via Operators.min.
val inline min : source:seq<'T> -> 'T when 'T : comparison
/// Returns the lowest of all elements of the sequence, compared via Operators.min on the function result.
val inline minBy : projection:('T -> 'U) -> source:seq<'T> -> 'T when 'U : comparison
/// Computes the nth element in the collection.
val nth : index:int -> source:seq<'T> -> 'T
/// Views the given array as a sequence.
val ofArray : source:'T [] -> seq<'T>
/// Views the given list as a sequence.
val ofList : source:'T list -> seq<'T>
/// Returns a sequence of each element in the input sequence and its predecessor, with the
/// exception of the first element which is only returned as the predecessor of the second element.
val pairwise : source:seq<'T> -> seq<'T * 'T>
/// Applies the given function to successive elements, returning the first
/// x where the function returns "Some(x)".
val pick : chooser:('T -> 'U option) -> source:seq<'T> -> 'U
/// Builds a new sequence object that delegates to the given sequence object. This ensures
/// the original sequence cannot be rediscovered and mutated by a type cast. For example,
/// if given an array the returned sequence will return the elements of the array, but
/// you cannot cast the returned sequence object to an array.
val readonly : source:seq<'T> -> seq<'T>
/// Applies a function to each element of the sequence, threading an accumulator argument
/// through the computation. Begin by applying the function to the first two elements.
/// Then feed this result into the function along with the third element and so on.
/// Return the final result.
val reduce : reduction:('T -> 'T -> 'T) -> source:seq<'T> -> 'T
/// Like fold, but computes on-demand and returns the sequence of intermediary and final results.
val scan : folder:('State -> 'T -> 'State) -> state:'State -> source:seq<'T> -> seq<'State>
/// Returns a sequence that yields one item only.
val singleton : value:'T -> seq<'T>
/// Returns a sequence that skips N elements of the underlying sequence and then yields the
/// remaining elements of the sequence.
val skip : count:int -> source:seq<'T> -> seq<'T>
/// Returns a sequence that, when iterated, skips elements of the underlying sequence while the
/// given predicate returns true, and then yields the remaining elements of the sequence.
val skipWhile : predicate:('T -> bool) -> source:seq<'T> -> seq<'T>
/// Yields a sequence ordered by keys.
val sort : source:seq<'T> -> seq<'T> when 'T : comparison
/// Applies a key-generating function to each element of a sequence and yield a sequence ordered
/// by keys. The keys are compared using generic comparison as implemented by Operators.compare.
val sortBy : projection:('T -> 'Key) -> source:seq<'T> -> seq<'T> when 'Key : comparison
/// Returns the sum of the elements in the sequence.
val inline sum : source:seq< ^T> -> ^T when ^T : (static member ( + ) : ^T * ^T -> ^T) and ^T : (static member Zero : ^T)
/// Returns the sum of the results generated by applying the function to each element of the sequence.
val inline sumBy : projection:('T -> ^U) -> source:seq<'T> -> ^U when ^U : (static member ( + ) : ^U * ^U -> ^U) and ^U : (static member Zero : ^U)
/// Returns the first N elements of the sequence.
val take : count:int -> source:seq<'T> -> seq<'T>
/// Returns a sequence that, when iterated, yields elements of the underlying sequence while the
/// given predicate returns true, and then returns no further elements.
val takeWhile : predicate:('T -> bool) -> source:seq<'T> -> seq<'T>
/// Builds an array from the given collection.
val toArray : source:seq<'T> -> 'T []
/// Builds a list from the given collection.
val toList : source:seq<'T> -> 'T list
/// Returns the first element for which the given function returns true.
/// Return None if no such element exists.
val tryFind : predicate:('T -> bool) -> source:seq<'T> -> 'T option
/// Returns the index of the first element in the sequence
/// that satisfies the given predicate. Return None if no such element exists.
val tryFindIndex : predicate:('T -> bool) -> source:seq<'T> -> int option
/// Applies the given function to successive elements, returning the first
/// result where the function returns "Some(x)".
val tryPick : chooser:('T -> 'U option) -> source:seq<'T> -> 'U option
/// Returns a sequence that when enumerated returns at most N elements.
val truncate : count:int -> source:seq<'T> -> seq<'T>
/// Returns 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.
val unfold : generator:('State -> ('T * 'State) option) -> state:'State -> seq<'T>
/// Returns a sequence that yields sliding windows of containing elements drawn from the input
/// sequence. Each window is returned as a fresh array.
val windowed : windowSize:int -> source:seq<'T> -> seq<'T []>
/// Combines the two sequences into a list of pairs. The two sequences need not have equal lengths:
/// when one sequence is exhausted any remaining elements in the other
/// sequence are ignored.
val zip : source1:seq<'T1> -> source2:seq<'T2> -> seq<'T1 * 'T2>
/// Combines the three sequences into a list of triples. The sequences need not have equal lengths:
/// when one sequence is exhausted any remaining elements in the other
/// sequences are ignored.
val zip3 : source1:seq<'T1> -> source2:seq<'T2> -> source3:seq<'T3> -> seq<'T1 * 'T2 * 'T3>
namespace Microsoft.FSharp.Collections
/// An abbreviation for the CLI type System.Collections.Generic.List<_>
type ResizeArray<'T> = Collections.Generic.List<'T>
namespace Microsoft.FSharp.Collections
/// Immutable maps. Keys are ordered by F# generic comparison.
[<CompiledName("FSharpMap`2")>]
[<Sealed>]
type Map<'Key, 'Value when 'Key : comparison> =
interface System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<'Key,'Value>>
interface System.Collections.Generic.IDictionary<'Key,'Value>
interface System.Collections.IEnumerable
interface System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<'Key,'Value>>
/// Builds a map that contains the bindings of the given IEnumerable.
new : elements:seq<'Key * 'Value> -> Map<'Key, 'Value>
/// Returns a new map with the binding added to the given map.
member Add : key:'Key * value:'Value -> Map<'Key,'Value>
/// Tests if an element is in the domain of the map.
member ContainsKey : key:'Key -> bool
/// The number of bindings in the map.
member Count : int
override Equals : obj -> bool
/// Returns true if there are no bindings in the map.
member IsEmpty : bool
/// Lookup an element in the map. Raise KeyNotFoundException if no binding
/// exists in the map.
member Item : 'Value
/// Removes an element from the domain of the map. No exception is raised if the element is not present.
member Remove : key:'Key -> Map<'Key,'Value>
/// Lookup an element in the map, returning a Some value if the element is in the domain
/// of the map and None if not.
member TryFind : key:'Key -> 'Value option
/// Functional programming operators related to the Map<_,_> type.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Collections.Map
/// Returns a new map with the binding added to the given map.
val add : key:'Key -> value:'T -> table:Map<'Key,'T> -> Map<'Key,'T> when 'Key : comparison
/// Returns a new map made from the given bindings.
val ofList : elements:('Key * 'T) list -> Map<'Key,'T> when 'Key : comparison
/// Returns a new map made from the given bindings.
val ofArray : elements:('Key * 'T) [] -> Map<'Key,'T> when 'Key : comparison
/// Returns a new map made from the given bindings.
val ofSeq : elements:seq<'Key * 'T> -> Map<'Key,'T> when 'Key : comparison
/// Views the collection as an enumerable sequence of pairs.
/// The sequence will be ordered by the keys of the map.
val toSeq : table:Map<'Key,'T> -> seq<'Key * 'T> when 'Key : comparison
/// Returns a list of all key-value pairs in the mapping.
/// The list will be ordered by the keys of the map.
val toList : table:Map<'Key,'T> -> ('Key * 'T) list when 'Key : comparison
/// Returns an array of all key-value pairs in the mapping.
/// The array will be ordered by the keys of the map.
val toArray : table:Map<'Key,'T> -> ('Key * 'T) [] when 'Key : comparison
/// Is the map empty?
val isEmpty : table:Map<'Key,'T> -> bool when 'Key : comparison
/// The empty map.
val empty : Map<'Key,'T> when 'Key : comparison
/// Lookup an element in the map, raising KeyNotFoundException if no binding
/// exists in the map.
val find : key:'Key -> table:Map<'Key,'T> -> 'T when 'Key : comparison
/// Searches the map looking for the first element where the given function returns a Some value.
val tryPick : chooser:('Key -> 'T -> 'U option) -> table:Map<'Key,'T> -> 'U option when 'Key : comparison
/// Searches the map looking for the first element where the given function returns a Some value
val pick : chooser:('Key -> 'T -> 'U option) -> table:Map<'Key,'T> -> 'U when 'Key : comparison
/// Folds over the bindings in the map.
val foldBack : folder:('Key -> 'T -> 'State -> 'State) -> table:Map<'Key,'T> -> state:'State -> 'State when 'Key : comparison
/// Folds over the bindings in the map
val fold : folder:('State -> 'Key -> 'T -> 'State) -> state:'State -> table:Map<'Key,'T> -> 'State when 'Key : comparison
/// Applies the given function to each binding in the dictionary
val iter : action:('Key -> 'T -> unit) -> table:Map<'Key,'T> -> unit when 'Key : comparison
/// Returns true if the given predicate returns true for one of the
/// bindings in the map.
val exists : predicate:('Key -> 'T -> bool) -> table:Map<'Key,'T> -> bool when 'Key : comparison
/// Builds a new map containing only the bindings for which the given predicate returns 'true'.
val filter : predicate:('Key -> 'T -> bool) -> table:Map<'Key,'T> -> Map<'Key,'T> when 'Key : comparison
/// Returns true if the given predicate returns true for all of the
/// bindings in the map.
val forall : predicate:('Key -> 'T -> bool) -> table:Map<'Key,'T> -> bool when 'Key : comparison
/// Builds a new collection whose elements are the results of applying the given function
/// to each of the elements of the collection. The key passed to the
/// function indicates the key of element being transformed.
val map : mapping:('Key -> 'T -> 'U) -> table:Map<'Key,'T> -> Map<'Key,'U> when 'Key : comparison
/// Tests if an element is in the domain of the map.
val containsKey : key:'Key -> table:Map<'Key,'T> -> bool when 'Key : comparison
/// Builds two new maps, one containing the bindings for which the given predicate returns 'true',
/// and the other the remaining bindings.
val partition : predicate:('Key -> 'T -> bool) -> table:Map<'Key,'T> -> Map<'Key,'T> * Map<'Key,'T> when 'Key : comparison
/// Removes an element from the domain of the map. No exception is raised if the element is not present.
val remove : key:'Key -> table:Map<'Key,'T> -> Map<'Key,'T> when 'Key : comparison
/// Lookup an element in the map, returning a Some value if the element is in the domain
/// of the map and None if not.
val tryFind : key:'Key -> table:Map<'Key,'T> -> 'T option when 'Key : comparison
/// 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.
val findKey : predicate:('Key -> 'T -> bool) -> table:Map<'Key,'T> -> 'Key when 'Key : comparison
/// Returns the key of the first mapping in the collection that satisfies the given predicate.
/// Returns 'None' if no such element exists.
val tryFindKey : predicate:('Key -> 'T -> bool) -> table:Map<'Key,'T> -> 'Key option when 'Key : comparison
namespace Microsoft.FSharp.Collections
/// The type of immutable singly-linked lists.
[<DefaultAugmentation(false)>]
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpList`1")>]
type List<'T> =
| ( [] )
| ( :: ) of Head: 'T * Tail: 'T list
interface System.Collections.IEnumerable
interface System.Collections.Generic.IEnumerable<'T>
/// Gets the first element of the list
member Head : 'T
/// Gets a value indicating if the list contains no entries
member IsEmpty : bool
/// Gets the element of the list at the given position.
member Item : 'T
/// Gets the number of items contained in the list
member Length : int
/// Gets the tail of the list, which is a list containing all the elements of the list, excluding the first element
member Tail : 'T list
/// Returns a list with head as its first element and tail as its subsequent elements
static member Cons : head:'T * tail:'T list -> 'T list
/// Returns an empty list of a particular type
static member Empty : 'T list
/// Basic operations on lists.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Collections.List
/// Returns a new list that contains the elements of the first list
/// followed by elements of the second.
val append : list1:'T list -> list2:'T list -> 'T list
/// Returns the average of the elements in the list.
val inline average : list: ^T list -> ^T when ^T : (static member ( + ) : ^T * ^T -> ^T) and ^T : (static member DivideByInt : ^T * int -> ^T) and ^T : (static member Zero : ^T)
/// Returns the average of the elements generated by applying the function to each element of the list.
val inline averageBy : projection:('T -> ^U) -> list:'T list -> ^U when ^U : (static member ( + ) : ^U * ^U -> ^U) and ^U : (static member DivideByInt : ^U * int -> ^U) and ^U : (static member Zero : ^U)
/// Applies the given function to each element of the list. Returns
/// the list comprised of the results x for each element where
/// the function returns Some(x)
val choose : chooser:('T -> 'U option) -> list:'T list -> 'U list
/// For each element of the list, applies the given function. Concatenates all the results and return the combined list.
val collect : mapping:('T -> 'U list) -> list:'T list -> 'U list
/// Returns a new list that contains the elements of each the lists in order.
val concat : lists:seq<'T list> -> 'T list
/// Returns an empty list of the given type.
val empty : 'T list
/// Tests if any element of the list satisfies the given predicate.
val exists : predicate:('T -> bool) -> list:'T list -> bool
/// Tests if any pair of corresponding elements of the lists satisfies the given predicate.
val exists2 : predicate:('T1 -> 'T2 -> bool) -> list1:'T1 list -> list2:'T2 list -> bool
/// Returns the first element for which the given function returns true.
/// Raises KeyNotFoundException if no such element exists.
val find : predicate:('T -> bool) -> list:'T list -> 'T
/// Returns the index of the first element in the list
/// that satisfies the given predicate.
/// Raises KeyNotFoundException if no such element exists.
val findIndex : predicate:('T -> bool) -> list:'T list -> int
/// Returns a new collection containing only the elements of the collection
/// for which the given predicate returns "true"
val filter : predicate:('T -> bool) -> list:'T list -> 'T list
/// Applies 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.
val fold : folder:('State -> 'T -> 'State) -> state:'State -> list:'T list -> 'State
/// Applies a function to corresponding elements of two collections, threading an accumulator argument
/// through the computation. The collections must have identical sizes.
/// If the input function is f and the elements are i0...iN and j0...jN
/// then computes f (... (f s i0 j0)...) iN jN.
val fold2 : folder:('State -> 'T1 -> 'T2 -> 'State) -> state:'State -> list1:'T1 list -> list2:'T2 list -> 'State
/// Applies a function to each element of the collection, threading an accumulator argument
/// through the computation. If the input function is f and the elements are i0...iN then
/// computes f i0 (...(f iN s)).
val foldBack : folder:('T -> 'State -> 'State) -> list:'T list -> state:'State -> 'State
/// Applies a function to corresponding elements of two collections, threading an accumulator argument
/// through the computation. The collections must have identical sizes.
/// If the input function is f and the elements are i0...iN and j0...jN
/// then computes f i0 j0 (...(f iN jN s)).
val foldBack2 : folder:('T1 -> 'T2 -> 'State -> 'State) -> list1:'T1 list -> list2:'T2 list -> state:'State -> 'State
/// Tests if all elements of the collection satisfy the given predicate.
val forall : predicate:('T -> bool) -> list:'T list -> bool
/// Tests if all corresponding elements of the collection satisfy the given predicate pairwise.
val forall2 : predicate:('T1 -> 'T2 -> bool) -> list1:'T1 list -> list2:'T2 list -> bool
/// Returns the first element of the list.
val head : list:'T list -> 'T
/// Creates a list by calling the given generator on each index.
val init : length:int -> initializer:(int -> 'T) -> 'T list
/// Returns true if the list contains no elements, false otherwise.
val isEmpty : list:'T list -> bool
/// Applies the given function to each element of the collection.
val iter : action:('T -> unit) -> list:'T list -> unit
/// Applies the given function to two collections simultaneously. The
/// collections must have identical size.
val iter2 : action:('T1 -> 'T2 -> unit) -> list1:'T1 list -> list2:'T2 list -> unit
/// Applies the given function to each element of the collection. The integer passed to the
/// function indicates the index of element.
val iteri : action:(int -> 'T -> unit) -> list:'T list -> unit
/// Applies the given function to two collections simultaneously. The
/// collections must have identical size. The integer passed to the
/// function indicates the index of element.
val iteri2 : action:(int -> 'T1 -> 'T2 -> unit) -> list1:'T1 list -> list2:'T2 list -> unit
/// Returns the length of the list.
val length : list:'T list -> int
/// Builds a new collection whose elements are the results of applying the given function
/// to each of the elements of the collection.
val map : mapping:('T -> 'U) -> list:'T list -> 'U list
/// Builds a new collection whose elements are the results of applying the given function
/// to the corresponding elements of the two collections pairwise.
val map2 : mapping:('T1 -> 'T2 -> 'U) -> list1:'T1 list -> list2:'T2 list -> 'U list
/// Builds a new collection whose elements are the results of applying the given function
/// to the corresponding elements of the three collections simultaneously.
val map3 : mapping:('T1 -> 'T2 -> 'T3 -> 'U) -> list1:'T1 list -> list2:'T2 list -> list3:'T3 list -> 'U list
/// Builds 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.
val mapi : mapping:(int -> 'T -> 'U) -> list:'T list -> 'U list
/// Like mapi, but mapping corresponding elements from two lists of equal length.
val mapi2 : mapping:(int -> 'T1 -> 'T2 -> 'U) -> list1:'T1 list -> list2:'T2 list -> 'U list
/// Return the greatest of all elements of the list, compared via Operators.max.
val inline max : list:'T list -> 'T when 'T : comparison
/// Returns the greatest of all elements of the list, compared via Operators.max on the function result.
val inline maxBy : projection:('T -> 'U) -> list:'T list -> 'T when 'U : comparison
/// Returns the lowest of all elements of the list, compared via Operators.min.
val inline min : list:'T list -> 'T when 'T : comparison
/// Returns the lowest of all elements of the list, compared via Operators.min on the function result
val inline minBy : projection:('T -> 'U) -> list:'T list -> 'T when 'U : comparison
/// Indexes into the list. The first element has index 0.
val nth : list:'T list -> index:int -> 'T
/// Builds a list from the given array.
val ofArray : array:'T [] -> 'T list
/// Builds a new list from the given enumerable object.
val ofSeq : source:seq<'T> -> 'T list
/// Splits the collection into two collections, containing the
/// elements for which the given predicate returns true and false
/// respectively. Element order is preserved in both of the created lists.
val partition : predicate:('T -> bool) -> list:'T list -> 'T list * 'T list
/// Applies 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
val pick : chooser:('T -> 'U option) -> list:'T list -> 'U
/// Returns a list with all elements permuted according to the
/// specified permutation.
val permute : indexMap:(int -> int) -> list:'T list -> 'T list
/// 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.
val reduce : reduction:('T -> 'T -> 'T) -> list:'T list -> 'T
/// Applies a function to each element of the collection, threading an accumulator argument
/// through the computation. If the input function is f and the elements are i0...iN then computes
/// f i0 (...(f iN-1 iN)).
val reduceBack : reduction:('T -> 'T -> 'T) -> list:'T list -> 'T
/// Creates a list by calling the given generator on each index.
val replicate : count:int -> initial:'T -> 'T list
/// Returns a new list with the elements in reverse order.
val rev : list:'T list -> 'T list
/// Applies 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. Returns the list of intermediate results and the final result.
val scan : folder:('State -> 'T -> 'State) -> state:'State -> list:'T list -> 'State list
/// Like foldBack, but returns both the intermediary and final results
val scanBack : folder:('T -> 'State -> 'State) -> list:'T list -> state:'State -> 'State list
/// Sorts the given list using the given comparison function.
val sortWith : comparer:('T -> 'T -> int) -> list:'T list -> 'T list
/// Sorts the given list using keys given by the given projection. Keys are compared using Operators.compare.
val sortBy : projection:('T -> 'Key) -> list:'T list -> 'T list when 'Key : comparison
/// Sorts the given list using Operators.compare.
val sort : list:'T list -> 'T list when 'T : comparison
/// Returns the sum of the elements in the list.
val inline sum : list: ^T list -> ^T when ^T : (static member ( + ) : ^T * ^T -> ^T) and ^T : (static member Zero : ^T)
/// Returns the sum of the results generated by applying the function to each element of the list.
val inline sumBy : projection:('T -> ^U) -> list:'T list -> ^U when ^U : (static member ( + ) : ^U * ^U -> ^U) and ^U : (static member Zero : ^U)
/// Returns the list after removing the first element.
val tail : list:'T list -> 'T list
/// Builds an array from the given list.
val toArray : list:'T list -> 'T []
/// Views the given list as a sequence.
val toSeq : list:'T list -> seq<'T>
/// Applies 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.
val tryPick : chooser:('T -> 'U option) -> list:'T list -> 'U option
/// Returns the first element for which the given function returns true..
/// Return None if no such element exists.
val tryFind : predicate:('T -> bool) -> list:'T list -> 'T option
/// Returns the index of the first element in the list
/// that satisfies the given predicate.
/// Return None if no such element exists.
val tryFindIndex : predicate:('T -> bool) -> list:'T list -> int option
/// Splits a list of pairs into two lists.
val unzip : list:('T1 * 'T2) list -> 'T1 list * 'T2 list
/// Splits a list of triples into three lists.
val unzip3 : list:('T1 * 'T2 * 'T3) list -> 'T1 list * 'T2 list * 'T3 list
/// Combines the two lists into a list of pairs. The two lists must have equal lengths.
val zip : list1:'T1 list -> list2:'T2 list -> ('T1 * 'T2) list
/// Combines the three lists into a list of triples. The lists must have equal lengths.
val zip3 : list1:'T1 list -> list2:'T2 list -> list3:'T3 list -> ('T1 * 'T2 * 'T3) list
/// Common notions of value identity used with hash tables.
module Microsoft.FSharp.Collections.HashIdentity
/// Structural hashing. Hash using Operators.(=) and Operators.hash.
val Structural : Collections.Generic.IEqualityComparer<'T> when 'T : equality
val LimitedStructural : limit:int -> Collections.Generic.IEqualityComparer<'T> when 'T : equality
/// 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.
val Reference : Collections.Generic.IEqualityComparer<'T> when 'T : not struct
/// Hash using the given hashing and equality functions.
val inline FromFunctions : hasher:('T -> int) -> equality:('T -> 'T -> bool) -> Collections.Generic.IEqualityComparer<'T>
/// Common notions of comparison identity used with sorted data structures.
module Microsoft.FSharp.Collections.ComparisonIdentity
/// Structural comparison. Compare using Operators.compare.
val Structural : Collections.Generic.IComparer<'T> when 'T : comparison
/// Compare using the given comparer function.
val FromFunction : comparer:('T -> 'T -> int) -> Collections.Generic.IComparer<'T>
/// Basic operations on arrays.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Collections.Array
/// Builds a new array that contains the elements of the first array followed by the elements of the second array.
val append : array1:'T [] -> array2:'T [] -> 'T []
/// Returns the average of the elements in the array.
val inline average : array: ^T [] -> ^T when ^T : (static member ( + ) : ^T * ^T -> ^T) and ^T : (static member DivideByInt : ^T * int -> ^T) and ^T : (static member Zero : ^T)
/// Returns the average of the elements generated by applying the function to each element of the array.
val inline averageBy : projection:('T -> ^U) -> array:'T [] -> ^U when ^U : (static member ( + ) : ^U * ^U -> ^U) and ^U : (static member DivideByInt : ^U * int -> ^U) and ^U : (static member Zero : ^U)
/// Reads a range of elements from the first array and write them into the second.
val blit : source:'T [] -> sourceIndex:int -> target:'T [] -> targetIndex:int -> count:int -> unit
/// For each element of the array, applies the given function. Concatenates all the results and return the combined array.
val collect : mapping:('T -> 'U []) -> array:'T [] -> 'U []
/// Builds a new array that contains the elements of each of the given sequence of arrays.
val concat : arrays:seq<'T []> -> 'T []
/// Builds a new array that contains the elements of the given array.
val copy : array:'T [] -> 'T []
/// Creates an array whose elements are all initially the given value.
val create : count:int -> value:'T -> 'T []
/// Applies 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.
val tryPick : chooser:('T -> 'U option) -> array:'T [] -> 'U option
/// Fills a range of elements of the array with the given value.
val fill : target:'T [] -> targetIndex:int -> count:int -> value:'T -> unit
/// Applies 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.
val pick : chooser:('T -> 'U option) -> array:'T [] -> 'U
/// Applies the given function to each element of the array. Returns
/// the array comprised of the results "x" for each element where
/// the function returns Some(x)
val choose : chooser:('T -> 'U option) -> array:'T [] -> 'U []
/// Returns an empty array of the given type.
val empty : 'T []
/// Tests if any element of the array satisfies the given predicate.
val exists : predicate:('T -> bool) -> array:'T [] -> bool
/// Tests if any pair of corresponding elements of the arrays satisfies the given predicate.
val exists2 : predicate:('T1 -> 'T2 -> bool) -> array1:'T1 [] -> array2:'T2 [] -> bool
/// Returns a new collection containing only the elements of the collection
/// for which the given predicate returns "true".
val filter : predicate:('T -> bool) -> array:'T [] -> 'T []
/// Returns the first element for which the given function returns 'true'.
/// Raise KeyNotFoundException if no such element exists.
val find : predicate:('T -> bool) -> array:'T [] -> 'T
/// Returns the index of the first element in the array
/// that satisfies the given predicate. Raise KeyNotFoundException if
/// none of the elements satisy the predicate.
val findIndex : predicate:('T -> bool) -> array:'T [] -> int
/// Tests if all elements of the array satisfy the given predicate.
val forall : predicate:('T -> bool) -> array:'T [] -> bool
/// Tests if all corresponding elements of the array satisfy the given predicate pairwise.
val forall2 : predicate:('T1 -> 'T2 -> bool) -> array1:'T1 [] -> array2:'T2 [] -> bool
/// Applies a function to each element of the collection, threading an accumulator argument
/// through the computation. If the input function is f and the elements are i0...iN then computes
/// f (... (f s i0)...) iN
val fold : folder:('State -> 'T -> 'State) -> state:'State -> array:'T [] -> 'State
/// Applies 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))
val foldBack : folder:('T -> 'State -> 'State) -> array:'T [] -> state:'State -> 'State
/// Applies 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.
val fold2 : folder:('State -> 'T1 -> 'T2 -> 'State) -> state:'State -> array1:'T1 [] -> array2:'T2 [] -> 'State
/// 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.
val foldBack2 : folder:('T1 -> 'T2 -> 'State -> 'State) -> array1:'T1 [] -> array2:'T2 [] -> state:'State -> 'State
/// Gets an element from an array.
val get : array:'T [] -> index:int -> 'T
/// Creates an array given the dimension and a generator function to compute the elements.
val inline init : count:int -> initializer:(int -> 'T) -> 'T []
/// Creates an array where the entries are initially the default value Unchecked.defaultof<'T>.
val zeroCreate : count:int -> 'T []
/// Returns true if the given array is empty, otherwise false.
val isEmpty : array:'T [] -> bool
/// Applies the given function to each element of the array.
val inline iter : action:('T -> unit) -> array:'T [] -> unit
/// Applies 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.
val iter2 : action:('T1 -> 'T2 -> unit) -> array1:'T1 [] -> array2:'T2 [] -> unit
/// Applies the given function to each element of the array. The integer passed to the
/// function indicates the index of element.
val iteri : action:(int -> 'T -> unit) -> array:'T [] -> unit
/// Applies 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.
val iteri2 : action:(int -> 'T1 -> 'T2 -> unit) -> array1:'T1 [] -> array2:'T2 [] -> unit
/// Returns the length of an array. You can also use property arr.Length.
val length : array:'T [] -> int
/// Builds a new array whose elements are the results of applying the given function
/// to each of the elements of the array.
val inline map : mapping:('T -> 'U) -> array:'T [] -> 'U []
/// Builds 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.
val map2 : mapping:('T1 -> 'T2 -> 'U) -> array1:'T1 [] -> array2:'T2 [] -> 'U []
/// Builds 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.
val mapi2 : mapping:(int -> 'T1 -> 'T2 -> 'U) -> array1:'T1 [] -> array2:'T2 [] -> 'U []
/// Builds 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.
val mapi : mapping:(int -> 'T -> 'U) -> array:'T [] -> 'U []
/// Returns the greatest of all elements of the array, compared via Operators.max on the function result.
val inline max : array:'T [] -> 'T when 'T : comparison
/// Returns the greatest of all elements of the array, compared via Operators.max on the function result.
val inline maxBy : projection:('T -> 'U) -> array:'T [] -> 'T when 'U : comparison
/// Returns the lowest of all elements of the array, compared via Operators.min.
val inline min : array:'T [] -> 'T when 'T : comparison
/// Returns the lowest of all elements of the array, compared via Operators.min on the function result.
val inline minBy : projection:('T -> 'U) -> array:'T [] -> 'T when 'U : comparison
/// Builds an array from the given list.
val ofList : list:'T list -> 'T []
/// Builds a new array from the given enumerable object.
val ofSeq : source:seq<'T> -> 'T []
/// Splits the collection into two collections, containing the
/// elements for which the given predicate returns "true" and "false"
/// respectively.
val partition : predicate:('T -> bool) -> array:'T [] -> 'T [] * 'T []
/// Returns an array with all elements permuted according to the
/// specified permutation.
val permute : indexMap:(int -> int) -> array:'T [] -> 'T []
/// Applies 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.
val reduce : reduction:('T -> 'T -> 'T) -> array:'T [] -> 'T
/// Applies 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.
val reduceBack : reduction:('T -> 'T -> 'T) -> array:'T [] -> 'T
/// Returns a new array with the elements in reverse order.
val rev : array:'T [] -> 'T []
/// Like fold, but return the intermediary and final results.
val scan : folder:('State -> 'T -> 'State) -> state:'State -> array:'T [] -> 'State []
/// Like foldBack, but return both the intermediary and final results.
val scanBack : folder:('T -> 'State -> 'State) -> array:'T [] -> state:'State -> 'State []
/// Sets an element of an array.
val set : array:'T [] -> index:int -> value:'T -> unit
/// Builds a new array that contains the given subrange specified by
/// starting index and length.
val sub : array:'T [] -> startIndex:int -> count:int -> 'T []
/// Sorts the elements of an array, returning a new array. Elements are compared using Operators.compare.
val sort : array:'T [] -> 'T [] when 'T : comparison
/// Sorts the elements of an array, using the given projection for the keys and returning a new array.
/// Elements are compared using Operators.compare.
val sortBy : projection:('T -> 'Key) -> array:'T [] -> 'T [] when 'Key : comparison
/// Sorts the elements of an array, using the given comparison function as the order, returning a new array.
val sortWith : comparer:('T -> 'T -> int) -> array:'T [] -> 'T []
/// Sorts the elements of an array by mutating the array in-place, using the given projection for the keys.
/// Elements are compared using Operators.compare.
val sortInPlaceBy : projection:('T -> 'Key) -> array:'T [] -> unit when 'Key : comparison
/// Sorts the elements of an array by mutating the array in-place, using the given comparison function as the order.
val sortInPlaceWith : comparer:('T -> 'T -> int) -> array:'T [] -> unit
/// Sorts the elements of an array by mutating the array in-place, using the given comparison function.
/// Elements are compared using Operators.compare.
val sortInPlace : array:'T [] -> unit when 'T : comparison
/// Returns the sum of the elements in the array.
val inline sum : array: ^T [] -> ^T when ^T : (static member ( + ) : ^T * ^T -> ^T) and ^T : (static member Zero : ^T)
/// Returns the sum of the results generated by applying the function to each element of the array.
val inline sumBy : projection:('T -> ^U) -> array:'T [] -> ^U when ^U : (static member ( + ) : ^U * ^U -> ^U) and ^U : (static member Zero : ^U)
/// Builds a list from the given array.
val toList : array:'T [] -> 'T list
/// Views the given array as a sequence.
val toSeq : array:'T [] -> seq<'T>
/// Returns the first element for which the given function returns true.
/// Return None if no such element exists.
val tryFind : predicate:('T -> bool) -> array:'T [] -> 'T option
/// Returns the index of the first element in the array
/// that satisfies the given predicate.
val tryFindIndex : predicate:('T -> bool) -> array:'T [] -> int option
/// Splits an array of pairs into two arrays.
val unzip : array:('T1 * 'T2) [] -> 'T1 [] * 'T2 []
/// Splits an array of triples into three arrays.
val unzip3 : array:('T1 * 'T2 * 'T3) [] -> 'T1 [] * 'T2 [] * 'T3 []
/// Combines the two arrays into an array of pairs. The two arrays must have equal lengths, otherwise an ArgumentException is
/// raised.
val zip : array1:'T1 [] -> array2:'T2 [] -> ('T1 * 'T2) []
/// Combines three arrays into an array of pairs. The three arrays must have equal lengths, otherwise an ArgumentException is
/// raised.
val zip3 : array1:'T1 [] -> array2:'T2 [] -> array3:'T3 [] -> ('T1 * 'T2 * 'T3) []
/// Provides parallel operations on arrays
module Parallel =
/// 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).
val choose : chooser:('T -> 'U option) -> array:'T [] -> 'U []
/// For each element of the array, apply the given function. Concatenate all the results and return the combined array.
val collect : mapping:('T -> 'U []) -> array:'T [] -> 'U []
/// Build a new array whose elements are the results of applying the given function
/// to each of the elements of the array.
val map : mapping:('T -> 'U) -> array:'T [] -> 'U []
/// 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.
val mapi : mapping:(int -> 'T -> 'U) -> array:'T [] -> 'U []
/// Apply the given function to each element of the array.
val iter : action:('T -> unit) -> array:'T [] -> unit
/// Apply the given function to each element of the array. The integer passed to the
/// function indicates the index of element.
val iteri : action:(int -> 'T -> unit) -> array:'T [] -> unit
/// Create an array given the dimension and a generator function to compute the elements.
val init : count:int -> initializer:(int -> 'T) -> 'T []
/// Split the collection into two collections, containing the
/// elements for which the given predicate returns "true" and "false"
/// respectively
val partition : predicate:('T -> bool) -> array:'T [] -> 'T [] * 'T []
/// Basic operations on rank 4 arrays.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Collections.Array4D
/// Creates an array whose elements are all initially the given value
val create : length1:int -> length2:int -> length3:int -> length4:int -> initial:'T -> 'T [,,,]
/// Creates an array given the dimensions and a generator function to compute the elements.
val init : length1:int -> length2:int -> length3:int -> length4:int -> initializer:(int -> int -> int -> int -> 'T) -> 'T [,,,]
/// Returns the length of an array in the first dimension
val length1 : array:'T [,,,] -> int
/// Returns the length of an array in the second dimension.
val length2 : array:'T [,,,] -> int
/// Returns the length of an array in the third dimension.
val length3 : array:'T [,,,] -> int
/// Returns the length of an array in the fourth dimension.
val length4 : array:'T [,,,] -> int
/// Creates an array where the entries are initially the "default" value.
val zeroCreate : length1:int -> length2:int -> length3:int -> length4:int -> 'T [,,,]
/// Fetches an element from a 4D array. You can also use the syntax 'array.[index1,index2,index3,index4]'
val get : array:'T [,,,] -> index1:int -> index2:int -> index3:int -> index4:int -> 'T
/// Sets the value of an element in an array. You can also
/// use the syntax 'array.[index1,index2,index3,index4] <- value'.
val set : array:'T [,,,] -> index1:int -> index2:int -> index3:int -> index4:int -> value:'T -> unit
/// Basic operations on rank 3 arrays.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Collections.Array3D
/// Creates an array whose elements are all initially the given value.
val create : length1:int -> length2:int -> length3:int -> initial:'T -> 'T [,,]
/// Creates an array given the dimensions and a generator function to compute the elements.
val init : length1:int -> length2:int -> length3:int -> initializer:(int -> int -> int -> 'T) -> 'T [,,]
/// Fetches an element from a 3D array. You can also use the syntax 'array.[index1,index2,index3]'
val get : array:'T [,,] -> index1:int -> index2:int -> index3:int -> 'T
/// Applies the given function to each element of the array.
val iter : action:('T -> unit) -> array:'T [,,] -> unit
/// Applies the given function to each element of the array. The integer indicies passed to the
/// function indicates the index of element.
val iteri : action:(int -> int -> int -> 'T -> unit) -> array:'T [,,] -> unit
/// Returns the length of an array in the first dimension
val length1 : array:'T [,,] -> int
/// Returns the length of an array in the second dimension.
val length2 : array:'T [,,] -> int
/// Returns the length of an array in the third dimension.
val length3 : array:'T [,,] -> int
/// Builds a new array whose elements are the results of applying the given function
/// to each of the elements of the array.
val map : mapping:('T -> 'U) -> array:'T [,,] -> 'U [,,]
/// Builds 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.
val mapi : mapping:(int -> int -> int -> 'T -> 'U) -> array:'T [,,] -> 'U [,,]
/// Sets the value of an element in an array. You can also
/// use the syntax 'array.[index1,index2,index3] <- value'.
val set : array:'T [,,] -> index1:int -> index2:int -> index3:int -> value:'T -> unit
/// Creates an array where the entries are initially the "default" value.
val zeroCreate : length1:int -> length2:int -> length3:int -> 'T [,,]
/// Basic operations on 2-dimensional arrays.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Collections.Array2D
/// Fetches the base-index for the first dimension of the array.
val base1 : array:'T [,] -> int
/// Fetches the base-index for the second dimension of the array.
val base2 : array:'T [,] -> int
/// Builds a new array whose elements are the same as the input array.
val copy : array:'T [,] -> 'T [,]
/// Reads a range of elements from the first array and write them into the second.
val blit : source:'T [,] -> sourceIndex1:int -> sourceIndex2:int -> target:'T [,] -> targetIndex1:int -> targetIndex2:int -> length1:int -> length2:int -> unit
/// Creates an array given the dimensions and a generator function to compute the elements.
val init : length1:int -> length2:int -> initializer:(int -> int -> 'T) -> 'T [,]
/// Creates an array whose elements are all initially the given value.
val create : length1:int -> length2:int -> value:'T -> 'T [,]
/// Creates an array where the entries are initially Unchecked.defaultof<'T>.
val zeroCreate : length1:int -> length2:int -> 'T [,]
/// Creates a based array given the dimensions and a generator function to compute the elements.
val initBased : base1:int -> base2:int -> length1:int -> length2:int -> initializer:(int -> int -> 'T) -> 'T [,]
/// Creates a based array whose elements are all initially the given value.
val createBased : base1:int -> base2:int -> length1:int -> length2:int -> initial:'T -> 'T [,]
/// Creates a based array where the entries are initially Unchecked.defaultof<'T>.
val zeroCreateBased : base1:int -> base2:int -> length1:int -> length2:int -> 'T [,]
/// Applies the given function to each element of the array.
val iter : action:('T -> unit) -> array:'T [,] -> unit
/// Applies the given function to each element of the array. The integer indices passed to the
/// function indicates the index of element.
val iteri : action:(int -> int -> 'T -> unit) -> array:'T [,] -> unit
/// Returns the length of an array in the first dimension.
val length1 : array:'T [,] -> int
/// Returns the length of an array in the second dimension.
val length2 : array:'T [,] -> int
/// Builds a new array whose elements are the results of applying the given function
/// to each of the elements of the array.
val map : mapping:('T -> 'U) -> array:'T [,] -> 'U [,]
/// Builds 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.
val mapi : mapping:(int -> int -> 'T -> 'U) -> array:'T [,] -> 'U [,]
/// Builds 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.
val rebase : array:'T [,] -> 'T [,]
/// Sets the value of an element in an array. You can also use the syntax array.[index1,index2] <- value.
val set : array:'T [,] -> index1:int -> index2:int -> value:'T -> unit
/// Fetches an element from a 2D array. You can also use the syntax array.[index1,index2].
val get : array:'T [,] -> index1:int -> index2:int -> 'T
Raw
4.0.fsi
namespace Microsoft.FSharp.Reflection
/// Represents a case of a discriminated union type
[<Sealed>]
[<Class>]
type UnionCaseInfo =
/// The type in which the case occurs.
member DeclaringType : Type
/// Returns the custom attributes associated with the case.
member GetCustomAttributes : unit -> obj []
/// Returns the custom attributes associated with the case matching the given attribute type.
member GetCustomAttributes : attributeType:Type -> obj []
/// Returns the custom attributes data associated with the case.
member GetCustomAttributesData : unit -> Collections.Generic.IList<Reflection.CustomAttributeData>
/// The fields associated with the case, represented by a PropertyInfo.
member GetFields : unit -> Reflection.PropertyInfo []
/// The name of the case.
member Name : string
/// The integer tag for the case.
member Tag : int
namespace Microsoft.FSharp.Reflection
/// Contains operations associated with constructing and analyzing values associated with F# types
/// such as records, unions and tuples.
[<AbstractClass>]
[<Sealed>]
type FSharpValue =
/// Reads all the fields from a value built using an instance of an F# exception declaration
static member GetExceptionFields : exn:obj * ?bindingFlags:Reflection.BindingFlags -> obj []
/// Reads a field from a record value.
static member GetRecordField : record:obj * info:Reflection.PropertyInfo -> obj
/// Reads all the fields from a record value.
static member GetRecordFields : record:obj * ?bindingFlags:Reflection.BindingFlags -> obj []
/// Reads a field from a tuple value.
static member GetTupleField : tuple:obj * index:int -> obj
/// Reads all fields from a tuple.
static member GetTupleFields : tuple:obj -> obj []
/// Identify the union case and its fields for an object
static member GetUnionFields : value:obj * unionType:Type * ?bindingFlags:Reflection.BindingFlags -> Reflection.UnionCaseInfo * obj []
/// Builds a typed function from object from a dynamic function implementation
static member MakeFunction : functionType:Type * implementation:(obj -> obj) -> obj
/// Creates an instance of a record type.
static member MakeRecord : recordType:Type * values:obj [] * ?bindingFlags:Reflection.BindingFlags -> obj
/// Creates an instance of a tuple type
static member MakeTuple : tupleElements:obj [] * tupleType:Type -> obj
/// Create a union case value.
static member MakeUnion : unionCase:Reflection.UnionCaseInfo * args:obj [] * ?bindingFlags:Reflection.BindingFlags -> obj
/// Precompute a function for constructing a record value.
static member PreComputeRecordConstructor : recordType:Type * ?bindingFlags:Reflection.BindingFlags -> obj [] -> obj
/// Get a ConstructorInfo for a record type
static member PreComputeRecordConstructorInfo : recordType:Type * ?bindingFlags:Reflection.BindingFlags -> Reflection.ConstructorInfo
/// 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.
static member PreComputeRecordFieldReader : info:Reflection.PropertyInfo -> obj -> obj
/// 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.
static member PreComputeRecordReader : recordType:Type * ?bindingFlags:Reflection.BindingFlags -> obj -> obj []
/// Precomputes a function for reading the values of a particular tuple type
static member PreComputeTupleConstructor : tupleType:Type -> obj [] -> obj
/// Gets a method that constructs objects of the given tuple type.
/// For small tuples, no additional type will be returned.
static member PreComputeTupleConstructorInfo : tupleType:Type -> Reflection.ConstructorInfo * Type option
/// Gets information that indicates how to read a field of a tuple
static member PreComputeTuplePropertyInfo : tupleType:Type * index:int -> Reflection.PropertyInfo * (Type * int) option
/// Precomputes a function for reading the values of a particular tuple type
static member PreComputeTupleReader : tupleType:Type -> obj -> obj []
/// Precomputes a function for constructing a discriminated union value for a particular union case.
static member PreComputeUnionConstructor : unionCase:Reflection.UnionCaseInfo * ?bindingFlags:Reflection.BindingFlags -> obj [] -> obj
/// A method that constructs objects of the given case
static member PreComputeUnionConstructorInfo : unionCase:Reflection.UnionCaseInfo * ?bindingFlags:Reflection.BindingFlags -> Reflection.MethodInfo
/// Precomputes a function for reading all the fields for a particular discriminator case of a union type
static member PreComputeUnionReader : unionCase:Reflection.UnionCaseInfo * ?bindingFlags:Reflection.BindingFlags -> obj -> obj []
/// Precompute a property or static method for reading an integer representing the case tag of a union type.
static member PreComputeUnionTagMemberInfo : unionType:Type * ?bindingFlags:Reflection.BindingFlags -> Reflection.MemberInfo
/// Assumes the given type is a union type.
/// If not, ArgumentException is raised during pre-computation.
static member PreComputeUnionTagReader : unionType:Type * ?bindingFlags:Reflection.BindingFlags -> obj -> int
namespace Microsoft.FSharp.Reflection
/// Contains operations associated with constructing and analyzing F# types such as records, unions and tuples
[<AbstractClass>]
[<Sealed>]
type FSharpType =
/// Reads all the fields from an F# exception declaration, in declaration order
static member GetExceptionFields : exceptionType:Type * ?bindingFlags:Reflection.BindingFlags -> Reflection.PropertyInfo []
/// Gets the domain and range types from an F# function type or from the runtime type of a closure implementing an F# type
static member GetFunctionElements : functionType:Type -> Type * Type
/// Reads all the fields from a record value, in declaration order
static member GetRecordFields : recordType:Type * ?bindingFlags:Reflection.BindingFlags -> Reflection.PropertyInfo []
/// Gets the tuple elements from the representation of an F# tuple type.
static member GetTupleElements : tupleType:Type -> Type []
/// Gets the cases of a union type.
static member GetUnionCases : unionType:Type * ?bindingFlags:Reflection.BindingFlags -> Reflection.UnionCaseInfo []
/// Returns true if the typ is a representation of an F# exception declaration
static member IsExceptionRepresentation : exceptionType:Type * ?bindingFlags:Reflection.BindingFlags -> bool
/// 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
static member IsFunction : typ:Type -> bool
/// Return true if the typ is a System.Type value corresponding to the compiled form of an F# module
static member IsModule : typ:Type -> bool
/// Return true if the typ is a representation of an F# record type
static member IsRecord : typ:Type * ?bindingFlags:Reflection.BindingFlags -> bool
/// Return true if the typ is a representation of an F# tuple type
static member IsTuple : typ:Type -> bool
/// Returns true if the typ is a representation of an F# union type or the runtime type of a value of that type
static member IsUnion : typ:Type * ?bindingFlags:Reflection.BindingFlags -> bool
/// Returns a System.Type representing the F# function type with the given domain and range
static member MakeFunctionType : domain:Type * range:Type -> Type
/// Returns a System.Type representing an F# tuple type with the given element types
static member MakeTupleType : types:Type [] -> Type
[<AutoOpen>]
module Microsoft.FSharp.Reflection.FSharpReflectionExtensions
/// Creates an instance of a record type.
val MakeRecord : recordType:Type * values:obj [] * ?allowAccessToPrivateRepresentation:bool -> obj
/// Reads all the fields from a record value.
val GetRecordFields : record:obj * ?allowAccessToPrivateRepresentation:bool -> obj []
/// 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.
val PreComputeRecordReader : recordType:Type * ?allowAccessToPrivateRepresentation:bool -> obj -> obj []
/// Precompute a function for constructing a record value.
val PreComputeRecordConstructor : recordType:Type * ?allowAccessToPrivateRepresentation:bool -> obj [] -> obj
/// Get a ConstructorInfo for a record type
val PreComputeRecordConstructorInfo : recordType:Type * ?allowAccessToPrivateRepresentation:bool -> Reflection.ConstructorInfo
/// Create a union case value.
val MakeUnion : unionCase:Reflection.UnionCaseInfo * args:obj [] * ?allowAccessToPrivateRepresentation:bool -> obj
/// Identify the union case and its fields for an object
val GetUnionFields : value:obj * unionType:Type * ?allowAccessToPrivateRepresentation:bool -> Reflection.UnionCaseInfo * obj []
/// Assumes the given type is a union type.
/// If not, ArgumentException is raised during pre-computation.
val PreComputeUnionTagReader : unionType:Type * ?allowAccessToPrivateRepresentation:bool -> obj -> int
/// Precompute a property or static method for reading an integer representing the case tag of a union type.
val PreComputeUnionTagMemberInfo : unionType:Type * ?allowAccessToPrivateRepresentation:bool -> Reflection.MemberInfo
/// Precomputes a function for reading all the fields for a particular discriminator case of a union type
val PreComputeUnionReader : unionCase:Reflection.UnionCaseInfo * ?allowAccessToPrivateRepresentation:bool -> obj -> obj []
/// Precomputes a function for constructing a discriminated union value for a particular union case.
val PreComputeUnionConstructor : unionCase:Reflection.UnionCaseInfo * ?allowAccessToPrivateRepresentation:bool -> obj [] -> obj
/// A method that constructs objects of the given case
val PreComputeUnionConstructorInfo : unionCase:Reflection.UnionCaseInfo * ?allowAccessToPrivateRepresentation:bool -> Reflection.MethodInfo
/// Reads all the fields from a value built using an instance of an F# exception declaration
val GetExceptionFields : exn:obj * ?allowAccessToPrivateRepresentation:bool -> obj []
/// Reads all the fields from a record value, in declaration order
val GetRecordFields : recordType:Type * ?allowAccessToPrivateRepresentation:bool -> Reflection.PropertyInfo []
/// Gets the cases of a union type.
val GetUnionCases : unionType:Type * ?allowAccessToPrivateRepresentation:bool -> Reflection.UnionCaseInfo []
/// Return true if the typ is a representation of an F# record type
val IsRecord : typ:Type * ?allowAccessToPrivateRepresentation:bool -> bool
/// Returns true if the typ is a representation of an F# union type or the runtime type of a value of that type
val IsUnion : typ:Type * ?allowAccessToPrivateRepresentation:bool -> bool
/// Reads all the fields from an F# exception declaration, in declaration order
val GetExceptionFields : exceptionType:Type * ?allowAccessToPrivateRepresentation:bool -> Reflection.PropertyInfo []
/// Returns true if the typ is a representation of an F# exception declaration
val IsExceptionRepresentation : exceptionType:Type * ?allowAccessToPrivateRepresentation:bool -> bool
namespace Microsoft.FSharp.Quotations
/// Information at the binding site of a variable
[<Sealed>]
[<CompiledName("FSharpVar")>]
type Var =
/// Creates a new variable with the given name, type and mutability
new : name:string * typ:Type * ?isMutable:bool -> Var
/// Indicates if the variable represents a mutable storage location
member IsMutable : bool
/// The declared name of the variable
member Name : string
/// The type associated with the variable
member Type : Type
/// Fetches or create a new variable with the given name and type from a global pool of shared variables
/// indexed by name and type
static member Global : name:string * typ:Type -> Quotations.Var
namespace Microsoft.FSharp.Quotations
/// Quoted expressions annotated with System.Type values.
[<CompiledName("FSharpExpr")>]
[<Class>]
type Expr =
/// Returns the custom attributes of an expression.
member CustomAttributes : Quotations.Expr list
override Equals : obj:obj -> bool
/// Gets the free expression variables of an expression as a list.
member GetFreeVars : unit -> seq<Quotations.Var>
/// Substitutes 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.
member Substitute : substitution:(Quotations.Var -> Quotations.Expr option) -> Quotations.Expr
/// Format the expression as a string
member ToString : full:bool -> string
/// Returns type of an expression.
member Type : Type
/// Builds an expression that represents getting the address of a value.
static member AddressOf : target:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents setting the value held at a particular address.
static member AddressSet : target:Quotations.Expr * value:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents the application of a first class function value to a single argument.
static member Application : functionExpr:Quotations.Expr * argument:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents the application of a first class function value to multiple arguments
static member Applications : functionExpr:Quotations.Expr * arguments:Quotations.Expr list list -> Quotations.Expr
/// Builds an expression that represents a call to an static method or module-bound function
static member Call : methodInfo:Reflection.MethodInfo * arguments:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents a call to an instance method associated with an object
static member Call : obj:Quotations.Expr * methodInfo:Reflection.MethodInfo * arguments:Quotations.Expr list -> Quotations.Expr
/// Returns 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.
static member Cast : source:Quotations.Expr -> Quotations.Expr<'T>
/// Builds an expression that represents the coercion of an expression to a type
static member Coerce : source:Quotations.Expr * target:Type -> Quotations.Expr
/// Builds an expression that represents the invocation of a default object constructor
static member DefaultValue : expressionType:Type -> Quotations.Expr
/// 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 quoted 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.
static member Deserialize : qualifyingType:Type * spliceTypes:Type list * spliceExprs:Quotations.Expr list * bytes:byte [] -> Quotations.Expr
/// Builds an expression that represents the access of a static field
static member FieldGet : fieldInfo:Reflection.FieldInfo -> Quotations.Expr
/// Builds an expression that represents the access of a field of an object
static member FieldGet : obj:Quotations.Expr * fieldInfo:Reflection.FieldInfo -> Quotations.Expr
/// Builds an expression that represents writing to a static field
static member FieldSet : fieldInfo:Reflection.FieldInfo * value:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents writing to a field of an object
static member FieldSet : obj:Quotations.Expr * fieldInfo:Reflection.FieldInfo * value:Quotations.Expr -> Quotations.Expr
/// Builds a 'for i = ... to ... do ...' expression that represent loops over integer ranges
static member ForIntegerRangeLoop : loopVariable:Quotations.Var * start:Quotations.Expr * endExpr:Quotations.Expr * body:Quotations.Expr -> Quotations.Expr
/// Fetches or creates 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
static member GlobalVar : name:string -> Quotations.Expr<'T>
/// Builds 'if ... then ... else' expressions.
static member IfThenElse : guard:Quotations.Expr * thenExpr:Quotations.Expr * elseExpr:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents the constrution of an F# function value
static member Lambda : parameter:Quotations.Var * body:Quotations.Expr -> Quotations.Expr
/// Builds expressions associated with 'let' constructs
static member Let : letVariable:Quotations.Var * letExpr:Quotations.Expr * body:Quotations.Expr -> Quotations.Expr
/// Builds recursives expressions associated with 'let rec' constructs
static member LetRecursive : bindings:(Quotations.Var * Quotations.Expr) list * body:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents the creation of an array value initialized with the given elements
static member NewArray : elementType:Type * elements:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents the creation of a delegate value for the given type
static member NewDelegate : delegateType:Type * parameters:Quotations.Var list * body:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents the invocation of an object constructor
static member NewObject : constructorInfo:Reflection.ConstructorInfo * arguments:Quotations.Expr list -> Quotations.Expr
/// Builds record-construction expressions
static member NewRecord : recordType:Type * elements:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents the creation of an F# tuple value
static member NewTuple : elements:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents the creation of a union case value
static member NewUnionCase : unionCase:Reflection.UnionCaseInfo * arguments:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents reading a property of an object
static member PropertyGet : obj:Quotations.Expr * property:Reflection.PropertyInfo * ?indexerArgs:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents reading a static property
static member PropertyGet : property:Reflection.PropertyInfo * ?indexerArgs:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents writing to a property of an object
static member PropertySet : obj:Quotations.Expr * property:Reflection.PropertyInfo * value:Quotations.Expr * ?indexerArgs:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents writing to a static property
static member PropertySet : property:Reflection.PropertyInfo * value:Quotations.Expr * ?indexerArgs:Quotations.Expr list -> Quotations.Expr
/// Builds an expression that represents a nested quotation literal
static member Quote : inner:Quotations.Expr -> Quotations.Expr
/// Permits 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.
static member RegisterReflectedDefinitions : assembly:Reflection.Assembly * resource:string * serializedValue:byte [] -> unit
/// Builds an expression that represents the sequential execution of one expression followed by another
static member Sequential : first:Quotations.Expr * second:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents a try/finally construct
static member TryFinally : body:Quotations.Expr * compensation:Quotations.Expr -> Quotations.Expr
/// 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.
static member TryGetReflectedDefinition : methodBase:Reflection.MethodBase -> Quotations.Expr option
/// Builds an expression that represents a try/with construct for exception filtering and catching.
static member TryWith : body:Quotations.Expr * filterVar:Quotations.Var * filterBody:Quotations.Expr * catchVar:Quotations.Var * catchBody:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents getting a field of a tuple
static member TupleGet : tuple:Quotations.Expr * index:int -> Quotations.Expr
/// Builds an expression that represents a type test.
static member TypeTest : source:Quotations.Expr * target:Type -> Quotations.Expr
/// Builds an expression that represents a test of a value is of a particular union case
static member UnionCaseTest : source:Quotations.Expr * unionCase:Reflection.UnionCaseInfo -> Quotations.Expr
/// Builds an expression that represents a constant value of a particular type
static member Value : value:obj * expressionType:Type -> Quotations.Expr
/// Builds an expression that represents a constant value
static member Value : value:'T -> Quotations.Expr
/// Builds an expression that represents a variable
static member Var : variable:Quotations.Var -> Quotations.Expr
/// Builds an expression that represents setting a mutable variable
static member VarSet : variable:Quotations.Var * value:Quotations.Expr -> Quotations.Expr
/// Builds an expression that represents a while loop
static member WhileLoop : guard:Quotations.Expr * body:Quotations.Expr -> Quotations.Expr
namespace Microsoft.FSharp.Quotations
/// Type-carrying quoted expressions. Expressions are generated either
/// by quotations in source text or programatically
[<CompiledName("FSharpExpr`1")>]
[<Class>]
type Expr<'T> =
inherit Quotations.Expr
/// Gets the raw expression associated with this type-carrying expression
member Raw : Quotations.Expr
/// Contains a set of primitive F# active patterns to analyze F# expression objects
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
module Microsoft.FSharp.Quotations.Patterns
/// An active pattern to recognize expressions that represent getting the address of a value
val (|AddressOf|_|) : input:Quotations.Expr -> Quotations.Expr option
/// An active pattern to recognize expressions that represent setting the value held at an address
val (|AddressSet|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions that represent applications of first class function values
val (|Application|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions that represent calls to static and instance methods, and functions defined in modules
val (|Call|_|) : input:Quotations.Expr -> (Quotations.Expr option * Reflection.MethodInfo * Quotations.Expr list) option
/// An active pattern to recognize expressions that represent coercions from one type to another
val (|Coerce|_|) : input:Quotations.Expr -> (Quotations.Expr * Type) option
/// An active pattern to recognize expressions that represent getting a static or instance field
val (|FieldGet|_|) : input:Quotations.Expr -> (Quotations.Expr option * Reflection.FieldInfo) option
/// An active pattern to recognize expressions that represent setting a static or instance field
val (|FieldSet|_|) : input:Quotations.Expr -> (Quotations.Expr option * Reflection.FieldInfo * Quotations.Expr) option
/// An active pattern to recognize expressions that represent loops over integer ranges
val (|ForIntegerRangeLoop|_|) : input:Quotations.Expr -> (Quotations.Var * Quotations.Expr * Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions that represent while loops
val (|WhileLoop|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions that represent conditionals
val (|IfThenElse|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions that represent first class function values
val (|Lambda|_|) : input:Quotations.Expr -> (Quotations.Var * Quotations.Expr) option
/// An active pattern to recognize expressions that represent let bindings
val (|Let|_|) : input:Quotations.Expr -> (Quotations.Var * Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions that represent recursive let bindings of one or more variables
val (|LetRecursive|_|) : input:Quotations.Expr -> ((Quotations.Var * Quotations.Expr) list * Quotations.Expr) option
/// An active pattern to recognize expressions that represent the construction of arrays
val (|NewArray|_|) : input:Quotations.Expr -> (Type * Quotations.Expr list) option
/// An active pattern to recognize expressions that represent invocations of a default constructor of a struct
val (|DefaultValue|_|) : input:Quotations.Expr -> Type option
/// An active pattern to recognize expressions that represent construction of delegate values
val (|NewDelegate|_|) : input:Quotations.Expr -> (Type * Quotations.Var list * Quotations.Expr) option
/// An active pattern to recognize expressions that represent invocation of object constructors
val (|NewObject|_|) : input:Quotations.Expr -> (Reflection.ConstructorInfo * Quotations.Expr list) option
/// An active pattern to recognize expressions that represent construction of record values
val (|NewRecord|_|) : input:Quotations.Expr -> (Type * Quotations.Expr list) option
/// An active pattern to recognize expressions that represent construction of particular union case values
val (|NewUnionCase|_|) : input:Quotations.Expr -> (Reflection.UnionCaseInfo * Quotations.Expr list) option
/// An active pattern to recognize expressions that represent construction of tuple values
val (|NewTuple|_|) : input:Quotations.Expr -> Quotations.Expr list option
/// 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
val (|PropertyGet|_|) : input:Quotations.Expr -> (Quotations.Expr option * Reflection.PropertyInfo * Quotations.Expr list) option
/// An active pattern to recognize expressions that represent setting a static or instance property, or a non-function value declared in a module
val (|PropertySet|_|) : input:Quotations.Expr -> (Quotations.Expr option * Reflection.PropertyInfo * Quotations.Expr list * Quotations.Expr) option
/// An active pattern to recognize expressions that represent a nested quotation literal
val (|Quote|_|) : input:Quotations.Expr -> Quotations.Expr option
/// An active pattern to recognize expressions that represent sequential exeuction of one expression followed by another
val (|Sequential|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions that represent a try/with construct for exception filtering and catching
val (|TryWith|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Var * Quotations.Expr * Quotations.Var * Quotations.Expr) option
/// An active pattern to recognize expressions that represent a try/finally construct
val (|TryFinally|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions that represent getting a tuple field
val (|TupleGet|_|) : input:Quotations.Expr -> (Quotations.Expr * int) option
/// An active pattern to recognize expressions that represent a dynamic type test
val (|TypeTest|_|) : input:Quotations.Expr -> (Quotations.Expr * Type) option
/// An active pattern to recognize expressions that represent a test if a value is of a particular union case
val (|UnionCaseTest|_|) : input:Quotations.Expr -> (Quotations.Expr * Reflection.UnionCaseInfo) option
/// An active pattern to recognize expressions that represent a constant value
val (|Value|_|) : input:Quotations.Expr -> (obj * Type) option
/// An active pattern to recognize expressions that represent a variable
val (|Var|_|) : input:Quotations.Expr -> Quotations.Var option
/// An active pattern to recognize expressions that represent setting a mutable variable
val (|VarSet|_|) : input:Quotations.Expr -> (Quotations.Var * Quotations.Expr) option
/// Contains a set of derived F# active patterns to analyze F# expression objects
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
module Microsoft.FSharp.Quotations.DerivedPatterns
/// An active pattern to recognize expressions that represent a (possibly curried or tupled) first class function value
val (|Lambdas|_|) : input:Quotations.Expr -> (Quotations.Var list list * Quotations.Expr) option
/// An active pattern to recognize expressions that represent the application of a (possibly curried or tupled) first class function value
val (|Applications|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr list list) option
/// An active pattern to recognize expressions of the form a && b
val (|AndAlso|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize expressions of the form a || b
val (|OrElse|_|) : input:Quotations.Expr -> (Quotations.Expr * Quotations.Expr) option
/// An active pattern to recognize () constant expressions
val (|Unit|_|) : input:Quotations.Expr -> unit option
/// An active pattern to recognize constant boolean expressions
val (|Bool|_|) : input:Quotations.Expr -> bool option
/// An active pattern to recognize constant string expressions
val (|String|_|) : input:Quotations.Expr -> string option
/// An active pattern to recognize constant 32-bit floating point number expressions
val (|Single|_|) : input:Quotations.Expr -> float32 option
/// An active pattern to recognize constant 64-bit floating point number expressions
val (|Double|_|) : input:Quotations.Expr -> float option
/// An active pattern to recognize constant unicode character expressions
val (|Char|_|) : input:Quotations.Expr -> char option
/// An active pattern to recognize constant signed byte expressions
val (|SByte|_|) : input:Quotations.Expr -> sbyte option
/// An active pattern to recognize constant byte expressions
val (|Byte|_|) : input:Quotations.Expr -> byte option
/// An active pattern to recognize constant int16 expressions
val (|Int16|_|) : input:Quotations.Expr -> int16 option
/// An active pattern to recognize constant unsigned int16 expressions
val (|UInt16|_|) : input:Quotations.Expr -> uint16 option
/// An active pattern to recognize constant int32 expressions
val (|Int32|_|) : input:Quotations.Expr -> int32 option
/// An active pattern to recognize constant unsigned int32 expressions
val (|UInt32|_|) : input:Quotations.Expr -> uint32 option
/// An active pattern to recognize constant int64 expressions
val (|Int64|_|) : input:Quotations.Expr -> int64 option
/// An active pattern to recognize constant unsigned int64 expressions
val (|UInt64|_|) : input:Quotations.Expr -> uint64 option
/// A parameterized active pattern to recognize calls to a specified function or method.
/// The returned elements are the optional target object (present if the target is an
/// instance method), the generic type instantation (non-empty if the target is a generic
/// instantiation), and the arguments to the function or method.
val (|SpecificCall|_|) : templateParameter:Quotations.Expr -> Quotations.Expr -> (Quotations.Expr option * Type list * Quotations.Expr list) option
/// An active pattern to recognize methods that have an associated ReflectedDefinition
val (|MethodWithReflectedDefinition|_|) : methodBase:Reflection.MethodBase -> Quotations.Expr option
/// An active pattern to recognize property getters or values in modules that have an associated ReflectedDefinition
val (|PropertyGetterWithReflectedDefinition|_|) : propertyInfo:Reflection.PropertyInfo -> Quotations.Expr option
/// An active pattern to recognize property setters that have an associated ReflectedDefinition
val (|PropertySetterWithReflectedDefinition|_|) : propertyInfo:Reflection.PropertyInfo -> Quotations.Expr option
/// Active patterns for traversing, visiting, rebuilding and tranforming expressions in a generic way
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
module Microsoft.FSharp.Quotations.ExprShape
/// An active pattern that performs a complete decomposition viewing the expression tree as a binding structure
val (|ShapeVar|ShapeLambda|ShapeCombination|) : input:Quotations.Expr -> Choice<Quotations.Var,(Quotations.Var * Quotations.Expr),(obj * Quotations.Expr list)>
/// Re-build combination expressions. The first parameter should be an object
/// returned by the ShapeCombination case of the active pattern in this module.
val RebuildShapeCombination : shape:obj * arguments:Quotations.Expr list -> Quotations.Expr
/// Contains operations on native pointers. Use of these operators may
/// result in the generation of unverifiable code.
[<RequireQualifiedAccess>]
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
module Microsoft.FSharp.NativeInterop.NativePtr
/// Returns a typed native pointer for a given machine address.
val inline ofNativeInt : address:nativeint -> nativeptr<'T> when 'T : unmanaged
/// Returns a machine address for a given typed native pointer.
val inline toNativeInt : address:nativeptr<'T> -> nativeint when 'T : unmanaged
/// Returns a typed native pointer by adding index * sizeof<'T> to the
/// given input pointer.
val inline add : address:nativeptr<'T> -> index:int -> nativeptr<'T> when 'T : unmanaged
/// Dereferences the typed native pointer computed by adding index * sizeof<'T> to the
/// given input pointer.
val inline get : address:nativeptr<'T> -> index:int -> 'T when 'T : unmanaged
/// Dereferences the given typed native pointer.
val inline read : address:nativeptr<'T> -> 'T when 'T : unmanaged
/// Assigns the value into the memory location referenced by the given typed native pointer.
val inline write : address:nativeptr<'T> -> value:'T -> unit when 'T : unmanaged
/// Assigns the value into the memory location referenced by the typed native
/// pointer computed by adding index * sizeof<'T> to the given input pointer.
val inline set : address:nativeptr<'T> -> index:int -> value:'T -> unit when 'T : unmanaged
/// Allocates a region of memory on the stack.
val inline stackalloc : count:int -> nativeptr<'T> when 'T : unmanaged
module Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter
/// When used in a quotation, this function indicates a specific conversion
/// should be performed when converting the quotation to a LINQ expression.
///
/// This function should not be called directly.
val ImplicitExpressionConversionHelper : 'T -> Linq.Expressions.Expression<'T>
/// When used in a quotation, this function indicates a specific conversion
/// should be performed when converting the quotation to a LINQ expression.
///
/// This function should not be called directly.
val MemberInitializationHelper : 'T -> 'T
/// When used in a quotation, this function indicates a specific conversion
/// should be performed when converting the quotation to a LINQ expression.
///
/// This function should not be called directly.
val NewAnonymousObjectHelper : 'T -> 'T
/// Converts a subset of F# quotations to a LINQ expression, for the subset of LINQ expressions represented by the
/// expression syntax in the C# language.
val QuotationToExpression : Quotations.Expr -> Linq.Expressions.Expression
/// Converts a subset of F# quotations to a LINQ expression, for the subset of LINQ expressions represented by the
/// expression syntax in the C# language.
val QuotationToLambdaExpression : Quotations.Expr<'T> -> Linq.Expressions.Expression<'T>
/// Evaluates a subset of F# quotations by first converting to a LINQ expression, for the subset of LINQ expressions represented by the
/// expression syntax in the C# language.
val EvaluateQuotation : Quotations.Expr -> obj
/// A runtime helper used to evaluate nested quotation literals.
val SubstHelper : Quotations.Expr * Quotations.Var [] * obj [] -> Quotations.Expr<'T>
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// A type used to reconstruct a grouping after applying a mutable->immutable mapping transformation
/// on a result of a query.
type Grouping<'K, 'T> =
interface System.Collections.Generic.IEnumerable<'T>
interface System.Collections.IEnumerable
interface System.Linq.IGrouping<'K,'T>
new : key:'K * values:seq<'T> -> Grouping<'K, 'T>
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// This type shouldn't be used directly from user code.
type AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8> =
new : Item1:'T1 * Item2:'T2 * Item3:'T3 * Item4:'T4 * Item5:'T5 * Item6:'T6 * Item7:'T7 * Item8:'T8 -> AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8>
member Item1 : 'T1
member Item2 : 'T2
member Item3 : 'T3
member Item4 : 'T4
member Item5 : 'T5
member Item6 : 'T6
member Item7 : 'T7
member Item8 : 'T8
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// This type shouldn't be used directly from user code.
type AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7> =
new : Item1:'T1 * Item2:'T2 * Item3:'T3 * Item4:'T4 * Item5:'T5 * Item6:'T6 * Item7:'T7 -> AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7>
member Item1 : 'T1
member Item2 : 'T2
member Item3 : 'T3
member Item4 : 'T4
member Item5 : 'T5
member Item6 : 'T6
member Item7 : 'T7
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// This type shouldn't be used directly from user code.
type AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5, 'T6> =
new : Item1:'T1 * Item2:'T2 * Item3:'T3 * Item4:'T4 * Item5:'T5 * Item6:'T6 -> AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5, 'T6>
member Item1 : 'T1
member Item2 : 'T2
member Item3 : 'T3
member Item4 : 'T4
member Item5 : 'T5
member Item6 : 'T6
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// This type shouldn't be used directly from user code.
type AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5> =
new : Item1:'T1 * Item2:'T2 * Item3:'T3 * Item4:'T4 * Item5:'T5 -> AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5>
member Item1 : 'T1
member Item2 : 'T2
member Item3 : 'T3
member Item4 : 'T4
member Item5 : 'T5
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// This type shouldn't be used directly from user code.
type AnonymousObject<'T1, 'T2, 'T3, 'T4> =
new : Item1:'T1 * Item2:'T2 * Item3:'T3 * Item4:'T4 -> AnonymousObject<'T1, 'T2, 'T3, 'T4>
member Item1 : 'T1
member Item2 : 'T2
member Item3 : 'T3
member Item4 : 'T4
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// This type shouldn't be used directly from user code.
type AnonymousObject<'T1, 'T2, 'T3> =
new : Item1:'T1 * Item2:'T2 * Item3:'T3 -> AnonymousObject<'T1, 'T2, 'T3>
member Item1 : 'T1
member Item2 : 'T2
member Item3 : 'T3
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// This type shouldn't be used directly from user code.
type AnonymousObject<'T1, 'T2> =
new : Item1:'T1 * Item2:'T2 -> AnonymousObject<'T1, 'T2>
member Item1 : 'T1
member Item2 : 'T2
namespace Microsoft.FSharp.Linq.RuntimeHelpers
/// This type shouldn't be used directly from user code.
type AnonymousObject<'T1> =
new : Item1:'T1 -> AnonymousObject<'T1>
member Item1 : 'T1
namespace Microsoft.FSharp.Linq
/// A partial input or result in an F# query. This type is used to support the F# query syntax.
[<NoComparison>]
[<NoEquality>]
[<Sealed>]
type QuerySource<'T, 'Q> =
/// A method used to support the F# query syntax.
new : seq<'T> -> QuerySource<'T, 'Q>
/// A property used to support the F# query syntax.
member Source : seq<'T>
module Microsoft.FSharp.Linq.QueryRunExtensions.LowPriority
/// A method used to support the F# query syntax. Runs the given quotation as a query using LINQ rules.
val Run : Quotations.Expr<'T> -> 'T
module Microsoft.FSharp.Linq.QueryRunExtensions.HighPriority
/// A method used to support the F# query syntax. Runs the given quotation as a query using LINQ IEnumerable rules.
val Run : Quotations.Expr<Linq.QuerySource<'T,Collections.IEnumerable>> -> seq<'T>
namespace Microsoft.FSharp.Linq
/// The type used to support the F# query syntax. Use 'query { ... }' to use the query syntax.
[<Class>]
type QueryBuilder =
/// Create an instance of this builder. Use 'query { ... }' to use the query syntax.
new : unit -> QueryBuilder
/// A query operator that determines whether all elements selected so far satisfies a condition.
[<CustomOperation("all")>]
member All : source:Linq.QuerySource<'T,'Q> * predicate:('T -> bool) -> bool
/// A query operator that selects a value for each element selected so far and returns the average of these values.
[<CustomOperation("averageBy")>]
member inline AverageBy : source:Linq.QuerySource<'T,'Q> * projection:('T -> ^Value) -> ^Value when ^Value : (static member ( + ) : ^Value * ^Value -> ^Value) and ^Value : (static member DivideByInt : ^Value * int -> ^Value) and ^Value : (static member Zero : ^Value)
/// A query operator that selects a nullable value for each element selected so far and returns the average of these values.
/// If any nullable does not have a value, it is ignored.
[<CustomOperation("averageByNullable")>]
member inline AverageByNullable : source:Linq.QuerySource<'T,'Q> * projection:('T -> Nullable< ^Value>) -> Nullable< ^Value> when ^Value : (static member ( + ) : ^Value * ^Value -> ^Value) and ^Value : (static member DivideByInt : ^Value * int -> ^Value) and ^Value : (static member Zero : ^Value) and ^Value : (new : unit -> ^Value) and ^Value : struct and ^Value :> ValueType
/// A query operator that determines whether the selected elements contains a specified element.
[<CustomOperation("contains")>]
member Contains : source:Linq.QuerySource<'T,'Q> * key:'T -> bool
/// A query operator that returns the number of selected elements.
[<CustomOperation("count")>]
member Count : source:Linq.QuerySource<'T,'Q> -> int
/// A query operator that selects distinct elements from the elements selected so far.
[<CustomOperation("distinct")>]
member Distinct : source:Linq.QuerySource<'T,'Q> -> Linq.QuerySource<'T,'Q> when 'T : equality
/// A query operator that selects the single, specific element selected so far
[<CustomOperation("exactlyOne")>]
member ExactlyOne : source:Linq.QuerySource<'T,'Q> -> 'T
/// A query operator that selects the single, specific element of those selected so far, or a default value if that element is not found.
[<CustomOperation("exactlyOneOrDefault")>]
member ExactlyOneOrDefault : source:Linq.QuerySource<'T,'Q> -> 'T
/// A query operator that determines whether any element selected so far satisfies a condition.
[<CustomOperation("exists")>]
member Exists : source:Linq.QuerySource<'T,'Q> * predicate:('T -> bool) -> bool
/// A query operator that selects the first element selected so far that satisfies a specified condition.
[<CustomOperation("find")>]
member Find : source:Linq.QuerySource<'T,'Q> * predicate:('T -> bool) -> 'T
/// A method used to support the F# query syntax. Projects each element of a sequence to another sequence and combines the resulting sequences into one sequence.
member For : source:Linq.QuerySource<'T,'Q> * body:('T -> Linq.QuerySource<'Result,'Q2>) -> Linq.QuerySource<'Result,'Q>
/// A query operator that groups the elements selected so far according to a specified key selector.
[<CustomOperation("groupBy")>]
member GroupBy : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> 'Key) -> Linq.QuerySource<Linq.IGrouping<'Key,'T>,'Q> when 'Key : equality
/// A query operator that correlates two sets of selected values based on matching keys and groups the results.
/// Normal usage is 'groupJoin y in elements2 on (key1 = key2) into group'.
[<CustomOperation("groupJoin")>]
member GroupJoin : outerSource:Linq.QuerySource<'Outer,'Q> * innerSource:Linq.QuerySource<'Inner,'Q> * outerKeySelector:('Outer -> 'Key) * innerKeySelector:('Inner -> 'Key) * resultSelector:('Outer -> seq<'Inner> -> 'Result) -> Linq.QuerySource<'Result,'Q>
/// A query operator that selects a value for each element selected so far and groups the elements by the given key.
[<CustomOperation("groupValBy")>]
member GroupValBy : source:Linq.QuerySource<'T,'Q> * resultSelector:('T -> 'Value) * keySelector:('T -> 'Key) -> Linq.QuerySource<Linq.IGrouping<'Key,'Value>,'Q> when 'Key : equality
/// A query operator that selects the first element from those selected so far.
[<CustomOperation("head")>]
member Head : source:Linq.QuerySource<'T,'Q> -> 'T
/// A query operator that selects the first element of those selected so far, or a default value if the sequence contains no elements.
[<CustomOperation("headOrDefault")>]
member HeadOrDefault : source:Linq.QuerySource<'T,'Q> -> 'T
/// A query operator that correlates two sets of selected values based on matching keys.
/// Normal usage is 'join y in elements2 on (key1 = key2)'.
[<CustomOperation("join")>]
member Join : outerSource:Linq.QuerySource<'Outer,'Q> * innerSource:Linq.QuerySource<'Inner,'Q> * outerKeySelector:('Outer -> 'Key) * innerKeySelector:('Inner -> 'Key) * resultSelector:('Outer -> 'Inner -> 'Result) -> Linq.QuerySource<'Result,'Q>
/// A query operator that selects the last element of those selected so far.
[<CustomOperation("last")>]
member Last : source:Linq.QuerySource<'T,'Q> -> 'T
/// A query operator that selects the last element of those selected so far, or a default value if no element is found.
[<CustomOperation("lastOrDefault")>]
member LastOrDefault : source:Linq.QuerySource<'T,'Q> -> 'T
/// A query operator that correlates two sets of selected values based on matching keys and groups the results.
/// If any group is empty, a group with a single default value is used instead.
/// Normal usage is 'leftOuterJoin y in elements2 on (key1 = key2) into group'.
[<CustomOperation("leftOuterJoin")>]
member LeftOuterJoin : outerSource:Linq.QuerySource<'Outer,'Q> * innerSource:Linq.QuerySource<'Inner,'Q> * outerKeySelector:('Outer -> 'Key) * innerKeySelector:('Inner -> 'Key) * resultSelector:('Outer -> seq<'Inner> -> 'Result) -> Linq.QuerySource<'Result,'Q>
/// A query operator that selects a value for each element selected so far and returns the maximum resulting value.
[<CustomOperation("maxBy")>]
member MaxBy : source:Linq.QuerySource<'T,'Q> * valueSelector:('T -> 'Value) -> 'Value when 'Value : comparison
/// A query operator that selects a nullable value for each element selected so far and returns the maximum of these values.
/// If any nullable does not have a value, it is ignored.
[<CustomOperation("maxByNullable")>]
member MaxByNullable : source:Linq.QuerySource<'T,'Q> * valueSelector:('T -> Nullable<'Value>) -> Nullable<'Value> when 'Value : comparison and 'Value : (new : unit -> 'Value) and 'Value : struct and 'Value :> ValueType
/// A query operator that selects a value for each element selected so far and returns the minimum resulting value.
[<CustomOperation("minBy")>]
member MinBy : source:Linq.QuerySource<'T,'Q> * valueSelector:('T -> 'Value) -> 'Value when 'Value : comparison
/// A query operator that selects a nullable value for each element selected so far and returns the minimum of these values.
/// If any nullable does not have a value, it is ignored.
[<CustomOperation("minByNullable")>]
member MinByNullable : source:Linq.QuerySource<'T,'Q> * valueSelector:('T -> Nullable<'Value>) -> Nullable<'Value> when 'Value : comparison and 'Value : (new : unit -> 'Value) and 'Value : struct and 'Value :> ValueType
/// A query operator that selects the element at a specified index amongst those selected so far.
[<CustomOperation("nth")>]
member Nth : source:Linq.QuerySource<'T,'Q> * index:int -> 'T
/// A method used to support the F# query syntax. Indicates that the query should be passed as a quotation to the Run method.
member Quote : Quotations.Expr<'T> -> Quotations.Expr<'T>
/// A method used to support the F# query syntax. Runs the given quotation as a query using LINQ IQueryable rules.
member Run : Quotations.Expr<Linq.QuerySource<'T,Linq.IQueryable>> -> Linq.IQueryable<'T>
/// A query operator that projects each of the elements selected so far.
[<CustomOperation("select")>]
member Select : source:Linq.QuerySource<'T,'Q> * projection:('T -> 'Result) -> Linq.QuerySource<'Result,'Q>
/// A query operator that bypasses a specified number of the elements selected so far and selects the remaining elements.
[<CustomOperation("skip")>]
member Skip : source:Linq.QuerySource<'T,'Q> * count:int -> Linq.QuerySource<'T,'Q>
/// A query operator that bypasses elements in a sequence as long as a specified condition is true and then selects the remaining elements.
[<CustomOperation("skipWhile")>]
member SkipWhile : source:Linq.QuerySource<'T,'Q> * predicate:('T -> bool) -> Linq.QuerySource<'T,'Q>
/// A query operator that sorts the elements selected so far in ascending order by the given sorting key.
[<CustomOperation("sortBy")>]
member SortBy : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> 'Key) -> Linq.QuerySource<'T,'Q> when 'Key : comparison
/// A query operator that sorts the elements selected so far in descending order by the given sorting key.
[<CustomOperation("sortByDescending")>]
member SortByDescending : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> 'Key) -> Linq.QuerySource<'T,'Q> when 'Key : comparison
/// A query operator that sorts the elements selected so far in ascending order by the given nullable sorting key.
[<CustomOperation("sortByNullable")>]
member SortByNullable : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> Nullable<'Key>) -> Linq.QuerySource<'T,'Q> when 'Key : comparison and 'Key : (new : unit -> 'Key) and 'Key : struct and 'Key :> ValueType
/// A query operator that sorts the elements selected so far in descending order by the given nullable sorting key.
[<CustomOperation("sortByNullableDescending")>]
member SortByNullableDescending : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> Nullable<'Key>) -> Linq.QuerySource<'T,'Q> when 'Key : comparison and 'Key : (new : unit -> 'Key) and 'Key : struct and 'Key :> ValueType
/// A method used to support the F# query syntax. Inputs to queries are implicitly wrapped by a call to one of the overloads of this method.
member Source : source:Linq.IQueryable<'T> -> Linq.QuerySource<'T,'Q>
/// A method used to support the F# query syntax. Inputs to queries are implicitly wrapped by a call to one of the overloads of this method.
member Source : source:Collections.Generic.IEnumerable<'T> -> Linq.QuerySource<'T,Collections.IEnumerable>
/// A query operator that selects a value for each element selected so far and returns the sum of these values.
[<CustomOperation("sumBy")>]
member inline SumBy : source:Linq.QuerySource<'T,'Q> * projection:('T -> ^Value) -> ^Value when ^Value : (static member ( + ) : ^Value * ^Value -> ^Value) and ^Value : (static member Zero : ^Value)
/// A query operator that selects a nullable value for each element selected so far and returns the sum of these values.
/// If any nullable does not have a value, it is ignored.
[<CustomOperation("sumByNullable")>]
member inline SumByNullable : source:Linq.QuerySource<'T,'Q> * valueSelector:('T -> Nullable< ^Value>) -> Nullable< ^Value> when ^Value : (static member ( + ) : ^Value * ^Value -> ^Value) and ^Value : (static member Zero : ^Value) and ^Value : (new : unit -> ^Value) and ^Value : struct and ^Value :> ValueType
/// A query operator that selects a specified number of contiguous elements from those selected so far.
[<CustomOperation("take")>]
member Take : source:Linq.QuerySource<'T,'Q> * count:int -> Linq.QuerySource<'T,'Q>
/// A query operator that selects elements from a sequence as long as a specified condition is true, and then skips the remaining elements.
[<CustomOperation("takeWhile")>]
member TakeWhile : source:Linq.QuerySource<'T,'Q> * predicate:('T -> bool) -> Linq.QuerySource<'T,'Q>
/// A query operator that performs a subsequent ordering of the elements selected so far in ascending order by the given sorting key.
/// This operator may only be used immediately after a 'sortBy', 'sortByDescending', 'thenBy' or 'thenByDescending', or their nullable variants.
[<CustomOperation("thenBy")>]
member ThenBy : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> 'Key) -> Linq.QuerySource<'T,'Q> when 'Key : comparison
/// A query operator that performs a subsequent ordering of the elements selected so far in descending order by the given sorting key.
/// This operator may only be used immediately after a 'sortBy', 'sortByDescending', 'thenBy' or 'thenByDescending', or their nullable variants.
[<CustomOperation("thenByDescending")>]
member ThenByDescending : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> 'Key) -> Linq.QuerySource<'T,'Q> when 'Key : comparison
/// A query operator that performs a subsequent ordering of the elements selected so far in ascending order by the given nullable sorting key.
/// This operator may only be used immediately after a 'sortBy', 'sortByDescending', 'thenBy' or 'thenByDescending', or their nullable variants.
[<CustomOperation("thenByNullable")>]
member ThenByNullable : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> Nullable<'Key>) -> Linq.QuerySource<'T,'Q> when 'Key : comparison and 'Key : (new : unit -> 'Key) and 'Key : struct and 'Key :> ValueType
/// A query operator that performs a subsequent ordering of the elements selected so far in descending order by the given nullable sorting key.
/// This operator may only be used immediately after a 'sortBy', 'sortByDescending', 'thenBy' or 'thenByDescending', or their nullable variants.
[<CustomOperation("thenByNullableDescending")>]
member ThenByNullableDescending : source:Linq.QuerySource<'T,'Q> * keySelector:('T -> Nullable<'Key>) -> Linq.QuerySource<'T,'Q> when 'Key : comparison and 'Key : (new : unit -> 'Key) and 'Key : struct and 'Key :> ValueType
/// A query operator that selects those elements based on a specified predicate.
[<CustomOperation("where")>]
member Where : source:Linq.QuerySource<'T,'Q> * predicate:('T -> bool) -> Linq.QuerySource<'T,'Q>
/// A method used to support the F# query syntax. Returns a sequence of length one that contains the specified value.
member Yield : value:'T -> Linq.QuerySource<'T,'Q>
/// A method used to support the F# query syntax. Returns a sequence that contains the specified values.
member YieldFrom : computation:Linq.QuerySource<'T,'Q> -> Linq.QuerySource<'T,'Q>
/// A method used to support the F# query syntax. Returns an empty sequence that has the specified type argument.
member Zero : unit -> Linq.QuerySource<'T,'Q>
/// Operators for working with nullable values
[<AutoOpen>]
module Microsoft.FSharp.Linq.NullableOperators
/// The '>=' operator where a nullable value appears on the left
val ( ?>= ) : Nullable<'T> -> 'T -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '>' operator where a nullable value appears on the left
val ( ?> ) : Nullable<'T> -> 'T -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<=' operator where a nullable value appears on the left
val ( ?<= ) : Nullable<'T> -> 'T -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<' operator where a nullable value appears on the left
val ( ?< ) : Nullable<'T> -> 'T -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '=' operator where a nullable value appears on the left
val ( ?= ) : Nullable<'T> -> 'T -> bool when 'T : equality and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<>' operator where a nullable value appears on the left
val ( ?<> ) : Nullable<'T> -> 'T -> bool when 'T : equality and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '>=' operator where a nullable value appears on the right
val ( >=? ) : 'T -> Nullable<'T> -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '>' operator where a nullable value appears on the right
val ( >? ) : 'T -> Nullable<'T> -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<=' operator where a nullable value appears on the right
val ( <=? ) : 'T -> Nullable<'T> -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<' operator where a nullable value appears on the right
val ( <? ) : 'T -> Nullable<'T> -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '=' operator where a nullable value appears on the right
val ( =? ) : 'T -> Nullable<'T> -> bool when 'T : equality and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<>' operator where a nullable value appears on the right
val ( <>? ) : 'T -> Nullable<'T> -> bool when 'T : equality and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '>=' operator where a nullable value appears on both left and right sides
val ( ?>=? ) : Nullable<'T> -> Nullable<'T> -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '>' operator where a nullable value appears on both left and right sides
val ( ?>? ) : Nullable<'T> -> Nullable<'T> -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<=' operator where a nullable value appears on both left and right sides
val ( ?<=? ) : Nullable<'T> -> Nullable<'T> -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<' operator where a nullable value appears on both left and right sides
val ( ?<? ) : Nullable<'T> -> Nullable<'T> -> bool when 'T : comparison and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '=' operator where a nullable value appears on both left and right sides
val ( ?=? ) : Nullable<'T> -> Nullable<'T> -> bool when 'T : equality and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The '<>' operator where a nullable value appears on both left and right sides
val ( ?<>? ) : Nullable<'T> -> Nullable<'T> -> bool when 'T : equality and 'T : (new : unit -> 'T) and 'T : struct and 'T :> ValueType
/// The addition operator where a nullable value appears on the left
val inline ( ?+ ) : Nullable< ^T1> -> ^T2 -> Nullable< ^T3> when ^T1 : (static member ( + ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( + ) : ^T1 * ^T2 -> ^T3) and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The addition operator where a nullable value appears on the right
val inline ( +? ) : ^T1 -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( + ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( + ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The addition operator where a nullable value appears on both left and right sides
val inline ( ?+? ) : Nullable< ^T1> -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( + ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( + ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The subtraction operator where a nullable value appears on the left
val inline ( ?- ) : Nullable< ^T1> -> ^T2 -> Nullable< ^T3> when ^T1 : (static member ( - ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( - ) : ^T1 * ^T2 -> ^T3) and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The subtraction operator where a nullable value appears on the right
val inline ( -? ) : ^T1 -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( - ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( - ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The subtraction operator where a nullable value appears on both left and right sides
val inline ( ?-? ) : Nullable< ^T1> -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( - ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( - ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The multiplication operator where a nullable value appears on the left
val inline ( ?* ) : Nullable< ^T1> -> ^T2 -> Nullable< ^T3> when ^T1 : (static member ( * ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( * ) : ^T1 * ^T2 -> ^T3) and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The multiplication operator where a nullable value appears on the right
val inline ( *? ) : ^T1 -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( * ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( * ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The multiplication operator where a nullable value appears on both left and right sides
val inline ( ?*? ) : Nullable< ^T1> -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( * ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( * ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The modulus operator where a nullable value appears on the left
val inline ( ?% ) : Nullable< ^T1> -> ^T2 -> Nullable< ^T3> when ^T1 : (static member ( % ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( % ) : ^T1 * ^T2 -> ^T3) and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The modulus operator where a nullable value appears on the right
val inline ( %? ) : ^T1 -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( % ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( % ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The modulus operator where a nullable value appears on both left and right sides
val inline ( ?%? ) : Nullable< ^T1> -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( % ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( % ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The division operator where a nullable value appears on the left
val inline ( ?/ ) : Nullable< ^T1> -> ^T2 -> Nullable< ^T3> when ^T1 : (static member ( / ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( / ) : ^T1 * ^T2 -> ^T3) and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The division operator where a nullable value appears on the right
val inline ( /? ) : ^T1 -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( / ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( / ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// The division operator where a nullable value appears on both left and right sides
val inline ( ?/? ) : Nullable< ^T1> -> Nullable< ^T2> -> Nullable< ^T3> when ^T1 : (static member ( / ) : ^T1 * ^T2 -> ^T3) and ^T1 : (new : unit -> ^T1) and ^T1 : struct and ^T1 :> ValueType and ^T2 : (static member ( / ) : ^T1 * ^T2 -> ^T3) and ^T2 : (new : unit -> ^T2) and ^T2 : struct and ^T2 :> ValueType and 'T3 : (new : unit -> 'T3) and 'T3 : struct and 'T3 :> ValueType
/// Functions for converting nullable values
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Linq.Nullable
/// Converts the argument to byte. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline byte : value:Nullable< ^T> -> Nullable<byte> when ^T : (static member op_Explicit : unit -> byte) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to signed byte. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline sbyte : value:Nullable< ^T> -> Nullable<sbyte> when ^T : (static member op_Explicit : unit -> sbyte) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to signed 16-bit integer. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline int16 : value:Nullable< ^T> -> Nullable<int16> when ^T : (static member op_Explicit : unit -> int16) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to unsigned 16-bit integer. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline uint16 : value:Nullable< ^T> -> Nullable<uint16> when ^T : (static member op_Explicit : unit -> uint16) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to signed 32-bit integer. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline int : value:Nullable< ^T> -> Nullable<int> when ^T : (static member op_Explicit : unit -> int) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to a particular enum type.
val inline enum : value:Nullable<int32> -> Nullable< ^U> when 'U : enum<int32> and 'U : (new : unit -> 'U) and 'U : struct and 'U :> ValueType
/// Converts the argument to signed 32-bit integer. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline int32 : value:Nullable< ^T> -> Nullable<int32> when ^T : (static member op_Explicit : unit -> int32) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to unsigned 32-bit integer. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline uint32 : value:Nullable< ^T> -> Nullable<uint32> when ^T : (static member op_Explicit : unit -> uint32) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to signed 64-bit integer. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline int64 : value:Nullable< ^T> -> Nullable<int64> when ^T : (static member op_Explicit : unit -> int64) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to unsigned 64-bit integer. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline uint64 : value:Nullable< ^T> -> Nullable<uint64> when ^T : (static member op_Explicit : unit -> uint64) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to 32-bit float. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline float32 : value:Nullable< ^T> -> Nullable<float32> when ^T : (static member op_Explicit : unit -> float32) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to 64-bit float. This is a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline float : value:Nullable< ^T> -> Nullable<float> when ^T : (static member op_Explicit : unit -> float) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to signed native integer. This is a direct conversion for all
/// primitive numeric types. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline nativeint : value:Nullable< ^T> -> Nullable<nativeint> when ^T : (static member op_Explicit : unit -> nativeint) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to unsigned native integer using a direct conversion for all
/// primitive numeric types. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline unativeint : value:Nullable< ^T> -> Nullable<unativeint> when ^T : (static member op_Explicit : unit -> unativeint) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to System.Decimal using a direct conversion for all
/// primitive numeric types. The operation requires an appropriate
/// static conversion method on the input type.
val inline decimal : value:Nullable< ^T> -> Nullable<decimal> when ^T : (static member op_Explicit : unit -> decimal) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
/// Converts the argument to character. Numeric inputs are converted according to the UTF-16
/// encoding for characters. The operation requires an appropriate static conversion method on the input type.
val inline char : value:Nullable< ^T> -> Nullable<char> when ^T : (static member op_Explicit : unit -> char) and ^T : (new : unit -> ^T) and ^T : struct and ^T :> ValueType
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for Metre, the SI unit of length
type m = Data.UnitSystems.SI.UnitNames.metre
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for kilogram, the SI unit of mass
type kg = Data.UnitSystems.SI.UnitNames.kilogram
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for second, the SI unit of time
type s = Data.UnitSystems.SI.UnitNames.second
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for ampere, the SI unit of electric current
type A = Data.UnitSystems.SI.UnitNames.ampere
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for kelvin, the SI unit of thermodynamic temperature
type K = Data.UnitSystems.SI.UnitNames.kelvin
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for mole, the SI unit of amount of substance
type mol = Data.UnitSystems.SI.UnitNames.mole
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for candela, the SI unit of luminous intensity
type cd = Data.UnitSystems.SI.UnitNames.candela
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for hertz, the SI unit of frequency
type Hz = Data.UnitSystems.SI.UnitNames.hertz
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for newton, the SI unit of force
type N = Data.UnitSystems.SI.UnitNames.newton
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for pascal, the SI unit of pressure, stress
type Pa = Data.UnitSystems.SI.UnitNames.pascal
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for joule, the SI unit of energy, work, amount of heat
type J = Data.UnitSystems.SI.UnitNames.joule
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for watt, the SI unit of power, radiant flux
type W = Data.UnitSystems.SI.UnitNames.watt
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for coulomb, the SI unit of electric charge, amount of electricity
type C = Data.UnitSystems.SI.UnitNames.coulomb
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for volt, the SI unit of electric potential difference, electromotive force
type V = Data.UnitSystems.SI.UnitNames.volt
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for farad, the SI unit of capacitance
type F = Data.UnitSystems.SI.UnitNames.farad
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for siemens, the SI unit of electric conductance
type S = Data.UnitSystems.SI.UnitNames.siemens
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for UnitNames.ohm, the SI unit of electric resistance.
type ohm = Data.UnitSystems.SI.UnitNames.ohm
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for weber, the SI unit of magnetic flux
type Wb = Data.UnitSystems.SI.UnitNames.weber
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for tesla, the SI unit of magnetic flux density
type T = Data.UnitSystems.SI.UnitNames.tesla
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for lumen, the SI unit of luminous flux
type lm = Data.UnitSystems.SI.UnitNames.lumen
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for lux, the SI unit of illuminance
type lx = Data.UnitSystems.SI.UnitNames.lux
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for becquerel, the SI unit of activity referred to a radionuclide
type Bq = Data.UnitSystems.SI.UnitNames.becquerel
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for gray, the SI unit of absorbed dose
type Gy = Data.UnitSystems.SI.UnitNames.gray
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for sievert, the SI unit of does equivalent
type Sv = Data.UnitSystems.SI.UnitNames.sievert
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for katal, the SI unit of catalytic activity
type kat = Data.UnitSystems.SI.UnitNames.katal
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols
/// A synonym for henry, the SI unit of inductance
type H = Data.UnitSystems.SI.UnitNames.henry
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of length
[<Measure>]
type metre =
class
end
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of length
type meter = Data.UnitSystems.SI.UnitNames.metre
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of mass
[<Measure>]
type kilogram =
class
end
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of time
[<Measure>]
type second =
class
end
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of electric current
[<Measure>]
type ampere =
class
end
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of thermodynamic temperature
[<Measure>]
type kelvin =
class
end
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of amount of substance
[<Measure>]
type mole =
class
end
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of luminous intensity
[<Measure>]
type candela =
class
end
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of frequency
type hertz = /Data.UnitSystems.SI.UnitNames.second
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of force
type newton = Data.UnitSystems.SI.UnitNames.kilogram Data.UnitSystems.SI.UnitNames.metre/Data.UnitSystems.SI.UnitNames.second ^ 2
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of pressure, stress
type pascal = Data.UnitSystems.SI.UnitNames.newton/Data.UnitSystems.SI.UnitNames.metre ^ 2
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of energy, work, amount of heat
type joule = Data.UnitSystems.SI.UnitNames.metre Data.UnitSystems.SI.UnitNames.newton
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of power, radiant flux
type watt = Data.UnitSystems.SI.UnitNames.joule/Data.UnitSystems.SI.UnitNames.second
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of electric charge, amount of electricity
type coulomb = Data.UnitSystems.SI.UnitNames.ampere Data.UnitSystems.SI.UnitNames.second
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of electric potential difference, electromotive force
type volt = Data.UnitSystems.SI.UnitNames.watt/Data.UnitSystems.SI.UnitNames.ampere
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of capacitance
type farad = Data.UnitSystems.SI.UnitNames.coulomb/Data.UnitSystems.SI.UnitNames.volt
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of electric resistance
type ohm = Data.UnitSystems.SI.UnitNames.volt/Data.UnitSystems.SI.UnitNames.ampere
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of electric conductance
type siemens = Data.UnitSystems.SI.UnitNames.ampere/Data.UnitSystems.SI.UnitNames.volt
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of magnetic flux
type weber = Data.UnitSystems.SI.UnitNames.second Data.UnitSystems.SI.UnitNames.volt
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of magnetic flux density
type tesla = Data.UnitSystems.SI.UnitNames.weber/Data.UnitSystems.SI.UnitNames.metre ^ 2
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of inductance
type henry = Data.UnitSystems.SI.UnitNames.weber/Data.UnitSystems.SI.UnitNames.ampere
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of luminous flux
type lumen = Data.UnitSystems.SI.UnitNames.candela
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of illuminance
type lux = Data.UnitSystems.SI.UnitNames.lumen/Data.UnitSystems.SI.UnitNames.metre ^ 2
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of activity referred to a radionuclide
type becquerel = /Data.UnitSystems.SI.UnitNames.second
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of absorbed dose
type gray = Data.UnitSystems.SI.UnitNames.joule/Data.UnitSystems.SI.UnitNames.kilogram
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of does equivalent
type sievert = Data.UnitSystems.SI.UnitNames.joule/Data.UnitSystems.SI.UnitNames.kilogram
namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
/// The SI unit of catalytic activity
type katal = Data.UnitSystems.SI.UnitNames.mole/Data.UnitSystems.SI.UnitNames.second
namespace Microsoft.FSharp.Core
/// The type 'unit', which has only one value "()". This value is special and
/// always uses the representation 'null'.
type unit = Unit
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.UIntPtr.
type unativeint = UIntPtr
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Byte.
type uint8 = Byte
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.UInt64.
type uint64 = UInt64
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.UInt32.
type uint32 = UInt32
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.UInt16.
type uint16 = UInt16
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.String.
type string = String
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Single.
type single = Single
namespace Microsoft.FSharp.Core
/// 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.
[<MeasureAnnotatedAbbreviation>]
[<Class>]
type sbyte<'Measure> =
inherit System.ValueType
interface System.IConvertible
interface System.IFormattable
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.SByte.
type sbyte = SByte
namespace Microsoft.FSharp.Core
/// The type of mutable references. Use the functions [:=] and [!] to get and
/// set values of this type.
type ref<'T> = Ref<'T>
namespace Microsoft.FSharp.Core
/// The type of optional values. When used from other CLI languages the
/// empty option is the null value.
type option<'T> = Option<'T>
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Object.
type obj = Object
namespace Microsoft.FSharp.Core
/// Represents an unmanaged pointer in F# code.
[<Class>]
type nativeptr<'T when 'T : unmanaged> =
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.IntPtr.
type nativeint = IntPtr
namespace Microsoft.FSharp.Core
/// 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.
[<MeasureAnnotatedAbbreviation>]
[<Class>]
type int<'Measure> =
inherit System.ValueType
interface System.IConvertible
interface System.IFormattable
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.SByte.
type int8 = SByte
namespace Microsoft.FSharp.Core
/// 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.
[<MeasureAnnotatedAbbreviation>]
[<Class>]
type int64<'Measure> =
inherit System.ValueType
interface System.IConvertible
interface System.IFormattable
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Int64.
type int64 = Int64
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Int32.
type int32 = Int32
namespace Microsoft.FSharp.Core
/// 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.
[<MeasureAnnotatedAbbreviation>]
[<Class>]
type int16<'Measure> =
inherit System.ValueType
interface System.IConvertible
interface System.IFormattable
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Int16.
type int16 = Int16
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Int32.
type int = int32
namespace Microsoft.FSharp.Core
/// This type is for internal use by the F# code generator.
[<Class>]
type ilsigptr<'T> =
namespace Microsoft.FSharp.Core
/// 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.
[<MeasureAnnotatedAbbreviation>]
[<Class>]
type float<'Measure> =
inherit System.ValueType
interface System.IConvertible
interface System.IFormattable
namespace Microsoft.FSharp.Core
/// 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.
[<MeasureAnnotatedAbbreviation>]
[<Class>]
type float32<'Measure> =
inherit System.ValueType
interface System.IConvertible
interface System.IFormattable
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Single.
type float32 = Single
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Double.
type float = Double
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Exception.
type exn = Exception
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Double.
type double = Double
namespace Microsoft.FSharp.Core
/// 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.
[<MeasureAnnotatedAbbreviation>]
[<Class>]
type decimal<'Measure> =
inherit System.ValueType
interface System.IConvertible
interface System.Runtime.Serialization.IDeserializationCallback
interface System.IFormattable
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Decimal.
type decimal = Decimal
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Char.
type char = Char
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Byte.
type byte = Byte
namespace Microsoft.FSharp.Core
/// Represents a managed pointer in F# code.
[<Class>]
type byref<'T> =
namespace Microsoft.FSharp.Core
/// An abbreviation for the CLI type System.Boolean.
type bool = Boolean
namespace Microsoft.FSharp.Core
type bigint = Numerics.BigInteger
namespace Microsoft.FSharp.Core
/// Single dimensional, zero-based arrays, written int[], string[] etc.
type array<'T> = 'T []
namespace Microsoft.FSharp.Core
/// Single dimensional, zero-based arrays, written int[], string[] etc.
[<Class>]
type ``[]``<'T> =
namespace Microsoft.FSharp.Core
/// Two dimensional arrays, typically zero-based.
[<Class>]
type ``[,]``<'T> =
namespace Microsoft.FSharp.Core
/// Three dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Four dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Five dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Six dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Seven dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Eight dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Nine dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Ten dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Eleven dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Twelve dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,,,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Thirteen dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,,,,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Fourteen dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,,,,,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Fifteen dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,,,,,,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Sixteen dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,,,,,,,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Seventeen dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,,,,,,,,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Eighteen dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,,,,,,,,,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Nineteen dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,,,,,,,,,,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Twenty dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,,,,,,,,,,,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Twenty-one dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,,,,,,,,,,,,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Twenty-two dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,,,,,,,,,,,,,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Twenty-three dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,,,,,,,,,,,,,,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Twenty-four dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,,,,,,,,,,,,,,,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Twenty-five dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,,,,,,,,,,,,,,,,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Twenty-six dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,,,,,,,,,,,,,,,,,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Twenty-seven dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,,,,,,,,,,,,,,,,,,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Twenty-eight dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,,,,,,,,,,,,,,,,,,,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Twenty-nine dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,,,,,,,,,,,,,,,,,,,,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Thirty dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Thirty-one dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Thirty-two dimensional arrays, typically zero-based. Non-zero-based arrays
/// can be created using methods on the System.Array type.
[<Class>]
type ``[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,]``<'T> =
namespace Microsoft.FSharp.Core
/// Adding this attribute to an F# mutable binding causes the "volatile"
/// prefix to be used for all accesses to the field.
[<Sealed>]
type VolatileFieldAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> VolatileFieldAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type UnverifiableAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> UnverifiableAttribute
namespace Microsoft.FSharp.Core
/// The type 'unit', which has only one value "()". This value is special and
/// always uses the representation 'null'.
[<Class>]
type Unit =
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type StructuredFormatDisplayAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : value:string -> StructuredFormatDisplayAttribute
/// 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.
member Value : string
namespace Microsoft.FSharp.Core
/// Adding this attribute to a record, union or struct type confirms the automatic
/// generation of overrides for 'System.Object.Equals(obj)' and
/// 'System.Object.GetHashCode()' for the type.
[<Sealed>]
type StructuralEqualityAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> StructuralEqualityAttribute
namespace Microsoft.FSharp.Core
/// Adding this attribute to a record, union, exception, or struct type confirms the
/// automatic generation of implementations for 'System.IComparable' for the type.
[<Sealed>]
type StructuralComparisonAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> StructuralComparisonAttribute
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type causes it to be represented using a CLI struct.
[<Sealed>]
type StructAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> StructAttribute
/// 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.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Core.String
/// Returns a new string made by concatenating the given strings
/// with separator sep, that is a1 + sep + ... + sep + aN.
val concat : sep:string -> strings:seq<string> -> string
/// Applies the function action to each character in the string.
val iter : action:(char -> unit) -> str:string -> unit
/// Applies the function action to the index of each character in the string and the
/// character itself.
val iteri : action:(int -> char -> unit) -> str:string -> unit
/// Builds a new string whose characters are the results of applying the function mapping
/// to each of the characters of the input string.
val map : mapping:(char -> char) -> str:string -> string
/// Builds a new string whose characters are the results of applying the function mapping
/// to each character and index of the input string.
val mapi : mapping:(int -> char -> char) -> str:string -> string
/// Builds 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.
val collect : mapping:(char -> string) -> str:string -> string
/// Builds a new string containing only the characters of the input string
/// for which the given predicate returns "true".
val filter : predicate:(char -> bool) -> str:string -> string
/// Builds 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.
val init : count:int -> initializer:(int -> string) -> string
/// Tests if all characters in the string satisfy the given predicate.
val forall : predicate:(char -> bool) -> str:string -> bool
/// Tests if any character of the string satisfies the given predicate.
val exists : predicate:(char -> bool) -> str:string -> bool
/// Returns a string by concatenating count instances of str.
val replicate : count:int -> str:string -> string
/// Returns the length of the string.
val length : str:string -> int
namespace Microsoft.FSharp.Core
/// Indicates the relationship between a compiled entity in a CLI binary and an element in F# source code.
type SourceConstructFlags =
/// Indicates that the compiled entity has no relationship to an element in F# source code.
| None = 0
/// Indicates that the compiled entity is part of the representation of an F# union type declaration.
| SumType = 1
/// Indicates that the compiled entity is part of the representation of an F# record type declaration.
| RecordType = 2
/// Indicates that the compiled entity is part of the representation of an F# class or other object type declaration.
| ObjectType = 3
/// Indicates that the compiled entity is part of the representation of an F# record or union case field declaration.
| Field = 4
/// Indicates that the compiled entity is part of the representation of an F# exception declaration.
| Exception = 5
/// Indicates that the compiled entity is part of the representation of an F# closure.
| Closure = 6
/// Indicates that the compiled entity is part of the representation of an F# module declaration.
| Module = 7
/// Indicates that the compiled entity is part of the representation of an F# union case declaration.
| UnionCase = 8
/// Indicates that the compiled entity is part of the representation of an F# value declaration.
| Value = 9
/// The mask of values related to the kind of the compiled entity.
| KindMask = 31
/// Indicates that the compiled entity had private or internal representation in F# source code.
| NonPublicRepresentation = 32
namespace Microsoft.FSharp.Core
/// Adding this attribute to class definition makes it sealed, which means it may not
/// be extended or implemented.
type SealedAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : value:bool -> SealedAttribute
/// Creates an instance of the attribute.
new : unit -> SealedAttribute
/// The value of the attribute, indicating whether the type is sealed or not.
member Value : bool
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type, value or member requires that
/// uses of the construct must explicitly instantiate any generic type parameters.
[<Sealed>]
type RequiresExplicitTypeArgumentsAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> RequiresExplicitTypeArgumentsAttribute
namespace Microsoft.FSharp.Core
/// This attribute is used to indicate that references to the elements of a module, record or union
/// type require explicit qualified access.
[<Sealed>]
type RequireQualifiedAccessAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> RequireQualifiedAccessAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type ReflectedDefinitionAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> ReflectedDefinitionAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type ReferenceEqualityAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> ReferenceEqualityAttribute
namespace Microsoft.FSharp.Core
/// The type of mutable references. Use the functions [:=] and [!] to get and
/// set values of this type.
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpRef`1")>]
type Ref<'T> =
{
/// The current value of the reference cell
contents: 'T
}
/// The current value of the reference cell
member Value : 'T with get, set
namespace Microsoft.FSharp.Core
/// Indicates that, when a custom operator is used in a computation expression,
/// a parameter is automatically parameterized by the variable space of the computation expression
[<Sealed>]
type ProjectionParameterAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> ProjectionParameterAttribute
/// Extensible printf-style formatting for numbers and other datatypes
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
module Microsoft.FSharp.Core.Printf
/// Print to a System.Text.StringBuilder
val bprintf : builder:Text.StringBuilder -> format:Printf.BuilderFormat<'T> -> 'T
/// Print to a text writer.
val fprintf : textWriter:IO.TextWriter -> format:Printf.TextWriterFormat<'T> -> 'T
/// Print to a text writer, adding a newline
val fprintfn : textWriter:IO.TextWriter -> format:Printf.TextWriterFormat<'T> -> 'T
/// Formatted printing to stderr
val eprintf : format:Printf.TextWriterFormat<'T> -> 'T
/// Formatted printing to stderr, adding a newline
val eprintfn : format:Printf.TextWriterFormat<'T> -> 'T
/// Formatted printing to stdout
val printf : format:Printf.TextWriterFormat<'T> -> 'T
/// Formatted printing to stdout, adding a newline.
val printfn : format:Printf.TextWriterFormat<'T> -> 'T
/// Print to a string via an internal string buffer and return
/// the result as a string. Helper printers must return strings.
val sprintf : format:Printf.StringFormat<'T> -> 'T
/// bprintf, but call the given 'final' function to generate the result.
/// See kprintf.
val kbprintf : continutation:(unit -> 'Result) -> builder:Text.StringBuilder -> format:Printf.BuilderFormat<'T,'Result> -> 'T
/// fprintf, but call the given 'final' function to generate the result.
/// See kprintf.
val kfprintf : continutation:(unit -> 'Result) -> textWriter:IO.TextWriter -> format:Printf.TextWriterFormat<'T,'Result> -> 'T
/// 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.
val kprintf : continutation:(string -> 'Result) -> format:Printf.StringFormat<'T,'Result> -> 'T
/// sprintf, but call the given 'final' function to generate the result.
/// See kprintf.
val ksprintf : continutation:(string -> 'Result) -> format:Printf.StringFormat<'T,'Result> -> 'T
/// Print to a string buffer and raise an exception with the given
/// result. Helper printers must return strings.
val failwithf : format:Printf.StringFormat<'T,'Result> -> 'T
/// 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.
type BuilderFormat<'T, 'Result> = Format<'T,Text.StringBuilder,unit,'Result>
/// 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.
type StringFormat<'T, 'Result> = Format<'T,unit,string,'Result>
/// 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.
type TextWriterFormat<'T, 'Result> = Format<'T,IO.TextWriter,unit,'Result>
/// 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.
type BuilderFormat<'T> = Printf.BuilderFormat<'T,unit>
/// Represents a statically-analyzed format when formatting builds a string. The type parameter indicates the
/// arguments and return type of the format operation.
type StringFormat<'T> = Printf.StringFormat<'T,string>
/// 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.
type TextWriterFormat<'T> = Printf.TextWriterFormat<'T,unit>
namespace Microsoft.FSharp.Core
/// Type of a formatting expression.
type PrintfFormat<'Printer, 'State, 'Residue, 'Result, 'Tuple> =
inherit PrintfFormat<'Printer,'State,'Residue,'Result>
/// Construct a format string
new : value:string -> PrintfFormat<'Printer, 'State, 'Residue, 'Result, 'Tuple>
namespace Microsoft.FSharp.Core
/// Type of a formatting expression.
type PrintfFormat<'Printer, 'State, 'Residue, 'Result> =
/// Construct a format string
new : value:string -> PrintfFormat<'Printer, 'State, 'Residue, 'Result>
/// The raw text of the format string.
member Value : string
namespace Microsoft.FSharp.Core
/// This attribute is added automatically for all optional arguments.
[<Sealed>]
type OptionalArgumentAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> OptionalArgumentAttribute
namespace Microsoft.FSharp.Core
/// The type of optional values. When used from other CLI languages the
/// empty option is the null value.
[<DefaultAugmentation(false)>]
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (8))>]
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpOption`1")>]
type Option<'T> =
/// The representation of "No value"
| None
/// The representation of "Value of type 'T"
| Some of Value: 'T
/// Return 'true' if the option is a 'None' value.
member IsNone : bool
/// Return 'true' if the option is a 'Some' value.
member IsSome : bool
/// Get the value of a 'Some' option. A NullReferenceException is raised if the option is 'None'.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (2))>]
member Value : 'T
/// Create an option value that is a 'None' value.
static member None : 'T option
/// Create an option value that is a 'Some' value.
static member Some : value:'T -> 'T option
/// Basic operations on options.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
module Microsoft.FSharp.Core.Option
/// Returns true if the option is not None.
val isSome : option:'T option -> bool
/// Returns true if the option is None.
val isNone : option:'T option -> bool
/// Gets the value associated with the option.
val get : option:'T option -> 'T
/// count inp evaluates to match inp with None -> 0 | Some _ -> 1.
val count : option:'T option -> int
/// fold f s inp evaluates to match inp with None -> s | Some x -> f s x.
val fold : folder:('State -> 'T -> 'State) -> state:'State -> option:'T option -> 'State
/// fold f inp s evaluates to match inp with None -> s | Some x -> f x s.
val foldBack : folder:('T -> 'State -> 'State) -> option:'T option -> state:'State -> 'State
/// exists p inp evaluates to match inp with None -> false | Some x -> p x.
val exists : predicate:('T -> bool) -> option:'T option -> bool
/// forall p inp evaluates to match inp with None -> true | Some x -> p x.
val forall : predicate:('T -> bool) -> option:'T option -> bool
/// iter f inp executes match inp with None -> () | Some x -> f x.
val iter : action:('T -> unit) -> option:'T option -> unit
/// map f inp evaluates to match inp with None -> None | Some x -> Some (f x).
val map : mapping:('T -> 'U) -> option:'T option -> 'U option
/// bind f inp evaluates to match inp with None -> None | Some x -> f x
val bind : binder:('T -> 'U option) -> option:'T option -> 'U option
/// filter f inp evaluates to match inp with None -> None | Some x -> if f x then Some x else None.
val filter : predicate:('T -> bool) -> option:'T option -> 'T option
/// Convert the option to an array of length 0 or 1.
val toArray : option:'T option -> 'T []
/// Convert the option to a list of length 0 or 1.
val toList : option:'T option -> 'T list
/// An implementation module used to hold some private implementations of function
/// value invocation.
module Microsoft.FSharp.Core.OptimizedClosures
/// The CLI 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 CLI languages.
[<AbstractClass>]
type FSharpFunc<'T1, 'T2, 'U> =
inherit Microsoft.FSharp.Core.FSharpFunc<'T1,('T2 -> 'U)>
/// Construct an optimized function value that can accept two curried
/// arguments without intervening execution.
new : unit -> FSharpFunc<'T1, 'T2, 'U>
/// Invoke the optimized function value with two curried arguments
abstract member Invoke : arg1:'T1 * arg2:'T2 -> 'U
/// Adapt an F# first class function value to be an optimized function value that can
/// accept two curried arguments without intervening execution.
static member Adapt : func:('T1 -> 'T2 -> 'U) -> OptimizedClosures.FSharpFunc<'T1,'T2,'U>
/// The CLI 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 CLI languages.
[<AbstractClass>]
type FSharpFunc<'T1, 'T2, 'T3, 'U> =
inherit Microsoft.FSharp.Core.FSharpFunc<'T1,('T2 -> 'T3 -> 'U)>
/// Construct an optimized function value that can accept three curried
/// arguments without intervening execution.
new : unit -> FSharpFunc<'T1, 'T2, 'T3, 'U>
/// Invoke an F# first class function value that accepts three curried arguments
/// without intervening execution
abstract member Invoke : arg1:'T1 * arg2:'T2 * arg3:'T3 -> 'U
/// Adapt an F# first class function value to be an optimized function value that can
/// accept three curried arguments without intervening execution.
static member Adapt : func:('T1 -> 'T2 -> 'T3 -> 'U) -> OptimizedClosures.FSharpFunc<'T1,'T2,'T3,'U>
/// The CLI type used to represent F# function values that accept four curried arguments
/// without intervening execution. This type should not typically used directly from
/// either F# code or from other CLI languages.
[<AbstractClass>]
type FSharpFunc<'T1, 'T2, 'T3, 'T4, 'U> =
inherit Microsoft.FSharp.Core.FSharpFunc<'T1,('T2 -> 'T3 -> 'T4 -> 'U)>
/// Construct an optimized function value that can accept four curried
/// arguments without intervening execution.
new : unit -> FSharpFunc<'T1, 'T2, 'T3, 'T4, 'U>
/// Invoke an F# first class function value that accepts four curried arguments
/// without intervening execution
abstract member Invoke : arg1:'T1 * arg2:'T2 * arg3:'T3 * arg4:'T4 -> 'U
/// Adapt an F# first class function value to be an optimized function value that can
/// accept four curried arguments without intervening execution.
static member Adapt : func:('T1 -> 'T2 -> 'T3 -> 'T4 -> 'U) -> OptimizedClosures.FSharpFunc<'T1,'T2,'T3,'T4,'U>
/// The CLI type used to represent F# function values that accept five curried arguments
/// without intervening execution. This type should not typically used directly from
/// either F# code or from other CLI languages.
[<AbstractClass>]
type FSharpFunc<'T1, 'T2, 'T3, 'T4, 'T5, 'U> =
inherit Microsoft.FSharp.Core.FSharpFunc<'T1,('T2 -> 'T3 -> 'T4 -> 'T5 -> 'U)>
/// Construct an optimized function value that can accept five curried
/// arguments without intervening execution.
new : unit -> FSharpFunc<'T1, 'T2, 'T3, 'T4, 'T5, 'U>
/// Invoke an F# first class function value that accepts five curried arguments
/// without intervening execution
abstract member Invoke : arg1:'T1 * arg2:'T2 * arg3:'T3 * arg4:'T4 * arg5:'T5 -> 'U
/// Adapt an F# first class function value to be an optimized function value that can
/// accept five curried arguments without intervening execution.
static member Adapt : func:('T1 -> 'T2 -> 'T3 -> 'T4 -> 'T5 -> 'U) -> OptimizedClosures.FSharpFunc<'T1,'T2,'T3,'T4,'T5,'U>
/// Basic F# Operators. This module is automatically opened in all F# code.
[<AutoOpen>]
module Microsoft.FSharp.Core.Operators
/// Overloaded unary negation.
val inline ( ~- ) : n: ^T -> ^T when ^T : (static member ( ~- ) : unit -> ^T)
/// Overloaded addition operator
val inline ( + ) : x: ^T1 -> y: ^T2 -> ^T3 when ^T1 : (static member ( + ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( + ) : ^T1 * ^T2 -> ^T3)
/// Overloaded subtraction operator
val inline ( - ) : x: ^T1 -> y: ^T2 -> ^T3 when ^T1 : (static member ( - ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( - ) : ^T1 * ^T2 -> ^T3)
/// Overloaded multiplication operator
val inline ( * ) : x: ^T1 -> y: ^T2 -> ^T3 when ^T1 : (static member ( * ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( * ) : ^T1 * ^T2 -> ^T3)
/// Overloaded division operator
val inline ( / ) : x: ^T1 -> y: ^T2 -> ^T3 when ^T1 : (static member ( / ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( / ) : ^T1 * ^T2 -> ^T3)
/// Overloaded modulo operator
val inline ( % ) : x: ^T1 -> y: ^T2 -> ^T3 when ^T1 : (static member ( % ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( % ) : ^T1 * ^T2 -> ^T3)
/// Overloaded bitwise-AND operator
val inline ( &&& ) : x: ^T -> y: ^T -> ^T when ^T : (static member ( &&& ) : ^T * ^T -> ^T)
/// Overloaded bitwise-OR operator
val inline ( ||| ) : x: ^T -> y: ^T -> ^T when ^T : (static member ( ||| ) : ^T * ^T -> ^T)
/// Overloaded bitwise-XOR operator
val inline ( ^^^ ) : x: ^T -> y: ^T -> ^T when ^T : (static member ( ^^^ ) : ^T * ^T -> ^T)
/// Overloaded byte-shift left operator by a specified number of bits
val inline ( <<< ) : value: ^T -> shift:int32 -> ^T when ^T : (static member ( <<< ) : ^T * int32 -> ^T)
/// Overloaded byte-shift right operator by a specified number of bits
val inline ( >>> ) : value: ^T -> shift:int32 -> ^T when ^T : (static member ( >>> ) : ^T * int32 -> ^T)
/// Overloaded bitwise-NOT operator
val inline ( ~~~ ) : value: ^T -> ^T when ^T : (static member ( ~~~ ) : unit -> ^T)
/// Overloaded prefix-plus operator
val inline ( ~+ ) : value: ^T -> ^T when ^T : (static member ( ~+ ) : unit -> ^T)
/// Structural less-than comparison
val inline ( < ) : x:'T -> y:'T -> bool when 'T : comparison
/// Structural greater-than
val inline ( > ) : x:'T -> y:'T -> bool when 'T : comparison
/// Structural greater-than-or-equal
val inline ( >= ) : x:'T -> y:'T -> bool when 'T : comparison
/// Structural less-than-or-equal comparison
val inline ( <= ) : x:'T -> y:'T -> bool when 'T : comparison
/// Structural equality
val inline ( = ) : x:'T -> y:'T -> bool when 'T : equality
/// Structural inequality
val inline ( <> ) : x:'T -> y:'T -> bool when 'T : equality
/// Compose two functions, the function on the left being applied first
val inline ( >> ) : func1:('T1 -> 'T2) -> func2:('T2 -> 'T3) -> 'T1 -> 'T3
/// Compose two functions, the function on the right being applied first
val inline ( << ) : func2:('T2 -> 'T3) -> func1:('T1 -> 'T2) -> 'T1 -> 'T3
/// Apply a function to a value, the value being on the left, the function on the right
val inline ( |> ) : arg:'T1 -> func:('T1 -> 'U) -> 'U
/// Apply a function to two values, the values being a pair on the left, the function on the right
val inline ( ||> ) : arg1:'T1 * arg2:'T2 -> func:('T1 -> 'T2 -> 'U) -> 'U
/// Apply a function to three values, the values being a triple on the left, the function on the right
val inline ( |||> ) : arg1:'T1 * arg2:'T2 * arg3:'T3 -> func:('T1 -> 'T2 -> 'T3 -> 'U) -> 'U
/// Apply a function to a value, the value being on the right, the function on the left
val inline ( <| ) : func:('T -> 'U) -> arg1:'T -> 'U
/// Apply a function to two values, the values being a pair on the right, the function on the left
val inline ( <|| ) : func:('T1 -> 'T2 -> 'U) -> arg1:'T1 * arg2:'T2 -> 'U
/// Apply a function to three values, the values being a triple on the right, the function on the left
val inline ( <||| ) : func:('T1 -> 'T2 -> 'T3 -> 'U) -> arg1:'T1 * arg2:'T2 * arg3:'T3 -> 'U
/// Used to specify a default value for an optional argument in the implementation of a function
val defaultArg : arg:'T option -> defaultValue:'T -> 'T
/// Concatenate two strings. The operator '+' may also be used.
val ( ^ ) : s1:string -> s2:string -> string
/// Raises an exception
val raise : exn:Exception -> 'T
/// Rethrows an exception. This should only be used when handling an exception
val inline rethrow : unit -> 'T
/// Rethrows an exception. This should only be used when handling an exception
val inline reraise : unit -> 'T
/// Builds a System.Exception object.
val Failure : message:string -> exn
/// Matches System.Exception objects whose runtime type is precisely System.Exception
val (|Failure|_|) : error:exn -> string option
/// Return the first element of a tuple, fst (a,b) = a.
val fst : tuple:('T1 * 'T2) -> 'T1
/// Return the second element of a tuple, snd (a,b) = b.
val snd : tuple:('T1 * 'T2) -> 'T2
/// Generic comparison.
val inline compare : e1:'T -> e2:'T -> int when 'T : comparison
/// Maximum based on generic comparison
val inline max : e1:'T -> e2:'T -> 'T when 'T : comparison
/// Minimum based on generic comparison
val inline min : e1:'T -> e2:'T -> 'T when 'T : comparison
/// Ignore the passed value. This is often used to throw away results of a computation.
val inline ignore : value:'T -> unit
/// Unboxes a strongly typed value. This is the inverse of box, unbox<t>(box<t> a) equals a.
val inline unbox : value:obj -> 'T
/// Boxes a strongly typed value.
val inline box : value:'T -> obj
/// Throw a System.Exception exception.
val failwith : message:string -> 'T
/// Throw a System.ArgumentException exception with
/// the given argument name and message.
val inline invalidArg : argumentName:string -> message:string -> 'T
/// Throw a System.ArgumentNullException exception
val inline nullArg : argumentName:string -> 'T
/// Throw a System.InvalidOperationException exception
val inline invalidOp : message:string -> 'T
/// The identity function
val id : x:'T -> 'T
/// Create a mutable reference cell
val ref : value:'T -> 'T ref
/// Assign to a mutable reference cell
val ( := ) : cell:'T ref -> value:'T -> unit
/// Dereference a mutable reference cell
val ( ! ) : cell:'T ref -> 'T
/// Decrement a mutable reference cell containing an integer
val decr : cell:int ref -> unit
/// Increment a mutable reference cell containing an integer
val incr : cell:int ref -> unit
/// Concatenate two lists.
val ( @ ) : list1:'T list -> list2:'T list -> 'T list
/// Negate a logical value. not true equals false and not false equals true
val inline not : value:bool -> bool
/// Builds a sequence using sequence expression syntax
val seq : sequence:seq<'T> -> seq<'T>
/// Exit the current hardware isolated process, if security settings permit,
/// otherwise raise an exception. Calls System.Environment.Exit.
val exit : exitcode:int -> 'T
/// Equivalent to System.Double.PositiveInfinity
val infinity : float
/// Equivalent to System.Double.NaN
val nan : float
/// Equivalent to System.Single.PositiveInfinity
val infinityf : float32
/// Equivalent to System.Single.NaN
val nanf : float32
/// Reads the value of the property System.Console.In.
val stdin : IO.TextReader
/// Reads the value of the property System.Console.Error.
val stderr : IO.TextWriter
/// Reads the value of the property System.Console.Out.
val stdout : IO.TextWriter
/// The standard overloaded range operator, e.g. [n..m] for lists, seq {n..m} for sequences
val inline ( .. ) : start: ^T -> finish: ^T -> seq< ^T> when ^T : (static member ( + ) : ^T * ^T -> ^T) and ^T : (static member One : ^T) and ^T : comparison
/// The standard overloaded skip range operator, e.g. [n..skip..m] for lists, seq {n..skip..m} for sequences
val inline ( .. .. ) : start: ^T -> step: ^Step -> finish: ^T -> seq< ^T> when ^T : (static member ( + ) : ^T * ^Step -> ^T) and ^T : comparison and ^Step : (static member ( + ) : ^T * ^Step -> ^T) and ^Step : (static member Zero : ^Step)
/// Execute the function as a mutual-exclusion region using the input value as a lock.
val inline lock : lockObject:'Lock -> action:(unit -> 'T) -> 'T when 'Lock : not struct
/// 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.
val using : resource:'T -> action:('T -> 'U) -> 'U when 'T :> IDisposable
/// Generate a System.Type runtime representation of a static type.
/// The static type is still maintained on the value returned.
val typeof : Type
/// 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.
val typedefof : Type
/// Returns the internal size of a type in bytes. For example, sizeof<int> returns 4.
val sizeof : int
/// 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.
val inline hash : obj:'T -> int when 'T : equality
/// 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.
val inline limitedHash : limit:int -> obj:'T -> int when 'T : equality
/// Absolute value of the given number.
val inline abs : value: ^T -> ^T when ^T : (static member Abs : unit -> ^T)
/// Inverse cosine of the given number
val inline acos : value: ^T -> ^T when ^T : (static member Acos : unit -> ^T)
/// Inverse sine of the given number
val inline asin : value: ^T -> ^T when ^T : (static member Asin : unit -> ^T)
/// Inverse tangent of the given number
val inline atan : value: ^T -> ^T when ^T : (static member Atan : unit -> ^T)
/// Inverse tangent of x/y where x and y are specified separately
val inline atan2 : y: ^T1 -> x: ^T1 -> 'T2 when ^T1 : (static member Atan2 : ^T1 * ^T1 -> 'T2)
/// Ceiling of the given number
val inline ceil : value: ^T -> ^T when ^T : (static member Ceiling : unit -> ^T)
/// Exponential of the given number
val inline exp : value: ^T -> ^T when ^T : (static member Exp : unit -> ^T)
/// Floor of the given number
val inline floor : value: ^T -> ^T when ^T : (static member Floor : unit -> ^T)
/// Sign of the given number
val inline sign : value: ^T -> int when ^T : (member Sign : int)
/// Round the given number
val inline round : value: ^T -> ^T when ^T : (static member Round : unit -> ^T)
/// Natural logarithm of the given number
val inline log : value: ^T -> ^T when ^T : (static member Log : unit -> ^T)
/// Logarithm to base 10 of the given number
val inline log10 : value: ^T -> ^T when ^T : (static member Log10 : unit -> ^T)
/// Square root of the given number
val inline sqrt : value: ^T -> ^U when ^T : (static member Sqrt : unit -> ^U)
/// Cosine of the given number
val inline cos : value: ^T -> ^T when ^T : (static member Cos : unit -> ^T)
/// Hyperbolic cosine of the given number
val inline cosh : value: ^T -> ^T when ^T : (static member Cosh : unit -> ^T)
/// Sine of the given number
val inline sin : value: ^T -> ^T when ^T : (static member Sin : unit -> ^T)
/// Hyperbolic sine of the given number
val inline sinh : value: ^T -> ^T when ^T : (static member Sinh : unit -> ^T)
/// Tangent of the given number
val inline tan : value: ^T -> ^T when ^T : (static member Tan : unit -> ^T)
/// Hyperbolic tangent of the given number
val inline tanh : value: ^T -> ^T when ^T : (static member Tanh : unit -> ^T)
/// Overloaded truncate operator.
val inline truncate : value: ^T -> ^T when ^T : (static member Truncate : unit -> ^T)
/// Overloaded power operator.
val inline ( ** ) : x: ^T -> y: ^U -> ^T when ^T : (static member Pow : ^T * ^U -> ^T)
/// Overloaded power operator. If n > 0 then equivalent to x*...*x for n occurrences of x.
val inline pown : x: ^T -> n:int -> ^T when ^T : (static member One : ^T) and ^T : (static member ( * ) : ^T * ^T -> ^T) and ^T : (static member ( / ) : ^T * ^T -> ^T)
/// Converts the argument to byte. This is a direct conversion for all
/// primitive numeric types. For strings, the input is converted using Byte.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline byte : value: ^T -> byte when ^T : (static member op_Explicit : unit -> byte)
/// 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 an appropriate
/// static conversion method on the input type.
val inline sbyte : value: ^T -> sbyte when ^T : (static member op_Explicit : unit -> sbyte)
/// 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 an appropriate
/// static conversion method on the input type.
val inline int16 : value: ^T -> int16 when ^T : (static member op_Explicit : unit -> int16)
/// 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 an appropriate
/// static conversion method on the input type.
val inline uint16 : value: ^T -> uint16 when ^T : (static member op_Explicit : unit -> uint16)
/// 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 an appropriate
/// static conversion method on the input type.
val inline int : value: ^T -> int when ^T : (static member op_Explicit : unit -> int)
/// Converts the argument to a particular enum type.
val inline enum : value:int32 -> ^U when 'U : enum<int32>
/// 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 an appropriate
/// static conversion method on the input type.
val inline int32 : value: ^T -> int32 when ^T : (static member op_Explicit : unit -> int32)
/// 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 an appropriate
/// static conversion method on the input type.
val inline uint32 : value: ^T -> uint32 when ^T : (static member op_Explicit : unit -> uint32)
/// 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 an appropriate
/// static conversion method on the input type.
val inline int64 : value: ^T -> int64 when ^T : (static member op_Explicit : unit -> int64)
/// 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 an appropriate
/// static conversion method on the input type.
val inline uint64 : value: ^T -> uint64 when ^T : (static member op_Explicit : unit -> uint64)
/// 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 an appropriate
/// static conversion method on the input type.
val inline float32 : value: ^T -> float32 when ^T : (static member op_Explicit : unit -> float32)
/// 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 an appropriate
/// static conversion method on the input type.
val inline float : value: ^T -> float when ^T : (static member op_Explicit : unit -> float)
/// Converts the argument to signed native integer. This is a direct conversion for all
/// primitive numeric types. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline nativeint : value: ^T -> nativeint when ^T : (static member op_Explicit : unit -> nativeint)
/// Converts the argument to unsigned native integer using a direct conversion for all
/// primitive numeric types. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline unativeint : value: ^T -> unativeint when ^T : (static member op_Explicit : unit -> unativeint)
/// Converts the argument to a string using ToString.
val inline string : value: ^T -> string
/// Converts the argument to System.Decimal using a direct conversion for all
/// primitive numeric types. For strings, the input is converted using UInt64.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline decimal : value: ^T -> decimal when ^T : (static member op_Explicit : unit -> decimal)
/// 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
/// input types the operation requires an appropriate static conversion method on the input type.
val inline char : value: ^T -> char when ^T : (static member op_Explicit : unit -> char)
/// An active pattern to match values of type System.Collections.Generic.KeyValuePair
val (|KeyValue|) : keyValuePair:Collections.Generic.KeyValuePair<'Key,'Value> -> 'Key * 'Value
/// A module of compiler intrinsic functions for efficient implementations of F# integer ranges
/// and dynamic invocations of other F# operators
module OperatorIntrinsics =
/// Gets a slice of an array
val inline GetArraySlice : source:'T [] -> start:int option -> finish:int option -> 'T []
/// Sets a slice of an array
val inline SetArraySlice : target:'T [] -> start:int option -> finish:int option -> source:'T [] -> unit
/// Gets a region slice of an array
val GetArraySlice2D : source:'T [,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> 'T [,]
/// Gets a vector slice of a 2D array. The index of the first dimension is fixed.
val inline GetArraySlice2DFixed1 : source:'T [,] -> index1:int -> start2:int option -> finish2:int option -> 'T []
/// Gets a vector slice of a 2D array. The index of the second dimension is fixed.
val inline GetArraySlice2DFixed2 : source:'T [,] -> start1:int option -> finish1:int option -> index2:int -> 'T []
/// Sets a region slice of an array
val SetArraySlice2D : target:'T [,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> source:'T [,] -> unit
/// Sets a vector slice of a 2D array. The index of the first dimension is fixed.
val inline SetArraySlice2DFixed1 : target:'T [,] -> index1:int -> start2:int option -> finish2:int option -> source:'T [] -> unit
/// Sets a vector slice of a 2D array. The index of the second dimension is fixed.
val inline SetArraySlice2DFixed2 : target:'T [,] -> start1:int option -> finish1:int option -> index2:int -> source:'T [] -> unit
/// Gets a slice of an array
val GetArraySlice3D : source:'T [,,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> start3:int option -> finish3:int option -> 'T [,,]
/// Sets a slice of an array
val SetArraySlice3D : target:'T [,,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> start3:int option -> finish3:int option -> source:'T [,,] -> unit
/// Gets a slice of an array
val GetArraySlice4D : source:'T [,,,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> start3:int option -> finish3:int option -> start4:int option -> finish4:int option -> 'T [,,,]
/// Sets a slice of an array
val SetArraySlice4D : target:'T [,,,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> start3:int option -> finish3:int option -> start4:int option -> finish4:int option -> source:'T [,,,] -> unit
/// Gets a slice from a string
val inline GetStringSlice : source:string -> start:int option -> finish:int option -> string
/// Generate a range of integers
val RangeInt32 : start:int -> step:int -> stop:int -> seq<int>
/// Generate a range of float values
val RangeDouble : start:float -> step:float -> stop:float -> seq<float>
/// Generate a range of float32 values
val RangeSingle : start:float32 -> step:float32 -> stop:float32 -> seq<float32>
/// Generate a range of int64 values
val RangeInt64 : start:int64 -> step:int64 -> stop:int64 -> seq<int64>
/// Generate a range of uint64 values
val RangeUInt64 : start:uint64 -> step:uint64 -> stop:uint64 -> seq<uint64>
/// Generate a range of uint32 values
val RangeUInt32 : start:uint32 -> step:uint32 -> stop:uint32 -> seq<uint32>
/// Generate a range of nativeint values
val RangeIntPtr : start:nativeint -> step:nativeint -> stop:nativeint -> seq<nativeint>
/// Generate a range of unativeint values
val RangeUIntPtr : start:unativeint -> step:unativeint -> stop:unativeint -> seq<unativeint>
/// Generate a range of int16 values
val RangeInt16 : start:int16 -> step:int16 -> stop:int16 -> seq<int16>
/// Generate a range of uint16 values
val RangeUInt16 : start:uint16 -> step:uint16 -> stop:uint16 -> seq<uint16>
/// Generate a range of sbyte values
val RangeSByte : start:sbyte -> step:sbyte -> stop:sbyte -> seq<sbyte>
/// Generate a range of byte values
val RangeByte : start:byte -> step:byte -> stop:byte -> seq<byte>
/// Generate a range of char values
val RangeChar : start:char -> stop:char -> seq<char>
/// Generate a range of values using the given zero, add, start, step and stop values
val RangeGeneric : one:'T -> add:('T -> 'T -> 'T) -> start:'T -> stop:'T -> seq<'T>
/// Generate a range of values using the given zero, add, start, step and stop values
val RangeStepGeneric : zero:'Step -> add:('T -> 'Step -> 'T) -> start:'T -> step:'Step -> stop:'T -> seq<'T>
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val AbsDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val AcosDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val AsinDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val AtanDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val Atan2Dynamic : y:'T1 -> x:'T1 -> 'T2
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val CeilingDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val ExpDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val FloorDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val TruncateDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val RoundDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val SignDynamic : 'T -> int
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val LogDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val Log10Dynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val SqrtDynamic : 'T1 -> 'T2
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val CosDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val CoshDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val SinDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val SinhDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val TanDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val TanhDynamic : x:'T -> 'T
/// This is a library intrinsic. Calls to this function may be generated by evaluating quotations.
val PowDynamic : x:'T -> y:'U -> 'T
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'byte'
val PowByte : x:byte -> n:int -> byte
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'sbyte'
val PowSByte : x:sbyte -> n:int -> sbyte
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'int16'
val PowInt16 : x:int16 -> n:int -> int16
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'uint16'
val PowUInt16 : x:uint16 -> n:int -> uint16
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'int32'
val PowInt32 : x:int32 -> n:int -> int32
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'uint32'
val PowUInt32 : x:uint32 -> n:int -> uint32
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'int64'
val PowInt64 : x:int64 -> n:int -> int64
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'uint64'
val PowUInt64 : x:uint64 -> n:int -> uint64
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'nativeint'
val PowIntPtr : x:nativeint -> n:int -> nativeint
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'unativeint'
val PowUIntPtr : x:unativeint -> n:int -> unativeint
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'float32'
val PowSingle : x:float32 -> n:int -> float32
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'float'
val PowDouble : x:float -> n:int -> float
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'decimal'
val PowDecimal : x:decimal -> n:int -> decimal
/// This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator
val PowGeneric : one:'T * mul:('T -> 'T -> 'T) * value:'T * exponent:int -> 'T
/// This module contains basic operations which do not apply runtime and/or static checks
module Unchecked =
/// Unboxes a strongly typed value. This is the inverse of box, unbox<t>(box<t> a) equals a.
val inline unbox : obj -> 'T
/// Generate a default 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.
val defaultof : 'T
/// Perform generic comparison on two values where the type of the values is not
/// statically required to have the 'comparison' constraint.
val inline compare : 'T -> 'T -> int
/// Perform generic equality on two values where the type of the values is not
/// statically required to satisfy the 'equality' constraint.
val inline equals : 'T -> 'T -> bool
/// Perform generic hashing on a value where the type of the value is not
/// statically required to satisfy the 'equality' constraint.
val inline hash : 'T -> int
/// This module contains the basic arithmetic operations with overflow checks.
module Checked =
/// Overloaded unary negation (checks for overflow)
val inline ( ~- ) : value: ^T -> ^T when ^T : (static member ( ~- ) : unit -> ^T)
/// Overloaded subtraction operator (checks for overflow)
val inline ( - ) : x: ^T1 -> y: ^T2 -> ^T3 when ^T1 : (static member ( - ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( - ) : ^T1 * ^T2 -> ^T3)
/// Overloaded addition operator (checks for overflow)
val inline ( + ) : x: ^T1 -> y: ^T2 -> ^T3 when ^T1 : (static member ( + ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( + ) : ^T1 * ^T2 -> ^T3)
/// Overloaded multiplication operator (checks for overflow)
val inline ( * ) : x: ^T1 -> y: ^T2 -> ^T3 when ^T1 : (static member ( * ) : ^T1 * ^T2 -> ^T3) and ^T2 : (static member ( * ) : ^T1 * ^T2 -> ^T3)
/// Converts the argument to byte. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.Byte.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline byte : value: ^T -> byte when ^T : (static member op_Explicit : unit -> byte)
/// Converts the argument to sbyte. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.SByte.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline sbyte : value: ^T -> sbyte when ^T : (static member op_Explicit : unit -> sbyte)
/// Converts the argument to int16. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.Int16.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline int16 : value: ^T -> int16 when ^T : (static member op_Explicit : unit -> int16)
/// Converts the argument to uint16. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.UInt16.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline uint16 : value: ^T -> uint16 when ^T : (static member op_Explicit : unit -> uint16)
/// Converts the argument to int. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.Int32.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline int : value: ^T -> int when ^T : (static member op_Explicit : unit -> int)
/// Converts the argument to int32. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.Int32.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline int32 : value: ^T -> int32 when ^T : (static member op_Explicit : unit -> int32)
/// Converts the argument to uint32. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.UInt32.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline uint32 : value: ^T -> uint32 when ^T : (static member op_Explicit : unit -> uint32)
/// Converts the argument to int64. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.Int64.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline int64 : value: ^T -> int64 when ^T : (static member op_Explicit : unit -> int64)
/// Converts the argument to uint64. This is a direct, checked conversion for all
/// primitive numeric types. For strings, the input is converted using System.UInt64.Parse()
/// with InvariantCulture settings. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline uint64 : value: ^T -> uint64 when ^T : (static member op_Explicit : unit -> uint64)
/// Converts the argument to nativeint. This is a direct, checked conversion for all
/// primitive numeric types. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline nativeint : value: ^T -> nativeint when ^T : (static member op_Explicit : unit -> nativeint)
/// Converts the argument to unativeint. This is a direct, checked conversion for all
/// primitive numeric types. Otherwise the operation requires an appropriate
/// static conversion method on the input type.
val inline unativeint : value: ^T -> unativeint when ^T : (static member op_Explicit : unit -> unativeint)
/// Converts the argument to char. Numeric inputs are converted using a checked
/// conversion according to the UTF-16 encoding for characters. String inputs must
/// be exactly one character long. For other input types the operation requires an
/// appropriate static conversion method on the input type.
val inline char : value: ^T -> char when ^T : (static member op_Explicit : unit -> char)
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
[<AutoOpen>]
module Microsoft.FSharp.Core.NumericLiterals
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
module NumericLiteralI =
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
val FromZero : unit -> 'T
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
val FromOne : unit -> 'T
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
val FromInt32 : value:int32 -> 'T
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
val FromInt64 : value:int64 -> 'T
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
val FromString : text:string -> 'T
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
val FromInt64Dynamic : value:int64 -> obj
/// Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI'
val FromStringDynamic : text:string -> obj
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type indicates it is a type where equality is an abnormal operation.
/// This means that the type does not satisfy the F# 'equality' constraint. Within the bounds of the
/// F# type system, this helps ensure that the F# generic equality function is not instantiated directly
/// at this type. The attribute and checking does not constrain the use of comparison with base or child
/// types of this type.
[<Sealed>]
type NoEqualityAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> NoEqualityAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type NoDynamicInvocationAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> NoDynamicInvocationAttribute
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type indicates it is a type where comparison is an abnormal operation.
/// This means that the type does not satisfy the F# 'comparison' constraint. Within the bounds of the
/// F# type system, this helps ensure that the F# generic comparison function is not instantiated directly
/// at this type. The attribute and checking does not constrain the use of comparison with base or child
/// types of this type.
[<Sealed>]
type NoComparisonAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> NoComparisonAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type MeasureAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> MeasureAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type MeasureAnnotatedAbbreviationAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> MeasureAnnotatedAbbreviationAttribute
namespace Microsoft.FSharp.Core
/// Non-exhaustive match failures will raise the MatchFailureException exception
exception MatchFailureException of string * int * int
namespace Microsoft.FSharp.Core
/// Adding this attribute to a value causes it to be compiled as a CLI constant literal.
[<Sealed>]
type LiteralAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> LiteralAttribute
/// Language primitives associated with the F# language
module Microsoft.FSharp.Core.LanguagePrimitives
/// Compare two values for equality using partial equivalence relation semantics ([nan] <> [nan])
val inline GenericEquality : e1:'T -> e2:'T -> bool when 'T : equality
/// Compare two values for equality using equivalence relation semantics ([nan] = [nan])
val inline GenericEqualityER : e1:'T -> e2:'T -> bool when 'T : equality
/// Compare two values for equality
val inline GenericEqualityWithComparer : comp:Collections.IEqualityComparer -> e1:'T -> e2:'T -> bool when 'T : equality
/// Compare two values
val inline GenericComparison : e1:'T -> e2:'T -> int when 'T : comparison
/// Compare two values. May be called as a recursive case from an implementation of System.IComparable to
/// ensure consistent NaN comparison semantics.
val inline GenericComparisonWithComparer : comp:Collections.IComparer -> e1:'T -> e2:'T -> int when 'T : comparison
/// Compare two values
val inline GenericLessThan : e1:'T -> e2:'T -> bool when 'T : comparison
/// Compare two values
val inline GenericGreaterThan : e1:'T -> e2:'T -> bool when 'T : comparison
/// Compare two values
val inline GenericLessOrEqual : e1:'T -> e2:'T -> bool when 'T : comparison
/// Compare two values
val inline GenericGreaterOrEqual : e1:'T -> e2:'T -> bool when 'T : comparison
/// Take the minimum of two values structurally according to the order given by GenericComparison
val inline GenericMinimum : e1:'T -> e2:'T -> 'T when 'T : comparison
/// Take the maximum of two values structurally according to the order given by GenericComparison
val inline GenericMaximum : e1:'T -> e2:'T -> 'T when 'T : comparison
/// Reference/physical equality.
/// True if the inputs are reference-equal, false otherwise.
val inline PhysicalEquality : e1:'T -> e2:'T -> bool when 'T : not struct
/// The physical hash. Hashes on the object identity, except for value types,
/// where we hash on the contents.
val inline PhysicalHash : obj:'T -> int when 'T : not struct
/// 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.
val GenericEqualityComparer : Collections.IEqualityComparer
/// 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. This equality comparer has equivalence
/// relation semantics ([nan] = [nan]).
val GenericEqualityERComparer : Collections.IEqualityComparer
/// A static F# comparer object
val GenericComparer : Collections.IComparer
/// Make an F# comparer object for the given type
val FastGenericComparer : Collections.Generic.IComparer<'T> when 'T : comparison
/// Make an F# hash/equality object for the given type
val FastGenericEqualityComparer : Collections.Generic.IEqualityComparer<'T> when 'T : equality
/// Make an F# hash/equality object for the given type using node-limited hashing when hashing F#
/// records, lists and union types.
val inline FastLimitedGenericEqualityComparer : limit:int -> Collections.Generic.IEqualityComparer<'T> when 'T : equality
/// Make an F# hash/equality object for the given type
val FastGenericEqualityComparerFromTable : Collections.Generic.IEqualityComparer<'T> when 'T : equality
/// Make an F# comparer object for the given type
val FastGenericComparerFromTable : Collections.Generic.IComparer<'T> when 'T : comparison
/// 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.
val inline GenericHash : obj:'T -> int
/// Hash a value according to its structure. Use the given limit to restrict the hash when hashing F#
/// records, lists and union types.
val inline GenericLimitedHash : limit:int -> obj:'T -> int
/// Recursively hash a part of a value according to its structure.
val inline GenericHashWithComparer : comparer:Collections.IEqualityComparer -> obj:'T -> int
/// Build an enum value from an underlying value
val inline EnumOfValue : value:'T -> 'Enum when 'Enum : enum<'T>
/// Get the underlying value for an enum value
val inline EnumToValue : enum:'Enum -> 'T when 'Enum : enum<'T>
/// Creates a float value with units-of-measure
val inline FloatWithMeasure : float -> float<'Measure>
/// Creates a float32 value with units-of-measure
val inline Float32WithMeasure : float32 -> float32<'Measure>
/// Creates a decimal value with units-of-measure
val inline DecimalWithMeasure : decimal -> decimal<'Measure>
/// Creates an int32 value with units-of-measure
val inline Int32WithMeasure : int -> int<'Measure>
/// Creates an int64 value with units-of-measure
val inline Int64WithMeasure : int64 -> int64<'Measure>
/// Creates an int16 value with units-of-measure
val inline Int16WithMeasure : int16 -> int16<'Measure>
/// Creates an sbyte value with units-of-measure
val inline SByteWithMeasure : sbyte -> sbyte<'Measure>
/// Parse an int32 according to the rules used by the overloaded 'int32' conversion operator when applied to strings
val ParseInt32 : s:string -> int32
/// Parse an uint32 according to the rules used by the overloaded 'uint32' conversion operator when applied to strings
val ParseUInt32 : s:string -> uint32
/// Parse an int64 according to the rules used by the overloaded 'int64' conversion operator when applied to strings
val ParseInt64 : s:string -> int64
/// Parse an uint64 according to the rules used by the overloaded 'uint64' conversion operator when applied to strings
val ParseUInt64 : s:string -> uint64
/// Resolves to the zero value for any primitive numeric type or any type with a static member called 'Zero'.
val GenericZeroDynamic : unit -> 'T
/// Resolves to the value 'one' for any primitive numeric type or any type with a static member called 'One'.
val GenericOneDynamic : unit -> 'T
/// A compiler intrinsic that implements dynamic invocations to the '+' operator.
val AdditionDynamic : x:'T1 -> y:'T2 -> 'U
/// A compiler intrinsic that implements dynamic invocations to the checked '+' operator.
val CheckedAdditionDynamic : x:'T1 -> y:'T2 -> 'U
/// A compiler intrinsic that implements dynamic invocations to the '*' operator.
val MultiplyDynamic : x:'T1 -> y:'T2 -> 'U
/// A compiler intrinsic that implements dynamic invocations to the checked '*' operator.
val CheckedMultiplyDynamic : x:'T1 -> y:'T2 -> 'U
/// A compiler intrinsic that implements dynamic invocations for the DivideByInt primitive.
val DivideByIntDynamic : x:'T -> y:int -> 'T
/// Resolves to the zero value for any primitive numeric type or any type with a static member called 'Zero'
val GenericZero : ^T when ^T : (static member Zero : ^T)
/// Resolves to the value 'one' for any primitive numeric type or any type with a static member called 'One'
val GenericOne : ^T when ^T : (static member One : ^T)
/// Divides a value by an integer.
val inline DivideByInt : x: ^T -> y:int -> ^T when ^T : (static member DivideByInt : ^T * int -> ^T)
/// For internal use only
module ErrorStrings =
val InputSequenceEmptyString : string
val InputArrayEmptyString : string
val AddressOpNotFirstClassString : string
val NoNegateMinValueString : string
val InputMustBeNonNegativeString : string
/// The F# compiler emits calls to some of the functions in this module as part of the compiled form of some language constructs
module IntrinsicOperators =
/// Binary 'and'. When used as a binary operator the right hand value is evaluated only on demand.
val ( & ) : e1:bool -> e2:bool -> bool
/// Binary 'and'. When used as a binary operator the right hand value is evaluated only on demand
val ( && ) : e1:bool -> e2:bool -> bool
/// Binary 'or'. When used as a binary operator the right hand value is evaluated only on demand.
val ``or`` : e1:bool -> e2:bool -> bool
/// Binary 'or'. When used as a binary operator the right hand value is evaluated only on demand
val ( || ) : e1:bool -> e2:bool -> bool
/// Address-of. Uses of this value may result in the generation of unverifiable code.
val inline ( ~& ) : obj:'T -> byref<'T>
/// Address-of. Uses of this value may result in the generation of unverifiable code.
val inline ( ~&& ) : obj:'T -> nativeptr<'T> when 'T : unmanaged
/// The F# compiler emits calls to some of the functions in this module as part of the compiled form of some language constructs
module IntrinsicFunctions =
/// A compiler intrinsic that implements the ':?>' operator
val UnboxGeneric : source:obj -> 'T
/// A compiler intrinsic that implements the ':?>' operator
val inline UnboxFast : source:obj -> 'T
/// A compiler intrinsic that implements the ':?' operator
val TypeTestGeneric : source:obj -> bool
/// A compiler intrinsic that implements the ':?' operator
val inline TypeTestFast : source:obj -> bool
/// Primitive used by pattern match compilation
val inline GetString : source:string -> index:int -> char
/// This function implements calls to default constructors
/// acccessed by 'new' constraints.
val inline CreateInstance : unit -> 'T when 'T : (new : unit -> 'T)
/// This function implements parsing of decimal constants
val inline MakeDecimal : low:int -> medium:int -> high:int -> isNegative:bool -> scale:byte -> decimal
/// A compiler intrinsic for the efficient compilation of sequence expressions
val Dispose : resource:'T -> unit when 'T :> IDisposable
/// A compiler intrinsic for checking initialization soundness of recursive bindings
val FailInit : unit -> unit
/// A compiler intrinsic for checking initialization soundness of recursive static bindings
val FailStaticInit : unit -> unit
/// A compiler intrinsic for checking initialization soundness of recursive bindings
val CheckThis : 'T -> 'T when 'T : not struct
/// The standard overloaded associative (indexed) lookup operator
val inline GetArray : source:'T [] -> index:int -> 'T
/// The standard overloaded associative (2-indexed) lookup operator
val inline GetArray2D : source:'T [,] -> index1:int -> index2:int -> 'T
/// The standard overloaded associative (3-indexed) lookup operator
val inline GetArray3D : source:'T [,,] -> index1:int -> index2:int -> index3:int -> 'T
/// The standard overloaded associative (4-indexed) lookup operator
val inline GetArray4D : source:'T [,,,] -> index1:int -> index2:int -> index3:int -> index4:int -> 'T
/// The standard overloaded associative (indexed) mutation operator
val inline SetArray : target:'T [] -> index:int -> value:'T -> unit
/// The standard overloaded associative (2-indexed) mutation operator
val inline SetArray2D : target:'T [,] -> index1:int -> index2:int -> value:'T -> unit
/// The standard overloaded associative (3-indexed) mutation operator
val inline SetArray3D : target:'T [,,] -> index1:int -> index2:int -> index3:int -> value:'T -> unit
/// The standard overloaded associative (4-indexed) mutation operator
val inline SetArray4D : target:'T [,,,] -> index1:int -> index2:int -> index3:int -> index4:int -> value:'T -> unit
/// The F# compiler emits calls to some of the functions in this module as part of the compiled form of some language constructs
module HashCompare =
/// A primitive entry point used by the F# compiler for optimization purposes.
val PhysicalHashIntrinsic : input:'T -> int when 'T : not struct
/// A primitive entry point used by the F# compiler for optimization purposes.
val PhysicalEqualityIntrinsic : x:'T -> y:'T -> bool when 'T : not struct
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericHashIntrinsic : input:'T -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val LimitedGenericHashIntrinsic : limit:int -> input:'T -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericHashWithComparerIntrinsic : comp:Collections.IEqualityComparer -> input:'T -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericComparisonWithComparerIntrinsic : comp:Collections.IComparer -> x:'T -> y:'T -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericComparisonIntrinsic : x:'T -> y:'T -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericEqualityIntrinsic : x:'T -> y:'T -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericEqualityERIntrinsic : x:'T -> y:'T -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericEqualityWithComparerIntrinsic : comp:Collections.IEqualityComparer -> x:'T -> y:'T -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericLessThanIntrinsic : x:'T -> y:'T -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericGreaterThanIntrinsic : x:'T -> y:'T -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericGreaterOrEqualIntrinsic : x:'T -> y:'T -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val GenericLessOrEqualIntrinsic : x:'T -> y:'T -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastHashTuple2 : comparer:Collections.IEqualityComparer -> tuple:('T1 * 'T2) -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastHashTuple3 : comparer:Collections.IEqualityComparer -> tuple:('T1 * 'T2 * 'T3) -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastHashTuple4 : comparer:Collections.IEqualityComparer -> tuple:('T1 * 'T2 * 'T3 * 'T4) -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastHashTuple5 : comparer:Collections.IEqualityComparer -> tuple:('T1 * 'T2 * 'T3 * 'T4 * 'T5) -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastEqualsTuple2 : comparer:Collections.IEqualityComparer -> tuple1:('T1 * 'T2) -> tuple2:('T1 * 'T2) -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastEqualsTuple3 : comparer:Collections.IEqualityComparer -> tuple1:('T1 * 'T2 * 'T3) -> tuple2:('T1 * 'T2 * 'T3) -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastEqualsTuple4 : comparer:Collections.IEqualityComparer -> tuple1:('T1 * 'T2 * 'T3 * 'T4) -> tuple2:('T1 * 'T2 * 'T3 * 'T4) -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastEqualsTuple5 : comparer:Collections.IEqualityComparer -> tuple1:('T1 * 'T2 * 'T3 * 'T4 * 'T5) -> tuple2:('T1 * 'T2 * 'T3 * 'T4 * 'T5) -> bool
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastCompareTuple2 : comparer:Collections.IComparer -> tuple1:('T1 * 'T2) -> tuple2:('T1 * 'T2) -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastCompareTuple3 : comparer:Collections.IComparer -> tuple1:('T1 * 'T2 * 'T3) -> tuple2:('T1 * 'T2 * 'T3) -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastCompareTuple4 : comparer:Collections.IComparer -> tuple1:('T1 * 'T2 * 'T3 * 'T4) -> tuple2:('T1 * 'T2 * 'T3 * 'T4) -> int
/// A primitive entry point used by the F# compiler for optimization purposes.
val inline FastCompareTuple5 : comparer:Collections.IComparer -> tuple1:('T1 * 'T2 * 'T3 * 'T4 * 'T5) -> tuple2:('T1 * 'T2 * 'T3 * 'T4 * 'T5) -> int
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type causes it to be represented using a CLI interface.
[<Sealed>]
type InterfaceAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> InterfaceAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type GeneralizableValueAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> GeneralizableValueAttribute
namespace Microsoft.FSharp.Core
/// Helper functions for converting F# first class function values to and from CLI representaions
/// of functions using delegates.
[<AbstractClass>]
[<Sealed>]
type FuncConvert =
/// A utility function to convert function values from tupled to curried form
static member FuncFromTupled : func:('T1 * 'T2 * 'T3 -> 'U) -> 'T1 -> 'T2 -> 'T3 -> 'U
/// A utility function to convert function values from tupled to curried form
static member FuncFromTupled : func:('T1 * 'T2 -> 'U) -> 'T1 -> 'T2 -> 'U
/// A utility function to convert function values from tupled to curried form
static member FuncFromTupled : func:('T1 * 'T2 * 'T3 * 'T4 * 'T5 -> 'U) -> 'T1 -> 'T2 -> 'T3 -> 'T4 -> 'T5 -> 'U
/// A utility function to convert function values from tupled to curried form
static member FuncFromTupled : func:('T1 * 'T2 * 'T3 * 'T4 -> 'U) -> 'T1 -> 'T2 -> 'T3 -> 'T4 -> 'U
/// Convert the given Action delegate object to an F# function value
static member ToFSharpFunc : action:Action<'T> -> 'T -> unit
/// Convert the given Converter delegate object to an F# function value
static member ToFSharpFunc : converter:Converter<'T,'U> -> 'T -> 'U
namespace Microsoft.FSharp.Core
/// Type of a formatting expression.
type Format<'Printer, 'State, 'Residue, 'Result, 'Tuple> = PrintfFormat<'Printer,'State,'Residue,'Result,'Tuple>
namespace Microsoft.FSharp.Core
/// Type of a formatting expression.
type Format<'Printer, 'State, 'Residue, 'Result> = PrintfFormat<'Printer,'State,'Residue,'Result>
namespace Microsoft.FSharp.Core
/// The CLI type used to represent F# first-class type function values. This type is for use
/// by compiled F# code.
[<AbstractClass>]
type FSharpTypeFunc =
/// Construct an instance of an F# first class type function value
new : unit -> FSharpTypeFunc
/// Specialize the type function at a given type
abstract member Specialize : unit -> obj
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type FSharpInterfaceDataVersionAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : major:int * minor:int * release:int -> FSharpInterfaceDataVersionAttribute
/// The major version number of the F# version associated with the attribute
member Major : int
/// The minor version number of the F# version associated with the attribute
member Minor : int
/// The release number of the F# version associated with the attribute
member Release : int
namespace Microsoft.FSharp.Core
/// The CLI type used to represent F# function values. This type is not
/// typically used directly, though may be used from other CLI languages.
[<AbstractClass>]
type FSharpFunc<'T, 'U> =
/// Construct an instance of an F# first class function value
new : unit -> FSharpFunc<'T, 'U>
/// Invoke an F# first class function value with one argument
abstract member Invoke : func:'T -> 'U
/// Convert an value of type System.Converter to a F# first class function value
static member FromConverter : converter:Converter<'T,'U> -> 'T -> 'U
/// 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.
static member InvokeFast : func:FSharpFunc<'T,('U -> 'V -> 'W -> 'X)> * arg1:'T * arg2:'U * arg3:'V * arg4:'W -> 'X
/// 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.
static member InvokeFast : func:FSharpFunc<'T,('U -> 'V -> 'W -> 'X -> 'Y)> * arg1:'T * arg2:'U * arg3:'V * arg4:'W * arg5:'X -> 'Y
/// 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.
static member InvokeFast : func:FSharpFunc<'T,('U -> 'V)> * arg1:'T * arg2:'U -> 'V
/// 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.
static member InvokeFast : func:FSharpFunc<'T,('U -> 'V -> 'W)> * arg1:'T * arg2:'U * arg3:'V -> 'W
/// Convert an value of type System.Converter to a F# first class function value
static member op_Implicit : converter:Converter<'T,'U> -> 'T -> 'U
/// Convert an F# first class function value to a value of type System.Converter
static member op_Implicit : func:('T -> 'U) -> Converter<'T,'U>
/// Convert an F# first class function value to a value of type System.Converter
static member ToConverter : func:('T -> 'U) -> Converter<'T,'U>
[<AutoOpen>]
module Microsoft.FSharp.Core.ExtraTopLevelOperators
/// Print to stdout using the given format.
val printf : format:Printf.TextWriterFormat<'T> -> 'T
/// Print to stdout using the given format, and add a newline.
val printfn : format:Printf.TextWriterFormat<'T> -> 'T
/// Print to stderr using the given format.
val eprintf : format:Printf.TextWriterFormat<'T> -> 'T
/// Print to stderr using the given format, and add a newline.
val eprintfn : format:Printf.TextWriterFormat<'T> -> 'T
/// Print to a string using the given format.
val sprintf : format:Printf.StringFormat<'T> -> 'T
/// Print to a string buffer and raise an exception with the given
/// result. Helper printers must return strings.
val failwithf : format:Printf.StringFormat<'T,'Result> -> 'T
/// Print to a file using the given format.
val fprintf : textWriter:IO.TextWriter -> format:Printf.TextWriterFormat<'T> -> 'T
/// Print to a file using the given format, and add a newline.
val fprintfn : textWriter:IO.TextWriter -> format:Printf.TextWriterFormat<'T> -> 'T
/// Builds a set from a sequence of objects. The objects are indexed using generic comparison.
val set : elements:seq<'T> -> Set<'T> when 'T : comparison
/// Builds an aysnchronous workflow using computation expression syntax.
val async : AsyncBuilder
/// Converts the argument to 32-bit float.
val inline single : value: ^T -> single when ^T : (static member op_Explicit : unit -> single)
/// Converts the argument to 64-bit float.
val inline double : value: ^T -> float when ^T : (static member op_Explicit : unit -> double)
/// Converts the argument to byte.
val inline uint8 : value: ^T -> byte when ^T : (static member op_Explicit : unit -> byte)
/// Converts the argument to signed byte.
val inline int8 : value: ^T -> sbyte when ^T : (static member op_Explicit : unit -> sbyte)
/// Builds a read-only lookup table from a sequence of key/value pairs. The key objects are indexed using generic hashing and equality.
val dict : keyValuePairs:seq<'Key * 'Value> -> Collections.Generic.IDictionary<'Key,'Value> when 'Key : equality
/// Builds a 2D array from a sequence of sequences of elements.
val array2D : rows:seq<'T3337> -> 'T [,] when 'T3337 :> seq<'T>
/// Special prefix operator for splicing typed expressions into quotation holes.
val ( ~% ) : expression:Quotations.Expr<'T> -> 'T
/// Special prefix operator for splicing untyped expressions into quotation holes.
val ( ~%% ) : expression:Quotations.Expr -> 'T
/// An active pattern to force the execution of values of type Lazy<_>.
val (|Lazy|) : input:Lazy<'T> -> 'T
/// Builds a query using query syntax and operators.
val query : Linq.QueryBuilder
namespace Microsoft.FSharp.Core
/// This attribute is used to tag values that are part of an experimental library
/// feature.
[<Sealed>]
type ExperimentalAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : message:string -> ExperimentalAttribute
/// Indicates the warning message to be emitted when F# source code uses this construct
member Message : string
namespace Microsoft.FSharp.Core
/// This attribute is used to indicate a generic container type satisfies the F# 'equality'
/// constraint only if a generic argument also satisfies this constraint. For example, adding
/// this attribute to parameter 'T on a type definition C<'T> means that a type C<X> only supports
/// equality if the type X also supports equality and all other conditions for C<X> to support
/// equality are also met. The type C<'T> can still be used with other type arguments, but a type such
/// as C<(int -> int)> will not support equality because the type (int -> int) is an F# function type
/// and does not support equality.
[<Sealed>]
type EqualityConditionalOnAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> EqualityConditionalOnAttribute
namespace Microsoft.FSharp.Core
/// Adding this attribute to a function indicates it is the entrypoint for an application.
/// If this attribute is not specified for an EXE then the initialization implicit in the
/// module bindings in the last file in the compilation sequence are used as the entrypoint.
[<Sealed>]
type EntryPointAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> EntryPointAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type DefaultValueAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : check:bool -> DefaultValueAttribute
/// Creates an instance of the attribute
new : unit -> DefaultValueAttribute
/// Indicates if a constraint is asserted that the field type supports 'null'
member Check : bool
namespace Microsoft.FSharp.Core
/// 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 CLI class for that type.
[<Sealed>]
type DefaultAugmentationAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : value:bool -> DefaultAugmentationAttribute
/// The value of the attribute, indicating whether the type has a default augmentation or not
member Value : bool
namespace Microsoft.FSharp.Core
/// Indicates that a member on a computation builder type is a custom query operator,
/// and indicates the name of that operator.
[<Sealed>]
type CustomOperationAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : name:string -> CustomOperationAttribute
/// Indicates if the custom operation supports the use of 'into' immediately after the use of the operation in a query or other computation expression to consume the results of the operation
member AllowIntoPattern : bool with get, set
/// Indicates if the custom operation is an operation similar to a group join in a sequence computation, supporting two inputs and a correlation constraint, and generating a group
member IsLikeGroupJoin : bool with get, set
/// Indicates if the custom operation is an operation similar to a join in a sequence computation, supporting two inputs and a correlation constraint
member IsLikeJoin : bool with get, set
/// Indicates if the custom operation is an operation similar to a zip in a sequence computation, supporting two inputs
member IsLikeZip : bool with get, set
/// Indicates the name used for the 'on' part of the custom query operator for join-like operators
member JoinConditionWord : string with get, set
/// Indicates if the custom operation maintains the variable space of the query of computation expression
member MaintainsVariableSpace : bool with get, set
/// Indicates if the custom operation maintains the variable space of the query of computation expression through the use of a bind operation
member MaintainsVariableSpaceUsingBind : bool with get, set
/// Get the name of the custom operation when used in a query or other computation expression
member Name : string
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type indicates it is a type with a user-defined implementation of equality.
[<Sealed>]
type CustomEqualityAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> CustomEqualityAttribute
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type indicates it is a type with a user-defined implementation of comparison.
[<Sealed>]
type CustomComparisonAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> CustomComparisonAttribute
namespace Microsoft.FSharp.Core.CompilerServices
/// The TypeProviderXmlDocAttribute attribute can be added to types and members.
/// The language service will display the CommentText property from the attribute
/// in the appropriate place when the user hovers over a type or member.
type TypeProviderXmlDocAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : commentText:string -> TypeProviderXmlDocAttribute
member CommentText : string
namespace Microsoft.FSharp.Core.CompilerServices
/// Additional type attribute flags related to provided types
type TypeProviderTypeAttributes =
| SuppressRelocate = -2147483648
| IsErased = 1073741824
namespace Microsoft.FSharp.Core.CompilerServices
/// Indicates that a code editor should hide all System.Object methods from the intellisense menus for instances of a provided type
type TypeProviderEditorHideMethodsAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> TypeProviderEditorHideMethodsAttribute
namespace Microsoft.FSharp.Core.CompilerServices
type TypeProviderDefinitionLocationAttribute =
inherit System.Attribute
new : unit -> TypeProviderDefinitionLocationAttribute
member Column : int with get, set
member FilePath : string with get, set
member Line : int with get, set
namespace Microsoft.FSharp.Core.CompilerServices
/// If the class that implements ITypeProvider has a constructor that accepts TypeProviderConfig
/// then it will be constructed with an instance of TypeProviderConfig.
type TypeProviderConfig =
new : systemRuntimeContainsType:(string -> bool) -> TypeProviderConfig
/// Indicates if the type provider instance is used in an environment which executes provided code such as F# Interactive.
member IsHostedExecution : bool with get, set
/// Indicates if the type provider host responds to invalidation events for type provider instances.
member IsInvalidationSupported : bool with get, set
/// Get the referenced assemblies for the type provider instance.
member ReferencedAssemblies : string [] with get, set
/// Get the full path to use to resolve relative paths in any file name arguments given to the type provider instance.
member ResolutionFolder : string with get, set
/// Get the full path to referenced assembly that caused this type provider instance to be created.
member RuntimeAssembly : string with get, set
/// version of referenced system runtime assembly
member SystemRuntimeAssemblyVersion : Version with get, set
/// Checks if given type exists in target system runtime library
member SystemRuntimeContainsType : string -> bool
/// Get the full path to use for temporary files for the type provider instance.
member TemporaryFolder : string with get, set
namespace Microsoft.FSharp.Core.CompilerServices
/// Place on a class that implements ITypeProvider to extend the compiler
type TypeProviderAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> TypeProviderAttribute
namespace Microsoft.FSharp.Core.CompilerServices
/// Place attribute on runtime assembly to indicate that there is a corresponding design-time
/// assembly that contains a type provider. Runtime and designer assembly may be the same.
type TypeProviderAssemblyAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : assemblyName:string -> TypeProviderAssemblyAttribute
/// Creates an instance of the attribute
new : unit -> TypeProviderAssemblyAttribute
member AssemblyName : string
/// A group of functions used as part of the compiled representation of F# sequence expressions.
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers
/// The F# compiler emits calls to this function to
/// implement the while operator for F# sequence expressions.
val EnumerateWhile : guard:(unit -> bool) -> source:seq<'T> -> seq<'T>
/// The F# compiler emits calls to this function to
/// implement the try/finally operator for F# sequence expressions.
val EnumerateThenFinally : source:seq<'T> -> compensation:(unit -> unit) -> seq<'T>
/// The F# compiler emits calls to this function to implement the compiler-intrinsic
/// conversions from untyped System.Collections.IEnumerable sequences to typed sequences.
val EnumerateFromFunctions : create:(unit -> 'T) -> moveNext:('T -> bool) -> current:('T -> 'U) -> seq<'U>
/// The F# compiler emits calls to this function to implement the use operator for F# sequence
/// expressions.
val EnumerateUsing : resource:'T -> source:('T -> 'Collection) -> seq<'U> when 'T :> IDisposable and 'Collection :> seq<'U>
/// Creates an anonymous event with the given handlers.
val CreateEvent : addHandler:('Delegate -> unit) -> removeHandler:('Delegate -> unit) -> createHandler:((obj -> 'Args -> unit) -> 'Delegate) -> IEvent<'Delegate,'Args> when 'Delegate : delegate<'Args, unit> and 'Delegate :> Delegate
namespace Microsoft.FSharp.Core.CompilerServices
/// Represents the product of two measure expressions when returned as a generic argument of a provided type.
[<Class>]
type MeasureProduct<'Measure1, 'Measure2> =
namespace Microsoft.FSharp.Core.CompilerServices
/// Represents the '1' measure expression when returned as a generic argument of a provided type.
[<Class>]
type MeasureOne =
namespace Microsoft.FSharp.Core.CompilerServices
/// Represents the inverse of a measure expressions when returned as a generic argument of a provided type.
[<Class>]
type MeasureInverse<'Measure> =
namespace Microsoft.FSharp.Core.CompilerServices
/// Represents additional, optional information for a type provider component
[<Interface>]
type ITypeProvider2 =
/// Apply static arguments to a provided method that accepts static arguments.
abstract member ApplyStaticArgumentsForMethod : methodWithoutArguments:Reflection.MethodBase * methodNameWithArguments:string * staticArguments:obj [] -> Reflection.MethodBase
/// Get the static parameters for a provided method.
abstract member GetStaticParametersForMethod : methodWithoutArguments:Reflection.MethodBase -> Reflection.ParameterInfo []
namespace Microsoft.FSharp.Core.CompilerServices
/// Represents an instantiation of a type provider component.
[<Interface>]
type ITypeProvider =
inherit System.IDisposable
/// Triggered when an assumption changes that invalidates the resolutions so far reported by the provider
[<CLIEvent>]
abstract member add_Invalidate : EventHandler -> unit
/// Apply static arguments to a provided type that accepts static arguments.
abstract member ApplyStaticArguments : typeWithoutArguments:Type * typePathWithArguments:string [] * staticArguments:obj [] -> Type
/// Get the physical contents of the given logical provided assembly.
abstract member GetGeneratedAssemblyContents : assembly:Reflection.Assembly -> byte []
/// Called by the compiler to ask for an Expression tree to replace the given MethodBase with.
abstract member GetInvokerExpression : syntheticMethodBase:Reflection.MethodBase * parameters:Quotations.Expr [] -> Quotations.Expr
/// Namespace name the this TypeProvider injects types into.
abstract member GetNamespaces : unit -> CompilerServices.IProvidedNamespace []
/// Get the static parameters for a provided type.
abstract member GetStaticParameters : typeWithoutArguments:Type -> Reflection.ParameterInfo []
/// Triggered when an assumption changes that invalidates the resolutions so far reported by the provider
[<CLIEvent>]
abstract member Invalidate : IEvent<EventHandler,EventArgs>
/// Triggered when an assumption changes that invalidates the resolutions so far reported by the provider
[<CLIEvent>]
abstract member remove_Invalidate : EventHandler -> unit
namespace Microsoft.FSharp.Core.CompilerServices
/// Represents a namespace provided by a type provider component.
[<Interface>]
type IProvidedNamespace =
/// The sub-namespaces in this namespace. An optional member to prevent generation of namespaces until an outer namespace is explored.
abstract member GetNestedNamespaces : unit -> CompilerServices.IProvidedNamespace []
/// The top-level types
abstract member GetTypes : unit -> Type []
/// Namespace name the provider injects types into.
abstract member NamespaceName : string
/// Compilers call this method to query a type provider for a type name.
abstract member ResolveTypeName : typeName:string -> Type
namespace Microsoft.FSharp.Core.CompilerServices
/// The F# compiler emits implementations of this type for compiled sequence expressions.
[<AbstractClass>]
type GeneratedSequenceBase<'T> =
interface System.Collections.IEnumerable
interface System.Collections.Generic.IEnumerable<'T>
interface System.Collections.IEnumerator
interface System.Collections.Generic.IEnumerator<'T>
/// The F# compiler emits implementations of this type for compiled sequence expressions.
new : unit -> GeneratedSequenceBase<'T>
/// The F# compiler emits implementations of this type for compiled sequence expressions.
abstract member CheckClose : bool
/// The F# compiler emits implementations of this type for compiled sequence expressions.
abstract member Close : unit -> unit
/// The F# compiler emits implementations of this type for compiled sequence expressions.
abstract member GenerateNext : result:byref<Collections.Generic.IEnumerable<'T>> -> int
/// The F# compiler emits implementations of this type for compiled sequence expressions.
abstract member GetFreshEnumerator : unit -> Collections.Generic.IEnumerator<'T>
/// The F# compiler emits implementations of this type for compiled sequence expressions.
abstract member LastGenerated : 'T
namespace Microsoft.FSharp.Core
/// Indicates that a message should be emitted when F# source code uses this construct.
[<Sealed>]
type CompilerMessageAttribute =
inherit System.Attribute
/// Creates an instance of the attribute.
new : message:string * messageNumber:int -> CompilerMessageAttribute
/// Indicates if the message should indicate a compiler error. Error numbers less than
/// 10000 are considered reserved for use by the F# compiler and libraries.
member IsError : bool with get, set
/// Indicates if the construct should always be hidden in an editing environment.
member IsHidden : bool with get, set
/// Indicates the warning message to be emitted when F# source code uses this construct
member Message : string
/// Indicates the number associated with the message.
member MessageNumber : int
namespace Microsoft.FSharp.Core
/// Adding this attribute to a value or function definition in an F# module changes the name used
/// for the value in compiled CLI code.
[<Sealed>]
type CompiledNameAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : compiledName:string -> CompiledNameAttribute
/// The name of the value as it appears in compiled code
member CompiledName : string
namespace Microsoft.FSharp.Core
/// This attribute is inserted automatically by the F# compiler to tag
/// methods which are given the 'CompiledName' attribute. It is not intended
/// for use from user code.
[<Sealed>]
type CompilationSourceNameAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : sourceName:string -> CompilationSourceNameAttribute
/// Indicates the name of the entity in F# source code
member SourceName : string
namespace Microsoft.FSharp.Core
/// Indicates one or more adjustments to the compiled representation of an F# type or member.
[<Flags ()>]
type CompilationRepresentationFlags =
/// No special compilation representation.
| None = 0
/// Compile an instance member as 'static' .
| Static = 1
/// Compile a member as 'instance' even if null is used as a representation for this type.
| Instance = 2
/// append 'Module' to the end of a module whose name clashes with a type name in the same namespace.
| ModuleSuffix = 4
/// Permit the use of null as a representation for nullary discriminators in a discriminated union.
| UseNullAsTrueValue = 8
/// Compile a property as a CLI event.
| Event = 16
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type CompilationRepresentationAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : flags:CompilationRepresentationFlags -> CompilationRepresentationAttribute
/// Indicates one or more adjustments to the compiled representation of an F# type or member
member Flags : CompilationRepresentationFlags
namespace Microsoft.FSharp.Core
/// This attribute is inserted automatically by the F# compiler to tag types
/// and methods in the generated CLI code with flags indicating the correspondence
/// with original source constructs. It is used by the functions in the
/// Microsoft.FSharp.Reflection namespace to reverse-map compiled constructs to
/// their original forms. It is not intended for use from user code.
[<Sealed>]
type CompilationMappingAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : sourceConstructFlags:SourceConstructFlags * variantNumber:int * sequenceNumber:int -> CompilationMappingAttribute
/// Creates an instance of the attribute
new : sourceConstructFlags:SourceConstructFlags * sequenceNumber:int -> CompilationMappingAttribute
/// Creates an instance of the attribute
new : sourceConstructFlags:SourceConstructFlags -> CompilationMappingAttribute
/// Indicates the sequence number of the entity, if any, in a linear sequence of elements with F# source code
member SequenceNumber : int
/// Indicates the relationship between the compiled entity and F# source code
member SourceConstructFlags : SourceConstructFlags
/// Indicates the variant number of the entity, if any, in a linear sequence of elements with F# source code
member VariantNumber : int
namespace Microsoft.FSharp.Core
/// This attribute is generated automatically by the F# compiler to tag functions and members
/// that accept a partial application of some of their arguments and return a residual function
[<Sealed>]
type CompilationArgumentCountsAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : counts:int [] -> CompilationArgumentCountsAttribute
/// Indicates the number of arguments in each argument group
member Counts : Collections.Generic.IEnumerable<int>
namespace Microsoft.FSharp.Core
/// This attribute is used to indicate a generic container type satisfies the F# 'comparison'
/// constraint only if a generic argument also satisfies this constraint. For example, adding
/// this attribute to parameter 'T on a type definition C<'T> means that a type C<X> only supports
/// comparison if the type X also supports comparison and all other conditions for C<X> to support
/// comparison are also met. The type C<'T> can still be used with other type arguments, but a type such
/// as C<(int -> int)> will not support comparison because the type (int -> int) is an F# function type
/// and does not support comparison.
[<Sealed>]
type ComparisonConditionalOnAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> ComparisonConditionalOnAttribute
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type causes it to be represented using a CLI class.
[<Sealed>]
type ClassAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> ClassAttribute
namespace Microsoft.FSharp.Core
/// Helper types for active patterns with 7 choices.
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpChoice`7")>]
type Choice<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7> =
/// Choice 1 of 7 choices
| Choice1Of7 of 'T1
/// Choice 2 of 7 choices
| Choice2Of7 of 'T2
/// Choice 3 of 7 choices
| Choice3Of7 of 'T3
/// Choice 4 of 7 choices
| Choice4Of7 of 'T4
/// Choice 5 of 7 choices
| Choice5Of7 of 'T5
/// Choice 6 of 7 choices
| Choice6Of7 of 'T6
/// Choice 7 of 7 choices
| Choice7Of7 of 'T7
namespace Microsoft.FSharp.Core
/// Helper types for active patterns with 6 choices.
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpChoice`6")>]
type Choice<'T1, 'T2, 'T3, 'T4, 'T5, 'T6> =
/// Choice 1 of 6 choices
| Choice1Of6 of 'T1
/// Choice 2 of 6 choices
| Choice2Of6 of 'T2
/// Choice 3 of 6 choices
| Choice3Of6 of 'T3
/// Choice 4 of 6 choices
| Choice4Of6 of 'T4
/// Choice 5 of 6 choices
| Choice5Of6 of 'T5
/// Choice 6 of 6 choices
| Choice6Of6 of 'T6
namespace Microsoft.FSharp.Core
/// Helper types for active patterns with 5 choices.
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpChoice`5")>]
type Choice<'T1, 'T2, 'T3, 'T4, 'T5> =
/// Choice 1 of 5 choices
| Choice1Of5 of 'T1
/// Choice 2 of 5 choices
| Choice2Of5 of 'T2
/// Choice 3 of 5 choices
| Choice3Of5 of 'T3
/// Choice 4 of 5 choices
| Choice4Of5 of 'T4
/// Choice 5 of 5 choices
| Choice5Of5 of 'T5
namespace Microsoft.FSharp.Core
/// Helper types for active patterns with 4 choices.
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpChoice`4")>]
type Choice<'T1, 'T2, 'T3, 'T4> =
/// Choice 1 of 4 choices
| Choice1Of4 of 'T1
/// Choice 2 of 4 choices
| Choice2Of4 of 'T2
/// Choice 3 of 4 choices
| Choice3Of4 of 'T3
/// Choice 4 of 4 choices
| Choice4Of4 of 'T4
namespace Microsoft.FSharp.Core
/// Helper types for active patterns with 3 choices.
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpChoice`3")>]
type Choice<'T1, 'T2, 'T3> =
/// Choice 1 of 3 choices
| Choice1Of3 of 'T1
/// Choice 2 of 3 choices
| Choice2Of3 of 'T2
/// Choice 3 of 3 choices
| Choice3Of3 of 'T3
namespace Microsoft.FSharp.Core
/// Helper types for active patterns with 2 choices.
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpChoice`2")>]
type Choice<'T1, 'T2> =
/// Choice 1 of 2 choices
| Choice1Of2 of 'T1
/// Choice 2 of 2 choices
| Choice2Of2 of 'T2
namespace Microsoft.FSharp.Core
/// Adding this attribute to a record type causes it to be compiled to a CLI representation
/// with a default constructor with property getters and setters.
[<Sealed>]
type CLIMutableAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> CLIMutableAttribute
namespace Microsoft.FSharp.Core
/// Adding this attribute to a property with event type causes it to be compiled with as a CLI
/// metadata event, through a syntactic translation to a pair of 'add_EventName' and
/// 'remove_EventName' methods.
[<Sealed>]
type CLIEventAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> CLIEventAttribute
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type with value 'false' disables the behaviour where F# makes the
/// type Serializable by default.
[<Sealed>]
type AutoSerializableAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : value:bool -> AutoSerializableAttribute
/// The value of the attribute, indicating whether the type is automatically marked serializable or not
member Value : bool
namespace Microsoft.FSharp.Core
/// 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 opened.
[<Sealed>]
type AutoOpenAttribute =
inherit System.Attribute
/// Creates an attribute used to mark a namespace or module path to be 'automatically opened' when an assembly is referenced
new : path:string -> AutoOpenAttribute
/// Creates an attribute used to mark a module as 'automatically opened' when the enclosing namespace is opened
new : unit -> AutoOpenAttribute
/// Indicates the namespace or module to be automatically opened when an assembly is referenced
/// or an enclosing module opened.
member Path : string
namespace Microsoft.FSharp.Core
/// Adding this attribute to a type lets the 'null' literal be used for the type
/// within F# code. This attribute may only be added to F#-defined class or
/// interface types.
[<Sealed>]
type AllowNullLiteralAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> AllowNullLiteralAttribute
namespace Microsoft.FSharp.Core
/// 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.
[<Sealed>]
type AbstractClassAttribute =
inherit System.Attribute
/// Creates an instance of the attribute
new : unit -> AbstractClassAttribute
namespace Microsoft.FSharp.Control
type ``lazy``<'T> = Lazy<'T>
/// A module of extension members providing asynchronous operations for some basic Web operations.
[<AutoOpen>]
module Microsoft.FSharp.Control.WebExtensions
/// Returns an asynchronous computation that, when run, will wait for a response to the given WebRequest.
val AsyncGetResponse : unit -> Async<Net.WebResponse>
/// Returns an asynchronous computation that, when run, will wait for the download of the given URI.
val AsyncDownloadString : address:Uri -> Async<string>
/// Basic operations on first class event and other observable objects.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Control.Observable
/// Returns an observable for the merged observations from the sources.
/// The returned object propagates success and error values arising
/// from either source and completes when both the sources have completed.
val merge : source1:IObservable<'T> -> source2:IObservable<'T> -> IObservable<'T>
/// Returns an observable which transforms the observations of the source by the
/// given function. The transformation function is executed once for each
/// subscribed observer. The returned object also propagates error observations
/// arising from the source and completes when the source completes.
val map : mapping:('T -> 'U) -> source:IObservable<'T> -> IObservable<'U>
/// Returns an observable which filters the observations of the source
/// by the given function. The observable will see only those observations
/// for which the predicate returns true. The predicate is executed once for
/// each subscribed observer. The returned object also propagates error
/// observations arising from the source and completes when the source completes.
val filter : predicate:('T -> bool) -> source:IObservable<'T> -> IObservable<'T>
/// Returns two observables which partition the observations of the source by
/// the given function. The first will trigger observations for those values
/// for which the predicate returns true. The second will trigger observations
/// for those values where the predicate returns false. The predicate is
/// executed once for each subscribed observer. Both also propagate all error
/// observations arising from the source and each completes when the source
/// completes.
val partition : predicate:('T -> bool) -> source:IObservable<'T> -> IObservable<'T> * IObservable<'T>
/// Returns two observables which split the observations of the source by the
/// given function. The first will trigger observations x for which the
/// splitter returns Choice1Of2 x. The second will trigger observations
/// y for which the splitter returns Choice2Of2 y The splitter is
/// executed once for each subscribed observer. Both also propagate error
/// observations arising from the source and each completes when the source
/// completes.
val split : splitter:('T -> Choice<'U1,'U2>) -> source:IObservable<'T> -> IObservable<'U1> * IObservable<'U2>
/// Returns an observable which chooses a projection of observations from the source
/// using the given function. The returned object will trigger observations x
/// for which the splitter returns Some x. The returned object also propagates
/// all errors arising from the source and completes when the source completes.
val choose : chooser:('T -> 'U option) -> source:IObservable<'T> -> IObservable<'U>
/// Returns an observable which, for each observer, allocates an item of state
/// and applies the given accumulating function to successive values arising from
/// the input. The returned object will trigger observations for each computed
/// state value, excluding the initial value. The returned object propagates
/// all errors arising from the source and completes when the source completes.
val scan : collector:('U -> 'T -> 'U) -> state:'U -> source:IObservable<'T> -> IObservable<'U>
/// Creates an observer which permanently subscribes to the given observable and which calls
/// the given function for each observation.
val add : callback:('T -> unit) -> source:IObservable<'T> -> unit
/// Creates an observer which subscribes to the given observable and which calls
/// the given function for each observation.
val subscribe : callback:('T -> unit) -> source:IObservable<'T> -> IDisposable
/// Returns a new observable that triggers on the second and subsequent triggerings of the input observable.
/// The Nth triggering of the input observable 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.
val pairwise : source:IObservable<'T> -> IObservable<'T * 'T>
namespace Microsoft.FSharp.Control
/// A message-processing agent which executes an asynchronous computation.
[<Sealed>]
[<AutoSerializable(false)>]
[<CompiledName("FSharpMailboxProcessor`1")>]
type MailboxProcessor<'Msg> =
interface System.IDisposable
/// Creates an agent. The body function is used to generate the asynchronous
/// computation executed by the agent. This function is not executed until
/// Start is called.
new : body:(MailboxProcessor<'Msg> -> Async<unit>) * ?cancellationToken:Threading.CancellationToken -> MailboxProcessor<'Msg>
/// Occurs when the execution of the agent results in an exception.
[<CLIEvent>]
member add_Error : Handler<Exception> -> unit
/// Returns the number of unprocessed messages in the message queue of the agent.
member CurrentQueueLength : int
/// Raises a timeout exception if a message not received in this amount of time. By default
/// no timeout is used.
member DefaultTimeout : int with get, set
/// Occurs when the execution of the agent results in an exception.
[<CLIEvent>]
member Error : IEvent<Exception>
/// Posts a message to the message queue of the MailboxProcessor, asynchronously.
member Post : message:'Msg -> unit
/// Posts a message to an agent and await a reply on the channel, asynchronously.
member PostAndAsyncReply : buildMessage:(AsyncReplyChannel<'Reply> -> 'Msg) * ?timeout:int -> Async<'Reply>
/// Posts a message to an agent and await a reply on the channel, synchronously.
member PostAndReply : buildMessage:(AsyncReplyChannel<'Reply> -> 'Msg) * ?timeout:int -> 'Reply
/// Like AsyncPostAndReply, but returns None if no reply within the timeout period.
member PostAndTryAsyncReply : buildMessage:(AsyncReplyChannel<'Reply> -> 'Msg) * ?timeout:int -> Async<'Reply option>
/// Waits for a message. This will consume the first message in arrival order.
member Receive : ?timeout:int -> Async<'Msg>
/// Occurs when the execution of the agent results in an exception.
[<CLIEvent>]
member remove_Error : Handler<Exception> -> unit
/// Scans for a message by looking through messages in arrival order until scanner
/// returns a Some value. Other messages remain in the queue.
member Scan : scanner:('Msg -> Async<'T> option) * ?timeout:int -> Async<'T>
/// Starts the agent.
member Start : unit -> unit
/// Like PostAndReply, but returns None if no reply within the timeout period.
member TryPostAndReply : buildMessage:(AsyncReplyChannel<'Reply> -> 'Msg) * ?timeout:int -> 'Reply option
/// Waits for a message. This will consume the first message in arrival order.
member TryReceive : ?timeout:int -> Async<'Msg option>
/// Scans for a message by looking through messages in arrival order until scanner
/// returns a Some value. Other messages remain in the queue.
member TryScan : scanner:('Msg -> Async<'T> option) * ?timeout:int -> Async<'T option>
/// Creates and starts an agent. The body function is used to generate the asynchronous
/// computation executed by the agent.
static member Start : body:(MailboxProcessor<'Msg> -> Async<unit>) * ?cancellationToken:Threading.CancellationToken -> MailboxProcessor<'Msg>
namespace Microsoft.FSharp.Control
/// The type of delayed computations.
type Lazy<'T> = Lazy<'T>
/// Extensions related to Lazy values.
[<AutoOpen>]
module Microsoft.FSharp.Control.LazyExtensions
/// Creates a lazy computation that evaluates to the result of the given function when forced.
val Create : creator:(unit -> 'T) -> Lazy<'T>
/// Creates a lazy computation that evaluates to the given value when forced.
val CreateFromValue : value:'T -> Lazy<'T>
/// Forces the execution of this value and return its result. Same as Value. Mutual exclusion is used to
/// prevent other threads also computing the value.
val Force : unit -> 'T
namespace Microsoft.FSharp.Control
/// First class event values for CLI events conforming to CLI Framework standards.
[<Interface>]
type IEvent<'Delegate, 'Args when 'Delegate : delegate<'Args, unit> and 'Delegate :> Delegate> =
interface
inherit IDelegateEvent<'Delegate>
inherit System.IObservable<'Args>
end
namespace Microsoft.FSharp.Control
/// First-class listening points (i.e. objects that permit you to register a callback
/// activated when the event is triggered).
type IEvent<'T> = IEvent<Handler<'T>,'T>
namespace Microsoft.FSharp.Control
/// First class event values for arbitrary delegate types.
[<Interface>]
type IDelegateEvent<'Delegate when 'Delegate :> Delegate> =
/// 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.
abstract member AddHandler : handler:'Delegate -> unit
/// Remove a listener delegate from an event listener store.
abstract member RemoveHandler : handler:'Delegate -> unit
namespace Microsoft.FSharp.Control
/// A delegate type associated with the F# event type IEvent<_>
type ``Handler`1`` =
delegate of sender:obj * args:'T -> unit
namespace Microsoft.FSharp.Control
/// Event implementations for a delegate types following the standard .NET Framework convention of a first 'sender' argument.
[<CompiledName("FSharpEvent`2")>]
type Event<'Delegate, 'Args when 'Delegate : delegate<'Args, unit> and 'Delegate :> Delegate> =
/// Creates an event object suitable for delegate types following the standard .NET Framework convention of a first 'sender' argument.
new : unit -> Event<'Delegate, 'Args>
/// Publishes the event as a first class event value.
member Publish : IEvent<'Delegate,'Args>
/// Triggers the event using the given sender object and parameters. The sender object may be null.
member Trigger : sender:obj * args:'Args -> unit
namespace Microsoft.FSharp.Control
/// Event implementations for the IEvent<_> type.
[<CompiledName("FSharpEvent`1")>]
type Event<'T> =
/// Creates an observable object.
new : unit -> Event<'T>
/// Publishes an observation as a first class value.
member Publish : IEvent<'T>
/// Triggers an observation using the given parameters.
member Trigger : arg:'T -> unit
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Control.Event
/// Fires the output event when either of the input events fire.
val merge : event1:IEvent<'Del1,'T> -> event2:IEvent<'Del2,'T> -> IEvent<'T> when 'Del1 : delegate<'T, unit> and 'Del1 :> Delegate and 'Del2 : delegate<'T, unit> and 'Del2 :> Delegate
/// Returns a new event that passes values transformed by the given function.
val map : mapping:('T -> 'U) -> sourceEvent:IEvent<'Del,'T> -> IEvent<'U> when 'Del : delegate<'T, unit> and 'Del :> Delegate
/// Returns 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.
val filter : predicate:('T -> bool) -> sourceEvent:IEvent<'Del,'T> -> IEvent<'T> when 'Del : delegate<'T, unit> and 'Del :> Delegate
/// Returns 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.
val partition : predicate:('T -> bool) -> sourceEvent:IEvent<'Del,'T> -> IEvent<'T> * IEvent<'T> when 'Del : delegate<'T, unit> and 'Del :> Delegate
/// Returns 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.
val split : splitter:('T -> Choice<'U1,'U2>) -> sourceEvent:IEvent<'Del,'T> -> IEvent<'U1> * IEvent<'U2> when 'Del : delegate<'T, unit> and 'Del :> Delegate
/// Returns 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.
val choose : chooser:('T -> 'U option) -> sourceEvent:IEvent<'Del,'T> -> IEvent<'U> when 'Del : delegate<'T, unit> and 'Del :> Delegate
/// Returns 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.
val scan : collector:('U -> 'T -> 'U) -> state:'U -> sourceEvent:IEvent<'Del,'T> -> IEvent<'U> when 'Del : delegate<'T, unit> and 'Del :> Delegate
/// Runs the given function each time the given event is triggered.
val add : callback:('T -> unit) -> sourceEvent:IEvent<'Del,'T> -> unit when 'Del : delegate<'T, unit> and 'Del :> Delegate
/// Returns 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.
val pairwise : sourceEvent:IEvent<'Del,'T> -> IEvent<'T * 'T> when 'Del : delegate<'T, unit> and 'Del :> Delegate
namespace Microsoft.FSharp.Control
/// Event implementations for an arbitrary type of delegate.
[<CompiledName("FSharpDelegateEvent`1")>]
type DelegateEvent<'Delegate when 'Delegate :> Delegate> =
/// Creates an event object suitable for implementing an arbitrary type of delegate.
new : unit -> DelegateEvent<'Delegate>
/// Publishes the event as a first class event value.
member Publish : IDelegateEvent<'Delegate>
/// Triggers the event using the given parameters.
member Trigger : args:obj [] -> unit
/// A module of extension members providing asynchronous operations for some basic CLI types related to concurrency and I/O.
[<AutoOpen>]
module Microsoft.FSharp.Control.CommonExtensions
/// Returns an asynchronous computation that will read from the stream into the given buffer.
val AsyncRead : buffer:byte [] * ?offset:int * ?count:int -> Async<int>
/// Returns an asynchronous computation that will read the given number of bytes from the stream.
val AsyncRead : count:int -> Async<byte []>
/// Returns an asynchronous computation that will write the given bytes to the stream.
val AsyncWrite : buffer:byte [] * ?offset:int * ?count:int -> Async<unit>
/// Permanently connects a listener function to the observable. The listener will
/// be invoked for each observation.
val Add : callback:('T -> unit) -> unit
/// Connects a listener function to the observable. The listener will
/// be invoked for each observation. The listener can be removed by
/// calling Dispose on the returned IDisposable object.
val Subscribe : callback:('T -> unit) -> IDisposable
namespace Microsoft.FSharp.Control
/// A compositional asynchronous computation, which, when run, will eventually produce a value
/// of type T, or else raises an exception.
[<Sealed>]
[<NoEquality>]
[<NoComparison>]
[<CompiledName("FSharpAsync`1")>]
[<Class>]
type Async<'T> =
namespace Microsoft.FSharp.Control
/// A handle to a capability to reply to a PostAndReply message.
[<Sealed>]
[<CompiledName("FSharpAsyncReplyChannel`1")>]
[<Class>]
type AsyncReplyChannel<'Reply> =
/// Sends a reply to a PostAndReply message.
member Reply : value:'Reply -> unit
namespace Microsoft.FSharp.Control
/// The type of the async operator, used to build workflows for asynchronous computations.
[<CompiledName("FSharpAsyncBuilder")>]
[<Sealed>]
type AsyncBuilder =
/// Creates an asynchronous computation that runs computation, and when
/// computation generates a result T, runs binder res.
member Bind : computation:Async<'T> * binder:('T -> Async<'U>) -> Async<'U>
/// Creates an asynchronous computation that first runs computation1
/// and then runs computation2, returning the result of computation2.
member Combine : computation1:Async<unit> * computation2:Async<'T> -> Async<'T>
/// Creates an asynchronous computation that runs generator.
member Delay : generator:(unit -> Async<'T>) -> Async<'T>
/// Creates an asynchronous computation that enumerates the sequence seq
/// on demand and runs body for each element.
member For : sequence:seq<'T> * body:('T -> Async<unit>) -> Async<unit>
/// Creates an asynchronous computation that returns the result v.
member Return : value:'T -> Async<'T>
/// Delegates to the input computation.
member ReturnFrom : computation:Async<'T> -> Async<'T>
/// Creates an asynchronous computation that runs computation. The action compensation is executed
/// after computation completes, whether computation exits normally or by an exception. If compensation raises an exception itself
/// the original exception is discarded and the new exception becomes the overall result of the computation.
member TryFinally : computation:Async<'T> * compensation:(unit -> unit) -> Async<'T>
/// Creates an asynchronous computation that runs computation and returns its result.
/// If an exception happens then catchHandler(exn) is called and the resulting computation executed instead.
member TryWith : computation:Async<'T> * catchHandler:(exn -> Async<'T>) -> Async<'T>
/// Creates an asynchronous computation that runs binder(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.
member Using : resource:'T * binder:('T -> Async<'U>) -> Async<'U> when 'T :> IDisposable
/// Creates an asynchronous computation that runs computation repeatedly
/// until guard() becomes false.
member While : guard:(unit -> bool) * computation:Async<unit> -> Async<unit>
/// Creates an asynchronous computation that just returns ().
member Zero : unit -> Async<unit>
namespace Microsoft.FSharp.Control
/// This static class holds members for creating and manipulating asynchronous computations.
[<Sealed>]
[<CompiledName("FSharpAsync")>]
[<Class>]
type Async =
/// Creates three functions that can be used to implement the .NET Asynchronous
/// Programming Model (APM) for a given asynchronous computation.
static member AsBeginEnd : computation:('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit)
/// Creates an asynchronous computation that waits for a single invocation of a CLI
/// event by adding a handler to the event. Once the computation completes or is
/// cancelled, the handler is removed from the event.
static member AwaitEvent : event:IEvent<'Del,'T> * ?cancelAction:(unit -> unit) -> Async<'T> when 'Del : delegate<'T, unit> and 'Del :> Delegate
/// Creates an asynchronous computation that will wait on the IAsyncResult.
static member AwaitIAsyncResult : iar:IAsyncResult * ?millisecondsTimeout:int -> Async<bool>
/// Return an asynchronous computation that will wait for the given task to complete and return
/// its result.
static member AwaitTask : task:Threading.Tasks.Task<'T> -> Async<'T>
/// Return an asynchronous computation that will wait for the given task to complete and return
/// its result.
static member AwaitTask : task:Threading.Tasks.Task -> Async<unit>
/// Creates an asynchronous computation that will wait on the given WaitHandle.
static member AwaitWaitHandle : waitHandle:Threading.WaitHandle * ?millisecondsTimeout:int -> Async<bool>
/// Raises the cancellation condition for the most recent set of asynchronous computations started
/// without any specific CancellationToken. Replaces the global CancellationTokenSource with a new
/// global token source for any asynchronous computations created after this point without any
/// specific CancellationToken.
static member CancelDefaultToken : unit -> unit
/// Creates an asynchronous computation that returns the CancellationToken governing the execution
/// of the computation.
static member CancellationToken : Async<Threading.CancellationToken>
/// Creates an asynchronous computation that executes computation.
/// If this computation completes successfully then return Choice1Of2 with the returned
/// value. If this computation raises an exception before it completes then return Choice2Of2
/// with the raised exception.
static member Catch : computation:Async<'T> -> Async<Choice<'T,exn>>
/// Gets the default cancellation token for executing asynchronous computations.
static member DefaultCancellationToken : Threading.CancellationToken
/// Creates an asynchronous computation in terms of a Begin/End pair of actions in
/// the style used in CLI APIs. This overlaod should be used if the operation is
/// qualified by three arguments. For example,
/// Async.FromBeginEnd(arg1,arg2,arg3,ws.BeginGetWeather,ws.EndGetWeather)
/// When the computation is run, beginFunc is executed, with
/// a callback which represents the continuation of the computation.
/// When the callback is invoked, the overall result is fetched using endFunc.
static member FromBeginEnd : arg1:'Arg1 * arg2:'Arg2 * arg3:'Arg3 * beginAction:('Arg1 * 'Arg2 * 'Arg3 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
/// Creates an asynchronous computation in terms of a Begin/End pair of actions in
/// the style used in CLI APIs. For example,
/// Async.FromBeginEnd(ws.BeginGetWeather,ws.EndGetWeather)
/// When the computation is run, beginFunc is executed, with
/// a callback which represents the continuation of the computation.
/// When the callback is invoked, the overall result is fetched using endFunc.
static member FromBeginEnd : beginAction:(AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
/// Creates an asynchronous computation in terms of a Begin/End pair of actions in
/// the style used in CLI APIs. This overlaod should be used if the operation is
/// qualified by two arguments. For example,
/// Async.FromBeginEnd(arg1,arg2,ws.BeginGetWeather,ws.EndGetWeather)
/// When the computation is run, beginFunc is executed, with
/// a callback which represents the continuation of the computation.
/// When the callback is invoked, the overall result is fetched using endFunc.
static member FromBeginEnd : arg1:'Arg1 * arg2:'Arg2 * beginAction:('Arg1 * 'Arg2 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
/// Creates an asynchronous computation in terms of a Begin/End pair of actions in
/// the style used in CLI APIs. This overlaod should be used if the operation is
/// qualified by one argument. For example,
/// Async.FromBeginEnd(place,ws.BeginGetWeather,ws.EndGetWeather)
/// When the computation is run, beginFunc is executed, with
/// a callback which represents the continuation of the computation.
/// When the callback is invoked, the overall result is fetched using endFunc.
static member FromBeginEnd : arg:'Arg1 * beginAction:('Arg1 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
/// Creates an asynchronous computation that captures the current
/// success, exception and cancellation continuations. The callback must
/// eventually call exactly one of the given continuations.
static member FromContinuations : callback:(('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T>
/// Creates an asynchronous computation that runs the given computation and ignores
/// its result.
static member Ignore : computation:Async<'T> -> Async<unit>
/// Generates a scoped, cooperative cancellation handler for use within an asynchronous workflow.
static member OnCancel : interruption:(unit -> unit) -> Async<IDisposable>
/// Creates an asynchronous computation that executes all the given asynchronous computations,
/// initially queueing each as work items and using a fork/join pattern.
static member Parallel : computations:seq<Async<'T>> -> Async<'T []>
/// Runs the asynchronous computation and await its result.
static member RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:Threading.CancellationToken -> 'T
/// Creates an asynchronous computation that will sleep for the given time. This is scheduled
/// using a System.Threading.Timer object. The operation will not block operating system threads
/// for the duration of the wait.
static member Sleep : millisecondsDueTime:int -> Async<unit>
/// Starts the asynchronous computation in the thread pool. Do not await its result.
static member Start : computation:Async<unit> * ?cancellationToken:Threading.CancellationToken -> unit
/// Executes a computation in the thread pool.
static member StartAsTask : computation:Async<'T> * ?taskCreationOptions:Threading.Tasks.TaskCreationOptions * ?cancellationToken:Threading.CancellationToken -> Threading.Tasks.Task<'T>
/// Starts a child computation within an asynchronous workflow.
/// This allows multiple asynchronous computations to be executed simultaneously.
static member StartChild : computation:Async<'T> * ?millisecondsTimeout:int -> Async<Async<'T>>
/// Creates an asynchronous computation which starts the given computation as a System.Threading.Tasks.Task
static member StartChildAsTask : computation:Async<'T> * ?taskCreationOptions:Threading.Tasks.TaskCreationOptions -> Async<Threading.Tasks.Task<'T>>
/// Runs an asynchronous computation, starting immediately on the current operating system
/// thread.
static member StartImmediate : computation:Async<unit> * ?cancellationToken:Threading.CancellationToken -> unit
/// Runs an asynchronous computation, starting immediately on the current operating system
/// thread. Call one of the three continuations when the operation completes.
static member StartWithContinuations : computation:Async<'T> * continuation:('T -> unit) * exceptionContinuation:(exn -> unit) * cancellationContinuation:(OperationCanceledException -> unit) * ?cancellationToken:Threading.CancellationToken -> unit
/// Creates an asynchronous computation that runs
/// its continuation using syncContext.Post. If syncContext is null
/// then the asynchronous computation is equivalent to SwitchToThreadPool().
static member SwitchToContext : syncContext:Threading.SynchronizationContext -> Async<unit>
/// Creates an asynchronous computation that creates a new thread and runs
/// its continuation in that thread.
static member SwitchToNewThread : unit -> Async<unit>
/// Creates an asynchronous computation that queues a work item that runs
/// its continuation.
static member SwitchToThreadPool : unit -> Async<unit>
/// Creates an asynchronous computation that executes computation.
/// If this computation is cancelled before it completes then the computation generated by
/// running compensation is executed.
static member TryCancelled : computation:Async<'T> * compensation:(OperationCanceledException -> unit) -> Async<'T>
namespace Microsoft.FSharp.Collections
/// An abbreviation for the CLI type System.Collections.Generic.IEnumerable<_>
type seq<'T> = Collections.Generic.IEnumerable<'T>
namespace Microsoft.FSharp.Collections
/// An abbreviation for the type of immutable singly-linked lists.
type list<'T> = List<'T>
namespace Microsoft.FSharp.Collections
/// Immutable sets based on binary trees, where comparison is the
/// F# structural comparison function, potentially using implementations
/// of the IComparable interface on key values.
[<Sealed>]
[<CompiledName("FSharpSet`1")>]
type Set<'T when 'T : comparison> =
interface System.Collections.Generic.ICollection<'T>
interface System.Collections.IEnumerable
interface System.Collections.Generic.IEnumerable<'T>
/// Create a set containing elements drawn from the given sequence.
new : elements:seq<'T> -> Set<'T>
/// 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.
member Add : value:'T -> Set<'T>
/// A useful shortcut for Set.contains. See the Set module for further operations on sets.
member Contains : value:'T -> bool
/// The number of elements in the set
member Count : int
override Equals : obj -> bool
/// A useful shortcut for Set.isEmpty. See the Set module for further operations on sets.
member IsEmpty : bool
/// Evaluates to "true" if all elements of the first set are in the second, and at least
/// one element of the second is not in the first.
member IsProperSubsetOf : otherSet:Set<'T> -> bool
/// Evaluates to "true" if all elements of the second set are in the first, and at least
/// one element of the first is not in the second.
member IsProperSupersetOf : otherSet:Set<'T> -> bool
/// Evaluates to "true" if all elements of the first set are in the second.
member IsSubsetOf : otherSet:Set<'T> -> bool
/// Evaluates to "true" if all elements of the second set are in the first.
member IsSupersetOf : otherSet:Set<'T> -> bool
/// Returns the highest element in the set according to the ordering being used for the set.
member MaximumElement : 'T
/// Returns the lowest element in the set according to the ordering being used for the set.
member MinimumElement : 'T
/// 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.
member Remove : value:'T -> Set<'T>
/// Compute the union of the two sets.
static member op_Addition : set1:Set<'T> * set2:Set<'T> -> Set<'T>
/// Returns a new set with the elements of the second set removed from the first.
static member op_Subtraction : set1:Set<'T> * set2:Set<'T> -> Set<'T>
/// Functional programming operators related to the Set<_> type.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Collections.Set
/// The empty set for the type 'T.
val empty : Set<'T> when 'T : comparison
/// The set containing the given element.
val singleton : value:'T -> Set<'T> when 'T : comparison
/// Returns a new set with an element added to the set. No exception is raised if
/// the set already contains the given element.
val add : value:'T -> set:Set<'T> -> Set<'T> when 'T : comparison
/// Evaluates to "true" if the given element is in the given set.
val contains : element:'T -> set:Set<'T> -> bool when 'T : comparison
/// Evaluates to "true" if all elements of the first set are in the second
val isSubset : set1:Set<'T> -> set2:Set<'T> -> bool when 'T : comparison
/// Evaluates to "true" if all elements of the first set are in the second, and at least
/// one element of the second is not in the first.
val isProperSubset : set1:Set<'T> -> set2:Set<'T> -> bool when 'T : comparison
/// Evaluates to "true" if all elements of the second set are in the first.
val isSuperset : set1:Set<'T> -> set2:Set<'T> -> bool when 'T : comparison
/// Evaluates to "true" if all elements of the second set are in the first, and at least
/// one element of the first is not in the second.
val isProperSuperset : set1:Set<'T> -> set2:Set<'T> -> bool when 'T : comparison
/// Returns the number of elements in the set. Same as size.
val count : set:Set<'T> -> int when 'T : comparison
/// Tests if any element of the collection satisfies the given predicate.
/// If the input function is predicate and the elements are i0...iN
/// then computes p i0 or ... or p iN.
val exists : predicate:('T -> bool) -> set:Set<'T> -> bool when 'T : comparison
/// Returns a new collection containing only the elements of the collection
/// for which the given predicate returns true.
val filter : predicate:('T -> bool) -> set:Set<'T> -> Set<'T> when 'T : comparison
/// Returns a new collection containing the results of applying the
/// given function to each element of the input set.
val map : mapping:('T -> 'U) -> set:Set<'T> -> Set<'U> when 'T : comparison and 'U : comparison
/// Applies the given accumulating function to all the elements of the set
val fold : folder:('State -> 'T -> 'State) -> state:'State -> set:Set<'T> -> 'State when 'T : comparison
/// Applies the given accumulating function to all the elements of the set.
val foldBack : folder:('T -> 'State -> 'State) -> set:Set<'T> -> state:'State -> 'State when 'T : comparison
/// Tests 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.
val forall : predicate:('T -> bool) -> set:Set<'T> -> bool when 'T : comparison
/// Computes the intersection of the two sets.
val intersect : set1:Set<'T> -> set2:Set<'T> -> Set<'T> when 'T : comparison
/// Computes the intersection of a sequence of sets. The sequence must be non-empty.
val intersectMany : sets:seq<Set<'T>> -> Set<'T> when 'T : comparison
/// Computes the union of the two sets.
val union : set1:Set<'T> -> set2:Set<'T> -> Set<'T> when 'T : comparison
/// Computes the union of a sequence of sets.
val unionMany : sets:seq<Set<'T>> -> Set<'T> when 'T : comparison
/// Returns "true" if the set is empty.
val isEmpty : set:Set<'T> -> bool when 'T : comparison
/// Applies the given function to each element of the set, in order according
/// to the comparison function.
val iter : action:('T -> unit) -> set:Set<'T> -> unit when 'T : comparison
/// Splits the set into two sets containing the elements for which the given predicate
/// returns true and false respectively.
val partition : predicate:('T -> bool) -> set:Set<'T> -> Set<'T> * Set<'T> when 'T : comparison
/// Returns a new set with the given element removed. No exception is raised if
/// the set doesn't contain the given element.
val remove : value:'T -> set:Set<'T> -> Set<'T> when 'T : comparison
/// Returns the lowest element in the set according to the ordering being used for the set.
val minElement : set:Set<'T> -> 'T when 'T : comparison
/// Returns the highest element in the set according to the ordering being used for the set.
val maxElement : set:Set<'T> -> 'T when 'T : comparison
/// Builds a set that contains the same elements as the given list.
val ofList : elements:'T list -> Set<'T> when 'T : comparison
/// Builds a list that contains the elements of the set in order.
val toList : set:Set<'T> -> 'T list when 'T : comparison
/// Builds a set that contains the same elements as the given array.
val ofArray : array:'T [] -> Set<'T> when 'T : comparison
/// Builds an array that contains the elements of the set in order.
val toArray : set:Set<'T> -> 'T [] when 'T : comparison
/// Returns an ordered view of the collection as an enumerable object.
val toSeq : set:Set<'T> -> seq<'T> when 'T : comparison
/// Builds a new collection from the given enumerable object.
val ofSeq : elements:seq<'T> -> Set<'T> when 'T : comparison
/// Returns a new set with the elements of the second set removed from the first.
val difference : set1:Set<'T> -> set2:Set<'T> -> Set<'T> when 'T : comparison
/// Basic operations on IEnumerables.
[<RequireQualifiedAccess>]
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
module Microsoft.FSharp.Collections.Seq
/// Wraps the two given enumerations as a single concatenated
/// enumeration.
val append : source1:seq<'T> -> source2:seq<'T> -> seq<'T>
/// Returns the average of the elements in the sequence.
val inline average : source:seq< ^T> -> ^T when ^T : (static member ( + ) : ^T * ^T -> ^T) and ^T : (static member DivideByInt : ^T * int -> ^T) and ^T : (static member Zero : ^T)
/// Returns the average of the results generated by applying the function to each element
/// of the sequence.
val inline averageBy : projection:('T -> ^U) -> source:seq<'T> -> ^U when ^U : (static member ( + ) : ^U * ^U -> ^U) and ^U : (static member DivideByInt : ^U * int -> ^U) and ^U : (static member Zero : ^U)
/// Returns 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. Caching a sequence is typically useful when repeatedly
/// evaluating items in the original sequence is computationally expensive or if
/// iterating the sequence causes side-effects that the user does not want to be
/// repeated multiple times.
///
/// 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.
val cache : source:seq<'T> -> seq<'T>
/// Wraps a loosely-typed System.Collections sequence as a typed sequence.
val cast : source:Collections.IEnumerable -> seq<'T>
/// Applies 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).
val choose : chooser:('T -> 'U option) -> source:seq<'T> -> seq<'U>
/// Applies the given function to each element of the sequence and concatenates all the
/// results.
val collect : mapping:('T -> 'Collection) -> source:seq<'T> -> seq<'U> when 'Collection :> seq<'U>
/// Compares two sequences using the given comparison function, element by element.
/// Returns the first non-zero result from the comparison function. If the end of a sequence
/// is reached it returns a -1 if the first sequence is shorter and a 1 if the second sequence
/// is shorter.
val compareWith : comparer:('T -> 'T -> int) -> source1:seq<'T> -> source2:seq<'T> -> int
/// Combines the given enumeration-of-enumerations as a single concatenated
/// enumeration.
val concat : sources:seq<'Collection> -> seq<'T> when 'Collection :> seq<'T>
/// Tests if the sequence contains the specified element.
val inline contains : value:'T -> source:seq<'T> -> bool when 'T : equality
/// Applies a key-generating function to each element of a sequence and returns a sequence yielding unique
/// keys and their number of occurrences in the original sequence.
val countBy : projection:('T -> 'Key) -> source:seq<'T> -> seq<'Key * int> when 'Key : equality
/// Returns a sequence that is built from the given delayed specification of a
/// sequence.
val delay : generator:(unit -> seq<'T>) -> seq<'T>
/// Returns a sequence that contains no duplicate entries according to generic hash and
/// equality comparisons on the entries.
/// If an element occurs multiple times in the sequence then the later occurrences are discarded.
val distinct : source:seq<'T> -> seq<'T> when 'T : equality
/// Returns a sequence that contains no duplicate entries according to the
/// generic hash and equality comparisons on the keys returned by the given key-generating function.
/// If an element occurs multiple times in the sequence then the later occurrences are discarded.
val distinctBy : projection:('T -> 'Key) -> source:seq<'T> -> seq<'T> when 'Key : equality
/// Creates an empty sequence.
val empty : seq<'T>
/// Tests if any element of the sequence satisfies the given predicate.
val exists : predicate:('T -> bool) -> source:seq<'T> -> bool
/// Tests if any pair of corresponding elements of the input sequences satisfies the given predicate.
val exists2 : predicate:('T1 -> 'T2 -> bool) -> source1:seq<'T1> -> source2:seq<'T2> -> bool
/// Returns a new collection containing only the elements of the collection
/// for which the given predicate returns "true". This is a synonym for Seq.where.
val filter : predicate:('T -> bool) -> source:seq<'T> -> seq<'T>
/// Returns a new collection containing only the elements of the collection
/// for which the given predicate returns "true".
val where : predicate:('T -> bool) -> source:seq<'T> -> seq<'T>
/// Returns the first element for which the given function returns true.
val find : predicate:('T -> bool) -> source:seq<'T> -> 'T
/// Returns the last element for which the given function returns true.
val findBack : predicate:('T -> bool) -> source:seq<'T> -> 'T
/// Returns the index of the first element for which the given function returns true.
val findIndex : predicate:('T -> bool) -> source:seq<'T> -> int
/// Returns the index of the last element for which the given function returns true.
val findIndexBack : predicate:('T -> bool) -> source:seq<'T> -> int
/// Applies a function to each element of the collection, threading an accumulator argument
/// through the computation. If the input function is f and the elements are i0...iN
/// then computes f (... (f s i0)...) iN
val fold : folder:('State -> 'T -> 'State) -> state:'State -> source:seq<'T> -> 'State
/// Applies a function to corresponding elements of two collections, threading an accumulator argument
/// through the computation. The two sequences need not have equal lengths:
/// when one sequence is exhausted any remaining elements in the other sequence are ignored.
/// If the input function is f and the elements are i0...iN and j0...jN
/// then computes f (... (f s i0 j0)...) iN jN.
val fold2 : folder:('State -> 'T1 -> 'T2 -> 'State) -> state:'State -> source1:seq<'T1> -> source2:seq<'T2> -> 'State
/// Applies a function to each element of the collection, starting from the end, 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)...)
val foldBack : folder:('T -> 'State -> 'State) -> source:seq<'T> -> state:'State -> 'State
/// Tests if all elements of the sequence satisfy the given predicate.
val forall : predicate:('T -> bool) -> source:seq<'T> -> bool
/// Tests the all pairs of elements drawn from the two sequences satisfy the
/// given predicate. If one sequence is shorter than
/// the other then the remaining elements of the longer sequence are ignored.
val forall2 : predicate:('T1 -> 'T2 -> bool) -> source1:seq<'T1> -> source2:seq<'T2> -> bool
/// Applies a key-generating function to each element of a sequence and yields a sequence of
/// unique keys. Each unique key contains a sequence of all elements that match
/// to this key.
val groupBy : projection:('T -> 'Key) -> source:seq<'T> -> seq<'Key * seq<'T>> when 'Key : equality
/// Returns the first element of the sequence.
val head : source:seq<'T> -> 'T
/// Returns the first element of the sequence, or None if the sequence is empty.
val tryHead : source:seq<'T> -> 'T option
/// Returns the last element of the sequence.
val last : source:seq<'T> -> 'T
/// Returns the last element of the sequence.
/// Return None if no such element exists.
val tryLast : source:seq<'T> -> 'T option
/// Returns the only element of the sequence.
val exactlyOne : source:seq<'T> -> 'T
/// Returns true if the sequence contains no elements, false otherwise.
val isEmpty : source:seq<'T> -> bool
/// Builds a new collection whose elements are the corresponding elements of the input collection
/// paired with the integer index (from 0) of each element.
val indexed : source:seq<'T> -> seq<int * 'T>
/// Generates a new sequence which, when iterated, will return successive
/// elements by calling the given function, up to the given count. Each element is saved after its
/// initialization. The function is passed the index of the item being
/// generated.
val init : count:int -> initializer:(int -> 'T) -> seq<'T>
/// Generates a new sequence which, when iterated, will return successive
/// elements by calling the given function. The results of calling the function
/// will not be saved, that is the function will be reapplied as necessary to
/// regenerate the elements. The function is passed the index of the item being
/// generated.
val initInfinite : initializer:(int -> 'T) -> seq<'T>
/// Computes the element at the specified index in the collection.
val item : index:int -> source:seq<'T> -> 'T
/// Applies the given function to each element of the collection.
val iter : action:('T -> unit) -> source:seq<'T> -> unit
/// Applies the given function to each element of the collection. The integer passed to the
/// function indicates the index of element.
val iteri : action:(int -> 'T -> unit) -> source:seq<'T> -> unit
/// Applies the given function to two collections simultaneously. If one sequence is shorter than
/// the other then the remaining elements of the longer sequence are ignored.
val iter2 : action:('T1 -> 'T2 -> unit) -> source1:seq<'T1> -> source2:seq<'T2> -> unit
/// Applies the given function to two collections simultaneously. If one sequence is shorter than
/// the other then the remaining elements of the longer sequence are ignored. The integer passed to the
/// function indicates the index of element.
val iteri2 : action:(int -> 'T1 -> 'T2 -> unit) -> source1:seq<'T1> -> source2:seq<'T2> -> unit
/// Returns the length of the sequence
val length : source:seq<'T> -> int
/// Builds 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.
val map : mapping:('T -> 'U) -> source:seq<'T> -> seq<'U>
/// Builds 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.
val map2 : mapping:('T1 -> 'T2 -> 'U) -> source1:seq<'T1> -> source2:seq<'T2> -> seq<'U>
/// Combines map and fold. Builds a new collection whose elements are the results of applying the given function
/// to each of the elements of the collection. The function is also used to accumulate a final value.
val mapFold : mapping:('State -> 'T -> 'Result * 'State) -> state:'State -> source:seq<'T> -> seq<'Result> * 'State
/// Combines map and foldBack. Builds a new collection whose elements are the results of applying the given function
/// to each of the elements of the collection. The function is also used to accumulate a final value.
val mapFoldBack : mapping:('T -> 'State -> 'Result * 'State) -> source:seq<'T> -> state:'State -> seq<'Result> * 'State
/// Builds a new collection whose elements are the results of applying the given function
/// to the corresponding triples of elements from the three sequences. If one input sequence if shorter than
/// the others then the remaining elements of the longer sequences are ignored.
val map3 : mapping:('T1 -> 'T2 -> 'T3 -> 'U) -> source1:seq<'T1> -> source2:seq<'T2> -> source3:seq<'T3> -> seq<'U>
/// Builds 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.
val mapi : mapping:(int -> 'T -> 'U) -> source:seq<'T> -> seq<'U>
/// Builds 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. The integer index passed to the
/// function indicates the index (from 0) of element being transformed.
val mapi2 : mapping:(int -> 'T1 -> 'T2 -> 'U) -> source1:seq<'T1> -> source2:seq<'T2> -> seq<'U>
/// Returns the greatest of all elements of the sequence, compared via Operators.max
val inline max : source:seq<'T> -> 'T when 'T : comparison
/// Returns the greatest of all elements of the sequence, compared via Operators.max on the function result.
val inline maxBy : projection:('T -> 'U) -> source:seq<'T> -> 'T when 'U : comparison
/// Returns the lowest of all elements of the sequence, compared via Operators.min.
val inline min : source:seq<'T> -> 'T when 'T : comparison
/// Returns the lowest of all elements of the sequence, compared via Operators.min on the function result.
val inline minBy : projection:('T -> 'U) -> source:seq<'T> -> 'T when 'U : comparison
/// Computes the nth element in the collection.
val nth : index:int -> source:seq<'T> -> 'T
/// Views the given array as a sequence.
val ofArray : source:'T [] -> seq<'T>
/// Views the given list as a sequence.
val ofList : source:'T list -> seq<'T>
/// Returns a sequence of each element in the input sequence and its predecessor, with the
/// exception of the first element which is only returned as the predecessor of the second element.
val pairwise : source:seq<'T> -> seq<'T * 'T>
/// Returns a sequence with all elements permuted according to the
/// specified permutation.
val permute : indexMap:(int -> int) -> source:seq<'T> -> seq<'T>
/// Applies the given function to successive elements, returning the first
/// x where the function returns "Some(x)".
val pick : chooser:('T -> 'U option) -> source:seq<'T> -> 'U
/// Builds a new sequence object that delegates to the given sequence object. This ensures
/// the original sequence cannot be rediscovered and mutated by a type cast. For example,
/// if given an array the returned sequence will return the elements of the array, but
/// you cannot cast the returned sequence object to an array.
val readonly : source:seq<'T> -> seq<'T>
/// Applies a function to each element of the sequence, threading an accumulator argument
/// through the computation. Begin by applying the function to the first two elements.
/// Then feed this result into the function along with the third element and so on.
/// Return the final result.
val reduce : reduction:('T -> 'T -> 'T) -> source:seq<'T> -> 'T
/// Creates a sequence by replicating the given initial value.
val replicate : count:int -> initial:'T -> seq<'T>
/// Applies a function to each element of the sequence, starting from the end, 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)).
val reduceBack : reduction:('T -> 'T -> 'T) -> source:seq<'T> -> 'T
/// Returns a new sequence with the elements in reverse order.
val rev : source:seq<'T> -> seq<'T>
/// Like fold, but computes on-demand and returns the sequence of intermediary and final results.
val scan : folder:('State -> 'T -> 'State) -> state:'State -> source:seq<'T> -> seq<'State>
/// Like foldBack, but returns the sequence of intermediary and final results.
val scanBack : folder:('T -> 'State -> 'State) -> source:seq<'T> -> state:'State -> seq<'State>
/// Returns a sequence that yields one item only.
val singleton : value:'T -> seq<'T>
/// Returns a sequence that skips N elements of the underlying sequence and then yields the
/// remaining elements of the sequence.
val skip : count:int -> source:seq<'T> -> seq<'T>
/// Returns a sequence that, when iterated, skips elements of the underlying sequence while the
/// given predicate returns true, and then yields the remaining elements of the sequence.
val skipWhile : predicate:('T -> bool) -> source:seq<'T> -> seq<'T>
/// Yields a sequence ordered by keys.
val sort : source:seq<'T> -> seq<'T> when 'T : comparison
/// Yields a sequence ordered using the given comparison function.
val sortWith : comparer:('T -> 'T -> int) -> source:seq<'T> -> seq<'T>
/// Applies a key-generating function to each element of a sequence and yield a sequence ordered
/// by keys. The keys are compared using generic comparison as implemented by Operators.compare.
val sortBy : projection:('T -> 'Key) -> source:seq<'T> -> seq<'T> when 'Key : comparison
/// Yields a sequence ordered descending by keys.
val inline sortDescending : source:seq<'T> -> seq<'T> when 'T : comparison
/// Applies a key-generating function to each element of a sequence and yield a sequence ordered
/// descending by keys. The keys are compared using generic comparison as implemented by Operators.compare.
val inline sortByDescending : projection:('T -> 'Key) -> source:seq<'T> -> seq<'T> when 'Key : comparison
/// Returns the sum of the elements in the sequence.
val inline sum : source:seq< ^T> -> ^T when ^T : (static member ( + ) : ^T * ^T -> ^T) and ^T : (static member Zero : ^T)
/// Returns the sum of the results generated by applying the function to each element of the sequence.
val inline sumBy : projection:('T -> ^U) -> source:seq<'T> -> ^U when ^U : (static member ( + ) : ^U * ^U -> ^U) and ^U : (static member Zero : ^U)
/// Returns a sequence that skips 1 element of the underlying sequence and then yields the
/// remaining elements of the sequence.
val tail : source:seq<'T> -> seq<'T>
/// Returns the first N elements of the sequence.
val take : count:int -> source:seq<'T> -> seq<'T>
/// Returns a sequence that, when iterated, yields elements of the underlying sequence while the
/// given predicate returns true, and then returns no further elements.
val takeWhile : predicate:('T -> bool) -> source:seq<'T> -> seq<'T>
/// Builds an array from the given collection.
val toArray : source:seq<'T> -> 'T []
/// Builds a list from the given collection.
val toList : source:seq<'T> -> 'T list
/// Returns the first element for which the given function returns true.
/// Return None if no such element exists.
val tryFind : predicate:('T -> bool) -> source:seq<'T> -> 'T option
/// Returns the last element for which the given function returns true.
/// Return None if no such element exists.
val tryFindBack : predicate:('T -> bool) -> source:seq<'T> -> 'T option
/// Returns the index of the first element in the sequence
/// that satisfies the given predicate. Return None if no such element exists.
val tryFindIndex : predicate:('T -> bool) -> source:seq<'T> -> int option
/// Tries to find the nth element in the sequence.
/// Returns None if index is negative or the input sequence does not contain enough elements.
val tryItem : index:int -> source:seq<'T> -> 'T option
/// Returns the index of the last element in the sequence
/// that satisfies the given predicate. Return None if no such element exists.
val tryFindIndexBack : predicate:('T -> bool) -> source:seq<'T> -> int option
/// Applies the given function to successive elements, returning the first
/// result where the function returns "Some(x)".
val tryPick : chooser:('T -> 'U option) -> source:seq<'T> -> 'U option
/// Returns a sequence that when enumerated returns at most N elements.
val truncate : count:int -> source:seq<'T> -> seq<'T>
/// Returns 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.
val unfold : generator:('State -> ('T * 'State) option) -> state:'State -> seq<'T>
/// Returns a sequence that yields sliding windows containing elements drawn from the input
/// sequence. Each window is returned as a fresh array.
val windowed : windowSize:int -> source:seq<'T> -> seq<'T []>
/// Combines the two sequences into a list of pairs. The two sequences need not have equal lengths:
/// when one sequence is exhausted any remaining elements in the other
/// sequence are ignored.
val zip : source1:seq<'T1> -> source2:seq<'T2> -> seq<'T1 * 'T2>
/// Combines the three sequences into a list of triples. The sequences need not have equal lengths:
/// when one sequence is exhausted any remaining elements in the other
/// sequences are ignored.
val zip3 : source1:seq<'T1> -> source2:seq<'T2> -> source3:seq<'T3> -> seq<'T1 * 'T2 * 'T3>
namespace Microsoft.FSharp.Collections
/// An abbreviation for the CLI type System.Collections.Generic.List<_>
type ResizeArray<'T> = Collections.Generic.List<'T>
namespace Microsoft.FSharp.Collections
/// Immutable maps. Keys are ordered by F# generic comparison.
[<CompiledName("FSharpMap`2")>]
[<Sealed>]
type Map<'Key, 'Value when 'Key : comparison> =
interface System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<'Key,'Value>>
interface System.Collections.Generic.IDictionary<'Key,'Value>
interface System.Collections.IEnumerable
interface System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<'Key,'Value>>
/// Builds a map that contains the bindings of the given IEnumerable.
new : elements:seq<'Key * 'Value> -> Map<'Key, 'Value>
/// Returns a new map with the binding added to the given map.
member Add : key:'Key * value:'Value -> Map<'Key,'Value>
/// Tests if an element is in the domain of the map.
member ContainsKey : key:'Key -> bool
/// The number of bindings in the map.
member Count : int
override Equals : obj -> bool
/// Returns true if there are no bindings in the map.
member IsEmpty : bool
/// Lookup an element in the map. Raise KeyNotFoundException if no binding
/// exists in the map.
member Item : 'Value
/// Removes an element from the domain of the map. No exception is raised if the element is not present.
member Remove : key:'Key -> Map<'Key,'Value>
/// Lookup an element in the map, returning a Some value if the element is in the domain
/// of the map and None if not.
member TryFind : key:'Key -> 'Value option
/// Functional programming operators related to the Map<_,_> type.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Collections.Map
/// Returns a new map with the binding added to the given map.
val add : key:'Key -> value:'T -> table:Map<'Key,'T> -> Map<'Key,'T> when 'Key : comparison
/// Returns a new map made from the given bindings.
val ofList : elements:('Key * 'T) list -> Map<'Key,'T> when 'Key : comparison
/// Returns a new map made from the given bindings.
val ofArray : elements:('Key * 'T) [] -> Map<'Key,'T> when 'Key : comparison
/// Returns a new map made from the given bindings.
val ofSeq : elements:seq<'Key * 'T> -> Map<'Key,'T> when 'Key : comparison
/// Views the collection as an enumerable sequence of pairs.
/// The sequence will be ordered by the keys of the map.
val toSeq : table:Map<'Key,'T> -> seq<'Key * 'T> when 'Key : comparison
/// Returns a list of all key-value pairs in the mapping.
/// The list will be ordered by the keys of the map.
val toList : table:Map<'Key,'T> -> ('Key * 'T) list when 'Key : comparison
/// Returns an array of all key-value pairs in the mapping.
/// The array will be ordered by the keys of the map.
val toArray : table:Map<'Key,'T> -> ('Key * 'T) [] when 'Key : comparison
/// Is the map empty?
val isEmpty : table:Map<'Key,'T> -> bool when 'Key : comparison
/// The empty map.
val empty : Map<'Key,'T> when 'Key : comparison
/// Lookup an element in the map, raising KeyNotFoundException if no binding
/// exists in the map.
val find : key:'Key -> table:Map<'Key,'T> -> 'T when 'Key : comparison
/// Searches the map looking for the first element where the given function returns a Some value.
val tryPick : chooser:('Key -> 'T -> 'U option) -> table:Map<'Key,'T> -> 'U option when 'Key : comparison
/// Searches the map looking for the first element where the given function returns a Some value
val pick : chooser:('Key -> 'T -> 'U option) -> table:Map<'Key,'T> -> 'U when 'Key : comparison
/// Folds over the bindings in the map.
val foldBack : folder:('Key -> 'T -> 'State -> 'State) -> table:Map<'Key,'T> -> state:'State -> 'State when 'Key : comparison
/// Folds over the bindings in the map
val fold : folder:('State -> 'Key -> 'T -> 'State) -> state:'State -> table:Map<'Key,'T> -> 'State when 'Key : comparison
/// Applies the given function to each binding in the dictionary
val iter : action:('Key -> 'T -> unit) -> table:Map<'Key,'T> -> unit when 'Key : comparison
/// Returns true if the given predicate returns true for one of the
/// bindings in the map.
val exists : predicate:('Key -> 'T -> bool) -> table:Map<'Key,'T> -> bool when 'Key : comparison
/// Builds a new map containing only the bindings for which the given predicate returns 'true'.
val filter : predicate:('Key -> 'T -> bool) -> table:Map<'Key,'T> -> Map<'Key,'T> when 'Key : comparison
/// Returns true if the given predicate returns true for all of the
/// bindings in the map.
val forall : predicate:('Key -> 'T -> bool) -> table:Map<'Key,'T> -> bool when 'Key : comparison
/// Builds a new collection whose elements are the results of applying the given function
/// to each of the elements of the collection. The key passed to the
/// function indicates the key of element being transformed.
val map : mapping:('Key -> 'T -> 'U) -> table:Map<'Key,'T> -> Map<'Key,'U> when 'Key : comparison
/// Tests if an element is in the domain of the map.
val containsKey : key:'Key -> table:Map<'Key,'T> -> bool when 'Key : comparison
/// Builds two new maps, one containing the bindings for which the given predicate returns 'true',
/// and the other the remaining bindings.
val partition : predicate:('Key -> 'T -> bool) -> table:Map<'Key,'T> -> Map<'Key,'T> * Map<'Key,'T> when 'Key : comparison
/// Removes an element from the domain of the map. No exception is raised if the element is not present.
val remove : key:'Key -> table:Map<'Key,'T> -> Map<'Key,'T> when 'Key : comparison
/// Lookup an element in the map, returning a Some value if the element is in the domain
/// of the map and None if not.
val tryFind : key:'Key -> table:Map<'Key,'T> -> 'T option when 'Key : comparison
/// 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.
val findKey : predicate:('Key -> 'T -> bool) -> table:Map<'Key,'T> -> 'Key when 'Key : comparison
/// Returns the key of the first mapping in the collection that satisfies the given predicate.
/// Returns 'None' if no such element exists.
val tryFindKey : predicate:('Key -> 'T -> bool) -> table:Map<'Key,'T> -> 'Key option when 'Key : comparison
namespace Microsoft.FSharp.Collections
/// The type of immutable singly-linked lists.
[<DefaultAugmentation(false)>]
[<StructuralEquality>]
[<StructuralComparison>]
[<CompiledName("FSharpList`1")>]
type List<'T> =
| ( [] )
| ( :: ) of Head: 'T * Tail: 'T list
interface System.Collections.IEnumerable
interface System.Collections.Generic.IEnumerable<'T>
/// Gets a slice of the list, the elements of the list from the given start index to the given end index.
member GetSlice : startIndex:int option * endIndex:int option -> 'T list
/// Gets the first element of the list
member Head : 'T
/// Gets a value indicating if the list contains no entries
member IsEmpty : bool
/// Gets the element of the list at the given position.
member Item : 'T
/// Gets the number of items contained in the list
member Length : int
/// Gets the tail of the list, which is a list containing all the elements of the list, excluding the first element
member Tail : 'T list
/// Returns a list with head as its first element and tail as its subsequent elements
static member Cons : head:'T * tail:'T list -> 'T list
/// Returns an empty list of a particular type
static member Empty : 'T list
/// Basic operations on lists.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Collections.List
/// Returns a new list that contains the elements of the first list
/// followed by elements of the second.
val append : list1:'T list -> list2:'T list -> 'T list
/// Returns the average of the elements in the list.
val inline average : list: ^T list -> ^T when ^T : (static member ( + ) : ^T * ^T -> ^T) and ^T : (static member DivideByInt : ^T * int -> ^T) and ^T : (static member Zero : ^T)
/// Returns the average of the elements generated by applying the function to each element of the list.
val inline averageBy : projection:('T -> ^U) -> list:'T list -> ^U when ^U : (static member ( + ) : ^U * ^U -> ^U) and ^U : (static member DivideByInt : ^U * int -> ^U) and ^U : (static member Zero : ^U)
/// Applies the given function to each element of the list. Returns
/// the list comprised of the results x for each element where
/// the function returns Some(x)
val choose : chooser:('T -> 'U option) -> list:'T list -> 'U list
/// For each element of the list, applies the given function. Concatenates all the results and return the combined list.
val collect : mapping:('T -> 'U list) -> list:'T list -> 'U list
/// Compares two lists using the given comparison function, element by element.
/// Returns the first non-zero result from the comparison function. If the end of a list
/// is reached it returns a -1 if the first list is shorter and a 1 if the second list
/// is shorter.
val inline compareWith : comparer:('T -> 'T -> int) -> list1:'T list -> list2:'T list -> int
/// Returns a new list that contains the elements of each the lists in order.
val concat : lists:seq<'T list> -> 'T list
/// Tests if the list contains the specified element.
val inline contains : value:'T -> source:'T list -> bool when 'T : equality
/// Returns a list that contains no duplicate entries according to generic hash and
/// equality comparisons on the entries.
/// If an element occurs multiple times in the list then the later occurrences are discarded.
val distinct : list:'T list -> 'T list when 'T : equality
/// Returns a list 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 list then the later occurrences are discarded.
val distinctBy : projection:('T -> 'Key) -> list:'T list -> 'T list when 'Key : equality
/// Applies a key-generating function to each element of a list and returns a list yielding unique
/// keys and their number of occurrences in the original list.
val countBy : projection:('T -> 'Key) -> list:'T list -> ('Key * int) list when 'Key : equality
/// Returns an empty list of the given type.
val empty : 'T list
/// Returns the only element of the list.
val exactlyOne : list:'T list -> 'T
/// Tests if any element of the list satisfies the given predicate.
val exists : predicate:('T -> bool) -> list:'T list -> bool
/// Tests if any pair of corresponding elements of the lists satisfies the given predicate.
val exists2 : predicate:('T1 -> 'T2 -> bool) -> list1:'T1 list -> list2:'T2 list -> bool
/// Returns the first element for which the given function returns true.
/// Raises KeyNotFoundException if no such element exists.
val find : predicate:('T -> bool) -> list:'T list -> 'T
/// Returns the last element for which the given function returns true.
/// Raises KeyNotFoundException if no such element exists.
val findBack : predicate:('T -> bool) -> list:'T list -> 'T
/// Returns the index of the first element in the list
/// that satisfies the given predicate.
/// Raises KeyNotFoundException if no such element exists.
val findIndex : predicate:('T -> bool) -> list:'T list -> int
/// Returns the index of the last element in the list
/// that satisfies the given predicate.
/// Raises KeyNotFoundException if no such element exists.
val findIndexBack : predicate:('T -> bool) -> list:'T list -> int
/// Returns a new collection containing only the elements of the collection
/// for which the given predicate returns "true"
val filter : predicate:('T -> bool) -> list:'T list -> 'T list
/// Applies 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.
val fold : folder:('State -> 'T -> 'State) -> state:'State -> list:'T list -> 'State
/// Applies a function to corresponding elements of two collections, threading an accumulator argument
/// through the computation. The collections must have identical sizes.
/// If the input function is f and the elements are i0...iN and j0...jN
/// then computes f (... (f s i0 j0)...) iN jN.
val fold2 : folder:('State -> 'T1 -> 'T2 -> 'State) -> state:'State -> list1:'T1 list -> list2:'T2 list -> 'State
/// Applies a function to each element of the collection, starting from the end, 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)).
val foldBack : folder:('T -> 'State -> 'State) -> list:'T list -> state:'State -> 'State
/// Applies a function to corresponding elements of two collections, threading an accumulator argument
/// through the computation. The collections must have identical sizes.
/// If the input function is f and the elements are i0...iN and j0...jN
/// then computes f i0 j0 (...(f iN jN s)).
val foldBack2 : folder:('T1 -> 'T2 -> 'State -> 'State) -> list1:'T1 list -> list2:'T2 list -> state:'State -> 'State
/// Tests if all elements of the collection satisfy the given predicate.
val forall : predicate:('T -> bool) -> list:'T list -> bool
/// Tests if all corresponding elements of the collection satisfy the given predicate pairwise.
val forall2 : predicate:('T1 -> 'T2 -> bool) -> list1:'T1 list -> list2:'T2 list -> bool
/// Applies a key-generating function to each element of a list and yields a list of
/// unique keys. Each unique key contains a list of all elements that match
/// to this key.
val groupBy : projection:('T -> 'Key) -> list:'T list -> ('Key * 'T list) list when 'Key : equality
/// Returns the first element of the list.
val head : list:'T list -> 'T
/// Returns a new list whose elements are the corresponding elements
/// of the input list paired with the index (from 0) of each element.
val indexed : list:'T list -> (int * 'T) list
/// Creates a list by calling the given generator on each index.
val init : length:int -> initializer:(int -> 'T) -> 'T list
/// Returns true if the list contains no elements, false otherwise.
val isEmpty : list:'T list -> bool
/// Indexes into the list. The first element has index 0.
val item : index:int -> list:'T list -> 'T
/// Applies the given function to each element of the collection.
val iter : action:('T -> unit) -> list:'T list -> unit
/// Applies the given function to two collections simultaneously. The
/// collections must have identical size.
val iter2 : action:('T1 -> 'T2 -> unit) -> list1:'T1 list -> list2:'T2 list -> unit
/// Applies the given function to each element of the collection. The integer passed to the
/// function indicates the index of element.
val iteri : action:(int -> 'T -> unit) -> list:'T list -> unit
/// Applies the given function to two collections simultaneously. The
/// collections must have identical size. The integer passed to the
/// function indicates the index of element.
val iteri2 : action:(int -> 'T1 -> 'T2 -> unit) -> list1:'T1 list -> list2:'T2 list -> unit
/// Returns the last element of the list.
val last : list:'T list -> 'T
/// Returns the length of the list.
val length : list:'T list -> int
/// Returns the last element of the list.
/// Return None if no such element exists.
val tryLast : list:'T list -> 'T option
/// Builds a new collection whose elements are the results of applying the given function
/// to each of the elements of the collection.
val map : mapping:('T -> 'U) -> list:'T list -> 'U list
/// Builds a new collection whose elements are the results of applying the given function
/// to the corresponding elements of the two collections pairwise.
val map2 : mapping:('T1 -> 'T2 -> 'U) -> list1:'T1 list -> list2:'T2 list -> 'U list
/// Builds a new collection whose elements are the results of applying the given function
/// to the corresponding elements of the three collections simultaneously.
val map3 : mapping:('T1 -> 'T2 -> 'T3 -> 'U) -> list1:'T1 list -> list2:'T2 list -> list3:'T3 list -> 'U list
/// Combines map and fold. Builds a new list whose elements are the results of applying the given function
/// to each of the elements of the input list. The function is also used to accumulate a final value.
val mapFold : mapping:('State -> 'T -> 'Result * 'State) -> state:'State -> list:'T list -> 'Result list * 'State
/// Combines map and foldBack. Builds a new list whose elements are the results of applying the given function
/// to each of the elements of the input list. The function is also used to accumulate a final value.
val mapFoldBack : mapping:('T -> 'State -> 'Result * 'State) -> list:'T list -> state:'State -> 'Result list * 'State
/// Builds 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.
val mapi : mapping:(int -> 'T -> 'U) -> list:'T list -> 'U list
/// Like mapi, but mapping corresponding elements from two lists of equal length.
val mapi2 : mapping:(int -> 'T1 -> 'T2 -> 'U) -> list1:'T1 list -> list2:'T2 list -> 'U list
/// Return the greatest of all elements of the list, compared via Operators.max.
val inline max : list:'T list -> 'T when 'T : comparison
/// Returns the greatest of all elements of the list, compared via Operators.max on the function result.
val inline maxBy : projection:('T -> 'U) -> list:'T list -> 'T when 'U : comparison
/// Returns the lowest of all elements of the list, compared via Operators.min.
val inline min : list:'T list -> 'T when 'T : comparison
/// Returns the lowest of all elements of the list, compared via Operators.min on the function result
val inline minBy : projection:('T -> 'U) -> list:'T list -> 'T when 'U : comparison
/// Indexes into the list. The first element has index 0.
val nth : list:'T list -> index:int -> 'T
/// Builds a list from the given array.
val ofArray : array:'T [] -> 'T list
/// Builds a new list from the given enumerable object.
val ofSeq : source:seq<'T> -> 'T list
/// Returns a list of each element in the input list and its predecessor, with the
/// exception of the first element which is only returned as the predecessor of the second element.
val pairwise : list:'T list -> ('T * 'T) list
/// Splits the collection into two collections, containing the
/// elements for which the given predicate returns true and false
/// respectively. Element order is preserved in both of the created lists.
val partition : predicate:('T -> bool) -> list:'T list -> 'T list * 'T list
/// Applies 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
val pick : chooser:('T -> 'U option) -> list:'T list -> 'U
/// Returns a list with all elements permuted according to the
/// specified permutation.
val permute : indexMap:(int -> int) -> list:'T list -> 'T list
/// 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.
val reduce : reduction:('T -> 'T -> 'T) -> list:'T list -> 'T
/// Applies a function to each element of the collection, starting from the end, 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)).
val reduceBack : reduction:('T -> 'T -> 'T) -> list:'T list -> 'T
/// Creates a list by replicating the given initial value.
val replicate : count:int -> initial:'T -> 'T list
/// Returns a new list with the elements in reverse order.
val rev : list:'T list -> 'T list
/// Applies 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. Returns the list of intermediate results and the final result.
val scan : folder:('State -> 'T -> 'State) -> state:'State -> list:'T list -> 'State list
/// Like foldBack, but returns both the intermediary and final results
val scanBack : folder:('T -> 'State -> 'State) -> list:'T list -> state:'State -> 'State list
/// Returns a list that contains one item only.
val inline singleton : value:'T -> 'T list
/// Returns the list after removing the first N elements.
val skip : count:int -> list:'T list -> 'T list
/// Bypasses elements in a list while the given predicate returns true, and then returns
/// the remaining elements of the list.
val skipWhile : predicate:('T -> bool) -> list:'T list -> 'T list
/// Sorts the given list using the given comparison function.
val sortWith : comparer:('T -> 'T -> int) -> list:'T list -> 'T list
/// Sorts the given list using keys given by the given projection. Keys are compared using Operators.compare.
val sortBy : projection:('T -> 'Key) -> list:'T list -> 'T list when 'Key : comparison
/// Sorts the given list using Operators.compare.
val sort : list:'T list -> 'T list when 'T : comparison
/// Splits a list into two lists, at the given index.
val splitAt : index:int -> list:'T list -> 'T list * 'T list
/// Sorts the given list in descending order using keys given by the given projection. Keys are compared using Operators.compare.
val inline sortByDescending : projection:('T -> 'Key) -> list:'T list -> 'T list when 'Key : comparison
/// Sorts the given list in descending order using Operators.compare.
val inline sortDescending : list:'T list -> 'T list when 'T : comparison
/// Returns the sum of the elements in the list.
val inline sum : list: ^T list -> ^T when ^T : (static member ( + ) : ^T * ^T -> ^T) and ^T : (static member Zero : ^T)
/// Returns the sum of the results generated by applying the function to each element of the list.
val inline sumBy : projection:('T -> ^U) -> list:'T list -> ^U when ^U : (static member ( + ) : ^U * ^U -> ^U) and ^U : (static member Zero : ^U)
/// Returns the list after removing the first element.
val tail : list:'T list -> 'T list
/// Returns the first N elements of the list.
val take : count:int -> list:'T list -> 'T list
/// Returns a list that contains all elements of the original list while the
/// given predicate returns true, and then returns no further elements.
val takeWhile : predicate:('T -> bool) -> list:'T list -> 'T list
/// Builds an array from the given list.
val toArray : list:'T list -> 'T []
/// Views the given list as a sequence.
val toSeq : list:'T list -> seq<'T>
/// Returns the first element of the list, or
/// None if the list is empty.
val tryHead : list:'T list -> 'T option
/// Returns at most N elements in a new list.
val truncate : count:int -> list:'T list -> 'T list
/// Applies 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.
val tryPick : chooser:('T -> 'U option) -> list:'T list -> 'U option
/// Returns the first element for which the given function returns true..
/// Return None if no such element exists.
val tryFind : predicate:('T -> bool) -> list:'T list -> 'T option
/// Returns the last element for which the given function returns true..
/// Return None if no such element exists.
val tryFindBack : predicate:('T -> bool) -> list:'T list -> 'T option
/// Returns the index of the first element in the list
/// that satisfies the given predicate.
/// Return None if no such element exists.
val tryFindIndex : predicate:('T -> bool) -> list:'T list -> int option
/// Tries to find the nth element in the list.
/// Returns None if index is negative or the list does not contain enough elements.
val tryItem : index:int -> list:'T list -> 'T option
/// Returns the index of the last element in the list
/// that satisfies the given predicate.
/// Return None if no such element exists.
val tryFindIndexBack : predicate:('T -> bool) -> list:'T list -> int option
/// Returns a list that contains the elements generated by the given computation.
/// The given initial state argument is passed to the element generator.
val unfold : generator:('State -> ('T * 'State) option) -> state:'State -> 'T list
/// Splits a list of pairs into two lists.
val unzip : list:('T1 * 'T2) list -> 'T1 list * 'T2 list
/// Splits a list of triples into three lists.
val unzip3 : list:('T1 * 'T2 * 'T3) list -> 'T1 list * 'T2 list * 'T3 list
/// Returns a new list containing only the elements of the list
/// for which the given predicate returns "true"
val where : predicate:('T -> bool) -> list:'T list -> 'T list
/// Returns a list of sliding windows containing elements drawn from the input
/// list. Each window is returned as a fresh array.
val windowed : windowSize:int -> list:'T list -> 'T [] list
/// Combines the two lists into a list of pairs. The two lists must have equal lengths.
val zip : list1:'T1 list -> list2:'T2 list -> ('T1 * 'T2) list
/// Combines the three lists into a list of triples. The lists must have equal lengths.
val zip3 : list1:'T1 list -> list2:'T2 list -> list3:'T3 list -> ('T1 * 'T2 * 'T3) list
/// Common notions of value identity used with hash tables.
module Microsoft.FSharp.Collections.HashIdentity
/// Structural hashing. Hash using Operators.(=) and Operators.hash.
val Structural : Collections.Generic.IEqualityComparer<'T> when 'T : equality
val inline LimitedStructural : limit:int -> Collections.Generic.IEqualityComparer<'T> when 'T : equality
/// 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.
val Reference : Collections.Generic.IEqualityComparer<'T> when 'T : not struct
/// Hash using the given hashing and equality functions.
val inline FromFunctions : hasher:('T -> int) -> equality:('T -> 'T -> bool) -> Collections.Generic.IEqualityComparer<'T>
/// Common notions of comparison identity used with sorted data structures.
module Microsoft.FSharp.Collections.ComparisonIdentity
/// Structural comparison. Compare using Operators.compare.
val Structural : Collections.Generic.IComparer<'T> when 'T : comparison
/// Compare using the given comparer function.
val FromFunction : comparer:('T -> 'T -> int) -> Collections.Generic.IComparer<'T>
/// Basic operations on arrays.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Collections.Array
/// Builds a new array that contains the elements of the first array followed by the elements of the second array.
val append : array1:'T [] -> array2:'T [] -> 'T []
/// Returns the average of the elements in the array.
val inline average : array: ^T [] -> ^T when ^T : (static member ( + ) : ^T * ^T -> ^T) and ^T : (static member DivideByInt : ^T * int -> ^T) and ^T : (static member Zero : ^T)
/// Returns the average of the elements generated by applying the function to each element of the array.
val inline averageBy : projection:('T -> ^U) -> array:'T [] -> ^U when ^U : (static member ( + ) : ^U * ^U -> ^U) and ^U : (static member DivideByInt : ^U * int -> ^U) and ^U : (static member Zero : ^U)
/// Reads a range of elements from the first array and write them into the second.
val blit : source:'T [] -> sourceIndex:int -> target:'T [] -> targetIndex:int -> count:int -> unit
/// For each element of the array, applies the given function. Concatenates all the results and return the combined array.
val collect : mapping:('T -> 'U []) -> array:'T [] -> 'U []
/// Compares two arrays using the given comparison function, element by element.
/// Returns the first non-zero result from the comparison function. If the end of an array
/// is reached it returns a -1 if the first array is shorter and a 1 if the second array
/// is shorter.
val inline compareWith : comparer:('T -> 'T -> int) -> array1:'T [] -> array2:'T [] -> int
/// Builds a new array that contains the elements of each of the given sequence of arrays.
val concat : arrays:seq<'T []> -> 'T []
/// Tests if the array contains the specified element.
val inline contains : value:'T -> array:'T [] -> bool when 'T : equality
/// Builds a new array that contains the elements of the given array.
val copy : array:'T [] -> 'T []
/// Applies a key-generating function to each element of an array and returns an array yielding unique
/// keys and their number of occurrences in the original array.
val countBy : projection:('T -> 'Key) -> array:'T [] -> ('Key * int) [] when 'Key : equality
/// Creates an array whose elements are all initially the given value.
val create : count:int -> value:'T -> 'T []
/// Returns the first element of the array, or
/// None if the array is empty.
val tryHead : array:'T [] -> 'T option
/// Applies 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.
val tryPick : chooser:('T -> 'U option) -> array:'T [] -> 'U option
/// Fills a range of elements of the array with the given value.
val fill : target:'T [] -> targetIndex:int -> count:int -> value:'T -> unit
/// Applies 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.
val pick : chooser:('T -> 'U option) -> array:'T [] -> 'U
/// Applies the given function to each element of the array. Returns
/// the array comprised of the results "x" for each element where
/// the function returns Some(x)
val choose : chooser:('T -> 'U option) -> array:'T [] -> 'U []
/// Returns an array that contains no duplicate entries according to generic hash and
/// equality comparisons on the entries.
/// If an element occurs multiple times in the array then the later occurrences are discarded.
val distinct : array:'T [] -> 'T [] when 'T : equality
/// Returns an array 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 array then the later occurrences are discarded.
val distinctBy : projection:('T -> 'Key) -> array:'T [] -> 'T [] when 'Key : equality
/// Returns an empty array of the given type.
val empty : 'T []
/// Returns the only element of the array.
val exactlyOne : array:'T [] -> 'T
/// Tests if any element of the array satisfies the given predicate.
val exists : predicate:('T -> bool) -> array:'T [] -> bool
/// Tests if any pair of corresponding elements of the arrays satisfies the given predicate.
val exists2 : predicate:('T1 -> 'T2 -> bool) -> array1:'T1 [] -> array2:'T2 [] -> bool
/// Returns a new collection containing only the elements of the collection
/// for which the given predicate returns "true".
val filter : predicate:('T -> bool) -> array:'T [] -> 'T []
/// Returns the first element for which the given function returns 'true'.
/// Raise KeyNotFoundException if no such element exists.
val find : predicate:('T -> bool) -> array:'T [] -> 'T
/// Returns the last element for which the given function returns 'true'.
/// Raise KeyNotFoundException if no such element exists.
val findBack : predicate:('T -> bool) -> array:'T [] -> 'T
/// Returns the index of the first element in the array
/// that satisfies the given predicate. Raise KeyNotFoundException if
/// none of the elements satisfy the predicate.
val findIndex : predicate:('T -> bool) -> array:'T [] -> int
/// Returns the index of the last element in the array
/// that satisfies the given predicate. Raise KeyNotFoundException if
/// none of the elements satisfy the predicate.
val findIndexBack : predicate:('T -> bool) -> array:'T [] -> int
/// Tests if all elements of the array satisfy the given predicate.
val forall : predicate:('T -> bool) -> array:'T [] -> bool
/// Tests if all corresponding elements of the array satisfy the given predicate pairwise.
val forall2 : predicate:('T1 -> 'T2 -> bool) -> array1:'T1 [] -> array2:'T2 [] -> bool
/// Applies a function to each element of the collection, threading an accumulator argument
/// through the computation. If the input function is f and the elements are i0...iN then computes
/// f (... (f s i0)...) iN
val fold : folder:('State -> 'T -> 'State) -> state:'State -> array:'T [] -> 'State
/// Applies a function to each element of the array, starting from the end, 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))
val foldBack : folder:('T -> 'State -> 'State) -> array:'T [] -> state:'State -> 'State
/// Applies 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.
val fold2 : folder:('State -> 'T1 -> 'T2 -> 'State) -> state:'State -> array1:'T1 [] -> array2:'T2 [] -> 'State
/// 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.
val foldBack2 : folder:('T1 -> 'T2 -> 'State -> 'State) -> array1:'T1 [] -> array2:'T2 [] -> state:'State -> 'State
/// Gets an element from an array.
val get : array:'T [] -> index:int -> 'T
/// Returns the first element of the array.
val head : array:'T [] -> 'T
/// Applies a key-generating function to each element of an array and yields an array of
/// unique keys. Each unique key contains an array of all elements that match
/// to this key.
val groupBy : projection:('T -> 'Key) -> array:'T [] -> ('Key * 'T []) [] when 'Key : equality
/// Builds a new array whose elements are the corresponding elements of the input array
/// paired with the integer index (from 0) of each element.
val indexed : array:'T [] -> (int * 'T) []
/// Creates an array given the dimension and a generator function to compute the elements.
val inline init : count:int -> initializer:(int -> 'T) -> 'T []
/// Creates an array where the entries are initially the default value Unchecked.defaultof<'T>.
val zeroCreate : count:int -> 'T []
/// Returns true if the given array is empty, otherwise false.
val isEmpty : array:'T [] -> bool
/// Applies the given function to each element of the array.
val inline iter : action:('T -> unit) -> array:'T [] -> unit
/// Applies 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.
val iter2 : action:('T1 -> 'T2 -> unit) -> array1:'T1 [] -> array2:'T2 [] -> unit
/// Applies the given function to each element of the array. The integer passed to the
/// function indicates the index of element.
val iteri : action:(int -> 'T -> unit) -> array:'T [] -> unit
/// Applies 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.
val iteri2 : action:(int -> 'T1 -> 'T2 -> unit) -> array1:'T1 [] -> array2:'T2 [] -> unit
/// Returns the last element of the array.
val inline last : array:'T [] -> 'T
/// Gets an element from an array.
val item : index:int -> array:'T [] -> 'T
/// Returns the length of an array. You can also use property arr.Length.
val length : array:'T [] -> int
/// Returns the last element of the array.
/// Return None if no such element exists.
val tryLast : array:'T [] -> 'T option
/// Builds a new array whose elements are the results of applying the given function
/// to each of the elements of the array.
val inline map : mapping:('T -> 'U) -> array:'T [] -> 'U []
/// Builds 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.
val map2 : mapping:('T1 -> 'T2 -> 'U) -> array1:'T1 [] -> array2:'T2 [] -> 'U []
/// Combines map and fold. Builds a new array whose elements are the results of applying the given function
/// to each of the elements of the input array. The function is also used to accumulate a final value.
val mapFold : mapping:('State -> 'T -> 'Result * 'State) -> state:'State -> array:'T [] -> 'Result [] * 'State
/// Combines map and foldBack. Builds a new array whose elements are the results of applying the given function
/// to each of the elements of the input array. The function is also used to accumulate a final value.
val mapFoldBack : mapping:('T -> 'State -> 'Result * 'State) -> array:'T [] -> state:'State -> 'Result [] * 'State
/// Builds a new collection whose elements are the results of applying the given function
/// to the corresponding triples from the three collections. The three input
/// arrays must have the same length, otherwise an ArgumentException is
/// raised.
val map3 : mapping:('T1 -> 'T2 -> 'T3 -> 'U) -> array1:'T1 [] -> array2:'T2 [] -> array3:'T3 [] -> 'U []
/// Builds 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.
val mapi2 : mapping:(int -> 'T1 -> 'T2 -> 'U) -> array1:'T1 [] -> array2:'T2 [] -> 'U []
/// Builds 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.
val mapi : mapping:(int -> 'T -> 'U) -> array:'T [] -> 'U []
/// Returns the greatest of all elements of the array, compared via Operators.max on the function result.
val inline max : array:'T [] -> 'T when 'T : comparison
/// Returns the greatest of all elements of the array, compared via Operators.max on the function result.
val inline maxBy : projection:('T -> 'U) -> array:'T [] -> 'T when 'U : comparison
/// Returns the lowest of all elements of the array, compared via Operators.min.
val inline min : array:'T [] -> 'T when 'T : comparison
/// Returns the lowest of all elements of the array, compared via Operators.min on the function result.
val inline minBy : projection:('T -> 'U) -> array:'T [] -> 'T when 'U : comparison
/// Builds an array from the given list.
val ofList : list:'T list -> 'T []
/// Builds a new array from the given enumerable object.
val ofSeq : source:seq<'T> -> 'T []
/// Returns an array of each element in the input array and its predecessor, with the
/// exception of the first element which is only returned as the predecessor of the second element.
val pairwise : array:'T [] -> ('T * 'T) []
/// Splits the collection into two collections, containing the
/// elements for which the given predicate returns "true" and "false"
/// respectively.
val partition : predicate:('T -> bool) -> array:'T [] -> 'T [] * 'T []
/// Returns an array with all elements permuted according to the
/// specified permutation.
val permute : indexMap:(int -> int) -> array:'T [] -> 'T []
/// Applies 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.
val reduce : reduction:('T -> 'T -> 'T) -> array:'T [] -> 'T
/// Applies a function to each element of the array, starting from the end, 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)).
val reduceBack : reduction:('T -> 'T -> 'T) -> array:'T [] -> 'T
/// Creates an array by replicating the given initial value.
val replicate : count:int -> initial:'T -> 'T []
/// Returns a new array with the elements in reverse order.
val rev : array:'T [] -> 'T []
/// Like fold, but return the intermediary and final results.
val scan : folder:('State -> 'T -> 'State) -> state:'State -> array:'T [] -> 'State []
/// Like foldBack, but return both the intermediary and final results.
val scanBack : folder:('T -> 'State -> 'State) -> array:'T [] -> state:'State -> 'State []
/// Returns an array that contains one item only.
val inline singleton : value:'T -> 'T []
/// Sets an element of an array.
val set : array:'T [] -> index:int -> value:'T -> unit
/// Builds a new array that contains the elements of the given array, excluding the first N elements.
val skip : count:int -> array:'T [] -> 'T []
/// Bypasses elements in an array while the given predicate returns true, and then returns
/// the remaining elements in a new array.
val skipWhile : predicate:('T -> bool) -> array:'T [] -> 'T []
/// Builds a new array that contains the given subrange specified by
/// starting index and length.
val sub : array:'T [] -> startIndex:int -> count:int -> 'T []
/// Sorts the elements of an array, returning a new array. Elements are compared using Operators.compare.
val sort : array:'T [] -> 'T [] when 'T : comparison
/// Sorts the elements of an array, using the given projection for the keys and returning a new array.
/// Elements are compared using Operators.compare.
val sortBy : projection:('T -> 'Key) -> array:'T [] -> 'T [] when 'Key : comparison
/// Sorts the elements of an array, using the given comparison function as the order, returning a new array.
val sortWith : comparer:('T -> 'T -> int) -> array:'T [] -> 'T []
/// Sorts the elements of an array by mutating the array in-place, using the given projection for the keys.
/// Elements are compared using Operators.compare.
val sortInPlaceBy : projection:('T -> 'Key) -> array:'T [] -> unit when 'Key : comparison
/// Sorts the elements of an array by mutating the array in-place, using the given comparison function as the order.
val sortInPlaceWith : comparer:('T -> 'T -> int) -> array:'T [] -> unit
/// Sorts the elements of an array by mutating the array in-place, using the given comparison function.
/// Elements are compared using Operators.compare.
val sortInPlace : array:'T [] -> unit when 'T : comparison
/// Splits an array into two arrays, at the given index.
val splitAt : index:int -> array:'T [] -> 'T [] * 'T []
/// Sorts the elements of an array, in descending order, returning a new array. Elements are compared using Operators.compare.
val inline sortDescending : array:'T [] -> 'T [] when 'T : comparison
/// Sorts the elements of an array, in descending order, using the given projection for the keys and returning a new array.
/// Elements are compared using Operators.compare.
val inline sortByDescending : projection:('T -> 'Key) -> array:'T [] -> 'T [] when 'Key : comparison
/// Returns the sum of the elements in the array.
val inline sum : array: ^T [] -> ^T when ^T : (static member ( + ) : ^T * ^T -> ^T) and ^T : (static member Zero : ^T)
/// Returns the sum of the results generated by applying the function to each element of the array.
val inline sumBy : projection:('T -> ^U) -> array:'T [] -> ^U when ^U : (static member ( + ) : ^U * ^U -> ^U) and ^U : (static member Zero : ^U)
/// Returns the first N elements of the array.
val take : count:int -> array:'T [] -> 'T []
/// Returns an array that contains all elements of the original array while the
/// given predicate returns true, and then returns no further elements.
val takeWhile : predicate:('T -> bool) -> array:'T [] -> 'T []
/// Returns a new array containing the elements of the original except the first element.
val tail : array:'T [] -> 'T []
/// Builds a list from the given array.
val toList : array:'T [] -> 'T list
/// Views the given array as a sequence.
val toSeq : array:'T [] -> seq<'T>
/// Returns at most N elements in a new array.
val truncate : count:int -> array:'T [] -> 'T []
/// Returns the first element for which the given function returns true.
/// Return None if no such element exists.
val tryFind : predicate:('T -> bool) -> array:'T [] -> 'T option
/// Returns the last element for which the given function returns true.
/// Return None if no such element exists.
val tryFindBack : predicate:('T -> bool) -> array:'T [] -> 'T option
/// Returns the index of the first element in the array
/// that satisfies the given predicate.
val tryFindIndex : predicate:('T -> bool) -> array:'T [] -> int option
/// Tries to find the nth element in the array.
/// Returns None if index is negative or the input array does not contain enough elements.
val tryItem : index:int -> array:'T [] -> 'T option
/// Returns the index of the last element in the array
/// that satisfies the given predicate.
val tryFindIndexBack : predicate:('T -> bool) -> array:'T [] -> int option
/// Returns an array that contains the elements generated by the given computation.
/// The given initial state argument is passed to the element generator.
val unfold : generator:('State -> ('T * 'State) option) -> state:'State -> 'T []
/// Splits an array of pairs into two arrays.
val unzip : array:('T1 * 'T2) [] -> 'T1 [] * 'T2 []
/// Splits an array of triples into three arrays.
val unzip3 : array:('T1 * 'T2 * 'T3) [] -> 'T1 [] * 'T2 [] * 'T3 []
/// Returns a new array containing only the elements of the array
/// for which the given predicate returns "true".
val where : predicate:('T -> bool) -> array:'T [] -> 'T []
/// Returns an array of sliding windows containing elements drawn from the input
/// array. Each window is returned as a fresh array.
val windowed : windowSize:int -> array:'T [] -> 'T [] []
/// Combines the two arrays into an array of pairs. The two arrays must have equal lengths, otherwise an ArgumentException is
/// raised.
val zip : array1:'T1 [] -> array2:'T2 [] -> ('T1 * 'T2) []
/// Combines three arrays into an array of pairs. The three arrays must have equal lengths, otherwise an ArgumentException is
/// raised.
val zip3 : array1:'T1 [] -> array2:'T2 [] -> array3:'T3 [] -> ('T1 * 'T2 * 'T3) []
/// Provides parallel operations on arrays
module Parallel =
/// 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).
val choose : chooser:('T -> 'U option) -> array:'T [] -> 'U []
/// For each element of the array, apply the given function. Concatenate all the results and return the combined array.
val collect : mapping:('T -> 'U []) -> array:'T [] -> 'U []
/// Build a new array whose elements are the results of applying the given function
/// to each of the elements of the array.
val map : mapping:('T -> 'U) -> array:'T [] -> 'U []
/// 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.
val mapi : mapping:(int -> 'T -> 'U) -> array:'T [] -> 'U []
/// Apply the given function to each element of the array.
val iter : action:('T -> unit) -> array:'T [] -> unit
/// Apply the given function to each element of the array. The integer passed to the
/// function indicates the index of element.
val iteri : action:(int -> 'T -> unit) -> array:'T [] -> unit
/// Create an array given the dimension and a generator function to compute the elements.
val init : count:int -> initializer:(int -> 'T) -> 'T []
/// Split the collection into two collections, containing the
/// elements for which the given predicate returns "true" and "false"
/// respectively
val partition : predicate:('T -> bool) -> array:'T [] -> 'T [] * 'T []
/// Basic operations on rank 4 arrays.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Collections.Array4D
/// Creates an array whose elements are all initially the given value
val create : length1:int -> length2:int -> length3:int -> length4:int -> initial:'T -> 'T [,,,]
/// Creates an array given the dimensions and a generator function to compute the elements.
val init : length1:int -> length2:int -> length3:int -> length4:int -> initializer:(int -> int -> int -> int -> 'T) -> 'T [,,,]
/// Returns the length of an array in the first dimension
val length1 : array:'T [,,,] -> int
/// Returns the length of an array in the second dimension.
val length2 : array:'T [,,,] -> int
/// Returns the length of an array in the third dimension.
val length3 : array:'T [,,,] -> int
/// Returns the length of an array in the fourth dimension.
val length4 : array:'T [,,,] -> int
/// Creates an array where the entries are initially the "default" value.
val zeroCreate : length1:int -> length2:int -> length3:int -> length4:int -> 'T [,,,]
/// Fetches an element from a 4D array. You can also use the syntax 'array.[index1,index2,index3,index4]'
val get : array:'T [,,,] -> index1:int -> index2:int -> index3:int -> index4:int -> 'T
/// Sets the value of an element in an array. You can also
/// use the syntax 'array.[index1,index2,index3,index4] <- value'.
val set : array:'T [,,,] -> index1:int -> index2:int -> index3:int -> index4:int -> value:'T -> unit
/// Basic operations on rank 3 arrays.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Collections.Array3D
/// Creates an array whose elements are all initially the given value.
val create : length1:int -> length2:int -> length3:int -> initial:'T -> 'T [,,]
/// Creates an array given the dimensions and a generator function to compute the elements.
val init : length1:int -> length2:int -> length3:int -> initializer:(int -> int -> int -> 'T) -> 'T [,,]
/// Fetches an element from a 3D array. You can also use the syntax 'array.[index1,index2,index3]'
val get : array:'T [,,] -> index1:int -> index2:int -> index3:int -> 'T
/// Applies the given function to each element of the array.
val iter : action:('T -> unit) -> array:'T [,,] -> unit
/// Applies the given function to each element of the array. The integer indicies passed to the
/// function indicates the index of element.
val iteri : action:(int -> int -> int -> 'T -> unit) -> array:'T [,,] -> unit
/// Returns the length of an array in the first dimension
val length1 : array:'T [,,] -> int
/// Returns the length of an array in the second dimension.
val length2 : array:'T [,,] -> int
/// Returns the length of an array in the third dimension.
val length3 : array:'T [,,] -> int
/// Builds a new array whose elements are the results of applying the given function
/// to each of the elements of the array.
val map : mapping:('T -> 'U) -> array:'T [,,] -> 'U [,,]
/// Builds 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.
val mapi : mapping:(int -> int -> int -> 'T -> 'U) -> array:'T [,,] -> 'U [,,]
/// Sets the value of an element in an array. You can also
/// use the syntax 'array.[index1,index2,index3] <- value'.
val set : array:'T [,,] -> index1:int -> index2:int -> index3:int -> value:'T -> unit
/// Creates an array where the entries are initially the "default" value.
val zeroCreate : length1:int -> length2:int -> length3:int -> 'T [,,]
/// Basic operations on 2-dimensional arrays.
[<CompilationRepresentation(enum<CompilationRepresentationFlags> (4))>]
[<RequireQualifiedAccess>]
module Microsoft.FSharp.Collections.Array2D
/// Fetches the base-index for the first dimension of the array.
val base1 : array:'T [,] -> int
/// Fetches the base-index for the second dimension of the array.
val base2 : array:'T [,] -> int
/// Builds a new array whose elements are the same as the input array.
val copy : array:'T [,] -> 'T [,]
/// Reads a range of elements from the first array and write them into the second.
val blit : source:'T [,] -> sourceIndex1:int -> sourceIndex2:int -> target:'T [,] -> targetIndex1:int -> targetIndex2:int -> length1:int -> length2:int -> unit
/// Creates an array given the dimensions and a generator function to compute the elements.
val init : length1:int -> length2:int -> initializer:(int -> int -> 'T) -> 'T [,]
/// Creates an array whose elements are all initially the given value.
val create : length1:int -> length2:int -> value:'T -> 'T [,]
/// Creates an array where the entries are initially Unchecked.defaultof<'T>.
val zeroCreate : length1:int -> length2:int -> 'T [,]
/// Creates a based array given the dimensions and a generator function to compute the elements.
val initBased : base1:int -> base2:int -> length1:int -> length2:int -> initializer:(int -> int -> 'T) -> 'T [,]
/// Creates a based array whose elements are all initially the given value.
val createBased : base1:int -> base2:int -> length1:int -> length2:int -> initial:'T -> 'T [,]
/// Creates a based array where the entries are initially Unchecked.defaultof<'T>.
val zeroCreateBased : base1:int -> base2:int -> length1:int -> length2:int -> 'T [,]
/// Applies the given function to each element of the array.
val iter : action:('T -> unit) -> array:'T [,] -> unit
/// Applies the given function to each element of the array. The integer indices passed to the
/// function indicates the index of element.
val iteri : action:(int -> int -> 'T -> unit) -> array:'T [,] -> unit
/// Returns the length of an array in the first dimension.
val length1 : array:'T [,] -> int
/// Returns the length of an array in the second dimension.
val length2 : array:'T [,] -> int
/// Builds a new array whose elements are the results of applying the given function
/// to each of the elements of the array.
val map : mapping:('T -> 'U) -> array:'T [,] -> 'U [,]
/// Builds 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.
val mapi : mapping:(int -> int -> 'T -> 'U) -> array:'T [,] -> 'U [,]
/// Builds 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.
val rebase : array:'T [,] -> 'T [,]
/// Sets the value of an element in an array. You can also use the syntax array.[index1,index2] <- value.
val set : array:'T [,] -> index1:int -> index2:int -> value:'T -> unit
/// Fetches an element from a 2D array. You can also use the syntax array.[index1,index2].
val get : array:'T [,] -> index1:int -> index2:int -> 'T
Raw
PublicSurfaceArea.fsx
This file has been truncated, but you can view the full file.
#r "System.Xml.Linq"
#r @"..\packages\FSharp.Compiler.Service\lib\net45\FSharp.Compiler.Service.dll"
#r @"..\src\FSharpVSPowerTools.Core\bin\Release\FSharpVSPowerTools.Core.dll"
open System
open System.IO
open System.Collections.Generic
open System.Text
open System.Xml.Linq
open Microsoft.FSharp.Compiler.AbstractIL.Internal.Library
open Microsoft.FSharp.Compiler.SourceCodeServices
open FSharpVSPowerTools.CodeGeneration
// http://fsharp.github.io/FSharp.Compiler.Service/filesystem.html
let defaultFileSystem = Shim.FileSystem
let fileName1 = @"c:\mycode\test1.fs" // note, the path doesn't exist
type MyFileSystem() =
// https://github.com/fsharp/FSharp.Compiler.Service/pull/287
// let dfs = DefaultFileSystem() :> IFileSystem
let dfs = defaultFileSystem
let file1 = """
open System
let a = 1
"""
let files = dict [(fileName1, file1)]
interface IFileSystem with
// Implement the service to open files for reading and writing
member __.FileStreamReadShim(fileName) =
match files.TryGetValue(fileName) with
| true, text -> new MemoryStream(Encoding.UTF8.GetBytes(text)) :> Stream
| _ -> dfs.FileStreamReadShim(fileName)
member __.FileStreamCreateShim(fileName) =
dfs.FileStreamCreateShim(fileName)
member __.FileStreamWriteExistingShim(fileName) =
dfs.FileStreamWriteExistingShim(fileName)
member __.ReadAllBytesShim(fileName) =
match files.TryGetValue(fileName) with
| true, text -> Encoding.UTF8.GetBytes(text)
| _ -> dfs.ReadAllBytesShim(fileName)
// Implement the service related to temporary paths and file time stamps
member __.GetTempPathShim() =
dfs.GetTempPathShim()
member __.GetLastWriteTimeShim(fileName) =
dfs.GetLastWriteTimeShim(fileName)
member __.GetFullPathShim(fileName) =
dfs.GetFullPathShim(fileName)
member __.IsInvalidPathShim(fileName) =
dfs.IsInvalidPathShim(fileName)
member __.IsPathRootedShim(fileName) =
dfs.IsPathRootedShim(fileName)
// Implement the service related to file existence and deletion
member __.SafeExists(fileName) =
files.ContainsKey(fileName) || dfs.SafeExists(fileName)
member __.FileDelete(fileName) =
dfs.FileDelete(fileName)
// Implement the service related to assembly loading, used to load type providers
// and for F# interactive.
member __.AssemblyLoadFrom(fileName) =
dfs.AssemblyLoadFrom fileName
member __.AssemblyLoad(assemblyName) =
dfs.AssemblyLoad assemblyName
Shim.FileSystem <- MyFileSystem()
let checker = FSharpChecker.Create()
// C:\Program Files (x86)
let programFiles86 = Environment.GetFolderPath Environment.SpecialFolder.ProgramFilesX86
// C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0
let net40 = programFiles86 + @"\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0"
let projectOptions =
let allFlags =
[| yield "--simpleresolution";
yield "--noframework";
yield "--debug:full";
yield "--define:DEBUG";
yield "--optimize-";
yield "--doc:test.xml";
yield "--warn:3";
yield "--fullpaths";
yield "--flaterrors";
yield "--target:library";
let references =
[ net40 + @"\mscorlib.dll"
net40 + @"\System.dll"
net40 + @"\System.Core.dll"
net40 + @"\System.Numerics.dll"
// C:\Program Files (x86)\Reference Assemblies\Microsoft\FSharp\.NETFramework\v4.0\4.3.0.0\FSharp.Core.dll
// programFiles86 + @"\Reference Assemblies\Microsoft\FSharp\.NETFramework\v4.0\4.3.0.0\FSharp.Core.dll"
// programFiles86 + @"\Reference Assemblies\Microsoft\FSharp\.NETFramework\v4.0\4.3.1.0\FSharp.Core.dll"
programFiles86 + @"\Reference Assemblies\Microsoft\FSharp\.NETFramework\v4.0\4.4.0.0\FSharp.Core.dll"
]
for r in references do
yield "-r:" + r |]
{ ProjectFileName = @"c:\mycode\compilation.fsproj" // Make a name that is unique in this directory.
ProjectFileNames = [| fileName1 |]
OtherOptions = allFlags
ReferencedProjects = [| |]
IsIncompleteTypeCheckEnvironment = false
UseScriptResolutionRules = true
LoadTime = System.DateTime.Now // Note using 'Now' forces reloading
UnresolvedReferences = None }
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment