diff --git a/src/fsharp/FSharp.Core/prim-types.fsi b/src/fsharp/FSharp.Core/prim-types.fsi index 24f68574e0a..f4bb2eccc87 100644 --- a/src/fsharp/FSharp.Core/prim-types.fsi +++ b/src/fsharp/FSharp.Core/prim-types.fsi @@ -99,14 +99,14 @@ namespace Microsoft.FSharp.Core inherit Attribute /// Creates an instance of the attribute. /// The created attribute. - new : unit -> SealedAttribute + new: unit -> SealedAttribute /// Creates an instance of the attribute /// /// Indicates whether the class is sealed. /// /// SealedAttribute - new : value:bool -> SealedAttribute + new: value:bool -> SealedAttribute /// The value of the attribute, indicating whether the type is sealed or not. member Value: bool @@ -122,7 +122,7 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// AbstractClassAttribute - new : unit -> AbstractClassAttribute + new: unit -> AbstractClassAttribute /// Adding this attribute to the let-binding for the definition of a top-level /// value makes the quotation expression that implements the value available @@ -136,14 +136,14 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// ReflectedDefinitionAttribute - new : unit -> ReflectedDefinitionAttribute + new: unit -> ReflectedDefinitionAttribute /// Creates an instance of the attribute /// /// Indicates whether to include the evaluated value of the definition as the outer node of the quotation /// /// ReflectedDefinitionAttribute - new : includeValue:bool -> ReflectedDefinitionAttribute + new: includeValue:bool -> ReflectedDefinitionAttribute /// The value of the attribute, indicating whether to include the evaluated value of the definition as the outer node of the quotation member IncludeValue: bool @@ -171,7 +171,7 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// EqualityConditionalOnAttribute - new : unit -> EqualityConditionalOnAttribute + new: unit -> EqualityConditionalOnAttribute /// This attribute is used to indicate a generic container type satisfies the F# 'comparison' /// constraint only if a generic argument also satisfies this constraint. @@ -194,7 +194,7 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// ComparisonConditionalOnAttribute - new : unit -> ComparisonConditionalOnAttribute + new: unit -> ComparisonConditionalOnAttribute /// Adding this attribute to a type causes it to be represented using a CLI struct. /// @@ -206,7 +206,7 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// StructAttribute - new : unit -> StructAttribute + new: unit -> StructAttribute /// 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. @@ -219,7 +219,7 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// MeasureAttribute - new : unit -> MeasureAttribute + new: unit -> MeasureAttribute /// 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. @@ -232,7 +232,7 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// MeasureAnnotatedAbbreviationAttribute - new : unit -> MeasureAnnotatedAbbreviationAttribute + new: unit -> MeasureAnnotatedAbbreviationAttribute /// Adding this attribute to a type causes it to be represented using a CLI interface. /// @@ -244,7 +244,7 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// InterfaceAttribute - new : unit -> InterfaceAttribute + new: unit -> InterfaceAttribute /// Adding this attribute to a type causes it to be represented using a CLI class. /// @@ -256,7 +256,7 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// ClassAttribute - new : unit -> ClassAttribute + new: unit -> ClassAttribute /// 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 @@ -270,11 +270,11 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// AllowNullLiteralAttribute - new : unit -> AllowNullLiteralAttribute + new: unit -> AllowNullLiteralAttribute /// Creates an instance of the attribute with the specified value /// AllowNullLiteralAttribute - new : value: bool -> AllowNullLiteralAttribute + new: value: bool -> AllowNullLiteralAttribute /// The value of the attribute, indicating whether the type allows the null literal or not member Value: bool @@ -289,7 +289,7 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// LiteralAttribute - new : unit -> LiteralAttribute + new: unit -> LiteralAttribute /// 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 @@ -303,7 +303,7 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// CLIEventAttribute - new : unit -> CLIEventAttribute + new: unit -> CLIEventAttribute /// 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. @@ -316,7 +316,7 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// CLIMutableAttribute - new : unit -> CLIMutableAttribute + new: unit -> CLIMutableAttribute /// Adding this attribute to a discriminated union with value false /// turns off the generation of standard helper member tester, constructor @@ -337,7 +337,7 @@ namespace Microsoft.FSharp.Core /// union. /// /// DefaultAugmentationAttribute - new : value:bool -> DefaultAugmentationAttribute + new: value:bool -> DefaultAugmentationAttribute /// Adding this attribute to an F# mutable binding causes the "volatile" /// prefix to be used for all accesses to the field. @@ -350,7 +350,7 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// VolatileFieldAttribute - new : unit -> VolatileFieldAttribute + new: unit -> VolatileFieldAttribute /// 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 @@ -364,7 +364,7 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// EntryPointAttribute - new : unit -> EntryPointAttribute + new: unit -> EntryPointAttribute /// Adding this attribute to a record or union type disables the automatic generation /// of overrides for 'System.Object.Equals(obj)', 'System.Object.GetHashCode()' @@ -378,7 +378,7 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// ReferenceEqualityAttribute - new : unit -> ReferenceEqualityAttribute + new: unit -> ReferenceEqualityAttribute /// Adding this attribute to a record, union or struct type confirms the automatic /// generation of overrides for 'System.Object.Equals(obj)' and @@ -392,7 +392,7 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// StructuralEqualityAttribute - new : unit -> StructuralEqualityAttribute + new: unit -> StructuralEqualityAttribute /// Adding this attribute to a record, union, exception, or struct type confirms the /// automatic generation of implementations for 'System.IComparable' for the type. @@ -405,7 +405,7 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// StructuralComparisonAttribute - new : unit -> StructuralComparisonAttribute + new: unit -> StructuralComparisonAttribute /// Indicates that a member on a computation builder type is a custom query operator, /// and indicates the name of that operator. @@ -418,31 +418,31 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// CustomOperationAttribute - new : name:string -> CustomOperationAttribute + new: name:string -> CustomOperationAttribute /// Get the name of the custom operation when used in a query or other computation expression - member Name : string + member Name: string /// 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 + member AllowIntoPattern: 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 + member IsLikeZip: 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 + member IsLikeJoin: 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 + member IsLikeGroupJoin: 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 + 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 + 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 + member MaintainsVariableSpaceUsingBind: bool with get,set /// 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 @@ -454,7 +454,7 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// ProjectionParameterAttribute - new : unit -> ProjectionParameterAttribute + new: unit -> ProjectionParameterAttribute inherit Attribute /// Adding this attribute to a type indicates it is a type where equality is an abnormal operation. @@ -471,7 +471,7 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// NoEqualityAttribute - new : unit -> NoEqualityAttribute + new: unit -> NoEqualityAttribute /// Adding this attribute to a type indicates it is a type with a user-defined implementation of equality. /// @@ -483,7 +483,7 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// CustomEqualityAttribute - new : unit -> CustomEqualityAttribute + new: unit -> CustomEqualityAttribute /// Adding this attribute to a type indicates it is a type with a user-defined implementation of comparison. /// @@ -495,7 +495,7 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// CustomComparisonAttribute - new : unit -> CustomComparisonAttribute + new: unit -> CustomComparisonAttribute /// 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 @@ -512,7 +512,7 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// NoComparisonAttribute - new : unit -> NoComparisonAttribute + new: unit -> NoComparisonAttribute /// 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'. @@ -530,14 +530,14 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// DefaultValueAttribute - new : unit -> DefaultValueAttribute + new: unit -> DefaultValueAttribute /// Creates an instance of the attribute /// /// Indicates whether to assert that the field type supports null. /// /// DefaultValueAttribute - new : check: bool -> DefaultValueAttribute + new: check: bool -> DefaultValueAttribute /// This attribute is added automatically for all optional arguments. /// @@ -549,7 +549,7 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// OptionalArgumentAttribute - new : unit -> OptionalArgumentAttribute + new: unit -> OptionalArgumentAttribute /// Adding this attribute to a type, value or member requires that /// uses of the construct must explicitly instantiate any generic type parameters. @@ -562,7 +562,7 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// RequiresExplicitTypeArgumentsAttribute - new : unit -> RequiresExplicitTypeArgumentsAttribute + new: unit -> RequiresExplicitTypeArgumentsAttribute /// 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. @@ -591,7 +591,7 @@ namespace Microsoft.FSharp.Core /// The name to use in compiled code. /// /// CompiledNameAttribute - new : compiledName:string -> CompiledNameAttribute + new: compiledName:string -> CompiledNameAttribute /// The name of the value as it appears in compiled code member CompiledName: string @@ -610,7 +610,7 @@ namespace Microsoft.FSharp.Core /// Indicates whether the type should be serializable by default. /// /// AutoSerializableAttribute - new : value:bool -> AutoSerializableAttribute + new: value:bool -> AutoSerializableAttribute /// The value of the attribute, indicating whether the type is automatically marked serializable or not member Value: bool @@ -632,7 +632,7 @@ namespace Microsoft.FSharp.Core /// The release number. /// /// FSharpInterfaceDataVersionAttribute - new : major:int * minor:int * release:int -> FSharpInterfaceDataVersionAttribute + new: major:int * minor:int * release:int -> FSharpInterfaceDataVersionAttribute /// The major version number of the F# version associated with the attribute member Major: int @@ -662,7 +662,7 @@ namespace Microsoft.FSharp.Core /// Indicates the type of source construct. /// /// CompilationMappingAttribute - new : sourceConstructFlags:SourceConstructFlags -> CompilationMappingAttribute + new: sourceConstructFlags:SourceConstructFlags -> CompilationMappingAttribute /// Creates an instance of the attribute /// @@ -670,7 +670,7 @@ namespace Microsoft.FSharp.Core /// Indicates the index in the sequence of constructs. /// /// CompilationMappingAttribute - new : sourceConstructFlags:SourceConstructFlags * sequenceNumber: int -> CompilationMappingAttribute + new: sourceConstructFlags:SourceConstructFlags * sequenceNumber: int -> CompilationMappingAttribute /// Creates an instance of the attribute /// @@ -679,7 +679,7 @@ namespace Microsoft.FSharp.Core /// Indicates the index in the sequence of constructs. /// /// CompilationMappingAttribute - new : sourceConstructFlags:SourceConstructFlags * variantNumber : int * sequenceNumber : int -> CompilationMappingAttribute + new: sourceConstructFlags:SourceConstructFlags * variantNumber: int * sequenceNumber: int -> CompilationMappingAttribute /// Creates an instance of the attribute /// @@ -687,21 +687,22 @@ namespace Microsoft.FSharp.Core /// The name of the resource needed to resolve the source construct. /// /// CompilationMappingAttribute - new : resourceName:string * typeDefinitions:System.Type[] -> CompilationMappingAttribute + new: resourceName:string * typeDefinitions:System.Type[] -> CompilationMappingAttribute /// Indicates the relationship between the compiled entity and F# source code - member SourceConstructFlags : SourceConstructFlags + member SourceConstructFlags: SourceConstructFlags /// Indicates the sequence number of the entity, if any, in a linear sequence of elements with F# source code - member SequenceNumber : int + member SequenceNumber: int /// Indicates the variant number of the entity, if any, in a linear sequence of elements with F# source code - member VariantNumber : int + member VariantNumber: int + /// Indicates the resource the source construct relates to - member ResourceName : string + member ResourceName: string /// Indicates the type definitions needed to resolve the source construct - member TypeDefinitions : System.Type[] + member TypeDefinitions: System.Type[] /// This attribute is inserted automatically by the F# compiler to tag /// methods which are given the 'CompiledName' attribute. @@ -722,10 +723,10 @@ namespace Microsoft.FSharp.Core /// The name of the method in source. /// /// CompilationSourceNameAttribute - new : sourceName:string -> CompilationSourceNameAttribute + new: sourceName:string -> CompilationSourceNameAttribute /// Indicates the name of the entity in F# source code - member SourceName : string + member SourceName: string /// This attribute is used to adjust the runtime representation for a type. /// For example, it may be used to note that the null representation @@ -743,16 +744,17 @@ namespace Microsoft.FSharp.Core /// Indicates adjustments to the compiled representation of the type or member. /// /// CompilationRepresentationAttribute - new : flags:CompilationRepresentationFlags -> CompilationRepresentationAttribute + new: flags: CompilationRepresentationFlags -> CompilationRepresentationAttribute /// Indicates one or more adjustments to the compiled representation of an F# type or member - member Flags : CompilationRepresentationFlags + member Flags: CompilationRepresentationFlags module internal ExperimentalAttributeMessages = [] - val RequiresPreview : string = "Experimental library feature, requires '--langversion:preview'" + val RequiresPreview: string = "Experimental library feature, requires '--langversion:preview'" + [] - val NotSupportedYet : string = "This construct is not supported by your version of the F# compiler" + val NotSupportedYet: string = "This construct is not supported by your version of the F# compiler" /// This attribute is used to tag values that are part of an experimental library /// feature. @@ -768,7 +770,7 @@ namespace Microsoft.FSharp.Core /// The warning message to be emitted when code uses this construct. /// /// ExperimentalAttribute - new : message:string-> ExperimentalAttribute + new: message:string-> ExperimentalAttribute /// Indicates the warning message to be emitted when F# source code uses this construct member Message: string @@ -787,7 +789,7 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// InlineIfLambdaAttribute - new : unit -> InlineIfLambdaAttribute + new: unit -> InlineIfLambdaAttribute /// 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. @@ -804,7 +806,7 @@ namespace Microsoft.FSharp.Core /// Indicates the number of arguments in each argument group. /// /// CompilationArgumentCountsAttribute - new : counts:int[] -> CompilationArgumentCountsAttribute + new: counts:int[] -> CompilationArgumentCountsAttribute /// Indicates the number of arguments in each argument group member Counts: System.Collections.Generic.IEnumerable @@ -825,7 +827,7 @@ namespace Microsoft.FSharp.Core /// Indicates the text to display when using the '%A' printf formatting. /// /// StructuredFormatDisplayAttribute - new : value:string-> StructuredFormatDisplayAttribute + 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 @@ -841,7 +843,7 @@ namespace Microsoft.FSharp.Core inherit Attribute /// Creates an instance of the attribute. - new : message:string * messageNumber: int -> CompilerMessageAttribute + new: message:string * messageNumber: int -> CompilerMessageAttribute /// Indicates the warning message to be emitted when F# source code uses this construct member Message: string @@ -869,7 +871,7 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// UnverifiableAttribute - new : unit -> UnverifiableAttribute + new: unit -> UnverifiableAttribute /// 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 @@ -885,9 +887,9 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// NoDynamicInvocationAttribute - new : unit -> NoDynamicInvocationAttribute + new: unit -> NoDynamicInvocationAttribute - internal new : isLegacy: bool -> NoDynamicInvocationAttribute + internal new: isLegacy: bool -> NoDynamicInvocationAttribute /// This attribute is used to indicate that references to the elements of a module, record or union /// type require explicit qualified access. @@ -900,7 +902,7 @@ namespace Microsoft.FSharp.Core /// Creates an instance of the attribute /// RequireQualifiedAccessAttribute - new : unit -> RequireQualifiedAccessAttribute + new: unit -> RequireQualifiedAccessAttribute /// Indicates a construct is automatically opened when brought into scope through /// an assembly reference or then opening of the containing namespace or module. @@ -922,7 +924,7 @@ namespace Microsoft.FSharp.Core /// Creates an attribute used to mark a module as 'automatically opened' when the enclosing namespace is opened /// AutoOpenAttribute - new : unit -> AutoOpenAttribute + new: unit -> AutoOpenAttribute /// Creates an attribute used to mark a namespace or module path to be 'automatically opened' when an assembly is referenced /// @@ -930,7 +932,7 @@ namespace Microsoft.FSharp.Core /// or an enclosing module opened. /// /// AutoOpenAttribute - new : path:string-> AutoOpenAttribute + new: path:string-> AutoOpenAttribute /// Indicates the namespace or module to be automatically opened when an assembly is referenced /// or an enclosing module opened. @@ -1179,7 +1181,7 @@ namespace Microsoft.FSharp.Core /// The second value. /// /// The result of the comparison. - val inline GenericEquality : e1:'T -> e2:'T -> bool when 'T : equality + val inline GenericEquality: e1: 'T -> e2: 'T -> bool when 'T: equality /// Compare two values for equality using equivalence relation semantics ([nan] = [nan]) /// @@ -1187,7 +1189,7 @@ namespace Microsoft.FSharp.Core /// The second value. /// /// The result of the comparison. - val inline GenericEqualityER : e1:'T -> e2:'T -> bool when 'T : equality + val inline GenericEqualityER: e1: 'T -> e2: 'T -> bool when 'T: equality /// Compare two values for equality /// @@ -1196,7 +1198,7 @@ namespace Microsoft.FSharp.Core /// The second value. /// /// The result of the comparison. - val inline GenericEqualityWithComparer : comp:System.Collections.IEqualityComparer -> e1:'T -> e2:'T -> bool when 'T : equality + val inline GenericEqualityWithComparer: comp: System.Collections.IEqualityComparer -> e1: 'T -> e2: 'T -> bool when 'T: equality /// Compare two values /// @@ -1204,7 +1206,7 @@ namespace Microsoft.FSharp.Core /// The second value. /// /// The result of the comparison. - val inline GenericComparison : e1:'T -> e2:'T -> int when 'T : comparison + 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. @@ -1214,7 +1216,7 @@ namespace Microsoft.FSharp.Core /// The second value. /// /// The result of the comparison. - val inline GenericComparisonWithComparer : comp:System.Collections.IComparer -> e1:'T -> e2:'T -> int when 'T : comparison + val inline GenericComparisonWithComparer: comp: System.Collections.IComparer -> e1: 'T -> e2: 'T -> int when 'T: comparison /// Compare two values /// @@ -1222,7 +1224,7 @@ namespace Microsoft.FSharp.Core /// The second value. /// /// The result of the comparison. - val inline GenericLessThan : e1:'T -> e2:'T -> bool when 'T : comparison + val inline GenericLessThan: e1: 'T -> e2: 'T -> bool when 'T: comparison /// Compare two values /// @@ -1230,7 +1232,7 @@ namespace Microsoft.FSharp.Core /// The second value. /// /// The result of the comparison. - val inline GenericGreaterThan : e1:'T -> e2:'T -> bool when 'T : comparison + val inline GenericGreaterThan: e1: 'T -> e2: 'T -> bool when 'T: comparison /// Compare two values /// @@ -1238,7 +1240,7 @@ namespace Microsoft.FSharp.Core /// The second value. /// /// The result of the comparison. - val inline GenericLessOrEqual : e1:'T -> e2:'T -> bool when 'T : comparison + val inline GenericLessOrEqual: e1: 'T -> e2: 'T -> bool when 'T: comparison /// Compare two values /// @@ -1246,7 +1248,7 @@ namespace Microsoft.FSharp.Core /// The second value. /// /// The result of the comparison. - val inline GenericGreaterOrEqual : e1:'T -> e2:'T -> bool when 'T : comparison + 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 /// @@ -1254,7 +1256,7 @@ namespace Microsoft.FSharp.Core /// The second value. /// /// The minimum value. - val inline GenericMinimum : e1:'T -> e2:'T -> 'T when 'T : comparison + 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 /// @@ -1262,7 +1264,7 @@ namespace Microsoft.FSharp.Core /// The second value. /// /// The maximum value. - val inline GenericMaximum : e1:'T -> e2:'T -> 'T when 'T : comparison + val inline GenericMaximum: e1: 'T -> e2: 'T -> 'T when 'T: comparison /// Reference/physical equality. /// True if the inputs are reference-equal, false otherwise. @@ -1271,7 +1273,7 @@ namespace Microsoft.FSharp.Core /// The second value. /// /// The result of the comparison. - val inline PhysicalEquality : e1:'T -> e2:'T -> bool when 'T : not struct + 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. @@ -1279,30 +1281,30 @@ namespace Microsoft.FSharp.Core /// The input object. /// /// The hashed value. - val inline PhysicalHash : obj:'T -> int when 'T : not struct + 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 : System.Collections.IEqualityComparer + val GenericEqualityComparer: System.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 : System.Collections.IEqualityComparer + val GenericEqualityERComparer: System.Collections.IEqualityComparer /// A static F# comparer object - val GenericComparer : System.Collections.IComparer + val GenericComparer: System.Collections.IComparer /// Make an F# comparer object for the given type - val inline FastGenericComparer<'T> : System.Collections.Generic.IComparer<'T> when 'T : comparison + val inline FastGenericComparer<'T> : System.Collections.Generic.IComparer<'T> when 'T: comparison /// Make an F# comparer object for the given type, where it can be null if System.Collections.Generic.Comparer<'T>.Default - val internal FastGenericComparerCanBeNull<'T> : System.Collections.Generic.IComparer<'T> when 'T : comparison + val internal FastGenericComparerCanBeNull<'T> : System.Collections.Generic.IComparer<'T> when 'T: comparison /// Make an F# hash/equality object for the given type - val inline FastGenericEqualityComparer<'T> : System.Collections.Generic.IEqualityComparer<'T> when 'T : equality + val inline FastGenericEqualityComparer<'T> : System.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. @@ -1310,15 +1312,15 @@ namespace Microsoft.FSharp.Core /// The input limit on the number of nodes. /// /// System.Collections.Generic.IEqualityComparer<'T> - val inline FastLimitedGenericEqualityComparer<'T> : limit: int -> System.Collections.Generic.IEqualityComparer<'T> when 'T : equality + val inline FastLimitedGenericEqualityComparer<'T> : limit: int -> System.Collections.Generic.IEqualityComparer<'T> when 'T: equality /// Make an F# hash/equality object for the given type [] - val FastGenericEqualityComparerFromTable<'T> : System.Collections.Generic.IEqualityComparer<'T> when 'T : equality + val FastGenericEqualityComparerFromTable<'T> : System.Collections.Generic.IEqualityComparer<'T> when 'T: equality /// Make an F# comparer object for the given type [] - val FastGenericComparerFromTable<'T> : System.Collections.Generic.IComparer<'T> when 'T : comparison + val FastGenericComparerFromTable<'T> : System.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. @@ -1326,7 +1328,7 @@ namespace Microsoft.FSharp.Core /// The input object. /// /// The hashed value. - val inline GenericHash : obj:'T -> int + 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. @@ -1335,7 +1337,7 @@ namespace Microsoft.FSharp.Core /// The input object. /// /// The hashed value. - val inline GenericLimitedHash : limit: int -> obj:'T -> int + val inline GenericLimitedHash: limit: int -> obj: 'T -> int /// Recursively hash a part of a value according to its structure. /// @@ -1343,70 +1345,70 @@ namespace Microsoft.FSharp.Core /// The input object. /// /// The hashed value. - val inline GenericHashWithComparer : comparer : System.Collections.IEqualityComparer -> obj:'T -> int + val inline GenericHashWithComparer: comparer: System.Collections.IEqualityComparer -> obj:'T -> int /// Build an enum value from an underlying value /// /// The input value. /// /// The value as an enumeration. - val inline EnumOfValue : value:'T -> 'Enum when 'Enum : enum<'T> + val inline EnumOfValue: value: 'T -> 'Enum when 'Enum: enum<'T> /// Get the underlying value for an enum value /// /// The input enum. /// /// The enumeration as a value. - val inline EnumToValue : enum:'Enum -> 'T when 'Enum : enum<'T> + val inline EnumToValue: enum: 'Enum -> 'T when 'Enum: enum<'T> /// Creates a float value with units-of-measure /// /// The input float. /// /// The float with units-of-measure. - val inline FloatWithMeasure : input: float -> float<'Measure> + val inline FloatWithMeasure: input: float -> float<'Measure> /// Creates a float32 value with units-of-measure /// /// The input float. /// /// The float with units-of-measure. - val inline Float32WithMeasure : input: float32 -> float32<'Measure> + val inline Float32WithMeasure: input: float32 -> float32<'Measure> /// Creates a decimal value with units-of-measure /// /// The input decimal. /// /// The decimal with units of measure. - val inline DecimalWithMeasure : input: decimal -> decimal<'Measure> + val inline DecimalWithMeasure: input: decimal -> decimal<'Measure> /// Creates an int32 value with units-of-measure /// /// The input int. /// /// The int with units of measure. - val inline Int32WithMeasure : input: int -> int<'Measure> + val inline Int32WithMeasure: input: int -> int<'Measure> /// Creates an int64 value with units-of-measure /// /// The input int64. /// /// The int64 with units of measure. - val inline Int64WithMeasure : input: int64 -> int64<'Measure> + val inline Int64WithMeasure: input: int64 -> int64<'Measure> /// Creates an int16 value with units-of-measure /// /// The input int16. /// /// The int16 with units-of-measure. - val inline Int16WithMeasure : input: int16 -> int16<'Measure> + val inline Int16WithMeasure: input: int16 -> int16<'Measure> /// Creates an sbyte value with units-of-measure /// /// The input sbyte. /// /// The sbyte with units-of-measure. - val inline SByteWithMeasure : input: sbyte -> sbyte<'Measure> + val inline SByteWithMeasure: input: sbyte -> sbyte<'Measure> /// Creates a nativeint value with units-of-measure /// @@ -1414,7 +1416,7 @@ namespace Microsoft.FSharp.Core /// /// The nativeint with units-of-measure. [] - val inline IntPtrWithMeasure : input: nativeint -> nativeint<'Measure> + val inline IntPtrWithMeasure: input: nativeint -> nativeint<'Measure> /// Creates a uint value with units-of-measure /// @@ -1422,7 +1424,7 @@ namespace Microsoft.FSharp.Core /// /// The uint with units-of-measure. [] - val inline UInt32WithMeasure : input: uint -> uint<'Measure> + val inline UInt32WithMeasure: input: uint -> uint<'Measure> /// Creates a uint64 value with units-of-measure /// @@ -1430,7 +1432,7 @@ namespace Microsoft.FSharp.Core /// /// The uint64 with units-of-measure. [] - val inline UInt64WithMeasure : input: uint64 -> uint64<'Measure> + val inline UInt64WithMeasure: input: uint64 -> uint64<'Measure> /// Creates a uint16 value with units-of-measure /// @@ -1438,7 +1440,7 @@ namespace Microsoft.FSharp.Core /// /// The uint16 with units-of-measure. [] - val inline UInt16WithMeasure : input: uint16 -> uint16<'Measure> + val inline UInt16WithMeasure: input: uint16 -> uint16<'Measure> /// Creates a byte value with units-of-measure /// @@ -1446,7 +1448,7 @@ namespace Microsoft.FSharp.Core /// /// The byte with units-of-measure. [] - val inline ByteWithMeasure : input: byte -> byte<'Measure> + val inline ByteWithMeasure: input: byte -> byte<'Measure> /// Creates a unativeint value with units-of-measure /// @@ -1454,147 +1456,147 @@ namespace Microsoft.FSharp.Core /// /// The unativeint with units-of-measure. [] - val inline UIntPtrWithMeasure : input: unativeint -> unativeint<'Measure> + val inline UIntPtrWithMeasure: input: unativeint -> unativeint<'Measure> /// Parse an int32 according to the rules used by the overloaded 'int32' conversion operator when applied to strings /// /// The input string. /// /// The parsed value. - val ParseInt32 : s: string -> int32 + val ParseInt32: s: string -> int32 /// Parse an uint32 according to the rules used by the overloaded 'uint32' conversion operator when applied to strings /// /// The input string. /// /// The parsed value. - val ParseUInt32 : s:string -> uint32 + val ParseUInt32: s: string -> uint32 /// Parse an int64 according to the rules used by the overloaded 'int64' conversion operator when applied to strings /// /// The input string. /// /// The parsed value. - val ParseInt64 : s:string -> int64 + val ParseInt64: s: string -> int64 /// Parse an uint64 according to the rules used by the overloaded 'uint64' conversion operator when applied to strings /// /// The input string. /// /// The parsed value. - val ParseUInt64 : s:string -> uint64 + 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 + 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 + val GenericOneDynamic: unit -> 'T /// A compiler intrinsic that implements dynamic invocations to the '+' operator. [] - val AdditionDynamic : x:'T1 -> y:'T2 -> 'U + 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 + val CheckedAdditionDynamic: x: 'T1 -> y: 'T2 -> 'U /// A compiler intrinsic that implements dynamic invocations to the '*' operator. [] - val MultiplyDynamic : x:'T1 -> y:'T2 -> 'U + 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 + val CheckedMultiplyDynamic: x: 'T1 -> y: 'T2 -> 'U /// A compiler intrinsic that implements dynamic invocations to the '-' operator. [] - val SubtractionDynamic : x:'T1 -> y:'T2 -> 'U + val SubtractionDynamic: x: 'T1 -> y: 'T2 -> 'U /// A compiler intrinsic that implements dynamic invocations to the '/' operator. [] - val DivisionDynamic : x:'T1 -> y:'T2 -> 'U + val DivisionDynamic: x: 'T1 -> y: 'T2 -> 'U /// A compiler intrinsic that implements dynamic invocations to the unary '-' operator. [] - val UnaryNegationDynamic : value:'T -> 'U + val UnaryNegationDynamic: value: 'T -> 'U /// A compiler intrinsic that implements dynamic invocations to the '%' operator. [] - val ModulusDynamic : x:'T1 -> y:'T2 -> 'U + val ModulusDynamic: x: 'T1 -> y: 'T2 -> 'U /// A compiler intrinsic that implements dynamic invocations to the checked '-' operator. [] - val CheckedSubtractionDynamic : x:'T1 -> y:'T2 -> 'U + val CheckedSubtractionDynamic: x: 'T1 -> y: 'T2 -> 'U /// A compiler intrinsic that implements dynamic invocations to the checked unary '-' operator. [] - val CheckedUnaryNegationDynamic : value:'T -> 'U + val CheckedUnaryNegationDynamic: value: 'T -> 'U /// A compiler intrinsic that implements dynamic invocations to the '<<<' operator. [] - val LeftShiftDynamic : value:'T1 -> shift:'T2 -> 'U + val LeftShiftDynamic: value: 'T1 -> shift: 'T2 -> 'U /// A compiler intrinsic that implements dynamic invocations to the '>>>' operator. [] - val RightShiftDynamic : value:'T1 -> shift:'T2 -> 'U + val RightShiftDynamic: value: 'T1 -> shift: 'T2 -> 'U /// A compiler intrinsic that implements dynamic invocations to the '&&&' operator. [] - val BitwiseAndDynamic : x:'T1 -> y:'T2 -> 'U + val BitwiseAndDynamic: x: 'T1 -> y: 'T2 -> 'U /// A compiler intrinsic that implements dynamic invocations to the '|||' operator. [] - val BitwiseOrDynamic : x:'T1 -> y:'T2 -> 'U + val BitwiseOrDynamic: x: 'T1 -> y: 'T2 -> 'U /// A compiler intrinsic that implements dynamic invocations related to the '^^^' operator. [] - val ExclusiveOrDynamic : x:'T1 -> y:'T2 -> 'U + val ExclusiveOrDynamic: x: 'T1 -> y: 'T2 -> 'U /// A compiler intrinsic that implements dynamic invocations related to the '~~~' operator. [] - val LogicalNotDynamic : value:'T -> 'U + val LogicalNotDynamic: value: 'T -> 'U /// A compiler intrinsic that implements dynamic invocations related to conversion operators. [] - val ExplicitDynamic : value:'T -> 'U + val ExplicitDynamic: value: 'T -> 'U /// A compiler intrinsic that implements dynamic invocations related to the '<' operator. [] - val LessThanDynamic : x:'T1 -> y:'T2 -> 'U + val LessThanDynamic: x: 'T1 -> y: 'T2 -> 'U /// A compiler intrinsic that implements dynamic invocations related to the '>' operator. [] - val GreaterThanDynamic : x:'T1 -> y:'T2 -> 'U + val GreaterThanDynamic: x: 'T1 -> y: 'T2 -> 'U /// A compiler intrinsic that implements dynamic invocations related to the '<=' operator. [] - val LessThanOrEqualDynamic : x:'T1 -> y:'T2 -> 'U + val LessThanOrEqualDynamic: x: 'T1 -> y: 'T2 -> 'U /// A compiler intrinsic that implements dynamic invocations related to the '>=' operator. [] - val GreaterThanOrEqualDynamic : x:'T1 -> y:'T2 -> 'U + val GreaterThanOrEqualDynamic: x: 'T1 -> y: 'T2 -> 'U /// A compiler intrinsic that implements dynamic invocations related to the '=' operator. [] - val EqualityDynamic : x:'T1 -> y:'T2 -> 'U + val EqualityDynamic: x: 'T1 -> y: 'T2 -> 'U /// A compiler intrinsic that implements dynamic invocations related to the '=' operator. [] - val InequalityDynamic : x:'T1 -> y:'T2 -> 'U + val InequalityDynamic: x: 'T1 -> y: 'T2 -> 'U /// A compiler intrinsic that implements dynamic invocations for the DivideByInt primitive. [] - val DivideByIntDynamic : x:'T -> y:int -> 'T + 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 inline GenericZero< ^T > : ^T when ^T : (static member Zero : ^T) + val inline GenericZero< ^T > : ^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 inline GenericOne< ^T > : ^T when ^T : (static member One : ^T) + val inline GenericOne< ^T > : ^T when ^T: (static member One: ^T) - val internal anyToStringShowingNull : 'T -> string + val internal anyToStringShowingNull: 'T -> string /// Divides a value by an integer. /// @@ -1602,26 +1604,25 @@ namespace Microsoft.FSharp.Core /// The input int. /// /// The division result. - val inline DivideByInt< ^T > : x:^T -> y:int -> ^T when ^T : (static member DivideByInt : ^T * int -> ^T) + val inline DivideByInt< ^T > : x: ^T -> y: int -> ^T when ^T: (static member DivideByInt: ^T * int -> ^T) /// For compiler use only module (* internal *) ErrorStrings = [] - val InputSequenceEmptyString : string + val InputSequenceEmptyString: string [] - val InputArrayEmptyString : string + val InputArrayEmptyString: string [] - val AddressOpNotFirstClassString : string + val AddressOpNotFirstClassString: string [] - val NoNegateMinValueString : string + val NoNegateMinValueString: string [] - val InputMustBeNonNegativeString : string - + val InputMustBeNonNegativeString: string //------------------------------------------------------------------------- @@ -1630,7 +1631,7 @@ namespace Microsoft.FSharp.Core /// Binary 'and'. When used as a binary operator the right hand value is evaluated only on demand. [] - val ( & ) : e1:bool -> e2:bool -> bool + val (&): e1: bool -> e2: bool -> bool /// Binary 'and'. When used as a binary operator the right hand value is evaluated only on demand /// @@ -1638,12 +1639,12 @@ namespace Microsoft.FSharp.Core /// The second value. /// /// The result of the operation. - val ( && ) : e1:bool -> e2:bool -> bool + 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 + val (or): e1: bool -> e2: bool -> bool /// Binary 'or'. When used as a binary operator the right hand value is evaluated only on demand /// @@ -1651,21 +1652,21 @@ namespace Microsoft.FSharp.Core /// The second value. /// /// The result of the operation. - val ( || ) : e1:bool -> e2:bool -> bool + val (||): e1: bool -> e2: bool -> bool /// Address-of. Uses of this value may result in the generation of unverifiable code. /// /// The input object. /// /// The managed pointer. - val inline ( ~& ) : obj:'T -> byref<'T> + val inline (~&): obj: 'T -> byref<'T> /// Address-of. Uses of this value may result in the generation of unverifiable code. /// /// The input object. /// /// The unmanaged pointer. - val inline ( ~&& ) : obj:'T -> nativeptr<'T> + val inline (~&&): obj: 'T -> nativeptr<'T> //------------------------------------------------------------------------- @@ -1674,190 +1675,186 @@ namespace Microsoft.FSharp.Core /// A compiler intrinsic that implements the ':?>' operator [] - val UnboxGeneric<'T> : source:obj -> 'T + val UnboxGeneric<'T> : source: obj -> 'T /// A compiler intrinsic that implements the ':?>' operator [] - val inline UnboxFast<'T> : source:obj -> 'T + val inline UnboxFast<'T> : source: obj -> 'T /// A compiler intrinsic that implements the ':?' operator [] - val TypeTestGeneric<'T> : source:obj -> bool + val TypeTestGeneric<'T> : source: obj -> bool /// A compiler intrinsic that implements the ':?' operator [] - val inline TypeTestFast<'T> : source:obj -> bool + val inline TypeTestFast<'T> : source: obj -> bool /// Primitive used by pattern match compilation //[] - val inline GetString : source:string -> index:int -> char + val inline GetString : source: string -> index: int -> char /// This function implements calls to default constructors /// accessed by 'new' constraints. [] - val inline CreateInstance : unit -> 'T when 'T : (new : unit -> 'T) + 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 + 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<'T when 'T :> System.IDisposable > : resource:'T -> unit + val Dispose<'T when 'T :> System.IDisposable> : resource: 'T -> unit /// A compiler intrinsic for checking initialization soundness of recursive bindings [] - val FailInit : unit -> unit + val FailInit: unit -> unit /// A compiler intrinsic for checking initialization soundness of recursive static bindings [] - val FailStaticInit : unit -> unit + val FailStaticInit: unit -> unit /// A compiler intrinsic for checking initialization soundness of recursive bindings [] - val CheckThis : 'T -> 'T when 'T : not struct + val CheckThis: 'T -> 'T when 'T: not struct /// The standard overloaded associative (indexed) lookup operator //[] - val inline GetArray : source:'T[] -> index:int -> 'T + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + val GenericHashIntrinsic: input:'T -> int /// A primitive entry point used by the F# compiler for optimization purposes. [] - val LimitedGenericHashIntrinsic : limit: int -> input:'T -> int + val LimitedGenericHashIntrinsic: limit: int -> input: 'T -> int /// A primitive entry point used by the F# compiler for optimization purposes. [] - val GenericHashWithComparerIntrinsic : comp:System.Collections.IEqualityComparer -> input:'T -> int + val GenericHashWithComparerIntrinsic: comp: System.Collections.IEqualityComparer -> input: 'T -> int /// A primitive entry point used by the F# compiler for optimization purposes. [] - val GenericComparisonWithComparerIntrinsic : comp:System.Collections.IComparer -> x:'T -> y:'T -> int + val GenericComparisonWithComparerIntrinsic: comp: System.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 + 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 + 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 + val GenericEqualityERIntrinsic: x: 'T -> y: 'T -> bool /// A primitive entry point used by the F# compiler for optimization purposes. [] - val GenericEqualityWithComparerIntrinsic : comp:System.Collections.IEqualityComparer -> x:'T -> y:'T -> bool + val GenericEqualityWithComparerIntrinsic: comp: System.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 + 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 + 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 + 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 + val GenericLessOrEqualIntrinsic: x: 'T -> y: 'T -> bool /// A primitive entry point used by the F# compiler for optimization purposes. [] - val inline FastHashTuple2 : comparer:System.Collections.IEqualityComparer -> tuple:('T1 * 'T2) -> int + val inline FastHashTuple2: comparer: System.Collections.IEqualityComparer -> tuple: ('T1 * 'T2) -> int /// A primitive entry point used by the F# compiler for optimization purposes. [] - val inline FastHashTuple3 : comparer:System.Collections.IEqualityComparer -> tuple:('T1 * 'T2 * 'T3) -> int + val inline FastHashTuple3: comparer: System.Collections.IEqualityComparer -> tuple: ('T1 * 'T2 * 'T3) -> int /// A primitive entry point used by the F# compiler for optimization purposes. [] - val inline FastHashTuple4 : comparer:System.Collections.IEqualityComparer -> tuple:('T1 * 'T2 * 'T3 * 'T4) -> int + val inline FastHashTuple4: comparer:System.Collections.IEqualityComparer -> tuple: ('T1 * 'T2 * 'T3 * 'T4) -> int /// A primitive entry point used by the F# compiler for optimization purposes. [] - val inline FastHashTuple5 : comparer:System.Collections.IEqualityComparer -> tuple:('T1 * 'T2 * 'T3 * 'T4 * 'T5) -> int + val inline FastHashTuple5: comparer: System.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:System.Collections.IEqualityComparer -> tuple1:('T1 * 'T2) -> tuple2:('T1 * 'T2) -> bool + val inline FastEqualsTuple2: comparer: System.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:System.Collections.IEqualityComparer -> tuple1:('T1 * 'T2 * 'T3) -> tuple2:('T1 * 'T2 * 'T3) -> bool + val inline FastEqualsTuple3: comparer: System.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:System.Collections.IEqualityComparer -> tuple1:('T1 * 'T2 * 'T3 * 'T4) -> tuple2:('T1 * 'T2 * 'T3 * 'T4) -> bool + val inline FastEqualsTuple4: comparer: System.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:System.Collections.IEqualityComparer -> tuple1:('T1 * 'T2 * 'T3 * 'T4 * 'T5) -> tuple2:('T1 * 'T2 * 'T3 * 'T4 * 'T5) -> bool + val inline FastEqualsTuple5: comparer: System.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:System.Collections.IComparer -> tuple1:('T1 * 'T2) -> tuple2:('T1 * 'T2) -> int + val inline FastCompareTuple2: comparer: System.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:System.Collections.IComparer -> tuple1:('T1 * 'T2 * 'T3) -> tuple2:('T1 * 'T2 * 'T3) -> int + val inline FastCompareTuple3: comparer: System.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:System.Collections.IComparer -> tuple1:('T1 * 'T2 * 'T3 * 'T4) -> tuple2:('T1 * 'T2 * 'T3 * 'T4) -> int + val inline FastCompareTuple4: comparer: System.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:System.Collections.IComparer -> tuple1:('T1 * 'T2 * 'T3 * 'T4 * 'T5) -> tuple2:('T1 * 'T2 * 'T3 * 'T4 * 'T5) -> int - - //------------------------------------------------------------------------- - // F# Choice Types - + val inline FastCompareTuple5: comparer: System.Collections.IComparer -> tuple1: ('T1 * 'T2 * 'T3 * 'T4 * 'T5) -> tuple2: ('T1 * 'T2 * 'T3 * 'T4 * 'T5) -> int /// Helper types for active patterns with 2 choices. /// Choices and Results @@ -1993,7 +1990,7 @@ namespace Microsoft.FSharp.Core /// Construct an instance of an F# first class type function value /// FSharpTypeFunc - new : unit -> FSharpTypeFunc + new: unit -> FSharpTypeFunc /// The CLI type used to represent F# function values. This type is not /// typically used directly, though may be used from other CLI languages. @@ -2003,42 +2000,42 @@ namespace Microsoft.FSharp.Core /// Construct an instance of an F# first class function value /// The created F# function. - new : unit -> FSharpFunc<'T,'U> + new: unit -> FSharpFunc<'T,'U> /// Invoke an F# first class function value with one argument /// /// /// /// 'U - abstract Invoke : func:'T -> 'U + abstract Invoke: func: 'T -> 'U /// Convert an F# first class function value to a value of type /// /// The input function. /// /// A System.Converter of the function type. - static member op_Implicit : func:('T -> 'U) -> System.Converter<'T,'U> + static member op_Implicit: func: ('T -> 'U) -> System.Converter<'T,'U> /// Convert an value of type to a F# first class function value /// /// The input System.Converter. /// /// An F# function of the same type. - static member op_Implicit : converter:System.Converter<'T,'U> -> ('T -> 'U) + static member op_Implicit: converter: System.Converter<'T,'U> -> ('T -> 'U) /// Convert an F# first class function value to a value of type /// /// The input function. /// /// System.Converter<'T,'U> - static member ToConverter : func:('T -> 'U) -> System.Converter<'T,'U> + static member ToConverter: func: ('T -> 'U) -> System.Converter<'T,'U> /// Convert an value of type to a F# first class function value /// /// The input System.Converter. /// /// An F# function of the same type. - static member FromConverter : converter:System.Converter<'T,'U> -> ('T -> 'U) + static member FromConverter: converter: System.Converter<'T,'U> -> ('T -> 'U) /// 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. @@ -2051,7 +2048,7 @@ namespace Microsoft.FSharp.Core /// The fifth arg. /// /// The function result. - static member InvokeFast : func: FSharpFunc<'T,('U -> 'V -> 'W -> 'X -> 'Y)> * arg1:'T * arg2:'U * arg3:'V * arg4:'W * arg5:'X -> 'Y + 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 four curried arguments. In some cases this /// will result in a more efficient application than applying the arguments successively. @@ -2063,7 +2060,7 @@ namespace Microsoft.FSharp.Core /// The fourth arg. /// /// The function result. - static member InvokeFast : func: FSharpFunc<'T,('U -> 'V -> 'W -> 'X)> * arg1:'T * arg2:'U * arg3:'V * arg4:'W -> 'X + 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 three curried arguments. In some cases this /// will result in a more efficient application than applying the arguments successively. @@ -2074,7 +2071,7 @@ namespace Microsoft.FSharp.Core /// The third arg. /// /// The function result. - static member InvokeFast : func: FSharpFunc<'T,('U -> 'V -> 'W)> * arg1:'T * arg2:'U * arg3:'V -> 'W + static member InvokeFast: func: FSharpFunc<'T,('U -> 'V -> 'W)> * arg1: 'T * arg2: 'U * arg3: 'V -> 'W /// 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. @@ -2084,7 +2081,7 @@ namespace Microsoft.FSharp.Core /// The second arg. /// /// The function result. - static member InvokeFast : func: FSharpFunc<'T,('U -> 'V)> * arg1:'T * arg2:'U -> 'V + static member InvokeFast: func: FSharpFunc<'T,('U -> 'V)> * arg1: 'T * arg2: 'U -> 'V /// Helper functions for converting F# first class function values to and from CLI representations /// of functions using delegates. @@ -2098,126 +2095,126 @@ namespace Microsoft.FSharp.Core /// The input Action delegate. /// /// The F# function. - static member inline ToFSharpFunc : action:Action<'T> -> ('T -> unit) + static member inline ToFSharpFunc: action: Action<'T> -> ('T -> unit) /// Convert the given Converter delegate object to an F# function value /// /// The input Converter delegate. /// /// The F# function. - static member inline ToFSharpFunc : converter:Converter<'T,'U> -> ('T -> 'U) + static member inline ToFSharpFunc: converter: Converter<'T,'U> -> ('T -> 'U) /// Convert the given Action delegate object to an F# function value /// /// The input Action delegate. /// /// The F# function. - static member inline FromAction : action:Action -> (unit -> unit) + static member inline FromAction: action: Action -> (unit -> unit) /// Convert the given Action delegate object to an F# function value /// /// The input Action delegate. /// /// The F# function. - static member inline FromAction : action:Action<'T> -> ('T -> unit) + static member inline FromAction: action: Action<'T> -> ('T -> unit) /// Convert the given Action delegate object to an F# function value /// /// The input Action delegate. /// /// The F#funcfunction. - static member inline FromAction : action:Action<'T1,'T2> -> ('T1 -> 'T2 -> unit) + static member inline FromAction: action: Action<'T1,'T2> -> ('T1 -> 'T2 -> unit) /// Convert the given Action delegate object to an F# function value /// /// The input Action delegate. /// /// The F# function. - static member inline FromAction : action:Action<'T1,'T2,'T3> -> ('T1 -> 'T2 -> 'T3 -> unit) + static member inline FromAction: action: Action<'T1,'T2,'T3> -> ('T1 -> 'T2 -> 'T3 -> unit) /// Convert the given Action delegate object to an F# function value /// /// The input Action delegate. /// /// The F# function. - static member inline FromAction : action:Action<'T1,'T2,'T3,'T4> -> ('T1 -> 'T2 -> 'T3 -> 'T4 -> unit) + static member inline FromAction: action: Action<'T1,'T2,'T3,'T4> -> ('T1 -> 'T2 -> 'T3 -> 'T4 -> unit) /// Convert the given Action delegate object to an F# function value /// /// The input Action delegate. /// /// The F# function. - static member inline FromAction : action:Action<'T1,'T2,'T3,'T4,'T5> -> ('T1 -> 'T2 -> 'T3 -> 'T4 -> 'T5 -> unit) + static member inline FromAction: action: Action<'T1,'T2,'T3,'T4,'T5> -> ('T1 -> 'T2 -> 'T3 -> 'T4 -> 'T5 -> unit) /// Convert the given Func delegate object to an F# function value /// /// The input Func delegate. /// /// The F# function. - static member inline FromFunc : func:Func<'T> -> (unit -> 'T) + static member inline FromFunc: func: Func<'T> -> (unit -> 'T) /// Convert the given Func delegate object to an F# function value /// /// The input Func delegate. /// /// The F# function. - static member inline FromFunc : func:Func<'T,'U> -> ('T -> 'U) + static member inline FromFunc: func: Func<'T,'U> -> ('T -> 'U) /// Convert the given Func delegate object to an F# function value /// /// The input Func delegate. /// /// The F#funcfunction. - static member inline FromFunc : func:Func<'T1,'T2,'U> -> ('T1 -> 'T2 -> 'U) + static member inline FromFunc: func: Func<'T1,'T2,'U> -> ('T1 -> 'T2 -> 'U) /// Convert the given Func delegate object to an F# function value /// /// The input Func delegate. /// /// The F# function. - static member inline FromFunc : func:Func<'T1,'T2,'T3,'U> -> ('T1 -> 'T2 -> 'T3 -> 'U) + static member inline FromFunc: func: Func<'T1,'T2,'T3,'U> -> ('T1 -> 'T2 -> 'T3 -> 'U) /// Convert the given Func delegate object to an F# function value /// /// The input Func delegate. /// /// The F# function. - static member inline FromFunc : func:Func<'T1,'T2,'T3,'T4,'U> -> ('T1 -> 'T2 -> 'T3 -> 'T4 -> 'U) + static member inline FromFunc: func: Func<'T1,'T2,'T3,'T4,'U> -> ('T1 -> 'T2 -> 'T3 -> 'T4 -> 'U) /// Convert the given Func delegate object to an F# function value /// /// The input Func delegate. /// /// The F# function. - static member inline FromFunc : func:Func<'T1,'T2,'T3,'T4,'T5,'U> -> ('T1 -> 'T2 -> 'T3 -> 'T4 -> 'T5 -> 'U) + static member inline FromFunc: func: 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 /// /// The input tupled function. /// /// The output curried function. - static member inline FuncFromTupled : func:('T1 * 'T2 -> 'U) -> ('T1 -> 'T2 -> 'U) + static member inline FuncFromTupled: func: ('T1 * 'T2 -> 'U) -> ('T1 -> 'T2 -> 'U) /// A utility function to convert function values from tupled to curried form /// /// The input tupled function. /// /// The output curried function. - static member inline FuncFromTupled : func:('T1 * 'T2 * 'T3 -> 'U) -> ('T1 -> 'T2 -> 'T3 -> 'U) + static member inline FuncFromTupled: func: ('T1 * 'T2 * 'T3 -> 'U) -> ('T1 -> 'T2 -> 'T3 -> 'U) /// A utility function to convert function values from tupled to curried form /// /// The input tupled function. /// /// The output curried function. - static member inline FuncFromTupled : func:('T1 * 'T2 * 'T3 * 'T4 -> 'U) -> ('T1 -> 'T2 -> 'T3 -> 'T4 -> 'U) + static member inline FuncFromTupled: func: ('T1 * 'T2 * 'T3 * 'T4 -> 'U) -> ('T1 -> 'T2 -> 'T3 -> 'T4 -> 'U) /// A utility function to convert function values from tupled to curried form /// /// The input tupled function. /// /// The output curried function. - static member inline FuncFromTupled : func:('T1 * 'T2 * 'T3 * 'T4 * 'T5 -> 'U) -> ('T1 -> 'T2 -> 'T3 -> 'T4 -> 'T5 -> 'U) + static member inline FuncFromTupled: func: ('T1 * 'T2 * 'T3 * 'T4 * 'T5 -> 'U) -> ('T1 -> 'T2 -> 'T3 -> 'T4 -> 'T5 -> 'U) /// An implementation module used to hold some private implementations of function /// value invocation. @@ -2237,7 +2234,7 @@ namespace Microsoft.FSharp.Core /// The second arg. /// /// The function result. - abstract Invoke : arg1:'T1 * arg2:'T2 -> 'U + abstract 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. @@ -2245,12 +2242,12 @@ namespace Microsoft.FSharp.Core /// The input function. /// /// The adapted function. - static member Adapt : func:('T1 -> 'T2 -> 'U) -> FSharpFunc<'T1,'T2,'U> + static member Adapt: func:('T1 -> 'T2 -> 'U) -> FSharpFunc<'T1,'T2,'U> /// Construct an optimized function value that can accept two curried /// arguments without intervening execution. /// The optimized function. - new : unit -> FSharpFunc<'T1,'T2,'U> + new: unit -> 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 @@ -2268,7 +2265,7 @@ namespace Microsoft.FSharp.Core /// The third arg. /// /// The function result. - abstract Invoke : arg1:'T1 * arg2:'T2 * arg3:'T3 -> 'U + abstract 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. @@ -2276,12 +2273,12 @@ namespace Microsoft.FSharp.Core /// The input function. /// /// The adapted function. - static member Adapt : func:('T1 -> 'T2 -> 'T3 -> 'U) -> FSharpFunc<'T1,'T2,'T3,'U> + static member Adapt: func: ('T1 -> 'T2 -> 'T3 -> 'U) -> FSharpFunc<'T1,'T2,'T3,'U> /// Construct an optimized function value that can accept three curried /// arguments without intervening execution. /// The optimized function. - new : unit -> FSharpFunc<'T1,'T2,'T3,'U> + new: unit -> 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 @@ -2299,7 +2296,7 @@ namespace Microsoft.FSharp.Core /// The fourth arg. /// /// The function result. - abstract Invoke : arg1:'T1 * arg2:'T2 * arg3:'T3 * arg4:'T4 -> 'U + abstract 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. @@ -2307,12 +2304,12 @@ namespace Microsoft.FSharp.Core /// The input function. /// /// The optimized function. - static member Adapt : func:('T1 -> 'T2 -> 'T3 -> 'T4 -> 'U) -> FSharpFunc<'T1,'T2,'T3,'T4,'U> + static member Adapt: func: ('T1 -> 'T2 -> 'T3 -> 'T4 -> 'U) -> FSharpFunc<'T1,'T2,'T3,'T4,'U> /// Construct an optimized function value that can accept four curried /// arguments without intervening execution. /// The optimized function. - new : unit -> FSharpFunc<'T1,'T2,'T3,'T4,'U> + new: unit -> 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 @@ -2331,7 +2328,7 @@ namespace Microsoft.FSharp.Core /// The fifth arg. /// /// The function result. - abstract Invoke : arg1:'T1 * arg2:'T2 * arg3:'T3 * arg4:'T4 * arg5:'T5 -> 'U + abstract 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. @@ -2339,12 +2336,12 @@ namespace Microsoft.FSharp.Core /// The input function. /// /// The optimized function. - static member Adapt : func:('T1 -> 'T2 -> 'T3 -> 'T4 -> 'T5 -> 'U) -> FSharpFunc<'T1,'T2,'T3,'T4,'T5,'U> + static member Adapt: func:('T1 -> 'T2 -> 'T3 -> 'T4 -> 'T5 -> 'U) -> FSharpFunc<'T1,'T2,'T3,'T4,'T5,'U> /// Construct an optimized function value that can accept five curried /// arguments without intervening execution. /// The optimized function. - new : unit -> FSharpFunc<'T1,'T2,'T3,'T4,'T5,'U> + new: unit -> FSharpFunc<'T1,'T2,'T3,'T4,'T5,'U> /// The type of mutable references. Use the functions [!] and [:=] to get and /// set values of this type. @@ -2358,7 +2355,7 @@ namespace Microsoft.FSharp.Core mutable contents: 'T } /// The current value of the reference cell - member Value : 'T with get,set + member Value: 'T with get,set /// The type of mutable references. Use the functions [!] and [:=] to get and /// set values of this type. @@ -2385,18 +2382,18 @@ namespace Microsoft.FSharp.Core type Option<'T> = /// The representation of "No value" - | None : 'T option + | None: 'T option /// The representation of "Value of type 'T" /// /// The input value. /// /// An option representing the value. - | Some : Value:'T -> 'T option + | Some: Value:'T -> 'T option /// Create an option value that is a 'None' value. /// - static member None : 'T option + static member None: 'T option /// Create an option value that is a 'Some' value. /// @@ -2404,7 +2401,7 @@ namespace Microsoft.FSharp.Core /// /// An option representing the value. /// - static member Some : value:'T -> 'T option + static member Some: value: 'T -> 'T option /// Implicitly converts a value into an optional that is a 'Some' value. /// @@ -2414,17 +2411,17 @@ namespace Microsoft.FSharp.Core /// /// An option representing the value. /// - static member op_Implicit : value:'T -> 'T option + static member op_Implicit: value: 'T -> 'T option /// Get the value of a 'Some' option. A NullReferenceException is raised if the option is 'None'. [] - member Value : 'T + member Value: 'T /// Return 'true' if the option is a 'Some' value. - member IsSome : bool + member IsSome: bool /// Return 'true' if the option is a 'None' value. - member IsNone : bool + member IsNone: bool /// The type of optional values. When used from other CLI languages the /// empty option is the null value. @@ -2463,11 +2460,11 @@ namespace Microsoft.FSharp.Core | ValueSome: 'T -> 'T voption /// Get the value of a 'ValueSome' option. An InvalidOperationException is raised if the option is 'ValueNone'. - member Value : 'T + member Value: 'T /// Create a value option value that is a 'ValueNone' value. /// - static member None : 'T voption + static member None: 'T voption /// Create a value option value that is a 'Some' value. /// @@ -2475,13 +2472,13 @@ namespace Microsoft.FSharp.Core /// /// A value option representing the value. /// - static member Some : value:'T -> 'T voption + static member Some: value: 'T -> 'T voption /// Return 'true' if the value option is a 'ValueSome' value. - member IsSome : bool + member IsSome: bool /// Return 'true' if the value option is a 'ValueNone' value. - member IsNone : bool + member IsNone: bool /// Implicitly converts a value into an optional that is a 'ValueSome' value. /// @@ -2535,30 +2532,30 @@ namespace Microsoft.FSharp.Collections [] [] type List<'T> = - | ([]) : 'T list - | (::) : Head: 'T * Tail: 'T list -> 'T list + | ([]): 'T list + | (::): Head: 'T * Tail: 'T list -> 'T list /// Returns an empty list of a particular type - static member Empty : 'T list + static member Empty: 'T list /// Gets the number of items contained in the list - member Length : int + member Length: int /// Gets a value indicating if the list contains no entries - member IsEmpty : bool + member IsEmpty: bool /// Gets the first element of the list - member Head : 'T + member Head: 'T /// 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 + member Tail: 'T list /// Gets the element of the list at the given position. /// Lists are represented as linked lists so this is an O(n) operation. /// The index. /// /// The value at the given index. - member Item : index:int -> 'T with get + member Item: index: int -> 'T with get /// Gets a slice of the list, the elements of the list from the given start index to the given end index. /// @@ -2566,7 +2563,7 @@ namespace Microsoft.FSharp.Collections /// The end index. /// /// The sub list specified by the input indices. - member GetSlice : startIndex:int option * endIndex:int option -> 'T list + member GetSlice: startIndex: int option * endIndex: int option -> 'T list /// Get the index for the element offset elements away from the end of the collection. /// @@ -2583,7 +2580,7 @@ namespace Microsoft.FSharp.Collections /// The existing list. /// /// The list with head appended to the front of tail. - static member Cons : head:'T * tail:'T list -> 'T list + static member Cons: head: 'T * tail: 'T list -> 'T list interface IEnumerable<'T> interface IEnumerable @@ -2632,7 +2629,10 @@ namespace Microsoft.FSharp.Core /// The value to negate. /// /// The result of the operation. - val inline ( ~- ) : n:^T -> ^T when ^T : (static member ( ~- ) : ^T -> ^T) and default ^T : int + /// + /// + /// + val inline (~-): n: ^T -> ^T when ^T: (static member ( ~- ): ^T -> ^T) and default ^T: int /// Overloaded addition operator /// @@ -2640,7 +2640,15 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the operation. - val inline ( + ) : x:^T1 -> y:^T2 -> ^T3 when (^T1 or ^T2) : (static member ( + ) : ^T1 * ^T2 -> ^T3) and default ^T2 : ^T3 and default ^T3 : ^T1 and default ^T3 : ^T2 and default ^T1 : ^T3 and default ^T1 : ^T2 and default ^T1 : int + /// + /// + /// + /// 2 + 2 // Evaluates to 4 + /// "Hello " + "Word" // Evaluates to "Hello World" + /// + /// + /// + val inline (+): x: ^T1 -> y: ^T2 -> ^T3 when (^T1 or ^T2): (static member (+): ^T1 * ^T2 -> ^T3) and default ^T2: ^T3 and default ^T3: ^T1 and default ^T3: ^T2 and default ^T1: ^T3 and default ^T1: ^T2 and default ^T1: int /// Overloaded subtraction operator /// @@ -2648,7 +2656,13 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the operation. - val inline ( - ) : x:^T1 -> y:^T2 -> ^T3 when (^T1 or ^T2) : (static member ( - ) : ^T1 * ^T2 -> ^T3) and default ^T2 : ^T3 and default ^T3 : ^T1 and default ^T3 : ^T2 and default ^T1 : ^T3 and default ^T1 : ^T2 and default ^T1 : int + /// + /// + /// + /// 10 - 2 // Evaluates to 8 + /// + /// + val inline (-): x: ^T1 -> y: ^T2 -> ^T3 when (^T1 or ^T2): (static member (-): ^T1 * ^T2 -> ^T3) and default ^T2: ^T3 and default ^T3: ^T1 and default ^T3: ^T2 and default ^T1: ^T3 and default ^T1: ^T2 and default ^T1: int /// Overloaded multiplication operator /// @@ -2656,7 +2670,13 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the operation. - val inline ( * ) : x:^T1 -> y:^T2 -> ^T3 when (^T1 or ^T2) : (static member ( * ) : ^T1 * ^T2 -> ^T3) and default ^T2 : ^T3 and default ^T3 : ^T1 and default ^T3 : ^T2 and default ^T1 : ^T3 and default ^T1 : ^T2 and default ^T1 : int + /// + /// + /// + /// 8 * 6 // Evaluates to 48 + /// + /// + val inline (*): x: ^T1 -> y: ^T2 -> ^T3 when (^T1 or ^T2): (static member (*): ^T1 * ^T2 -> ^T3) and default ^T2: ^T3 and default ^T3: ^T1 and default ^T3: ^T2 and default ^T1: ^T3 and default ^T1: ^T2 and default ^T1: int /// Overloaded division operator /// @@ -2664,7 +2684,13 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the operation. - val inline ( / ) : x:^T1 -> y:^T2 -> ^T3 when (^T1 or ^T2) : (static member ( / ) : ^T1 * ^T2 -> ^T3) and default ^T2 : ^T3 and default ^T3 : ^T1 and default ^T3 : ^T2 and default ^T1 : ^T3 and default ^T1 : ^T2 and default ^T1 : int + /// + /// + /// + /// 16 / 2 // Evaluates to 8 + /// + /// + val inline (/): x: ^T1 -> y: ^T2 -> ^T3 when (^T1 or ^T2): (static member (/): ^T1 * ^T2 -> ^T3) and default ^T2: ^T3 and default ^T3: ^T1 and default ^T3: ^T2 and default ^T1: ^T3 and default ^T1: ^T2 and default ^T1: int /// Overloaded modulo operator /// @@ -2672,7 +2698,13 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the operation. - val inline ( % ) : x:^T1 -> y:^T2 -> ^T3 when (^T1 or ^T2) : (static member ( % ) : ^T1 * ^T2 -> ^T3) and default ^T2 : ^T3 and default ^T3 : ^T1 and default ^T3 : ^T2 and default ^T1 : ^T3 and default ^T1 : ^T2 and default ^T1 : int + /// + /// + /// + /// 29 % 5 // Evaluates to 4 + /// + /// + val inline (%): x: ^T1 -> y: ^T2 -> ^T3 when (^T1 or ^T2): (static member (%): ^T1 * ^T2 -> ^T3) and default ^T2: ^T3 and default ^T3: ^T1 and default ^T3: ^T2 and default ^T1: ^T3 and default ^T1: ^T2 and default ^T1: int /// Overloaded bitwise-AND operator /// @@ -2680,7 +2712,16 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the operation. - val inline (&&&): x:^T -> y:^T -> ^T when ^T : (static member (&&&) : ^T * ^T -> ^T) and default ^T : int + /// + /// + /// + /// let a = 13 // 00000000000000000000000000001101 + /// let b = 11 // 00000000000000000000000000001011 + /// let c = a &&& b // 00000000000000000000000000001001 + /// + /// Evaluates to 9 + /// + val inline (&&&): x: ^T -> y: ^T -> ^T when ^T: (static member (&&&): ^T * ^T -> ^T) and default ^T: int /// Overloaded bitwise-OR operator /// @@ -2688,7 +2729,16 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the operation. - val inline (|||) : x:^T -> y:^T -> ^T when ^T : (static member (|||) : ^T * ^T -> ^T) and default ^T : int + /// + /// + /// + /// let a = 13 // 00000000000000000000000000001101 + /// let b = 11 // 00000000000000000000000000001011 + /// let c = a ||| b // 00000000000000000000000000001111 + /// + /// Evaluates to 15 + /// + val inline (|||): x: ^T -> y: ^T -> ^T when ^T: (static member (|||): ^T * ^T -> ^T) and default ^T: int /// Overloaded bitwise-XOR operator /// @@ -2696,7 +2746,16 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the operation. - val inline (^^^) : x:^T -> y:^T -> ^T when ^T : (static member (^^^) : ^T * ^T -> ^T) and default ^T : int + /// + /// + /// + /// let a = 13 // 00000000000000000000000000001101 + /// let b = 11 // 00000000000000000000000000001011 + /// let c = a ^^^ b // 00000000000000000000000000000110 + /// + /// Evaluates to 6 + /// + val inline (^^^): x: ^T -> y: ^T -> ^T when ^T: (static member (^^^): ^T * ^T -> ^T) and default ^T: int /// Overloaded byte-shift left operator by a specified number of bits /// @@ -2704,7 +2763,15 @@ namespace Microsoft.FSharp.Core /// The amount to shift. /// /// The result of the operation. - val inline (<<<) : value:^T -> shift:int32 -> ^T when ^T : (static member (<<<) : ^T * int32 -> ^T) and default ^T : int + /// + /// + /// + /// let a = 13 // 00000000000000000000000000001101 + /// let c = a << 4 // 00000000000000000000000011010000 + /// + /// Evaluates to 206 + /// + val inline (<<<): value: ^T -> shift: int32 -> ^T when ^T : (static member (<<<) : ^T * int32 -> ^T) and default ^T : int /// Overloaded byte-shift right operator by a specified number of bits /// @@ -2712,21 +2779,43 @@ namespace Microsoft.FSharp.Core /// The amount to shift. /// /// The result of the operation. - val inline (>>>) : value:^T -> shift:int32 -> ^T when ^T : (static member (>>>) : ^T * int32 -> ^T) and default ^T : int + /// + /// + /// + /// let a = 206 // 00000000000000000000000011010000 + /// let c1 = a >> 2 // 00000000000000000000000000110100 + /// // Evaluates to 51 + /// let c2 = a >> 6 // 00000000000000000000000000000011 + /// Evaluates to 3 + /// + /// + val inline (>>>): value: ^T -> shift: int32 -> ^T when ^T: (static member (>>>): ^T * int32 -> ^T) and default ^T: int /// Overloaded bitwise-NOT operator /// /// The input value. /// /// The result of the operation. - val inline (~~~) : value:^T -> ^T when ^T : (static member (~~~) : ^T -> ^T) and default ^T : int + /// + /// + /// + /// let byte1 = 60uy // 00111100 + /// let byte2 = ~~~b1 // 11000011 + /// + /// Evaluates to 195 + /// + /// + val inline (~~~): value: ^T -> ^T when ^T: (static member (~~~): ^T -> ^T) and default ^T: int /// Overloaded prefix-plus operator /// /// The input value. /// /// The result of the operation. - val inline (~+) : value:^T -> ^T when ^T : (static member (~+) : ^T -> ^T) and default ^T : int + /// + /// + /// + val inline (~+): value: ^T -> ^T when ^T: (static member (~+): ^T -> ^T) and default ^T: int /// Structural less-than comparison /// @@ -2734,7 +2823,16 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the comparison. - val inline ( < ) : x:'T -> y:'T -> bool when 'T : comparison + /// + /// + /// + /// 1 < 5 // Evaluates to true + /// 5 < 5 // Evaluates to false + /// (1, "a") < (1, "z") // Evaluates to true + /// + /// + /// + val inline (<): x: 'T -> y: 'T -> bool when 'T : comparison /// Structural greater-than /// @@ -2742,7 +2840,16 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the comparison. - val inline ( > ) : x:'T -> y:'T -> bool when 'T : comparison + /// + /// + /// + /// 5 > 1 // Evaluates to true + /// 5 > 5 // Evaluates to false + /// (1, "a") > (1, "z") // Evaluates to false + /// + /// + /// + val inline (>): x: 'T -> y: 'T -> bool when 'T: comparison /// Structural greater-than-or-equal /// @@ -2750,7 +2857,16 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the comparison. - val inline ( >= ) : x:'T -> y:'T -> bool when 'T : comparison + /// + /// + /// + /// 5 >= 1 // Evaluates to true + /// 5 >= 5 // Evaluates to true + /// [1; 5] >= [1; 6] // Evaluates to false + /// + /// + /// + val inline (>=): x: 'T -> y: 'T -> bool when 'T : comparison /// Structural less-than-or-equal comparison /// @@ -2758,7 +2874,16 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the comparison. - val inline ( <= ) : x:'T -> y:'T -> bool when 'T : comparison + /// + /// + /// + /// 5 <= 1 // Evaluates to false + /// 5 <= 5 // Evaluates to true + /// [1; 5] <= [1; 6] // Evaluates to true + /// + /// + /// + val inline (<=): x: 'T -> y: 'T -> bool when 'T: comparison /// Structural equality /// @@ -2766,7 +2891,17 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the comparison. - val inline ( = ) : x:'T -> y:'T -> bool when 'T : equality + /// + /// + /// + /// 5 = 5 // Evaluates to true + /// 5 = 6 // Evaluates to false + /// [1; 2] = [1; 2] // Evaluates to true + /// (1, 5) = (1, 6) // Evaluates to false + /// + /// + /// + val inline (=): x: 'T -> y: 'T -> bool when 'T: equality /// Structural inequality /// @@ -2774,7 +2909,16 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the comparison. - val inline ( <> ) : x:'T -> y:'T -> bool when 'T : equality + /// + /// + /// + /// 5 <> 5 // Evaluates to false + /// 5 <> 6 // Evaluates to true + /// [1; 2] <> [1; 2] // Evaluates to false + /// + /// + /// + val inline (<>): x:'T -> y:'T -> bool when 'T : equality /// Compose two functions, the function on the left being applied first /// @@ -2782,7 +2926,17 @@ namespace Microsoft.FSharp.Core /// The second function to apply. /// /// The composition of the input functions. - val inline (>>): func1:('T1 -> 'T2) -> func2:('T2 -> 'T3) -> ('T1 -> 'T3) + /// + /// + /// + /// let addOne x = x + 1 + /// let doubleIt x = x * 2 + /// let addThenDouble = addOne >> doubleIt + /// addThenDouble 3 // Evaluates to 8 + /// + /// + /// + val inline (>>): func1: ('T1 -> 'T2) -> func2: ('T2 -> 'T3) -> ('T1 -> 'T3) /// Compose two functions, the function on the right being applied first /// @@ -2790,7 +2944,17 @@ namespace Microsoft.FSharp.Core /// The first function to apply. /// /// The composition of the input functions. - val inline (<<): func2:('T2 -> 'T3) -> func1:('T1 -> 'T2) -> ('T1 -> 'T3) + /// + /// + /// + /// let addOne x = x + 1 + /// let doubleIt x = x * 2 + /// let doubleThenAdd = addOne << doubleIt + /// doubleThenAdd 3 + /// + /// + /// + 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 /// @@ -2798,7 +2962,15 @@ namespace Microsoft.FSharp.Core /// The function. /// /// The function result. - val inline (|>): arg:'T1 -> func:('T1 -> 'U) -> 'U + /// + /// + /// + /// let doubleIt x = x * 2 + /// 3 |> doubleIt // Evaluates to 6 + /// + /// + /// + 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 /// @@ -2807,7 +2979,15 @@ namespace Microsoft.FSharp.Core /// The function. /// /// The function result. - val inline (||>): arg1:'T1 * arg2:'T2 -> func:('T1 -> 'T2 -> 'U) -> 'U + /// + /// + /// + /// let sum x y = x + y + /// (3, 4) ||> sum // Evaluates to 7 + /// + /// + /// + 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 /// @@ -2817,7 +2997,15 @@ namespace Microsoft.FSharp.Core /// The function. /// /// The function result. - val inline (|||>): arg1:'T1 * arg2:'T2 * arg3:'T3 -> func:('T1 -> 'T2 -> 'T3 -> 'U) -> 'U + /// + /// + /// + /// let sum3 x y z = x + y + z + /// (3, 4, 5) |||> sum3 // Evaluates to 12 + /// + /// + /// + 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 /// @@ -2825,7 +3013,15 @@ namespace Microsoft.FSharp.Core /// The argument. /// /// The function result. - val inline (<|): func:('T -> 'U) -> arg1:'T -> 'U + /// + /// + /// + /// let doubleIt x = x * 2 + /// doubleIt <| 3 // Evaluates to 6 + /// + /// + /// + 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 /// @@ -2834,7 +3030,15 @@ namespace Microsoft.FSharp.Core /// The second argument. /// /// The function result. - val inline (<||): func:('T1 -> 'T2 -> 'U) -> arg1:'T1 * arg2:'T2 -> 'U + /// + /// + /// + /// let sum x y = x + y + /// sum <|| (3, 4) // Evaluates to 7 + /// + /// + /// + 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 /// @@ -2844,7 +3048,15 @@ namespace Microsoft.FSharp.Core /// The third argument. /// /// The function result. - val inline (<|||): func:('T1 -> 'T2 -> 'T3 -> 'U) -> arg1:'T1 * arg2:'T2 * arg3:'T3 -> 'U + /// + /// + /// + /// let sum3 x y z = x + y + z + /// sum3 <||| (3, 4, 5) // Evaluates to 12 + /// + /// + /// + 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 /// @@ -2852,8 +3064,24 @@ namespace Microsoft.FSharp.Core /// The default value of the argument. /// /// The argument value. If it is None, the defaultValue is returned. + /// + /// + /// + /// type Vector(x: double, y: double, ?z: double) = + /// let z = defaultArg z 0.0 + /// member this.X = x + /// member this.Y = y + /// member this.Z = z + /// + /// let v1 = Vector(1.0, 2.0) + /// v1.Z // Evaluates to 0. + /// let v2 = Vector(1.0, 2.0, 3.0) + /// v2.Z // Evaluates to 3.0 + /// + /// + /// [] - val defaultArg : arg:'T option -> defaultValue:'T -> 'T + val defaultArg: arg: 'T option -> defaultValue: 'T -> 'T /// Used to specify a default value for an optional argument in the implementation of a function /// @@ -2861,8 +3089,17 @@ namespace Microsoft.FSharp.Core /// The default value of the argument. /// /// The argument value. If it is None, the defaultValue is returned. + /// + /// + /// + /// let arg1 = ValueSome(5) + /// defaultValueArg arg1 6 // Evaluates to 5 + /// defaultValueArg ValueNone 6 // Evaluates to 6 + /// + /// + /// [] - val defaultValueArg : arg:'T voption -> defaultValue:'T -> 'T + val defaultValueArg: arg: 'T voption -> defaultValue: 'T -> 'T /// Concatenate two strings. The operator '+' may also be used. [] @@ -2873,50 +3110,110 @@ namespace Microsoft.FSharp.Core /// The exception to raise. /// /// The result value. + /// + /// + /// + /// open System.IO + /// exception FileNotFoundException of string + /// + /// let readFile (filename: string) = + /// if not (File.Exists(filename)) then + /// raise(FileNotFoundException(filename)) + /// File.ReadAllText(filename) + /// + /// readFile "/this-file-doest-exist" + /// + /// When executed, raises a FileNotFoundException. + /// + /// [] - val inline raise : exn:System.Exception -> 'T + val inline raise: exn: System.Exception -> 'T /// Rethrows an exception. This should only be used when handling an exception /// The result value. [] [] - val inline rethrow : unit -> 'T + val inline rethrow: unit -> 'T /// Rethrows an exception. This should only be used when handling an exception /// The result value. + /// + /// + /// + /// let readFile (filename: string) = + /// try + /// File.ReadAllText(filename) + /// with ex -> + /// eprintfn "Couldn't read %s" filename + /// reraise() + /// + /// readFile "/this-file-doest-exist" + /// // Prints the message to stderr + /// // Throws a System.IO.FileNotFoundException + /// + /// + /// [] - val inline reraise : unit -> 'T + val inline reraise: unit -> 'T /// Builds a object. /// /// The message for the Exception. /// /// A System.Exception. - val Failure : message:string -> exn + /// + /// + /// + /// let throwException() = + /// raise(Failure("Oh no!!!")) + /// true // Never gets here + /// + /// throwException() // Throws a generic Exception class + /// + /// + /// + val Failure: message: string -> exn /// Matches objects whose runtime type is precisely /// /// The input exception. /// /// A string option. + /// + /// + /// [] - val (|Failure|_|) : error:exn -> string option + val (|Failure|_|): error: exn -> string option /// Return the first element of a tuple, fst (a,b) = a. /// /// The input tuple. /// /// The first value. + /// + /// + /// + /// fst ("first", 2) // Evaluates to "first" + /// + /// + /// [] - val inline fst : tuple:('T1 * 'T2) -> 'T1 + val inline fst: tuple: ('T1 * 'T2) -> 'T1 /// Return the second element of a tuple, snd (a,b) = b. /// /// The input tuple. /// /// The second value. + /// + /// + /// + /// snd ("first", 2) // Evaluates to 2 + /// + /// + /// [] - val inline snd : tuple:('T1 * 'T2) -> 'T2 + val inline snd: tuple: ('T1 * 'T2) -> 'T2 /// Generic comparison. /// @@ -2924,8 +3221,20 @@ namespace Microsoft.FSharp.Core /// The second value. /// /// The result of the comparison. + /// + /// + /// + /// compare 1 2 // Evaluates to -1 + /// compare [1;2;3] [1;2;4] // Evaluates to -1 + /// compare 2 2 // Evaluates to 0 + /// compare [1;2;3] [1;2;3] // Evaluates to 0 + /// compare 2 1 // Evaluates to 1 + /// compare [1;2;4] [1;2;3] // Evaluates to 1 + /// + /// + /// [] - val inline compare: e1:'T -> e2:'T -> int when 'T : comparison + val inline compare: e1: 'T -> e2: 'T -> int when 'T: comparison /// Maximum based on generic comparison /// @@ -2933,8 +3242,17 @@ namespace Microsoft.FSharp.Core /// The second value. /// /// The maximum value. + /// + /// + /// + /// max 1 2 // Evaluates to 2 + /// max [1;2;3] [1;2;4] // Evaluates to [1;2;4] + /// max "zoo" "alpha" // Evaluates to "zoo" + /// + /// + /// [] - val inline max : e1:'T -> e2:'T -> 'T when 'T : comparison + val inline max: e1: 'T -> e2: 'T -> 'T when 'T: comparison /// Minimum based on generic comparison /// @@ -2942,46 +3260,100 @@ namespace Microsoft.FSharp.Core /// The second value. /// /// The minimum value. + /// + /// + /// + /// min 1 2 // Evaluates to 1 + /// min [1;2;3] [1;2;4] // Evaluates to [1;2;3] + /// min "zoo" "alpha" // Evaluates to "alpha" + /// + /// + /// [] - val inline min : e1:'T -> e2:'T -> 'T when 'T : 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. /// /// The value to ignore. + /// + /// + /// + /// ignore 55555 // Evaluates to () + /// + /// + /// [] - val inline ignore : value:'T -> unit + val inline ignore: value: 'T -> unit /// Unbox a strongly typed value. /// /// The boxed value. /// /// The unboxed result. + /// + /// + /// + /// let x: int = 123 + /// let obj1 = box x // obj1 is a generic object type + /// unbox<int> obj1 // Evaluates to 123 (int) + /// unbox<double> obj1 // Throws System.InvalidCastException + /// + /// + /// [] - val inline unbox : value:obj -> 'T + val inline unbox: value: obj -> 'T /// Boxes a strongly typed value. /// /// The value to box. /// /// The boxed object. + /// + /// + /// + /// let x: int = 123 + /// let obj1 = box x // obj1 is a generic object type + /// unbox<int> obj1 // Evaluates to 123 (int) + /// unbox<double> obj1 // Throws System.InvalidCastException + /// + /// + /// [] - val inline box : value:'T -> obj + val inline box: value: 'T -> obj /// Try to unbox a strongly typed value. /// /// The boxed value. /// /// The unboxed result as an option. + /// + /// + /// + /// let x: int = 123 + /// let obj1 = box x // obj1 is a generic object type + /// tryUnbox<int> obj1 // Evaluates to Some(123) + /// tryUnbox<double> obj1 // Evaluates to None + /// + /// + /// [] - val inline tryUnbox : value:obj -> 'T option + val inline tryUnbox: value: obj -> 'T option /// Determines whether the given value is null. /// /// The value to check. /// /// True when value is null, false otherwise. + /// + /// + /// + /// isNull null // Evaluates to true + /// isNull "Not null" // Evaluates to false + /// + /// + /// [] - val inline isNull : value:'T -> bool when 'T : null + val inline isNull: value: 'T -> bool when 'T: null /// Determines whether the given value is not null. /// @@ -2989,15 +3361,26 @@ namespace Microsoft.FSharp.Core /// /// True when value is not null, false otherwise. [] - val inline internal isNotNull : value:'T -> bool when 'T : null + val inline internal isNotNull: value: 'T -> bool when 'T: null /// Throw a exception. /// /// The exception message. /// /// The result value. + /// + /// + /// + /// let failingFunction() = + /// failwith "Oh no" // Throws an exception + /// true // Never reaches this + /// + /// failingFunction() // Throws a System.Exception + /// + /// + /// [] - val inline failwith : message:string -> 'T + val inline failwith: message: string -> 'T /// Throw a exception with /// the given argument name and message. @@ -3006,65 +3389,163 @@ namespace Microsoft.FSharp.Core /// The exception message. /// /// The result value. + /// + /// + /// + /// let fullName firstName lastName = + /// if String.IsNullOrWhiteSpace(firstName) then + /// invalidArg (nameof(firstName)) "First name can't be null or blank" + /// if String.IsNullOrWhiteSpace(lastName) then + /// invalidArg (nameof(lastName)) "Last name can't be null or blank" + /// firstName + " " + lastName + /// + /// fullName null "Jones" + /// + /// Throws System.ArgumentException: First name can't be null or blank (Parameter 'firstName') + /// + /// [] - val inline invalidArg : argumentName:string -> message:string -> 'T + val inline invalidArg: argumentName:string -> message:string -> 'T /// Throw a exception /// /// The argument name. /// /// The result value. + /// + /// + /// + /// let fullName firstName lastName = + /// nullArg (nameof(firstName)) + /// nullArg (nameof(lastName)) + /// firstName + " " + lastName + /// + /// fullName null "Jones" // Throws System.ArgumentNullException: Value cannot be null. (Parameter 'firstName') + /// + /// + /// [] - val inline nullArg : argumentName:string -> 'T + val inline nullArg: argumentName: string -> 'T /// Throw a exception /// /// The exception message. /// /// The result value. + /// + /// + /// + /// type FileReader(filename: string) = + /// let mutable isOpen = false + /// member this.Open() = + /// if isOpen then invalidOp "File is already open" + /// // ... Here we may open the file ... + /// isOpen <- true + /// + /// let reader = FileReader("journal.txt") + /// reader.Open() // Executes fine + /// reader.Open() // Throws System.InvalidOperationException: File is already open + /// + /// + /// [] - val inline invalidOp : message:string -> 'T + val inline invalidOp: message: string -> 'T /// The identity function /// /// The input value. /// /// The same value. + /// + /// + /// + /// id 12 // Evaulates to 12 + /// id "abc" // Evaulates to "abc" + /// + /// + /// [] - val id : x:'T -> 'T + val id: x: 'T -> 'T /// Create a mutable reference cell /// /// The value to contain in the cell. /// /// The created reference cell. + /// + /// + /// + /// let count = ref 0 // Creates a reference cell object with a mutable Value property + /// count.Value // Evaluates to 0 + /// count.Value <- 1 // Updates the value + /// count.Value // Evaluates to 1 + /// + /// + /// [] - val ref : value:'T -> 'T ref + val ref: value: 'T -> 'T ref /// Assign to a mutable reference cell /// /// The cell to mutate. /// The value to set inside the cell. - val ( := ) : cell:'T ref -> value:'T -> unit + /// + /// + /// + /// let count = ref 0 // Creates a reference cell object with a mutable Value property + /// count.Value <- 1 // Updates the value + /// count := 2 // Also updates the value, but with shorter syntax + /// count.Value // Evaluates to 2 + /// + /// + /// + val (:=): cell: 'T ref -> value: 'T -> unit /// Dereference a mutable reference cell /// /// The cell to dereference. /// /// The value contained in the cell. - val ( ! ) : cell:'T ref -> 'T + /// + /// + /// + /// let count = ref 12 // Creates a reference cell object with a mutable Value property + /// count.Value // Evaluates to 12 + /// !count // Also evaluates to 12 (with shorter syntax) + /// + /// + /// + val (!): cell: 'T ref -> 'T /// Decrement a mutable reference cell containing an integer /// /// The reference cell. + /// + /// + /// + /// let count = ref 99 // Creates a reference cell object with a mutable Value property + /// decr count // Decrements our counter + /// count.Value // Evaluates to 98 + /// + /// + /// [] - val decr: cell:int ref -> unit + val decr: cell: int ref -> unit /// Increment a mutable reference cell containing an integer /// /// The reference cell. + /// + /// + /// + /// let count = ref 99 // Creates a reference cell object with a mutable Value property + /// incr count // Increments our counter + /// count.Value // Evaluates to 100 + /// + /// + /// [] - val incr: cell:int ref -> unit + val incr: cell: int ref -> unit /// Concatenate two lists. /// @@ -3072,23 +3553,49 @@ namespace Microsoft.FSharp.Core /// The second list. /// /// The concatenation of the lists. - val (@): list1:'T list -> list2:'T list -> 'T list + /// + /// + /// + /// let l1 = ['a'; 'b'; 'c'] + /// let l2 = ['d'; 'e'; 'f'] + /// l1 @ l2 // Evalulates to ['a'; 'b'; 'c'; 'd'; 'e'; 'f'] + /// + /// + /// + val (@): list1: 'T list -> list2: 'T list -> 'T list /// Negate a logical value. Not True equals False and not False equals True /// /// The value to negate. /// /// The result of the negation. + /// + /// + /// + /// not (2 + 2 = 5) // Evaluates to true + /// + /// // not is a function that can be compose with other functions + /// let fileDoesNotExist = System.IO.File.Exists >> not + /// + /// + /// [] - val inline not : value:bool -> bool + val inline not: value: bool -> bool /// Builds a sequence using sequence expression syntax /// /// The input sequence. /// /// The result sequence. + /// + /// + /// + /// seq { for i in 0..10 do yield (i, i*i) } + /// + /// + /// [] - val seq : sequence:seq<'T> -> seq<'T> + val seq: sequence: seq<'T> -> seq<'T> /// Exit the current hardware isolated process, if security settings permit, /// otherwise raise an exception. Calls . @@ -3096,8 +3603,21 @@ namespace Microsoft.FSharp.Core /// The exit code to use. /// /// The result value. + /// + /// + /// + /// [<EntryPoint>] + /// let main argv = + /// if argv.Length = 0 then + /// eprintfn "You must provide arguments" + /// exit(-1) // Causes program to quit with an error code + /// printfn "Argument count: %i" argv.Length + /// 0 + /// + /// + /// [] - val exit: exitcode:int -> 'T when default 'T : obj + val exit: exitcode: int -> 'T when default 'T: obj /// Equivalent to [] @@ -3133,12 +3653,24 @@ namespace Microsoft.FSharp.Core /// The end value of the range. /// /// The sequence spanning the range. - val inline (..) : start:^T -> finish:^T -> seq< ^T > - when ^T : (static member (+) : ^T * ^T -> ^T) - and ^T : (static member One : ^T) - and ^T : equality - and ^T : comparison - and default ^T : int + /// + /// + /// + /// [1..4] // Evaluates to [1; 2; 3; 4] + /// [1.5..4.4] // Evaluates to [1.5; 2.5; 3.5] + /// ['a'..'d'] // Evaluates to ['a'; 'b'; 'c'; 'd'] + /// + /// [|1..4|] // Evaluates to an array [|1; 2; 3; 4|] + /// { 1..4 } // Evaluates to a sequence [1; 2; 3; 4]) + /// + /// + /// + val inline (..): start: ^T -> finish: ^T -> seq< ^T > + when ^T: (static member (+): ^T * ^T -> ^T) + and ^T: (static member One: ^T) + and ^T: equality + and ^T: comparison + and default ^T: int /// The standard overloaded skip range operator, e.g. [n..skip..m] for lists, seq {n..skip..m} for sequences /// @@ -3147,13 +3679,22 @@ namespace Microsoft.FSharp.Core /// The end value of the range. /// /// The sequence spanning the range using the specified step size. - val inline (.. ..) : start:^T -> step:^Step -> finish:^T -> seq< ^T > - when (^T or ^Step) : (static member (+) : ^T * ^Step -> ^T) - and ^Step : (static member Zero : ^Step) - and ^T : equality - and ^T : comparison - and default ^Step : ^T - and default ^T : int + /// + /// + /// + /// [1..2..6] // Evaluates to [1; 3; 5] + /// [1.1..0.2..1.5] // Evaluates to [1.1; 1.3; 1.5] + /// ['a'..'e'] // Evaluates to ['a'; 'b'; 'c'; 'd'; 'e'] + /// + /// + /// + val inline (.. ..): start: ^T -> step: ^Step -> finish: ^T -> seq< ^T > + when (^T or ^Step): (static member (+): ^T * ^Step -> ^T) + and ^Step: (static member Zero: ^Step) + and ^T: equality + and ^T: comparison + and default ^Step: ^T + and default ^T: int /// Execute the function as a mutual-exclusion region using the input value as a lock. /// @@ -3161,8 +3702,48 @@ namespace Microsoft.FSharp.Core /// The action to perform during the lock. /// /// The resulting value. + /// + /// + /// + /// open System.Linq + /// + /// /// A counter object, supporting unlocked and locked increment + /// type TestCounter () = + /// let mutable count = 0 + /// + /// /// Increment the counter, unlocked + /// member this.IncrementWithoutLock() = + /// count <- count + 1 + /// + /// /// Increment the counter, locked + /// member this.IncrementWithLock() = + /// lock this (fun () -> count <- count + 1) + /// + /// /// Get the count + /// member this.Count = count + /// + /// let counter = TestCounter() + /// + /// // Create a parallel sequence to that uses all our CPUs + /// (seq {1..100000}).AsParallel() + /// .ForAll(fun _ -> counter.IncrementWithoutLock()) + /// + /// // Evaluates to a number between 1-100000, non-deterministically because there is no locking + /// counter.Count + /// + /// let counter2 = TestCounter() + /// + /// // Create a parallel sequence to that uses all our CPUs + /// (seq {1..100000}).AsParallel() + /// .ForAll(fun _ -> counter2.IncrementWithLock()) + /// + /// // Evaluates to 100000 deterministically because the increment to the counter object is locked + /// counter.Count + /// + /// + /// [] - val inline lock: lockObject:'Lock -> action:(unit -> 'T) -> 'T when 'Lock : not struct + 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 @@ -3172,36 +3753,84 @@ namespace Microsoft.FSharp.Core /// The action that accepts the resource. /// /// The resulting value. + /// + /// + /// The following code appends 10 lines to test.txt, then closes the StreamWriter when finished. + /// + /// open System.IO + /// + /// using (File.AppendText "test.txt") (fun writer -> + /// for i in 1 .. 10 do + /// writer.WriteLine("Hello World {0}", i)) + /// + /// + /// + /// [] - val using: resource:('T :> System.IDisposable) -> action:('T -> 'U) -> 'U - + val using: resource: ('T :> System.IDisposable) -> action: ('T -> 'U) -> 'U /// Generate a System.Type runtime representation of a static type. + /// + /// + /// + /// let t = typeof<int> // Gets the System.Type + /// t.FullName // Evaluates to "System.Int32" + /// + /// + /// [] [] val inline typeof<'T> : System.Type - /// Returns the name of the given symbol. + /// Returns the name of the given symbol. + /// + /// + /// + /// let myVariableName = "This value doesn't matter" + /// nameof(myVariableName) // Evaluates to "myVariableName" + /// + /// + /// [] - val inline nameof : 'T -> string + val inline nameof: 'T -> string /// An internal, library-only compiler intrinsic for compile-time /// generation of a RuntimeMethodHandle. [] #if DEBUG - val methodhandleof : ('T -> 'TResult) -> System.RuntimeMethodHandle + val methodhandleof: ('T -> 'TResult) -> System.RuntimeMethodHandle #else - val internal methodhandleof : ('T -> 'TResult) -> System.RuntimeMethodHandle + val internal methodhandleof: ('T -> 'TResult) -> System.RuntimeMethodHandle #endif /// 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. + /// + /// + /// + /// typeof<int list;> // Evaluates to Microsoft.FSharp.Collections.FSharpList`1[System.Int32] + /// typedefof<int list;> // Evaluates to Microsoft.FSharp.Collections.FSharpList`1[T] /// + /// + /// + /// [] [] val inline typedefof<'T> : System.Type /// Returns the internal size of a type in bytes. For example, sizeof<int> returns 4. + /// + /// + /// + /// sizeof<bool> // Evaluates to 1 + /// sizeof<byte> // Evaluates to 1 + /// sizeof<int> // Evaluates to 4 + /// sizeof<double> // Evaluates to 8 + /// sizeof<struct(byte * byte)> // Evaluates to 2 + /// sizeof<nativeint> // Evaluates to 4 or 8 (32-bit or 64-bit) depending on your platform + /// + /// + /// [] [] val inline sizeof<'T> : int @@ -3215,8 +3844,15 @@ namespace Microsoft.FSharp.Core /// The input object. /// /// The computed hash. + /// + /// + /// + /// hash "Bob Jones" // Evaluates to -325251320 + /// + /// + /// [] - val inline hash: obj:'T -> int when 'T : equality + 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 @@ -3228,40 +3864,75 @@ namespace Microsoft.FSharp.Core /// The input object. /// /// The computed hash. - val inline limitedHash: limit: int -> obj:'T -> int when 'T : equality - + /// + /// + /// + val inline limitedHash: limit: int -> obj: 'T -> int when 'T : equality /// Absolute value of the given number. /// /// The input value. /// /// The absolute value of the input. + /// + /// + /// + /// abs -12 // Evaluates to 12 + /// abs -15.0 // Evaluates to 15.0 + /// + /// + /// [] - val inline abs : value:^T -> ^T when ^T : (static member Abs : ^T -> ^T) and default ^T : int + val inline abs: value: ^T -> ^T when ^T: (static member Abs: ^T -> ^T) and default ^T: int /// Inverse cosine of the given number /// /// The input value. /// /// The inverse cosine of the input. + /// + /// + /// + /// let angleFromAdjacent adjacent hypotenuse = acos(adjacent / hypotenuse) + /// angleFromAdjacent 8.0 10.0 // Evaluates to 0.6435011088 + /// + /// + /// [] - val inline acos : value:^T -> ^T when ^T : (static member Acos : ^T -> ^T) and default ^T : float + val inline acos: value: ^T -> ^T when ^T : (static member Acos : ^T -> ^T) and default ^T : float /// Inverse sine of the given number /// /// The input value. /// /// The inverse sine of the input. + /// + /// + /// + /// let angleFromOpposite opposite hypotenuse = asin(opposite / hypotenuse) + /// angleFromOpposite 6.0 10.0 // Evaluates to 0.6435011088 + /// angleFromOpposite 5.0 3.0 // Evaluates to nan + /// + /// + /// [] - val inline asin : value:^T -> ^T when ^T : (static member Asin : ^T -> ^T) and default ^T : float + val inline asin: value: ^T -> ^T when ^T: (static member Asin: ^T -> ^T) and default ^T: float /// Inverse tangent of the given number /// /// The input value. /// /// The inverse tangent of the input. + /// + /// + /// + /// let angleFrom opposite adjacent = atan(opposite / adjacent) + /// angleFrom 5.0 5.0 // Evaluates to 0.7853981634 + /// + /// + /// [] - val inline atan : value:^T -> ^T when ^T : (static member Atan : ^T -> ^T) and default ^T : float + val inline atan: value: ^T -> ^T when ^T: (static member Atan: ^T -> ^T) and default ^T: float /// Inverse tangent of x/y where x and y are specified separately /// @@ -3269,128 +3940,258 @@ namespace Microsoft.FSharp.Core /// The x input value. /// /// The inverse tangent of the input ratio. + /// + /// + /// + /// let angleFromPlaneAtXY x y = atan2 y x * 180.0 / System.Math.PI + /// angleFromPlaneAtXY 0.0 -1.0 // Evaluates to -90.0 + /// angleFromPlaneAtXY 1.0 1.0 // Evaluates to 45.0 + /// angleFromPlaneAtXY -1.0 1.0 // Evaluates to 135.0 + /// + /// + /// [] - val inline atan2 : y:^T1 -> x:^T1 -> 'T2 when ^T1 : (static member Atan2 : ^T1 * ^T1 -> 'T2) and default ^T1 : float + val inline atan2: y: ^T1 -> x: ^T1 -> 'T2 when ^T1: (static member Atan2: ^T1 * ^T1 -> 'T2) and default ^T1: float /// Ceiling of the given number /// /// The input value. /// /// The ceiling of the input. + /// + /// + /// + /// ceil 12.1 // Evaluates to 13.0 + /// ceil -1.9 // Evaluates to -1.0 + /// + /// + /// [] - val inline ceil : value:^T -> ^T when ^T : (static member Ceiling : ^T -> ^T) and default ^T : float + val inline ceil: value: ^T -> ^T when ^T: (static member Ceiling: ^T -> ^T) and default ^T: float /// Exponential of the given number /// /// The input value. /// /// The exponential of the input. + /// + /// + /// + /// exp 0.0 // Evaluates to 1.0 + /// exp 1.0 // Evaluates to 2.718281828 + /// exp -1.0 // Evaluates to 0.3678794412 + /// exp 2.0 // Evaluates to 7.389056099 + /// + /// + /// [] - val inline exp : value:^T -> ^T when ^T : (static member Exp : ^T -> ^T) and default ^T : float + val inline exp: value: ^T -> ^T when ^T : (static member Exp : ^T -> ^T) and default ^T : float /// Floor of the given number /// /// The input value. /// /// The floor of the input. + /// + /// + /// + /// floor 12.1 // Evaluates to 12.0 + /// floor -1.9 // Evaluates to -2.0 + /// + /// + /// [] - val inline floor : value:^T -> ^T when ^T : (static member Floor : ^T -> ^T) and default ^T : float + val inline floor: value: ^T -> ^T when ^T: (static member Floor: ^T -> ^T) and default ^T: float /// Sign of the given number /// /// The input value. /// /// -1, 0, or 1 depending on the sign of the input. + /// + /// + /// + /// sign -12.0 // Evaluates to -1 + /// sign 43 // Evaluates to 1 + /// + /// + /// [] - val inline sign : value:^T -> int when ^T : (member Sign : int) and default ^T : float + val inline sign: value: ^T -> int when ^T: (member Sign: int) and default ^T: float /// Round the given number /// /// The input value. /// /// The nearest integer to the input value. + /// + /// + /// + /// round 3.49 // Evaluates to 3.0 + /// round -3.49 // Evaluates to -3.0 + /// round 3.5 // Evaluates to 4.0 + /// round -3.5 // Evaluates to -4.0 + /// + /// + /// [] - val inline round : value:^T -> ^T when ^T : (static member Round : ^T -> ^T) and default ^T : float + val inline round: value: ^T -> ^T when ^T : (static member Round : ^T -> ^T) and default ^T : float /// Natural logarithm of the given number /// /// The input value. /// /// The natural logarithm of the input. + /// + /// + /// + /// let logBase baseNumber value = (log value) / (log baseNumber) + /// logBase 2.0 32.0 // Evaluates to 5.0 + /// logBase 10.0 1000.0 // Evaluates to 3.0 + /// + /// + /// [] - val inline log : value:^T -> ^T when ^T : (static member Log : ^T -> ^T) and default ^T : float + val inline log: value: ^T -> ^T when ^T: (static member Log: ^T -> ^T) and default ^T: float /// Logarithm to base 10 of the given number /// /// The input value. /// /// The logarithm to base 10 of the input. + /// + /// + /// + /// log10 1000.0 // Evaluates to 3.0 + /// log10 100000.0 // Evaluates to 5.0 + /// log10 0.0001 // Evaluates to -4.0 + /// log10 -20.0 // Evaluates to nan + /// + /// + /// [] - val inline log10 : value:^T -> ^T when ^T : (static member Log10 : ^T -> ^T) and default ^T : float + val inline log10: value: ^T -> ^T when ^T: (static member Log10: ^T -> ^T) and default ^T: float /// Square root of the given number /// /// The input value. /// /// The square root of the input. + /// + /// + /// + /// sqrt 2.0 // Evaluates to 1.414213562 + /// sqrt 100.0 // Evaluates to 10.0 + /// + /// + /// [] - val inline sqrt : value:^T -> ^U when ^T : (static member Sqrt : ^T -> ^U) and default ^U : ^T and default ^T : ^U and default ^T : float + val inline sqrt: value: ^T -> ^U when ^T : (static member Sqrt : ^T -> ^U) and default ^U : ^T and default ^T : ^U and default ^T : float /// Cosine of the given number /// /// The input value. /// /// The cosine of the input. + /// + /// + /// + /// + /// + /// + /// [] - val inline cos : value:^T -> ^T when ^T : (static member Cos : ^T -> ^T) and default ^T : float + val inline cos: value: ^T -> ^T when ^T: (static member Cos: ^T -> ^T) and default ^T: float /// Hyperbolic cosine of the given number /// /// The input value. /// /// The hyperbolic cosine of the input. + /// + /// + /// + /// + /// + /// + /// [] - val inline cosh : value:^T -> ^T when ^T : (static member Cosh : ^T -> ^T) and default ^T : float + val inline cosh: value: ^T -> ^T when ^T : (static member Cosh : ^T -> ^T) and default ^T : float /// Sine of the given number /// /// The input value. /// /// The sine of the input. + /// + /// + /// + /// + /// + /// + /// [] - val inline sin : value:^T -> ^T when ^T : (static member Sin : ^T -> ^T) and default ^T : float + val inline sin: value: ^T -> ^T when ^T: (static member Sin: ^T -> ^T) and default ^T: float /// Hyperbolic sine of the given number /// /// The input value. /// /// The hyperbolic sine of the input. + /// + /// + /// + + /// + /// + /// [] - val inline sinh : value:^T -> ^T when ^T : (static member Sinh : ^T -> ^T) and default ^T : float + val inline sinh: value: ^T -> ^T when ^T: (static member Sinh: ^T -> ^T) and default ^T: float /// Tangent of the given number /// /// The input value. /// /// The tangent of the input. + /// + /// + /// + /// + /// + /// + /// [] - val inline tan : value:^T -> ^T when ^T : (static member Tan : ^T -> ^T) and default ^T : float + val inline tan: value: ^T -> ^T when ^T: (static member Tan: ^T -> ^T) and default ^T: float /// Hyperbolic tangent of the given number /// /// The input value. /// /// The hyperbolic tangent of the input. + /// + /// + /// + /// + /// + /// + /// [] - val inline tanh : value:^T -> ^T when ^T : (static member Tanh : ^T -> ^T) and default ^T : float + val inline tanh: value: ^T -> ^T when ^T: (static member Tanh: ^T -> ^T) and default ^T: float /// Overloaded truncate operator. /// /// The input value. /// /// The truncated value. + /// + /// + /// + /// + /// + /// + /// [] - val inline truncate : value:^T -> ^T when ^T : (static member Truncate : ^T -> ^T) and default ^T : float + val inline truncate: value:^T -> ^T when ^T: (static member Truncate: ^T -> ^T) and default ^T: float /// Overloaded power operator. /// @@ -3398,7 +4199,14 @@ namespace Microsoft.FSharp.Core /// The input exponent. /// /// The base raised to the exponent. - val inline ( ** ) : x:^T -> y:^U -> ^T when ^T : (static member Pow : ^T * ^U -> ^T) and default ^U : float and default ^T : float + /// + /// + /// + /// + /// + /// + /// + val inline ( ** ): x: ^T -> y: ^U -> ^T when ^T: (static member Pow: ^T * ^U -> ^T) and default ^U: float and default ^T: float /// Overloaded power operator. If n > 0 then equivalent to x*...*x for n occurrences of x. /// @@ -3406,11 +4214,19 @@ namespace Microsoft.FSharp.Core /// The input exponent. /// /// The base raised to the exponent. + /// + /// + /// + /// + /// + /// + /// [] - 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) - and default ^T : int + 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) + and default ^T: int /// Converts the argument to byte. This is a direct conversion for all /// primitive numeric types. For strings, the input is converted using Byte.Parse() @@ -3420,8 +4236,15 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted byte + /// + /// + /// + /// + /// + /// + /// [] - val inline byte : value:^T -> byte when ^T : (static member op_Explicit : ^T -> byte) and default ^T : int + val inline byte: value: ^T -> byte when ^T: (static member op_Explicit: ^T -> byte) and default ^T: int /// 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() @@ -3431,8 +4254,15 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted sbyte + /// + /// + /// + /// + /// + /// + /// [] - val inline sbyte : value:^T -> sbyte when ^T : (static member op_Explicit : ^T -> sbyte) and default ^T : int + val inline sbyte: value:^T -> sbyte when ^T: (static member op_Explicit: ^T -> sbyte) and default ^T: int /// 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() @@ -3442,8 +4272,15 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted int16 + /// + /// + /// + /// + /// + /// + /// [] - val inline int16 : value:^T -> int16 when ^T : (static member op_Explicit : ^T -> int16) and default ^T : int + val inline int16: value: ^T -> int16 when ^T: (static member op_Explicit: ^T -> int16) and default ^T: int /// 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() @@ -3453,8 +4290,15 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted uint16 + /// + /// + /// + /// + /// + /// + /// [] - val inline uint16 : value:^T -> uint16 when ^T : (static member op_Explicit : ^T -> uint16) and default ^T : int + val inline uint16: value: ^T -> uint16 when ^T: (static member op_Explicit: ^T -> uint16) and default ^T: int /// 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() @@ -3464,8 +4308,15 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted int + /// + /// + /// + /// + /// + /// + /// [] - val inline int : value:^T -> int when ^T : (static member op_Explicit : ^T -> int) and default ^T : int + val inline int: value: ^T -> int when ^T: (static member op_Explicit: ^T -> int) and default ^T: int /// Converts the argument to an unsigned 32-bit integer. This is a direct conversion for all /// primitive numeric types. For strings, the input is converted using UInt32.Parse() @@ -3475,16 +4326,30 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted int + /// + /// + /// + /// + /// + /// + /// [] - val inline uint: value:^T -> uint when ^T: (static member op_Explicit: ^T -> uint) and default ^T: uint + val inline uint: value: ^T -> uint when ^T: (static member op_Explicit: ^T -> uint) and default ^T: uint /// Converts the argument to a particular enum type. /// /// The input value. /// /// The converted enum type. + /// + /// + /// + /// + /// + /// + /// [] - val inline enum : value:int32 -> ^U when ^U : enum + val inline enum: value: int32 -> ^U when ^U: enum /// 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() @@ -3494,8 +4359,15 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted int32 + /// + /// + /// + /// + /// + /// + /// [] - val inline int32 : value:^T -> int32 when ^T : (static member op_Explicit : ^T -> int32) and default ^T : int + val inline int32: value: ^T -> int32 when ^T: (static member op_Explicit: ^T -> int32) and default ^T: int /// 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() @@ -3505,8 +4377,15 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted uint32 + /// + /// + /// + /// + /// + /// + /// [] - val inline uint32 : value:^T -> uint32 when ^T : (static member op_Explicit : ^T -> uint32) and default ^T : int + val inline uint32: value: ^T -> uint32 when ^T: (static member op_Explicit: ^T -> uint32) and default ^T: int /// 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() @@ -3516,8 +4395,15 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted int64 + /// + /// + /// + /// + /// + /// + /// [] - val inline int64 : value:^T -> int64 when ^T : (static member op_Explicit : ^T -> int64) and default ^T : int + val inline int64: value: ^T -> int64 when ^T : (static member op_Explicit : ^T -> int64) and default ^T : int /// 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() @@ -3527,8 +4413,15 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted uint64 + /// + /// + /// + /// + /// + /// + /// [] - val inline uint64 : value:^T -> uint64 when ^T : (static member op_Explicit : ^T -> uint64) and default ^T : int + val inline uint64: value: ^T -> uint64 when ^T: (static member op_Explicit: ^T -> uint64) and default ^T: int /// 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() @@ -3538,8 +4431,15 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted float32 + /// + /// + /// + /// + /// + /// + /// [] - val inline float32 : value:^T -> float32 when ^T : (static member op_Explicit : ^T -> float32) and default ^T : int + val inline float32: value: ^T -> float32 when ^T: (static member op_Explicit: ^T -> float32) and default ^T: int /// 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() @@ -3549,8 +4449,15 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted float + /// + /// + /// + /// + /// + /// + /// [] - val inline float : value:^T -> float when ^T : (static member op_Explicit : ^T -> float) and default ^T : int + val inline float: value: ^T -> float when ^T: (static member op_Explicit: ^T -> float) and default ^T: int /// Converts the argument to signed native integer. This is a direct conversion for all /// primitive numeric types. Otherwise the operation requires an appropriate @@ -3559,8 +4466,15 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted nativeint + /// + /// + /// + /// + /// + /// + /// [] - val inline nativeint : value:^T -> nativeint when ^T : (static member op_Explicit : ^T -> nativeint) and default ^T : int + val inline nativeint: value: ^T -> nativeint when ^T: (static member op_Explicit: ^T -> nativeint) and default ^T: int /// Converts the argument to unsigned native integer using a direct conversion for all /// primitive numeric types. Otherwise the operation requires an appropriate @@ -3569,8 +4483,15 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted unativeint + /// + /// + /// + /// + /// + /// + /// [] - val inline unativeint : value:^T -> unativeint when ^T : (static member op_Explicit : ^T -> unativeint) and default ^T : int + val inline unativeint: value: ^T -> unativeint when ^T: (static member op_Explicit: ^T -> unativeint) and default ^T: int /// Converts the argument to a string using ToString. /// @@ -3579,8 +4500,15 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted string. + /// + /// + /// + /// + /// + /// + /// [] - val inline string : value:'T -> string + 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() @@ -3590,8 +4518,15 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted decimal. + /// + /// + /// + /// + /// + /// + /// [] - val inline decimal : value:^T -> decimal when ^T : (static member op_Explicit : ^T -> decimal) and default ^T : int + val inline decimal: value: ^T -> decimal when ^T: (static member op_Explicit: ^T -> decimal) and default ^T: int /// 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 @@ -3600,16 +4535,30 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted char. + /// + /// + /// + /// + /// + /// + /// [] - val inline char : value:^T -> char when ^T : (static member op_Explicit : ^T -> char) and default ^T : int + val inline char: value: ^T -> char when ^T: (static member op_Explicit: ^T -> char) and default ^T: int /// An active pattern to match values of type /// /// The input key/value pair. /// /// A tuple containing the key and value. + /// + /// + /// + /// + /// + /// + /// [] - val ( |KeyValue| ): keyValuePair:KeyValuePair<'Key,'Value> -> 'Key * 'Value + val (|KeyValue|): keyValuePair: KeyValuePair<'Key,'Value> -> 'Key * 'Value /// Contains extension methods to allow the use of F# indexer notation with arrays. /// This module is automatically opened in all F# code. @@ -3666,7 +4615,6 @@ namespace Microsoft.FSharp.Core [] member GetReverseIndex: rank: int * offset: int -> int - /// A module of compiler intrinsic functions for efficient implementations of F# integer ranges /// and dynamic invocations of other F# operators module OperatorIntrinsics = @@ -3678,7 +4626,7 @@ namespace Microsoft.FSharp.Core /// The end index. /// /// The sub array from the input indices. - val inline GetArraySlice : source:'T[] -> start:int option -> finish:int option -> 'T[] + val inline GetArraySlice: source:'T[] -> start:int option -> finish:int option -> 'T[] /// Sets a slice of an array /// @@ -3686,7 +4634,7 @@ namespace Microsoft.FSharp.Core /// The start index. /// The end index. /// The source array. - val inline SetArraySlice : target:'T[] -> start:int option -> finish:int option -> source:'T[] -> unit + val inline SetArraySlice: target:'T[] -> start:int option -> finish:int option -> source:'T[] -> unit /// Gets a region slice of an array /// @@ -3697,7 +4645,7 @@ namespace Microsoft.FSharp.Core /// The end index of the second dimension. /// /// The two dimensional sub array from the input indices. - val inline GetArraySlice2D : source:'T[,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> 'T[,] + val inline 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. /// @@ -3707,7 +4655,7 @@ namespace Microsoft.FSharp.Core /// The end index of the second dimension. /// /// The sub array from the input indices. - val inline GetArraySlice2DFixed1 : source:'T[,] -> index1:int -> start2:int option -> finish2:int option -> 'T[] + 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. /// @@ -3717,7 +4665,7 @@ namespace Microsoft.FSharp.Core /// The fixed index of the second dimension. /// /// The sub array from the input indices. - val inline GetArraySlice2DFixed2 : source:'T[,] -> start1:int option -> finish1:int option -> index2: int -> 'T[] + val inline GetArraySlice2DFixed2: source:'T[,] -> start1:int option -> finish1:int option -> index2: int -> 'T[] /// Sets a region slice of an array /// @@ -3727,7 +4675,7 @@ namespace Microsoft.FSharp.Core /// The start index of the second dimension. /// The end index of the second dimension. /// The source array. - val inline SetArraySlice2D : target:'T[,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> source:'T[,] -> unit + val inline 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. /// @@ -3736,7 +4684,7 @@ namespace Microsoft.FSharp.Core /// The start index of the second dimension. /// The end index of the second dimension. /// The source array. - val inline SetArraySlice2DFixed1 : target:'T[,] -> index1:int -> start2:int option -> finish2:int option -> source:'T[] -> unit + 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. /// @@ -3745,7 +4693,7 @@ namespace Microsoft.FSharp.Core /// The end index of the first dimension. /// The index of the second dimension. /// The source array. - val inline SetArraySlice2DFixed2 : target:'T[,] -> start1:int option -> finish1:int option -> index2:int -> source:'T[] -> unit + val inline SetArraySlice2DFixed2: target:'T[,] -> start1:int option -> finish1:int option -> index2:int -> source:'T[] -> unit /// Gets a slice of an array /// @@ -3758,7 +4706,7 @@ namespace Microsoft.FSharp.Core /// The end index of the third dimension. /// /// The three dimensional sub array from the given indices. - val inline GetArraySlice3D : source:'T[,,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> start3:int option -> finish3:int option -> 'T[,,] + val inline GetArraySlice3D: source:'T[,,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> start3:int option -> finish3:int option -> 'T[,,] /// Gets a 2D slice of a 3D array. /// @@ -3771,7 +4719,7 @@ namespace Microsoft.FSharp.Core /// /// The two dimensional sub array from the given indices. [] - val inline GetArraySlice3DFixedSingle1 : source:'T[,,] -> index1:int -> start2:int option -> finish2:int option -> start3:int option -> finish3:int option -> 'T[,] + val inline GetArraySlice3DFixedSingle1: source:'T[,,] -> index1:int -> start2:int option -> finish2:int option -> start3:int option -> finish3:int option -> 'T[,] /// Gets a 2D slice of a 3D array. /// @@ -3784,7 +4732,7 @@ namespace Microsoft.FSharp.Core /// /// The two dimensional sub array from the given indices. [] - val inline GetArraySlice3DFixedSingle2 : source:'T[,,] -> start1:int option -> finish1:int option -> index2: int -> start3:int option -> finish3:int option -> 'T[,] + val inline GetArraySlice3DFixedSingle2: source:'T[,,] -> start1:int option -> finish1:int option -> index2: int -> start3:int option -> finish3:int option -> 'T[,] /// Gets a 2D slice of a 3D array. /// @@ -3797,7 +4745,7 @@ namespace Microsoft.FSharp.Core /// /// The two dimensional sub array from the given indices. [] - val inline GetArraySlice3DFixedSingle3 : source:'T[,,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> index3: int -> 'T[,] + val inline GetArraySlice3DFixedSingle3: source:'T[,,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> index3: int -> 'T[,] /// Gets a 1D slice of a 3D array. /// @@ -3809,7 +4757,7 @@ namespace Microsoft.FSharp.Core /// /// The one dimensional sub array from the given indices. [] - val inline GetArraySlice3DFixedDouble1 : source:'T[,,] -> index1:int -> index2:int -> start3:int option -> finish3:int option -> 'T[] + val inline GetArraySlice3DFixedDouble1: source:'T[,,] -> index1:int -> index2:int -> start3:int option -> finish3:int option -> 'T[] /// Gets a 1D slice of a 3D array. /// @@ -3821,7 +4769,7 @@ namespace Microsoft.FSharp.Core /// /// The one dimensional sub array from the given indices. [] - val inline GetArraySlice3DFixedDouble2 : source:'T[,,] -> index1:int -> start2:int option -> finish2:int option -> index3:int -> 'T[] + val inline GetArraySlice3DFixedDouble2: source:'T[,,] -> index1:int -> start2:int option -> finish2:int option -> index3:int -> 'T[] /// Gets a 1D slice of a 3D array. /// @@ -3833,7 +4781,7 @@ namespace Microsoft.FSharp.Core /// /// The one dimensional sub array from the given indices. [] - val inline GetArraySlice3DFixedDouble3 : source:'T[,,] -> start1:int option -> finish1:int option -> index2:int -> index3:int -> 'T[] + val inline GetArraySlice3DFixedDouble3: source:'T[,,] -> start1:int option -> finish1:int option -> index2:int -> index3:int -> 'T[] /// Sets a slice of an array /// @@ -3845,7 +4793,7 @@ namespace Microsoft.FSharp.Core /// The start index of the third dimension. /// The end index of the third dimension. /// The source array. - val inline SetArraySlice3D : target:'T[,,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> start3:int option -> finish3:int option -> source:'T[,,] -> unit + val inline SetArraySlice3D: target:'T[,,] -> start1: int option -> finish1: int option -> start2: int option -> finish2: int option -> start3: int option -> finish3: int option -> source: 'T[,,] -> unit /// Sets a 2D slice of a 3D array /// @@ -3859,7 +4807,7 @@ namespace Microsoft.FSharp.Core /// /// The two dimensional sub array from the given indices. [] - val inline SetArraySlice3DFixedSingle1 : target: 'T[,,] -> index1: int -> start2: int option -> finish2: int option -> start3: int option -> finish3: int option -> source: 'T[,] -> unit + val inline SetArraySlice3DFixedSingle1: target: 'T[,,] -> index1: int -> start2: int option -> finish2: int option -> start3: int option -> finish3: int option -> source: 'T[,] -> unit /// Sets a 2D slice of a 3D array /// @@ -3873,7 +4821,7 @@ namespace Microsoft.FSharp.Core /// /// The two dimensional sub array from the given indices. [] - val inline SetArraySlice3DFixedSingle2 : target: 'T[,,] -> start1: int option -> finish1: int option -> index2: int -> start3: int option -> finish3: int option -> source: 'T[,] -> unit + val inline SetArraySlice3DFixedSingle2: target: 'T[,,] -> start1: int option -> finish1: int option -> index2: int -> start3: int option -> finish3: int option -> source: 'T[,] -> unit /// Sets a 2D slice of a 3D array /// @@ -3887,7 +4835,7 @@ namespace Microsoft.FSharp.Core /// /// The two dimensional sub array from the given indices. [] - val inline SetArraySlice3DFixedSingle3 : target: 'T[,,] -> start1: int option -> finish1: int option -> start2: int option -> finish2: int option -> index3: int -> source: 'T[,] -> unit + val inline SetArraySlice3DFixedSingle3: target: 'T[,,] -> start1: int option -> finish1: int option -> start2: int option -> finish2: int option -> index3: int -> source: 'T[,] -> unit /// Sets a 1D slice of a 3D array. /// @@ -3900,7 +4848,7 @@ namespace Microsoft.FSharp.Core /// /// The one dimensional sub array from the given indices. [] - val inline SetArraySlice3DFixedDouble1 : target: 'T[,,] -> index1: int -> index2: int -> start3: int option -> finish3: int option -> source: 'T[] -> unit + val inline SetArraySlice3DFixedDouble1: target: 'T[,,] -> index1: int -> index2: int -> start3: int option -> finish3: int option -> source: 'T[] -> unit /// Sets a 1D slice of a 3D array. /// @@ -3913,7 +4861,7 @@ namespace Microsoft.FSharp.Core /// /// The one dimensional sub array from the given indices. [] - val inline SetArraySlice3DFixedDouble2 : target: 'T[,,] -> index1: int -> start2: int option -> finish2: int option -> index3: int -> source: 'T[] -> unit + val inline SetArraySlice3DFixedDouble2: target: 'T[,,] -> index1: int -> start2: int option -> finish2: int option -> index3: int -> source: 'T[] -> unit /// Sets a 1D slice of a 3D array. /// @@ -3926,7 +4874,7 @@ namespace Microsoft.FSharp.Core /// /// The one dimensional sub array from the given indices. [] - val inline SetArraySlice3DFixedDouble3 : target: 'T[,,] -> start1: int option -> finish1: int option -> index2: int -> index3: int -> source: 'T[] -> unit + val inline SetArraySlice3DFixedDouble3: target: 'T[,,] -> start1: int option -> finish1: int option -> index2: int -> index3: int -> source: 'T[] -> unit /// Gets a slice of an array /// @@ -3941,7 +4889,7 @@ namespace Microsoft.FSharp.Core /// The end index of the fourth dimension. /// /// The four dimensional sub array from the given indices. - val inline 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[,,,] + val inline 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[,,,] /// Gets a 3D slice of a 4D array /// @@ -3955,7 +4903,7 @@ namespace Microsoft.FSharp.Core /// The end index of the fourth dimension. /// /// The three dimensional sub array from the given indices. - val inline GetArraySlice4DFixedSingle1 : source:'T[,,,] -> index1:int -> start2: int option -> finish2:int option -> start3:int option -> finish3:int option -> start4:int option -> finish4:int option -> 'T[,,] + val inline GetArraySlice4DFixedSingle1: source: 'T[,,,] -> index1: int -> start2: int option -> finish2: int option -> start3: int option -> finish3: int option -> start4: int option -> finish4: int option -> 'T[,,] /// Gets a 3D slice of a 4D array /// @@ -3969,7 +4917,7 @@ namespace Microsoft.FSharp.Core /// The end index of the fourth dimension. /// /// The three dimensional sub array from the given indices. - val inline GetArraySlice4DFixedSingle2 : source:'T[,,,] -> start1:int option -> finish1:int option -> index2:int -> start3:int option -> finish3:int option -> start4:int option -> finish4:int option -> 'T[,,] + val inline GetArraySlice4DFixedSingle2: source: 'T[,,,] -> start1: int option -> finish1: int option -> index2: int -> start3: int option -> finish3: int option -> start4: int option -> finish4: int option -> 'T[,,] /// Gets a 3D slice of a 4D array /// @@ -3983,7 +4931,7 @@ namespace Microsoft.FSharp.Core /// The end index of the fourth dimension. /// /// The three dimensional sub array from the given indices. - val inline GetArraySlice4DFixedSingle3 : source:'T[,,,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> index3:int -> start4:int option -> finish4:int option -> 'T[,,] + val inline GetArraySlice4DFixedSingle3: source: 'T[,,,] -> start1: int option -> finish1: int option -> start2: int option -> finish2: int option -> index3: int -> start4: int option -> finish4: int option -> 'T[,,] /// Gets a 3D slice of a 4D array /// @@ -3997,7 +4945,7 @@ namespace Microsoft.FSharp.Core /// The fixed index of the fourth dimension. /// /// The three dimensional sub array from the given indices. - val inline GetArraySlice4DFixedSingle4 : source:'T[,,,] -> start1:int option -> finish1:int option -> start2: int option -> finish2:int option -> start3:int option -> finish3:int option -> index4:int -> 'T[,,] + val inline GetArraySlice4DFixedSingle4: source: 'T[,,,] -> start1: int option -> finish1: int option -> start2: int option -> finish2: int option -> start3: int option -> finish3: int option -> index4: int -> 'T[,,] /// Gets a 2D slice of a 4D array /// @@ -4010,7 +4958,7 @@ namespace Microsoft.FSharp.Core /// The end index of the fourth dimension. /// /// The two dimensional sub array from the given indices. - val inline GetArraySlice4DFixedDouble1 : source:'T[,,,] -> index1: int -> index2:int -> start3:int option -> finish3:int option -> start4:int option -> finish4:int option -> 'T[,] + val inline GetArraySlice4DFixedDouble1: source:'T[,,,] -> index1: int -> index2: int -> start3: int option -> finish3: int option -> start4: int option -> finish4: int option -> 'T[,] /// Gets a 2D slice of a 4D array /// @@ -4023,7 +4971,7 @@ namespace Microsoft.FSharp.Core /// The end index of the fourth dimension. /// /// The two dimensional sub array from the given indices. - val inline GetArraySlice4DFixedDouble2 : source:'T[,,,] -> index1: int -> start2: int option -> finish2:int option -> index3:int -> start4:int option -> finish4:int option -> 'T[,] + val inline GetArraySlice4DFixedDouble2: source:'T[,,,] -> index1: int -> start2: int option -> finish2: int option -> index3: int -> start4: int option -> finish4: int option -> 'T[,] /// Gets a 2D slice of a 4D array /// @@ -4036,7 +4984,7 @@ namespace Microsoft.FSharp.Core /// The fixed index of the fourth dimension. /// /// The two dimensional sub array from the given indices. - val inline GetArraySlice4DFixedDouble3 : source:'T[,,,] -> index1:int -> start2: int option -> finish2:int option -> start3:int option -> finish3:int option -> index4:int -> 'T[,] + val inline GetArraySlice4DFixedDouble3: source: 'T[,,,] -> index1: int -> start2: int option -> finish2: int option -> start3: int option -> finish3: int option -> index4: int -> 'T[,] /// Gets a 2D slice of a 4D array /// @@ -4049,7 +4997,7 @@ namespace Microsoft.FSharp.Core /// The end index of the fourth dimension. /// /// The two dimensional sub array from the given indices. - val inline GetArraySlice4DFixedDouble4 : source:'T[,,,] -> start1:int option -> finish1:int option -> index2:int -> index3:int -> start4:int option -> finish4:int option -> 'T[,] + val inline GetArraySlice4DFixedDouble4: source: 'T[,,,] -> start1: int option -> finish1: int option -> index2: int -> index3: int -> start4: int option -> finish4: int option -> 'T[,] /// Gets a 2D slice of a 4D array /// @@ -4062,7 +5010,7 @@ namespace Microsoft.FSharp.Core /// The fixed index of the fourth dimension. /// /// The two dimensional sub array from the given indices. - val inline GetArraySlice4DFixedDouble5 : source:'T[,,,] -> start1:int option -> finish1:int option -> index2:int -> start3:int option -> finish3:int option -> index4:int -> 'T[,] + val inline GetArraySlice4DFixedDouble5: source: 'T[,,,] -> start1: int option -> finish1: int option -> index2: int -> start3: int option -> finish3: int option -> index4: int -> 'T[,] /// Gets a 2D slice of a 4D array /// @@ -4075,7 +5023,7 @@ namespace Microsoft.FSharp.Core /// The fixed index of the fourth dimension. /// /// The two dimensional sub array from the given indices. - val inline GetArraySlice4DFixedDouble6 : source:'T[,,,] -> start1:int option -> finish1:int option -> start2: int option -> finish2:int option -> index3:int -> index4:int -> 'T[,] + val inline GetArraySlice4DFixedDouble6: source: 'T[,,,] -> start1: int option -> finish1: int option -> start2: int option -> finish2: int option -> index3: int -> index4:int -> 'T[,] /// Gets a 1D slice of a 4D array /// @@ -4087,7 +5035,7 @@ namespace Microsoft.FSharp.Core /// The end index of the fourth dimension. /// /// The one dimensional sub array from the given indices. - val inline GetArraySlice4DFixedTriple4 : source:'T[,,,] -> index1:int -> index2:int -> index3:int -> start4:int option -> finish4:int option -> 'T[] + val inline GetArraySlice4DFixedTriple4: source: 'T[,,,] -> index1: int -> index2: int -> index3: int -> start4: int option -> finish4: int option -> 'T[] /// Gets a 1D slice of a 4D array /// @@ -4099,7 +5047,7 @@ namespace Microsoft.FSharp.Core /// The fixed index of the fourth dimension. /// /// The one dimensional sub array from the given indices. - val inline GetArraySlice4DFixedTriple3 : source:'T[,,,] -> index1:int -> index2:int -> start3:int option -> finish3:int option -> index4:int -> 'T[] + val inline GetArraySlice4DFixedTriple3: source: 'T[,,,] -> index1: int -> index2: int -> start3: int option -> finish3: int option -> index4: int -> 'T[] /// Gets a 1D slice of a 4D array /// @@ -4111,7 +5059,7 @@ namespace Microsoft.FSharp.Core /// The fixed index of the fourth dimension. /// /// The one dimensional sub array from the given indices. - val inline GetArraySlice4DFixedTriple2 : source:'T[,,,] -> index1:int -> start2: int option -> finish2:int option -> index3:int -> index4:int -> 'T[] + val inline GetArraySlice4DFixedTriple2: source:'T[,,,] -> index1: int -> start2: int option -> finish2: int option -> index3: int -> index4: int -> 'T[] /// Gets a 1D slice of a 4D array /// @@ -4123,7 +5071,7 @@ namespace Microsoft.FSharp.Core /// The fixed index of the fourth dimension. /// /// The one dimensional sub array from the given indices. - val inline GetArraySlice4DFixedTriple1 : source:'T[,,,] -> start1:int option -> finish1:int option -> index2:int -> index3:int -> index4:int -> 'T[] + val inline GetArraySlice4DFixedTriple1: source: 'T[,,,] -> start1: int option -> finish1: int option -> index2: int -> index3: int -> index4: int -> 'T[] /// Sets a 3D slice of a 4D array /// @@ -4136,7 +5084,7 @@ namespace Microsoft.FSharp.Core /// The start index of the fourth dimension. /// The end index of the fourth dimension. /// The source array. - val inline SetArraySlice4DFixedSingle1 : target:'T[,,,] -> index1:int -> start2: int option -> finish2:int option -> start3:int option -> finish3:int option -> start4:int option -> finish4:int option -> source: 'T[,,] -> unit + val inline SetArraySlice4DFixedSingle1: target: 'T[,,,] -> index1: int -> start2: int option -> finish2: int option -> start3: int option -> finish3: int option -> start4: int option -> finish4: int option -> source: 'T[,,] -> unit /// Sets a 3D slice of a 4D array /// @@ -4149,7 +5097,7 @@ namespace Microsoft.FSharp.Core /// The start index of the fourth dimension. /// The end index of the fourth dimension. /// The source array. - val inline SetArraySlice4DFixedSingle2 : target:'T[,,,] -> start1:int option -> finish1:int option -> index2:int -> start3:int option -> finish3:int option -> start4:int option -> finish4:int option -> source: 'T[,,] -> unit + val inline SetArraySlice4DFixedSingle2: target:'T[,,,] -> start1: int option -> finish1: int option -> index2: int -> start3: int option -> finish3: int option -> start4: int option -> finish4: int option -> source: 'T[,,] -> unit /// Sets a 3D slice of a 4D array /// @@ -4162,7 +5110,7 @@ namespace Microsoft.FSharp.Core /// The start index of the fourth dimension. /// The end index of the fourth dimension. /// The source array. - val inline SetArraySlice4DFixedSingle3 : target:'T[,,,] -> start1:int option -> finish1:int option -> start2:int option -> finish2:int option -> index3:int -> start4:int option -> finish4:int option -> source: 'T[,,] -> unit + val inline SetArraySlice4DFixedSingle3: target: 'T[,,,] -> start1: int option -> finish1: int option -> start2: int option -> finish2: int option -> index3: int -> start4: int option -> finish4: int option -> source: 'T[,,] -> unit /// Sets a 3D slice of a 4D array /// @@ -4175,7 +5123,7 @@ namespace Microsoft.FSharp.Core /// The end index of the third dimension. /// The fixed index of the fourth dimension. /// The source array. - val inline SetArraySlice4DFixedSingle4 : target:'T[,,,] -> start1:int option -> finish1:int option -> start2: int option -> finish2:int option -> start3:int option -> finish3:int option -> index4:int -> source: 'T[,,] -> unit + val inline SetArraySlice4DFixedSingle4: target:'T[,,,] -> start1: int option -> finish1: int option -> start2: int option -> finish2: int option -> start3: int option -> finish3: int option -> index4: int -> source: 'T[,,] -> unit /// Sets a 2D slice of a 4D array /// @@ -4187,7 +5135,7 @@ namespace Microsoft.FSharp.Core /// The start index of the fourth dimension. /// The end index of the fourth dimension. /// The source array. - val inline SetArraySlice4DFixedDouble1 : target:'T[,,,] -> index1: int -> index2:int -> start3:int option -> finish3:int option -> start4:int option -> finish4:int option -> source: 'T[,] -> unit + val inline SetArraySlice4DFixedDouble1: target:'T[,,,] -> index1: int -> index2: int -> start3: int option -> finish3: int option -> start4: int option -> finish4: int option -> source: 'T[,] -> unit /// Sets a 2D slice of a 4D array /// @@ -4199,7 +5147,7 @@ namespace Microsoft.FSharp.Core /// The start index of the fourth dimension. /// The end index of the fourth dimension. /// The source array. - val inline SetArraySlice4DFixedDouble2 : target:'T[,,,] -> index1: int -> start2: int option -> finish2:int option -> index3:int -> start4:int option -> finish4:int option -> source: 'T[,] -> unit + val inline SetArraySlice4DFixedDouble2: target:'T[,,,] -> index1: int -> start2: int option -> finish2:int option -> index3:int -> start4:int option -> finish4:int option -> source: 'T[,] -> unit /// Sets a 2D slice of a 4D array /// @@ -4211,7 +5159,7 @@ namespace Microsoft.FSharp.Core /// The end index of the third dimension. /// The fixed index of the fourth dimension. /// The source array. - val inline SetArraySlice4DFixedDouble3 : target:'T[,,,] -> index1:int -> start2: int option -> finish2:int option -> start3:int option -> finish3:int option -> index4:int -> source: 'T[,] -> unit + val inline SetArraySlice4DFixedDouble3: target:'T[,,,] -> index1:int -> start2: int option -> finish2:int option -> start3:int option -> finish3:int option -> index4:int -> source: 'T[,] -> unit /// Sets a 2D slice of a 4D array /// @@ -4223,7 +5171,7 @@ namespace Microsoft.FSharp.Core /// The start index of the fourth dimension. /// The end index of the fourth dimension. /// The source array. - val inline SetArraySlice4DFixedDouble4 : target:'T[,,,] -> start1:int option -> finish1:int option -> index2:int -> index3:int -> start4:int option -> finish4:int option -> source: 'T[,] -> unit + val inline SetArraySlice4DFixedDouble4: target:'T[,,,] -> start1:int option -> finish1:int option -> index2:int -> index3:int -> start4:int option -> finish4:int option -> source: 'T[,] -> unit /// Sets a 2D slice of a 4D array /// @@ -4235,7 +5183,7 @@ namespace Microsoft.FSharp.Core /// The end index of the third dimension. /// The fixed index of the fourth dimension. /// The source array. - val inline SetArraySlice4DFixedDouble5 : target:'T[,,,] -> start1:int option -> finish1:int option -> index2:int -> start3:int option -> finish3:int option -> index4:int -> source: 'T[,] -> unit + val inline SetArraySlice4DFixedDouble5: target:'T[,,,] -> start1:int option -> finish1:int option -> index2:int -> start3:int option -> finish3:int option -> index4:int -> source: 'T[,] -> unit /// Sets a 2D slice of a 4D array /// @@ -4247,7 +5195,7 @@ namespace Microsoft.FSharp.Core /// The fixed index of the third dimension. /// The fixed index of the fourth dimension. /// The source array. - val inline SetArraySlice4DFixedDouble6 : target:'T[,,,] -> start1:int option -> finish1:int option -> start2: int option -> finish2:int option -> index3:int -> index4:int -> source: 'T[,] -> unit + val inline SetArraySlice4DFixedDouble6: target:'T[,,,] -> start1:int option -> finish1:int option -> start2: int option -> finish2:int option -> index3:int -> index4:int -> source: 'T[,] -> unit /// Sets a 1D slice of a 4D array /// @@ -4258,7 +5206,7 @@ namespace Microsoft.FSharp.Core /// The start index of the fourth dimension. /// The end index of the fourth dimension. /// The source array. - val inline SetArraySlice4DFixedTriple4 : target:'T[,,,] -> index1:int -> index2:int -> index3:int -> start4:int option -> finish4:int option -> source: 'T[] -> unit + val inline SetArraySlice4DFixedTriple4: target:'T[,,,] -> index1:int -> index2:int -> index3:int -> start4:int option -> finish4:int option -> source: 'T[] -> unit /// Sets a 1D slice of a 4D array /// @@ -4269,7 +5217,7 @@ namespace Microsoft.FSharp.Core /// The end index of the third dimension. /// The fixed index of the fourth dimension. /// The source array. - val inline SetArraySlice4DFixedTriple3 : target:'T[,,,] -> index1:int -> index2:int -> start3:int option -> finish3:int option -> index4:int -> source: 'T[] -> unit + val inline SetArraySlice4DFixedTriple3: target:'T[,,,] -> index1:int -> index2:int -> start3:int option -> finish3:int option -> index4:int -> source: 'T[] -> unit /// Sets a 1D slice of a 4D array /// @@ -4280,7 +5228,7 @@ namespace Microsoft.FSharp.Core /// The fixed index of the third dimension. /// The fixed index of the fourth dimension. /// The source array. - val inline SetArraySlice4DFixedTriple2 : target:'T[,,,] -> index1:int -> start2: int option -> finish2:int option -> index3:int -> index4:int -> source: 'T[] -> unit + val inline SetArraySlice4DFixedTriple2: target:'T[,,,] -> index1:int -> start2: int option -> finish2:int option -> index3:int -> index4:int -> source: 'T[] -> unit /// Sets a 1D slice of a 4D array /// @@ -4291,7 +5239,7 @@ namespace Microsoft.FSharp.Core /// The fixed index of the third dimension. /// The fixed index of the fourth dimension. /// The source array. - val inline SetArraySlice4DFixedTriple1 : target:'T[,,,] -> start1:int option -> finish1:int option -> index2:int -> index3:int -> index4:int -> source: 'T[] -> unit + val inline SetArraySlice4DFixedTriple1: target:'T[,,,] -> start1:int option -> finish1:int option -> index2:int -> index3:int -> index4:int -> source: 'T[] -> unit /// Sets a slice of an array /// @@ -4305,7 +5253,7 @@ namespace Microsoft.FSharp.Core /// The start index of the fourth dimension. /// The end index of the fourth dimension. /// The source array. - val inline 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 + val inline 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 /// @@ -4314,207 +5262,207 @@ namespace Microsoft.FSharp.Core /// The index of the last character of the slice. /// /// The substring from the given indices. - val inline GetStringSlice : source:string -> start:int option -> finish:int option -> 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 + val RangeInt32: start: int -> step: int -> stop: int -> seq /// Generate a range of float values [] - val RangeDouble : start:float -> step:float -> stop:float -> seq + val RangeDouble: start: float -> step: float -> stop: float -> seq /// Generate a range of float32 values [] - val RangeSingle : start:float32 -> step:float32 -> stop:float32 -> seq + val RangeSingle: start: float32 -> step: float32 -> stop: float32 -> seq /// Generate a range of int64 values [] - val RangeInt64 : start:int64 -> step:int64 -> stop:int64 -> seq + val RangeInt64: start: int64 -> step: int64 -> stop: int64 -> seq /// Generate a range of uint64 values [] - val RangeUInt64 : start:uint64 -> step:uint64 -> stop:uint64 -> seq + val RangeUInt64: start: uint64 -> step: uint64 -> stop: uint64 -> seq /// Generate a range of uint32 values [] - val RangeUInt32 : start:uint32 -> step:uint32 -> stop:uint32 -> seq + val RangeUInt32: start: uint32 -> step: uint32 -> stop: uint32 -> seq /// Generate a range of nativeint values [] - val RangeIntPtr : start:nativeint -> step:nativeint -> stop:nativeint -> seq + val RangeIntPtr: start: nativeint -> step: nativeint -> stop: nativeint -> seq /// Generate a range of unativeint values [] - val RangeUIntPtr : start:unativeint -> step:unativeint -> stop:unativeint -> seq + val RangeUIntPtr: start: unativeint -> step: unativeint -> stop: unativeint -> seq /// Generate a range of int16 values [] - val RangeInt16 : start:int16 -> step:int16 -> stop:int16 -> seq + val RangeInt16: start: int16 -> step: int16 -> stop: int16 -> seq /// Generate a range of uint16 values [] - val RangeUInt16 : start:uint16 -> step:uint16 -> stop:uint16 -> seq + val RangeUInt16: start: uint16 -> step: uint16 -> stop: uint16 -> seq /// Generate a range of sbyte values [] - val RangeSByte : start:sbyte -> step:sbyte -> stop:sbyte -> seq + val RangeSByte: start: sbyte -> step: sbyte -> stop: sbyte -> seq /// Generate a range of byte values [] - val RangeByte : start:byte -> step:byte -> stop:byte -> seq + val RangeByte: start: byte -> step: byte -> stop: byte -> seq /// Generate a range of char values [] - val RangeChar : start:char -> stop:char -> seq + val RangeChar: start: char -> stop: char -> seq /// 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> + 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> + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + val RoundDynamic: x: 'T -> 'T /// This is a library intrinsic. Calls to this function may be generated by evaluating quotations. [] - val SignDynamic : 'T -> int + val SignDynamic: 'T -> int /// This is a library intrinsic. Calls to this function may be generated by evaluating quotations. [] - val LogDynamic : x:'T -> 'T + 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 + val Log10Dynamic: x: 'T -> 'T /// This is a library intrinsic. Calls to this function may be generated by evaluating quotations. [] - val SqrtDynamic : 'T1 -> 'T2 + val SqrtDynamic: 'T1 -> 'T2 /// This is a library intrinsic. Calls to this function may be generated by evaluating quotations. [] - val CosDynamic : x:'T -> 'T + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 = @@ -4524,12 +5472,18 @@ namespace Microsoft.FSharp.Core /// The boxed value. /// /// The unboxed result. + /// + /// + /// [] val inline unbox<'T> : value: 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 inline defaultof<'T> : 'T @@ -4537,20 +5491,29 @@ namespace Microsoft.FSharp.Core /// Perform generic comparison on two values where the type of the values is not /// statically required to have the 'comparison' constraint. /// The result of the comparison. + /// + /// + /// [] - val inline compare : 'T -> 'T -> int + 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. /// The result of the comparison. + /// + /// + /// [] - val inline equals : 'T -> 'T -> bool + 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. /// The computed hash value. + /// + /// + /// [] - val inline hash : 'T -> int + val inline hash: 'T -> int /// A module of comparison and equality operators that are statically resolved, but which are not fully generic and do not make structural comparison. Opening this /// module may make code that relies on structural or generic comparison no longer compile. @@ -4562,7 +5525,10 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the comparison. - val inline ( < ) : x:^T -> y:^U -> bool when (^T or ^U) : (static member ( < ) : ^T * ^U -> bool) + /// + /// + /// + val inline (<): x: ^T -> y: ^U -> bool when (^T or ^U): (static member (<): ^T * ^U -> bool) /// Compares the two values for greater-than /// @@ -4570,7 +5536,10 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the comparison. - val inline ( > ) : x:^T -> y:^U -> bool when (^T or ^U) : (static member ( > ) : ^T * ^U -> bool) + /// + /// + /// + val inline (>): x: ^T -> y: ^U -> bool when (^T or ^U): (static member (>): ^T * ^U -> bool) /// Compares the two values for greater-than-or-equal /// @@ -4578,7 +5547,10 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the comparison. - val inline ( >= ) : x:^T -> y:^U -> bool when (^T or ^U) : (static member ( >= ) : ^T * ^U -> bool) + /// + /// + /// + val inline (>=): x: ^T -> y: ^U -> bool when (^T or ^U): (static member (>=): ^T * ^U -> bool) /// Compares the two values for less-than-or-equal /// @@ -4586,7 +5558,10 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the comparison. - val inline ( <= ) : x:^T -> y:^U -> bool when (^T or ^U) : (static member ( <= ) : ^T * ^U -> bool) + /// + /// + /// + val inline (<=): x: ^T -> y: ^U -> bool when (^T or ^U): (static member (<=): ^T * ^U -> bool) /// Compares the two values for equality /// @@ -4594,7 +5569,10 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the comparison. - val inline ( = ) : x:^T -> y:^T -> bool when ^T : (static member ( = ) : ^T * ^T -> bool) + /// + /// + /// + val inline (=): x: ^T -> y: ^T -> bool when ^T: (static member (=): ^T * ^T -> bool) /// Compares the two values for inequality /// @@ -4602,7 +5580,10 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the comparison. - val inline ( <> ) : x:^T -> y:^T -> bool when ^T : (static member ( <> ) : ^T * ^T -> bool) + /// + /// + /// + val inline (<>): x: ^T -> y: ^T -> bool when ^T: (static member (<>): ^T * ^T -> bool) /// Compares the two values /// @@ -4610,8 +5591,11 @@ namespace Microsoft.FSharp.Core /// The second value. /// /// The result of the comparison. + /// + /// + /// [] - val inline compare: e1:'T -> e2:^T -> int when ^T : (static member ( < ) : ^T * ^T -> bool) and ^T : (static member ( > ) : ^T * ^T -> bool) + val inline compare: e1: ^T -> e2: ^T -> int when ^T: (static member (<): ^T * ^T -> bool) and ^T: (static member (>): ^T * ^T -> bool) /// Maximum of the two values /// @@ -4619,8 +5603,11 @@ namespace Microsoft.FSharp.Core /// The second value. /// /// The maximum value. + /// + /// + /// [] - val inline max : e1:^T -> e2:^T -> ^T when ^T : (static member ( < ) : ^T * ^T -> bool) + val inline max: e1: ^T -> e2: ^T -> ^T when ^T: (static member (<): ^T * ^T -> bool) /// Minimum of the two values /// @@ -4628,16 +5615,22 @@ namespace Microsoft.FSharp.Core /// The second value. /// /// The minimum value. + /// + /// + /// [] - val inline min : e1:^T -> e2:^T -> ^T when ^T : (static member ( < ) : ^T * ^T -> bool) + val inline min: e1: ^T -> e2: ^T -> ^T when ^T: (static member (<): ^T * ^T -> bool) /// Calls GetHashCode() on the value /// /// The value. /// /// The hash code. + /// + /// + /// [] - val inline hash :value:'T -> int when 'T : equality + val inline hash: value: 'T -> int when 'T: equality /// This module contains the basic arithmetic operations with overflow checks. module Checked = @@ -4646,7 +5639,10 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The negated value. - val inline ( ~- ) : value:^T -> ^T when ^T : (static member ( ~- ) : ^T -> ^T) and default ^T : int + /// + /// + /// + val inline (~-): value: ^T -> ^T when ^T: (static member (~-): ^T -> ^T) and default ^T: int /// Overloaded subtraction operator (checks for overflow) /// @@ -4654,7 +5650,10 @@ namespace Microsoft.FSharp.Core /// The second value. /// /// The first value minus the second value. - val inline ( - ) : x:^T1 -> y:^T2 -> ^T3 when (^T1 or ^T2) : (static member ( - ) : ^T1 * ^T2 -> ^T3) and default ^T2 : ^T3 and default ^T3 : ^T1 and default ^T3 : ^T2 and default ^T1 : ^T3 and default ^T1 : ^T2 and default ^T1 : int + /// + /// + /// + val inline (-): x: ^T1 -> y: ^T2 -> ^T3 when (^T1 or ^T2): (static member (-): ^T1 * ^T2 -> ^T3) and default ^T2: ^T3 and default ^T3: ^T1 and default ^T3: ^T2 and default ^T1: ^T3 and default ^T1: ^T2 and default ^T1: int /// Overloaded addition operator (checks for overflow) /// @@ -4662,7 +5661,10 @@ namespace Microsoft.FSharp.Core /// The second value. /// /// The sum of the two input values. - val inline ( + ) : x:^T1 -> y:^T2 -> ^T3 when (^T1 or ^T2) : (static member ( + ) : ^T1 * ^T2 -> ^T3) and default ^T2 : ^T3 and default ^T3 : ^T1 and default ^T3 : ^T2 and default ^T1 : ^T3 and default ^T1 : ^T2 and default ^T1 : int + /// + /// + /// + val inline (+): x: ^T1 -> y: ^T2 -> ^T3 when (^T1 or ^T2): (static member (+): ^T1 * ^T2 -> ^T3) and default ^T2: ^T3 and default ^T3: ^T1 and default ^T3: ^T2 and default ^T1: ^T3 and default ^T1: ^T2 and default ^T1: int /// Overloaded multiplication operator (checks for overflow) /// @@ -4670,7 +5672,10 @@ namespace Microsoft.FSharp.Core /// The second value. /// /// The product of the two input values. - val inline ( * ) : x:^T1 -> y:^T2 -> ^T3 when (^T1 or ^T2) : (static member ( * ) : ^T1 * ^T2 -> ^T3) and default ^T2 : ^T3 and default ^T3 : ^T1 and default ^T3 : ^T2 and default ^T1 : ^T3 and default ^T1 : ^T2 and default ^T1 : int + /// + /// + /// + val inline (*): x: ^T1 -> y: ^T2 -> ^T3 when (^T1 or ^T2): (static member (*): ^T1 * ^T2 -> ^T3) and default ^T2: ^T3 and default ^T3: ^T1 and default ^T3: ^T2 and default ^T1: ^T3 and default ^T1: ^T2 and default ^T1: int /// Converts the argument to byte. This is a direct, checked conversion for all /// primitive numeric types. For strings, the input is converted using @@ -4680,8 +5685,11 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted byte + /// + /// + /// [] - val inline byte : value:^T -> byte when ^T : (static member op_Explicit : ^T -> byte) and default ^T : int + val inline byte: value: ^T -> byte when ^T: (static member op_Explicit: ^T -> byte) and default ^T: int /// Converts the argument to sbyte. This is a direct, checked conversion for all /// primitive numeric types. For strings, the input is converted using @@ -4691,8 +5699,11 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted sbyte + /// + /// + /// [] - val inline sbyte : value:^T -> sbyte when ^T : (static member op_Explicit : ^T -> sbyte) and default ^T : int + val inline sbyte: value: ^T -> sbyte when ^T: (static member op_Explicit: ^T -> sbyte) and default ^T: int /// Converts the argument to int16. This is a direct, checked conversion for all /// primitive numeric types. For strings, the input is converted using @@ -4702,8 +5713,11 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted int16 + /// + /// + /// [] - val inline int16 : value:^T -> int16 when ^T : (static member op_Explicit : ^T -> int16) and default ^T : int + val inline int16: value: ^T -> int16 when ^T: (static member op_Explicit: ^T -> int16) and default ^T: int /// Converts the argument to uint16. This is a direct, checked conversion for all /// primitive numeric types. For strings, the input is converted using @@ -4713,8 +5727,11 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted uint16 + /// + /// + /// [] - val inline uint16 : value:^T -> uint16 when ^T : (static member op_Explicit : ^T -> uint16) and default ^T : int + val inline uint16: value: ^T -> uint16 when ^T: (static member op_Explicit: ^T -> uint16) and default ^T: int /// Converts the argument to int. This is a direct, checked conversion for all /// primitive numeric types. For strings, the input is converted using @@ -4724,8 +5741,11 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted int + /// + /// + /// [] - val inline int : value:^T -> int when ^T : (static member op_Explicit : ^T -> int) and default ^T : int + val inline int: value: ^T -> int when ^T: (static member op_Explicit: ^T -> int) and default ^T: int /// Converts the argument to int32. This is a direct, checked conversion for all /// primitive numeric types. For strings, the input is converted using @@ -4735,8 +5755,11 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted int32 + /// + /// + /// [] - val inline int32 : value:^T -> int32 when ^T : (static member op_Explicit : ^T -> int32) and default ^T : int + val inline int32: value: ^T -> int32 when ^T: (static member op_Explicit: ^T -> int32) and default ^T: int /// Converts the argument to uint32. This is a direct, checked conversion for all /// primitive numeric types. For strings, the input is converted using @@ -4746,8 +5769,11 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted uint32 + /// + /// + /// [] - val inline uint32 : value:^T -> uint32 when ^T : (static member op_Explicit : ^T -> uint32) and default ^T : int + val inline uint32: value: ^T -> uint32 when ^T: (static member op_Explicit: ^T -> uint32) and default ^T: int /// Converts the argument to int64. This is a direct, checked conversion for all /// primitive numeric types. For strings, the input is converted using @@ -4757,8 +5783,11 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted int64 + /// + /// + /// [] - val inline int64 : value:^T -> int64 when ^T : (static member op_Explicit : ^T -> int64) and default ^T : int + val inline int64: value: ^T -> int64 when ^T: (static member op_Explicit: ^T -> int64) and default ^T: int /// Converts the argument to uint64. This is a direct, checked conversion for all /// primitive numeric types. For strings, the input is converted using @@ -4768,8 +5797,11 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted uint64 + /// + /// + /// [] - val inline uint64 : value:^T -> uint64 when ^T : (static member op_Explicit : ^T -> uint64) and default ^T : int + val inline uint64: value: ^T -> uint64 when ^T: (static member op_Explicit: ^T -> uint64) and default ^T: int /// Converts the argument to . This is a direct, checked conversion for all /// primitive numeric types. Otherwise the operation requires an appropriate @@ -4778,8 +5810,11 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted nativeint + /// + /// + /// [] - val inline nativeint : value:^T -> nativeint when ^T : (static member op_Explicit : ^T -> nativeint) and default ^T : int + val inline nativeint: value: ^T -> nativeint when ^T: (static member op_Explicit: ^T -> nativeint) and default ^T: int /// Converts the argument to unativeint. This is a direct, checked conversion for all /// primitive numeric types. Otherwise the operation requires an appropriate @@ -4788,8 +5823,11 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted unativeint + /// + /// + /// [] - val inline unativeint : value:^T -> unativeint when ^T : (static member op_Explicit : ^T -> unativeint) and default ^T : int + val inline unativeint: value: ^T -> unativeint when ^T: (static member op_Explicit: ^T -> unativeint) and default ^T: int /// Converts the argument to char. Numeric inputs are converted using a checked /// conversion according to the UTF-16 encoding for characters. String inputs must @@ -4799,9 +5837,11 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted char + /// + /// + /// [] - val inline char : value:^T -> char when ^T : (static member op_Explicit : ^T -> char) and default ^T : int - + val inline char: value: ^T -> char when ^T: (static member op_Explicit: ^T -> char) and default ^T: int namespace Microsoft.FSharp.Control @@ -4821,7 +5861,7 @@ namespace Microsoft.FSharp.Control /// /// The created Lazy object. [] // give the extension member a 'nice', unmangled compiled name, unique within this module - static member Create : creator:(unit -> 'T) -> System.Lazy<'T> + static member Create: creator: (unit -> 'T) -> System.Lazy<'T> /// Creates a lazy computation that evaluates to the given value when forced. /// @@ -4829,13 +5869,13 @@ namespace Microsoft.FSharp.Control /// /// The created Lazy object. [] // give the extension member a 'nice', unmangled compiled name, unique within this module - static member CreateFromValue : value:'T -> System.Lazy<'T> + static member CreateFromValue: value: 'T -> System.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. /// The value of the Lazy object. [] // give the extension member a 'nice', unmangled compiled name, unique within this module - member Force : unit -> 'T + member Force: unit -> 'T /// The type of delayed computations. /// @@ -4868,18 +5908,22 @@ namespace Microsoft.FSharp.Control /// be invoked when the event is fired. /// /// A delegate to be invoked when the event is fired. - abstract AddHandler: handler:'Delegate -> unit + /// + /// + abstract AddHandler: handler: 'Delegate -> unit /// Remove a listener delegate from an event listener store. /// /// The delegate to be removed from the event listener store. - abstract RemoveHandler: handler:'Delegate -> unit + /// + /// + abstract RemoveHandler: handler: 'Delegate -> unit /// First class event values for CLI events conforming to CLI Framework standards. /// /// Events and Observables [] - type IEvent<'Delegate,'Args when 'Delegate : delegate<'Args,unit> and 'Delegate :> System.Delegate > = + type IEvent<'Delegate,'Args when 'Delegate: delegate<'Args,unit> and 'Delegate :> System.Delegate > = inherit IDelegateEvent<'Delegate> inherit IObservable<'Args>