From c9d8b7280fb7343417d4e6baecc095f719b342cd Mon Sep 17 00:00:00 2001 From: Steve Goguen Date: Tue, 21 Sep 2021 23:05:02 -0400 Subject: [PATCH 1/7] WIP - FSharp.Core.Operators - Added examples for: * Arithmetic * Bitwise Operators * Comparison Operators * Composition and Pipeline Operators * defaultArgs * raise, reraise, Failure * Tuple fst, snd --- src/fsharp/FSharp.Core/prim-types.fsi | 613 +++++++++++++++++++++++++- 1 file changed, 612 insertions(+), 1 deletion(-) diff --git a/src/fsharp/FSharp.Core/prim-types.fsi b/src/fsharp/FSharp.Core/prim-types.fsi index 24f68574e0a..4d465ad5914 100644 --- a/src/fsharp/FSharp.Core/prim-types.fsi +++ b/src/fsharp/FSharp.Core/prim-types.fsi @@ -2632,6 +2632,9 @@ 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 /// Overloaded addition operator @@ -2640,6 +2643,13 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the operation. + /// + /// + /// + /// 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,6 +2658,12 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the operation. + /// + /// + /// + /// 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,6 +2672,12 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the operation. + /// + /// + /// + /// 8 * 6 // Evaluates to 64 + /// + /// 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,6 +2686,12 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the operation. + /// + /// + /// + /// 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,6 +2700,12 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the operation. + /// + /// + /// + /// 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,6 +2714,15 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the operation. + /// + /// + /// + /// 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,6 +2731,15 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the operation. + /// + /// + /// + /// 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,6 +2748,15 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the operation. + /// + /// + /// + /// 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,6 +2765,14 @@ namespace Microsoft.FSharp.Core /// The amount to shift. /// /// The result of the operation. + /// + /// + /// + /// 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,6 +2781,16 @@ namespace Microsoft.FSharp.Core /// The amount to shift. /// /// The result of the operation. + /// + /// + /// + /// 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 @@ -2719,6 +2798,15 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The result of the operation. + /// + /// + /// + /// 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 @@ -2726,6 +2814,9 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The result of the operation. + /// + /// + /// val inline (~+) : value:^T -> ^T when ^T : (static member (~+) : ^T -> ^T) and default ^T : int /// Structural less-than comparison @@ -2734,6 +2825,15 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the 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,6 +2842,15 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the 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,6 +2859,15 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the 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,6 +2876,15 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the 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,6 +2893,15 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the comparison. + /// + /// + /// + /// 5 = 5 // Evaluates to true + /// 5 = 6 // Evaluates to false + /// [1; 2] = [1; 2] // Evaluates to true + /// + /// + /// val inline ( = ) : x:'T -> y:'T -> bool when 'T : equality /// Structural inequality @@ -2774,6 +2910,15 @@ namespace Microsoft.FSharp.Core /// The second parameter. /// /// The result of the comparison. + /// + /// + /// + /// 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,6 +2927,16 @@ namespace Microsoft.FSharp.Core /// The second function to apply. /// /// The composition of the input functions. + /// + /// + /// + /// 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,6 +2945,16 @@ namespace Microsoft.FSharp.Core /// The first function to apply. /// /// The composition of the input functions. + /// + /// + /// + /// 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,6 +2963,16 @@ namespace Microsoft.FSharp.Core /// The function. /// /// The function result. + /// + /// + /// + /// let addOne x = x + 1 + /// let doubleIt x = x * 2 + /// let doubleThenAdd = addOne << doubleIt + /// doubleThenAdd 3 + /// + /// + /// 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,6 +2982,14 @@ namespace Microsoft.FSharp.Core /// The function. /// /// The function result. + /// + /// + /// + /// 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,6 +3000,14 @@ namespace Microsoft.FSharp.Core /// The function. /// /// The function result. + /// + /// + /// + /// 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,6 +3016,9 @@ namespace Microsoft.FSharp.Core /// The argument. /// /// The function result. + /// + /// + /// 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,6 +3028,9 @@ namespace Microsoft.FSharp.Core /// The second argument. /// /// The function result. + /// + /// + /// 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,6 +3041,9 @@ namespace Microsoft.FSharp.Core /// The third argument. /// /// The function result. + /// + /// + /// 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,6 +3052,22 @@ 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 @@ -2861,6 +3077,15 @@ 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 @@ -2873,6 +3098,21 @@ namespace Microsoft.FSharp.Core /// The exception to raise. /// /// The result value. + /// + /// + /// + /// open System.IO + /// exception AintGotNoFileException of string + /// + /// let readFile (filename: string) = + /// if not (File.Exists(filename)) then + /// raise(AintGotNoFileException(filename)) + /// File.ReadAllText(filename) + /// + /// readFile "/this-file-doest-exist" // Throws an AintGotNoFileException + /// + /// + /// [] val inline raise : exn:System.Exception -> 'T @@ -2884,6 +3124,22 @@ namespace Microsoft.FSharp.Core /// 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 @@ -2892,6 +3148,17 @@ namespace Microsoft.FSharp.Core /// The message for the Exception. /// /// A System.Exception. + /// + /// + /// + /// 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 @@ -2899,6 +3166,9 @@ namespace Microsoft.FSharp.Core /// The input exception. /// /// A string option. + /// + /// + /// [] val (|Failure|_|) : error:exn -> string option @@ -2907,6 +3177,13 @@ namespace Microsoft.FSharp.Core /// The input tuple. /// /// The first value. + /// + /// + /// + /// fst ("first", 2) // Evaluates to "first" + /// + /// + /// [] val inline fst : tuple:('T1 * 'T2) -> 'T1 @@ -2915,6 +3192,13 @@ namespace Microsoft.FSharp.Core /// The input tuple. /// /// The second value. + /// + /// + /// + /// fst ("first", 2) // Evaluates to 2 + /// + /// + /// [] val inline snd : tuple:('T1 * 'T2) -> 'T2 @@ -2924,6 +3208,9 @@ namespace Microsoft.FSharp.Core /// The second value. /// /// The result of the comparison. + /// + /// + /// [] val inline compare: e1:'T -> e2:'T -> int when 'T : comparison @@ -2933,6 +3220,18 @@ namespace Microsoft.FSharp.Core /// The second value. /// /// The maximum value. + /// + /// + /// + /// 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 max : e1:'T -> e2:'T -> 'T when 'T : comparison @@ -2942,12 +3241,18 @@ namespace Microsoft.FSharp.Core /// The second value. /// /// The minimum value. + /// + /// + /// [] 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. + /// + /// + /// [] val inline ignore : value:'T -> unit @@ -2956,6 +3261,9 @@ namespace Microsoft.FSharp.Core /// The boxed value. /// /// The unboxed result. + /// + /// + /// [] val inline unbox : value:obj -> 'T @@ -2964,6 +3272,9 @@ namespace Microsoft.FSharp.Core /// The value to box. /// /// The boxed object. + /// + /// + /// [] val inline box : value:'T -> obj @@ -2972,6 +3283,9 @@ namespace Microsoft.FSharp.Core /// The boxed value. /// /// The unboxed result as an option. + /// + /// + /// [] val inline tryUnbox : value:obj -> 'T option @@ -2980,6 +3294,9 @@ namespace Microsoft.FSharp.Core /// The value to check. /// /// True when value is null, false otherwise. + /// + /// + /// [] val inline isNull : value:'T -> bool when 'T : null @@ -2988,6 +3305,9 @@ namespace Microsoft.FSharp.Core /// The value to check. /// /// True when value is not null, false otherwise. + /// + /// + /// [] val inline internal isNotNull : value:'T -> bool when 'T : null @@ -2996,6 +3316,9 @@ namespace Microsoft.FSharp.Core /// The exception message. /// /// The result value. + /// + /// + /// [] val inline failwith : message:string -> 'T @@ -3006,6 +3329,9 @@ namespace Microsoft.FSharp.Core /// The exception message. /// /// The result value. + /// + /// + /// [] val inline invalidArg : argumentName:string -> message:string -> 'T @@ -3014,6 +3340,9 @@ namespace Microsoft.FSharp.Core /// The argument name. /// /// The result value. + /// + /// + /// [] val inline nullArg : argumentName:string -> 'T @@ -3022,6 +3351,9 @@ namespace Microsoft.FSharp.Core /// The exception message. /// /// The result value. + /// + /// + /// [] val inline invalidOp : message:string -> 'T @@ -3030,6 +3362,9 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The same value. + /// + /// + /// [] val id : x:'T -> 'T @@ -3038,6 +3373,9 @@ namespace Microsoft.FSharp.Core /// The value to contain in the cell. /// /// The created reference cell. + /// + /// + /// [] val ref : value:'T -> 'T ref @@ -3045,6 +3383,9 @@ namespace Microsoft.FSharp.Core /// /// The cell to mutate. /// The value to set inside the cell. + /// + /// + /// val ( := ) : cell:'T ref -> value:'T -> unit /// Dereference a mutable reference cell @@ -3052,17 +3393,26 @@ namespace Microsoft.FSharp.Core /// The cell to dereference. /// /// The value contained in the cell. + /// + /// + /// val ( ! ) : cell:'T ref -> 'T /// Decrement a mutable reference cell containing an integer /// /// The reference cell. + /// + /// + /// [] val decr: cell:int ref -> unit /// Increment a mutable reference cell containing an integer /// /// The reference cell. + /// + /// + /// [] val incr: cell:int ref -> unit @@ -3072,6 +3422,9 @@ namespace Microsoft.FSharp.Core /// The second list. /// /// The concatenation of the lists. + /// + /// + /// val (@): list1:'T list -> list2:'T list -> 'T list /// Negate a logical value. Not True equals False and not False equals True @@ -3079,6 +3432,9 @@ namespace Microsoft.FSharp.Core /// The value to negate. /// /// The result of the negation. + /// + /// + /// [] val inline not : value:bool -> bool @@ -3087,6 +3443,9 @@ namespace Microsoft.FSharp.Core /// The input sequence. /// /// The result sequence. + /// + /// + /// [] val seq : sequence:seq<'T> -> seq<'T> @@ -3096,6 +3455,9 @@ namespace Microsoft.FSharp.Core /// The exit code to use. /// /// The result value. + /// + /// + /// [] val exit: exitcode:int -> 'T when default 'T : obj @@ -3133,6 +3495,9 @@ 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) @@ -3147,6 +3512,9 @@ 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) @@ -3161,6 +3529,9 @@ namespace Microsoft.FSharp.Core /// The action to perform during the lock. /// /// The resulting value. + /// + /// + /// [] val inline lock: lockObject:'Lock -> action:(unit -> 'T) -> 'T when 'Lock : not struct @@ -3172,21 +3543,33 @@ namespace Microsoft.FSharp.Core /// The action that accepts the resource. /// /// The resulting value. + /// + /// + /// [] val using: resource:('T :> System.IDisposable) -> action:('T -> 'U) -> 'U /// Generate a System.Type runtime representation of a static type. + /// + /// + /// [] [] val inline typeof<'T> : System.Type - /// Returns the name of the given symbol. + /// Returns the name of the given symbol. + /// + /// + /// [] 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 @@ -3197,11 +3580,17 @@ namespace Microsoft.FSharp.Core /// Generate a System.Type representation for a type definition. If the /// input type is a generic type instantiation then return the /// generic type definition associated with all such instantiations. + /// + /// + /// [] [] val inline typedefof<'T> : System.Type /// Returns the internal size of a type in bytes. For example, sizeof<int> returns 4. + /// + /// + /// [] [] val inline sizeof<'T> : int @@ -3215,6 +3604,9 @@ namespace Microsoft.FSharp.Core /// The input object. /// /// The computed hash. + /// + /// + /// [] val inline hash: obj:'T -> int when 'T : equality @@ -3228,6 +3620,9 @@ namespace Microsoft.FSharp.Core /// The input object. /// /// The computed hash. + /// + /// + /// val inline limitedHash: limit: int -> obj:'T -> int when 'T : equality @@ -3236,6 +3631,9 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The absolute value of the input. + /// + /// + /// [] val inline abs : value:^T -> ^T when ^T : (static member Abs : ^T -> ^T) and default ^T : int @@ -3244,6 +3642,9 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The inverse cosine of the input. + /// + /// + /// [] val inline acos : value:^T -> ^T when ^T : (static member Acos : ^T -> ^T) and default ^T : float @@ -3252,6 +3653,9 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The inverse sine of the input. + /// + /// + /// [] val inline asin : value:^T -> ^T when ^T : (static member Asin : ^T -> ^T) and default ^T : float @@ -3260,6 +3664,9 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The inverse tangent of the input. + /// + /// + /// [] val inline atan : value:^T -> ^T when ^T : (static member Atan : ^T -> ^T) and default ^T : float @@ -3269,6 +3676,9 @@ namespace Microsoft.FSharp.Core /// The x input value. /// /// The inverse tangent of the input ratio. + /// + /// + /// [] val inline atan2 : y:^T1 -> x:^T1 -> 'T2 when ^T1 : (static member Atan2 : ^T1 * ^T1 -> 'T2) and default ^T1 : float @@ -3277,6 +3687,9 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The ceiling of the input. + /// + /// + /// [] val inline ceil : value:^T -> ^T when ^T : (static member Ceiling : ^T -> ^T) and default ^T : float @@ -3285,6 +3698,9 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The exponential of the input. + /// + /// + /// [] val inline exp : value:^T -> ^T when ^T : (static member Exp : ^T -> ^T) and default ^T : float @@ -3293,6 +3709,9 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The floor of the input. + /// + /// + /// [] val inline floor : value:^T -> ^T when ^T : (static member Floor : ^T -> ^T) and default ^T : float @@ -3301,6 +3720,9 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// -1, 0, or 1 depending on the sign of the input. + /// + /// + /// [] val inline sign : value:^T -> int when ^T : (member Sign : int) and default ^T : float @@ -3309,6 +3731,9 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The nearest integer to the input value. + /// + /// + /// [] val inline round : value:^T -> ^T when ^T : (static member Round : ^T -> ^T) and default ^T : float @@ -3317,6 +3742,9 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The natural logarithm of the input. + /// + /// + /// [] val inline log : value:^T -> ^T when ^T : (static member Log : ^T -> ^T) and default ^T : float @@ -3325,6 +3753,9 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The logarithm to base 10 of the input. + /// + /// + /// [] val inline log10 : value:^T -> ^T when ^T : (static member Log10 : ^T -> ^T) and default ^T : float @@ -3333,6 +3764,9 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The square root of the input. + /// + /// + /// [] 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 @@ -3341,6 +3775,9 @@ namespace Microsoft.FSharp.Core /// 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 @@ -3349,6 +3786,9 @@ namespace Microsoft.FSharp.Core /// 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 @@ -3357,6 +3797,9 @@ namespace Microsoft.FSharp.Core /// 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 @@ -3365,6 +3808,9 @@ namespace Microsoft.FSharp.Core /// 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 @@ -3373,6 +3819,9 @@ namespace Microsoft.FSharp.Core /// 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 @@ -3381,6 +3830,9 @@ namespace Microsoft.FSharp.Core /// 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 @@ -3389,6 +3841,9 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The truncated value. + /// + /// + /// [] val inline truncate : value:^T -> ^T when ^T : (static member Truncate : ^T -> ^T) and default ^T : float @@ -3398,6 +3853,9 @@ 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 /// Overloaded power operator. If n > 0 then equivalent to x*...*x for n occurrences of x. @@ -3406,6 +3864,9 @@ 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) @@ -3420,6 +3881,9 @@ 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 @@ -3431,6 +3895,9 @@ 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 @@ -3442,6 +3909,9 @@ 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 @@ -3453,6 +3923,9 @@ 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 @@ -3464,6 +3937,9 @@ 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 @@ -3475,6 +3951,9 @@ 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 @@ -3483,6 +3962,9 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted enum type. + /// + /// + /// [] val inline enum : value:int32 -> ^U when ^U : enum @@ -3494,6 +3976,9 @@ 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 @@ -3505,6 +3990,9 @@ 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 @@ -3516,6 +4004,9 @@ 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 @@ -3527,6 +4018,9 @@ 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 @@ -3538,6 +4032,9 @@ 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 @@ -3549,6 +4046,9 @@ 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 @@ -3559,6 +4059,9 @@ 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 @@ -3569,6 +4072,9 @@ 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 @@ -3579,6 +4085,9 @@ namespace Microsoft.FSharp.Core /// The input value. /// /// The converted string. + /// + /// + /// [] val inline string : value:'T -> string @@ -3590,6 +4099,9 @@ 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 @@ -3600,6 +4112,9 @@ 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 @@ -3608,6 +4123,9 @@ namespace Microsoft.FSharp.Core /// The input key/value pair. /// /// A tuple containing the key and value. + /// + /// + /// [] val ( |KeyValue| ): keyValuePair:KeyValuePair<'Key,'Value> -> 'Key * 'Value @@ -4524,12 +5042,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,18 +5061,27 @@ 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 /// 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 /// 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 @@ -4562,6 +5095,9 @@ 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) /// Compares the two values for greater-than @@ -4570,6 +5106,9 @@ 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) /// Compares the two values for greater-than-or-equal @@ -4578,6 +5117,9 @@ 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) /// Compares the two values for less-than-or-equal @@ -4586,6 +5128,9 @@ 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) /// Compares the two values for equality @@ -4594,6 +5139,9 @@ 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) /// Compares the two values for inequality @@ -4602,6 +5150,9 @@ 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) /// Compares the two values @@ -4610,6 +5161,9 @@ 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) @@ -4619,6 +5173,9 @@ 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) @@ -4628,6 +5185,9 @@ 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) @@ -4636,6 +5196,9 @@ namespace Microsoft.FSharp.Core /// The value. /// /// The hash code. + /// + /// + /// [] val inline hash :value:'T -> int when 'T : equality @@ -4646,6 +5209,9 @@ 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 /// Overloaded subtraction operator (checks for overflow) @@ -4654,6 +5220,9 @@ 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 /// Overloaded addition operator (checks for overflow) @@ -4662,6 +5231,9 @@ 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 /// Overloaded multiplication operator (checks for overflow) @@ -4670,6 +5242,9 @@ 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 /// Converts the argument to byte. This is a direct, checked conversion for all @@ -4680,6 +5255,9 @@ 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 @@ -4691,6 +5269,9 @@ 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 @@ -4702,6 +5283,9 @@ 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 @@ -4713,6 +5297,9 @@ 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 @@ -4724,6 +5311,9 @@ 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 @@ -4735,6 +5325,9 @@ 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 @@ -4746,6 +5339,9 @@ 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 @@ -4757,6 +5353,9 @@ 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 @@ -4768,6 +5367,9 @@ 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 @@ -4778,6 +5380,9 @@ 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 @@ -4788,6 +5393,9 @@ 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 @@ -4799,6 +5407,9 @@ 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 From 9f5bd968fda6e7e065ca0f0e80f908dbe4b09df8 Mon Sep 17 00:00:00 2001 From: Steve Goguen Date: Sun, 26 Sep 2021 19:46:13 -0400 Subject: [PATCH 2/7] FSharp.Core.Operators - Work in Progress --- src/fsharp/FSharp.Core/prim-types.fsi | 541 ++++++++++++++++++++------ 1 file changed, 428 insertions(+), 113 deletions(-) diff --git a/src/fsharp/FSharp.Core/prim-types.fsi b/src/fsharp/FSharp.Core/prim-types.fsi index 4d465ad5914..0124d0116fb 100644 --- a/src/fsharp/FSharp.Core/prim-types.fsi +++ b/src/fsharp/FSharp.Core/prim-types.fsi @@ -2650,6 +2650,7 @@ namespace Microsoft.FSharp.Core /// "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 @@ -2966,10 +2967,8 @@ namespace Microsoft.FSharp.Core /// /// /// - /// let addOne x = x + 1 /// let doubleIt x = x * 2 - /// let doubleThenAdd = addOne << doubleIt - /// doubleThenAdd 3 + /// 3 |> doubleIt // Evaluates to 6 /// /// /// @@ -2983,7 +2982,7 @@ namespace Microsoft.FSharp.Core /// /// The function result. /// - /// + /// /// /// let sum x y = x + y /// (3, 4) ||> sum // Evaluates to 7 @@ -3001,7 +3000,7 @@ namespace Microsoft.FSharp.Core /// /// The function result. /// - /// + /// /// /// let sum3 x y z = x + y + z /// (3, 4, 5) |||> sum3 // Evaluates to 12 @@ -3017,7 +3016,12 @@ namespace Microsoft.FSharp.Core /// /// The function result. /// - /// + /// + /// + /// let doubleIt x = x * 2 + /// doubleIt <| 3 // Evaluates to 6 + /// + /// /// val inline (<|): func:('T -> 'U) -> arg1:'T -> 'U @@ -3029,7 +3033,12 @@ namespace Microsoft.FSharp.Core /// /// The function result. /// - /// + /// + /// + /// let sum x y = x + y + /// sum <|| (3, 4) // Evaluates to 7 + /// + /// /// val inline (<||): func:('T1 -> 'T2 -> 'U) -> arg1:'T1 * arg2:'T2 -> 'U @@ -3042,7 +3051,12 @@ namespace Microsoft.FSharp.Core /// /// The function result. /// - /// + /// + /// + /// 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 @@ -3195,7 +3209,7 @@ namespace Microsoft.FSharp.Core /// /// /// - /// fst ("first", 2) // Evaluates to 2 + /// snd ("first", 2) // Evaluates to 2 /// /// /// @@ -3209,7 +3223,16 @@ namespace Microsoft.FSharp.Core /// /// 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 @@ -3221,14 +3244,11 @@ namespace Microsoft.FSharp.Core /// /// The maximum value. /// - /// + /// /// - /// 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 + // max 1 2 // Evaluates to 2 + // max [1;2;3] [1;2;4] // Evaluates to [1;2;4] + // max "zoo" "alpha" // Evaluates to "zoo" /// /// /// @@ -3242,7 +3262,13 @@ namespace Microsoft.FSharp.Core /// /// 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 @@ -3251,7 +3277,11 @@ namespace Microsoft.FSharp.Core /// /// The value to ignore. /// - /// + /// + /// + // ignore 55555 // Evaluates to () + /// + /// /// [] val inline ignore : value:'T -> unit @@ -3262,7 +3292,14 @@ namespace Microsoft.FSharp.Core /// /// The unboxed result. /// - /// + /// + /// + /// let x: int = 123 + /// let obj1 = box x // obj1 is a generic object type + /// unbox obj1 // Evaluates to 123 (int) + /// unbox obj1 // Throws System.InvalidCastException + /// + /// /// [] val inline unbox : value:obj -> 'T @@ -3273,7 +3310,14 @@ namespace Microsoft.FSharp.Core /// /// The boxed object. /// - /// + /// + /// + /// let x: int = 123 + /// let obj1 = box x // obj1 is a generic object type + /// unbox obj1 // Evaluates to 123 (int) + /// unbox obj1 // Throws System.InvalidCastException + /// + /// /// [] val inline box : value:'T -> obj @@ -3283,8 +3327,15 @@ namespace Microsoft.FSharp.Core /// The boxed value. /// /// The unboxed result as an option. - /// - /// + /// + /// + /// + /// let x: int = 123 + /// let obj1 = box x // obj1 is a generic object type + /// tryUnbox obj1 // Evaluates to Some(123) + /// tryUnbox obj1 // Evaluates to None + /// + /// /// [] val inline tryUnbox : value:obj -> 'T option @@ -3295,7 +3346,12 @@ namespace Microsoft.FSharp.Core /// /// 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 @@ -3305,8 +3361,13 @@ namespace Microsoft.FSharp.Core /// The value to check. /// /// True when value is not null, false otherwise. - /// - /// + /// + /// + /// + /// IsNotNull null // Evaluates to false + /// IsNotNull "Not null" // Evaluates to true + /// + /// /// [] val inline internal isNotNull : value:'T -> bool when 'T : null @@ -3316,8 +3377,16 @@ namespace Microsoft.FSharp.Core /// 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 @@ -3329,8 +3398,19 @@ 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 @@ -3341,7 +3421,16 @@ namespace Microsoft.FSharp.Core /// /// 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 @@ -3352,7 +3441,20 @@ namespace Microsoft.FSharp.Core /// /// 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 @@ -3363,7 +3465,12 @@ namespace Microsoft.FSharp.Core /// /// The same value. /// - /// + /// + /// + /// id 12 // Evaulates to 12 + /// id "abc" // Evaulates to "abc" + /// + /// /// [] val id : x:'T -> 'T @@ -3374,7 +3481,14 @@ namespace Microsoft.FSharp.Core /// /// 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 @@ -3384,7 +3498,14 @@ namespace Microsoft.FSharp.Core /// The cell to mutate. /// The value to set inside the cell. /// - /// + /// + /// + /// 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 @@ -3394,7 +3515,13 @@ namespace Microsoft.FSharp.Core /// /// The value contained in the cell. /// - /// + /// + /// + /// 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 @@ -3402,7 +3529,13 @@ namespace Microsoft.FSharp.Core /// /// 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 @@ -3411,7 +3544,13 @@ namespace Microsoft.FSharp.Core /// /// 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 @@ -3423,7 +3562,13 @@ namespace Microsoft.FSharp.Core /// /// The concatenation of the lists. /// - /// + /// + /// + /// 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 @@ -3433,7 +3578,14 @@ namespace Microsoft.FSharp.Core /// /// 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 @@ -3444,7 +3596,12 @@ namespace Microsoft.FSharp.Core /// /// The result sequence. /// - /// + /// + /// + /// let list1 = [1;2;3;4] + /// let seq1 = seq list1 // Casts the list to a seq + /// + /// /// [] val seq : sequence:seq<'T> -> seq<'T> @@ -3456,7 +3613,17 @@ namespace Microsoft.FSharp.Core /// /// The result value. /// - /// + /// + /// + /// [] + /// 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 @@ -3496,7 +3663,16 @@ namespace Microsoft.FSharp.Core /// /// The sequence spanning the range. /// - /// + /// + /// + /// [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) @@ -3513,7 +3689,13 @@ namespace Microsoft.FSharp.Core /// /// The sequence spanning the range using the specified step size. /// - /// + /// + /// + /// [1..2..6] // Evaluates to [1; 3; 5] + /// [1.1..0.2..1.5] // Evaluates to [1.1; 1.3; 1.5] + /// ['a'..char(2)..'g'] // Evaluates to ['a'; 'c'; 'e'; 'g'] + /// + /// /// val inline (.. ..) : start:^T -> step:^Step -> finish:^T -> seq< ^T > when (^T or ^Step) : (static member (+) : ^T * ^Step -> ^T) @@ -3530,7 +3712,30 @@ namespace Microsoft.FSharp.Core /// /// The resulting value. /// - /// + /// + /// + /// type TestCounter () = + /// let mutable count = 0 + /// member this.PlainOldIncrement() = count <- count + 1 + /// member this.ThreadSafeIncrement() = lock this (this.PlainOldIncrement) + /// member this.Count = count + /// + /// open System.Linq + /// let counter = TestCounter() + /// // Create a parallel sequence to that uses all our CPUs + /// ({1..100000}).AsParallel() + /// .ForAll(fun _ -> counter.PlainOldIncrement()) + /// + /// counter.Count // Evaluates to a random number between 1-100000 + /// + /// let counter = TestCounter() + /// // Create a parallel sequence to that uses all our CPUs + /// ({1..100000}).AsParallel() + /// .ForAll(fun _ -> counter.ThreadSafeIncrement()) + /// + /// counter.Count // Evaluates to 100000 + /// + /// /// [] val inline lock: lockObject:'Lock -> action:(unit -> 'T) -> 'T when 'Lock : not struct @@ -3544,7 +3749,18 @@ namespace Microsoft.FSharp.Core /// /// The resulting value. /// - /// + /// + /// + /// open System.IO + /// + /// let writeHellos (writer: StreamWriter) = + /// for i in 1 .. 10 do + /// writer.WriteLine("Hello World {0}", i) + /// + /// using (File.AppendText "test.txt") writeHellos + /// // Appends 10 hellos to test.txt, then closes the StreamWriter when finished + /// + /// /// [] val using: resource:('T :> System.IDisposable) -> action:('T -> 'U) -> 'U @@ -3552,24 +3768,31 @@ namespace Microsoft.FSharp.Core /// Generate a System.Type runtime representation of a static type. /// - /// - /// + /// + /// + /// let t: System.Type = typeof + /// t.FullName // Evaluates to System.Int32 + /// + /// + /// [] [] val inline typeof<'T> : System.Type /// Returns the name of the given symbol. /// - /// - /// + /// + /// + /// let myVariableName = "This value doesn't matter" + /// nameof(myVariableName) // Evaluates to "myVariableName" + /// + /// + /// [] 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 @@ -3581,16 +3804,29 @@ namespace Microsoft.FSharp.Core /// input type is a generic type instantiation then return the /// generic type definition associated with all such instantiations. /// - /// - /// + /// + /// + /// typeof> // Evaluates to Microsoft.FSharp.Collections.FSharpList`1[System.Int32] + /// typedefof> // 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 // Evaluates to 1 + /// sizeof // Evaluates to 1 + /// sizeof // Evaluates to 4 + /// sizeof // Evaluates to 8 + /// sizeof // Evaluates to 2 + /// + /// + /// [] [] val inline sizeof<'T> : int @@ -3605,8 +3841,12 @@ namespace Microsoft.FSharp.Core /// /// The computed hash. /// - /// - /// + /// + /// + /// hash "Bob Jones" // Evaluates to -325251320 + /// + /// + /// [] val inline hash: obj:'T -> int when 'T : equality @@ -3632,8 +3872,13 @@ namespace Microsoft.FSharp.Core /// /// 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 @@ -3643,8 +3888,13 @@ namespace Microsoft.FSharp.Core /// /// 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 @@ -3654,8 +3904,14 @@ namespace Microsoft.FSharp.Core /// /// 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 @@ -3665,8 +3921,13 @@ namespace Microsoft.FSharp.Core /// /// 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 @@ -3677,8 +3938,15 @@ namespace Microsoft.FSharp.Core /// /// 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 @@ -3688,8 +3956,13 @@ namespace Microsoft.FSharp.Core /// /// 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 @@ -3699,8 +3972,15 @@ namespace Microsoft.FSharp.Core /// /// 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 @@ -3710,8 +3990,13 @@ namespace Microsoft.FSharp.Core /// /// 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 @@ -3721,8 +4006,13 @@ namespace Microsoft.FSharp.Core /// /// -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 @@ -3732,8 +4022,15 @@ namespace Microsoft.FSharp.Core /// /// 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 @@ -3743,8 +4040,14 @@ namespace Microsoft.FSharp.Core /// /// 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 @@ -3754,8 +4057,15 @@ namespace Microsoft.FSharp.Core /// /// 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 @@ -3765,8 +4075,13 @@ namespace Microsoft.FSharp.Core /// /// 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 @@ -3777,7 +4092,7 @@ namespace Microsoft.FSharp.Core /// The cosine of the input. /// /// - /// + /// [] val inline cos : value:^T -> ^T when ^T : (static member Cos : ^T -> ^T) and default ^T : float @@ -3788,7 +4103,7 @@ namespace Microsoft.FSharp.Core /// The hyperbolic cosine of the input. /// /// - /// + /// [] val inline cosh : value:^T -> ^T when ^T : (static member Cosh : ^T -> ^T) and default ^T : float @@ -3799,7 +4114,7 @@ namespace Microsoft.FSharp.Core /// The sine of the input. /// /// - /// + /// [] val inline sin : value:^T -> ^T when ^T : (static member Sin : ^T -> ^T) and default ^T : float @@ -3810,7 +4125,7 @@ namespace Microsoft.FSharp.Core /// The hyperbolic sine of the input. /// /// - /// + /// [] val inline sinh : value:^T -> ^T when ^T : (static member Sinh : ^T -> ^T) and default ^T : float @@ -3821,7 +4136,7 @@ namespace Microsoft.FSharp.Core /// The tangent of the input. /// /// - /// + /// [] val inline tan : value:^T -> ^T when ^T : (static member Tan : ^T -> ^T) and default ^T : float @@ -3832,7 +4147,7 @@ namespace Microsoft.FSharp.Core /// The hyperbolic tangent of the input. /// /// - /// + /// [] val inline tanh : value:^T -> ^T when ^T : (static member Tanh : ^T -> ^T) and default ^T : float @@ -3843,7 +4158,7 @@ namespace Microsoft.FSharp.Core /// The truncated value. /// /// - /// + /// [] val inline truncate : value:^T -> ^T when ^T : (static member Truncate : ^T -> ^T) and default ^T : float @@ -3855,7 +4170,7 @@ namespace Microsoft.FSharp.Core /// 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 /// Overloaded power operator. If n > 0 then equivalent to x*...*x for n occurrences of x. @@ -3866,7 +4181,7 @@ namespace Microsoft.FSharp.Core /// 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) @@ -3883,7 +4198,7 @@ namespace Microsoft.FSharp.Core /// The converted byte /// /// - /// + /// [] val inline byte : value:^T -> byte when ^T : (static member op_Explicit : ^T -> byte) and default ^T : int @@ -3897,7 +4212,7 @@ namespace Microsoft.FSharp.Core /// The converted sbyte /// /// - /// + /// [] val inline sbyte : value:^T -> sbyte when ^T : (static member op_Explicit : ^T -> sbyte) and default ^T : int @@ -3911,7 +4226,7 @@ namespace Microsoft.FSharp.Core /// The converted int16 /// /// - /// + /// [] val inline int16 : value:^T -> int16 when ^T : (static member op_Explicit : ^T -> int16) and default ^T : int @@ -3925,7 +4240,7 @@ namespace Microsoft.FSharp.Core /// The converted uint16 /// /// - /// + /// [] val inline uint16 : value:^T -> uint16 when ^T : (static member op_Explicit : ^T -> uint16) and default ^T : int @@ -3939,7 +4254,7 @@ namespace Microsoft.FSharp.Core /// The converted int /// /// - /// + /// [] val inline int : value:^T -> int when ^T : (static member op_Explicit : ^T -> int) and default ^T : int @@ -3953,7 +4268,7 @@ namespace Microsoft.FSharp.Core /// The converted int /// /// - /// + /// [] val inline uint: value:^T -> uint when ^T: (static member op_Explicit: ^T -> uint) and default ^T: uint @@ -3964,7 +4279,7 @@ namespace Microsoft.FSharp.Core /// The converted enum type. /// /// - /// + /// [] val inline enum : value:int32 -> ^U when ^U : enum @@ -3978,7 +4293,7 @@ namespace Microsoft.FSharp.Core /// The converted int32 /// /// - /// + /// [] val inline int32 : value:^T -> int32 when ^T : (static member op_Explicit : ^T -> int32) and default ^T : int @@ -3992,7 +4307,7 @@ namespace Microsoft.FSharp.Core /// The converted uint32 /// /// - /// + /// [] val inline uint32 : value:^T -> uint32 when ^T : (static member op_Explicit : ^T -> uint32) and default ^T : int @@ -4006,7 +4321,7 @@ namespace Microsoft.FSharp.Core /// The converted int64 /// /// - /// + /// [] val inline int64 : value:^T -> int64 when ^T : (static member op_Explicit : ^T -> int64) and default ^T : int @@ -4020,7 +4335,7 @@ namespace Microsoft.FSharp.Core /// The converted uint64 /// /// - /// + /// [] val inline uint64 : value:^T -> uint64 when ^T : (static member op_Explicit : ^T -> uint64) and default ^T : int @@ -4034,7 +4349,7 @@ namespace Microsoft.FSharp.Core /// The converted float32 /// /// - /// + /// [] val inline float32 : value:^T -> float32 when ^T : (static member op_Explicit : ^T -> float32) and default ^T : int @@ -4048,7 +4363,7 @@ namespace Microsoft.FSharp.Core /// The converted float /// /// - /// + /// [] val inline float : value:^T -> float when ^T : (static member op_Explicit : ^T -> float) and default ^T : int @@ -4061,7 +4376,7 @@ namespace Microsoft.FSharp.Core /// The converted nativeint /// /// - /// + /// [] val inline nativeint : value:^T -> nativeint when ^T : (static member op_Explicit : ^T -> nativeint) and default ^T : int @@ -4074,7 +4389,7 @@ namespace Microsoft.FSharp.Core /// The converted unativeint /// /// - /// + /// [] val inline unativeint : value:^T -> unativeint when ^T : (static member op_Explicit : ^T -> unativeint) and default ^T : int @@ -4087,7 +4402,7 @@ namespace Microsoft.FSharp.Core /// The converted string. /// /// - /// + /// [] val inline string : value:'T -> string @@ -4101,7 +4416,7 @@ namespace Microsoft.FSharp.Core /// The converted decimal. /// /// - /// + /// [] val inline decimal : value:^T -> decimal when ^T : (static member op_Explicit : ^T -> decimal) and default ^T : int @@ -4114,7 +4429,7 @@ namespace Microsoft.FSharp.Core /// The converted char. /// /// - /// + /// [] val inline char : value:^T -> char when ^T : (static member op_Explicit : ^T -> char) and default ^T : int @@ -4125,7 +4440,7 @@ namespace Microsoft.FSharp.Core /// A tuple containing the key and value. /// /// - /// + /// [] val ( |KeyValue| ): keyValuePair:KeyValuePair<'Key,'Value> -> 'Key * 'Value From 0803ba206092e7005698a24a23884fe1ff720311 Mon Sep 17 00:00:00 2001 From: Steve Goguen Date: Sat, 9 Oct 2021 14:53:00 -0400 Subject: [PATCH 3/7] FSharp.Core - Fixed examples per code review --- src/fsharp/FSharp.Core/prim-types.fsi | 265 ++++++++++++++++++-------- 1 file changed, 190 insertions(+), 75 deletions(-) diff --git a/src/fsharp/FSharp.Core/prim-types.fsi b/src/fsharp/FSharp.Core/prim-types.fsi index 0124d0116fb..67c7855df41 100644 --- a/src/fsharp/FSharp.Core/prim-types.fsi +++ b/src/fsharp/FSharp.Core/prim-types.fsi @@ -2676,7 +2676,7 @@ namespace Microsoft.FSharp.Core /// /// /// - /// 8 * 6 // Evaluates to 64 + /// 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 @@ -2690,7 +2690,7 @@ namespace Microsoft.FSharp.Core /// /// /// - /// 16 * 2 // Evaluates to 8 + /// 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 @@ -2720,7 +2720,7 @@ namespace Microsoft.FSharp.Core /// /// let a = 13 // 00000000000000000000000000001101 /// let b = 11 // 00000000000000000000000000001011 - /// let c = a &&& b // 00000000000000000000000000001001 + /// let c = a &&& b // 00000000000000000000000000001001 /// /// Evaluates to 9 /// @@ -2737,7 +2737,7 @@ namespace Microsoft.FSharp.Core /// /// let a = 13 // 00000000000000000000000000001101 /// let b = 11 // 00000000000000000000000000001011 - /// let c = a &&& b // 00000000000000000000000000001111 + /// let c = a ||| b // 00000000000000000000000000001111 /// /// Evaluates to 15 /// @@ -2770,7 +2770,7 @@ namespace Microsoft.FSharp.Core /// /// /// let a = 13 // 00000000000000000000000000001101 - /// let c = a << 4 // 00000000000000000000000011010000 + /// let c = a << 4 // 00000000000000000000000011010000 /// /// Evaluates to 206 /// @@ -2786,9 +2786,9 @@ namespace Microsoft.FSharp.Core /// /// /// let a = 206 // 00000000000000000000000011010000 - /// let c1 = a >> 2 // 00000000000000000000000000110100 + /// let c1 = a >> 2 // 00000000000000000000000000110100 /// // Evaluates to 51 - /// let c2 = a >> 6 // 00000000000000000000000000000011 + /// let c2 = a >> 6 // 00000000000000000000000000000011 /// Evaluates to 3 /// /// @@ -2829,9 +2829,9 @@ namespace Microsoft.FSharp.Core /// /// /// - /// 1 < 5 // Evaluates to true - /// 5 < 5 // Evaluates to false - /// (1, "a") < (1, "z") // Evaluates to true + /// 1 < 5 // Evaluates to true + /// 5 < 5 // Evaluates to false + /// (1, "a") < (1, "z") // Evaluates to true /// /// /// @@ -2846,9 +2846,9 @@ namespace Microsoft.FSharp.Core /// /// /// - /// 5 > 1 // Evaluates to true - /// 5 > 5 // Evaluates to false - /// (1, "a") > (1, "z") // Evaluates to false + /// 5 > 1 // Evaluates to true + /// 5 > 5 // Evaluates to false + /// (1, "a") > (1, "z") // Evaluates to false /// /// /// @@ -2880,9 +2880,9 @@ namespace Microsoft.FSharp.Core /// /// /// - /// 5 <= 1 // Evaluates to false - /// 5 <= 5 // Evaluates to true - /// [1; 5] <= [1; 6] // Evaluates to true + /// 5 <= 1 // Evaluates to false + /// 5 <= 5 // Evaluates to true + /// [1; 5] <= [1; 6] // Evaluates to true /// /// /// @@ -2914,9 +2914,9 @@ namespace Microsoft.FSharp.Core /// /// /// - /// 5 <> 5 // Evaluates to false - /// 5 <> 6 // Evaluates to true - /// [1; 2] <> [1; 2] // Evaluates to false + /// 5 <> 5 // Evaluates to false + /// 5 <> 6 // Evaluates to true + /// [1; 2] <> [1; 2] // Evaluates to false /// /// /// @@ -2951,7 +2951,7 @@ namespace Microsoft.FSharp.Core /// /// let addOne x = x + 1 /// let doubleIt x = x * 2 - /// let doubleThenAdd = addOne << doubleIt + /// let doubleThenAdd = addOne << doubleIt /// doubleThenAdd 3 /// /// @@ -3019,7 +3019,7 @@ namespace Microsoft.FSharp.Core /// /// /// let doubleIt x = x * 2 - /// doubleIt <| 3 // Evaluates to 6 + /// doubleIt <| 3 // Evaluates to 6 /// /// /// @@ -3036,7 +3036,7 @@ namespace Microsoft.FSharp.Core /// /// /// let sum x y = x + y - /// sum <|| (3, 4) // Evaluates to 7 + /// sum <|| (3, 4) // Evaluates to 7 /// /// /// @@ -3054,7 +3054,7 @@ namespace Microsoft.FSharp.Core /// /// /// let sum3 x y z = x + y + z - /// sum3 <||| (3, 4, 5) // Evaluates to 12 + /// sum3 <||| (3, 4, 5) // Evaluates to 12 /// /// /// @@ -3296,8 +3296,8 @@ namespace Microsoft.FSharp.Core /// /// let x: int = 123 /// let obj1 = box x // obj1 is a generic object type - /// unbox obj1 // Evaluates to 123 (int) - /// unbox obj1 // Throws System.InvalidCastException + /// unbox<int> obj1 // Evaluates to 123 (int) + /// unbox<double> obj1 // Throws System.InvalidCastException /// /// /// @@ -3314,8 +3314,8 @@ namespace Microsoft.FSharp.Core /// /// let x: int = 123 /// let obj1 = box x // obj1 is a generic object type - /// unbox obj1 // Evaluates to 123 (int) - /// unbox obj1 // Throws System.InvalidCastException + /// unbox<int> obj1 // Evaluates to 123 (int) + /// unbox<double> obj1 // Throws System.InvalidCastException /// /// /// @@ -3332,8 +3332,8 @@ namespace Microsoft.FSharp.Core /// /// let x: int = 123 /// let obj1 = box x // obj1 is a generic object type - /// tryUnbox obj1 // Evaluates to Some(123) - /// tryUnbox obj1 // Evaluates to None + /// tryUnbox<int> obj1 // Evaluates to Some(123) + /// tryUnbox<double> obj1 // Evaluates to None /// /// /// @@ -3448,7 +3448,7 @@ namespace Microsoft.FSharp.Core /// member this.Open() = /// if isOpen then invalidOp "File is already open" /// // ... Here we may open the file ... - /// isOpen <- true + /// isOpen <- true /// /// let reader = FileReader("journal.txt") /// reader.Open() // Executes fine @@ -3485,7 +3485,7 @@ namespace Microsoft.FSharp.Core /// /// 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 <- 1 // Updates the value /// count.Value // Evaluates to 1 /// /// @@ -3501,7 +3501,7 @@ namespace Microsoft.FSharp.Core /// /// /// let count = ref 0 // Creates a reference cell object with a mutable Value property - /// count.Value <- 1 // Updates the value + /// count.Value <- 1 // Updates the value /// count := 2 // Also updates the value, but with shorter syntax /// count.Value // Evaluates to 2 /// @@ -3599,7 +3599,7 @@ namespace Microsoft.FSharp.Core /// /// /// let list1 = [1;2;3;4] - /// let seq1 = seq list1 // Casts the list to a seq + /// let seq1 = seq list1 // Casts the list<int> to a seq<int> /// /// /// @@ -3615,7 +3615,7 @@ namespace Microsoft.FSharp.Core /// /// /// - /// [] + /// [<EntryPoint>] /// let main argv = /// if argv.Length = 0 then /// eprintfn "You must provide arguments" @@ -3716,21 +3716,22 @@ namespace Microsoft.FSharp.Core /// /// type TestCounter () = /// let mutable count = 0 - /// member this.PlainOldIncrement() = count <- count + 1 - /// member this.ThreadSafeIncrement() = lock this (this.PlainOldIncrement) + /// member this.PlainOldIncrement() = count <- count + 1 + /// member this.ThreadSafeIncrement() = + /// lock this (fun () -> count <- count + 1) /// member this.Count = count /// /// open System.Linq /// let counter = TestCounter() /// // Create a parallel sequence to that uses all our CPUs - /// ({1..100000}).AsParallel() + /// (seq {1..100000}).AsParallel() /// .ForAll(fun _ -> counter.PlainOldIncrement()) /// /// counter.Count // Evaluates to a random number between 1-100000 /// /// let counter = TestCounter() /// // Create a parallel sequence to that uses all our CPUs - /// ({1..100000}).AsParallel() + /// (seq {1..100000}).AsParallel() /// .ForAll(fun _ -> counter.ThreadSafeIncrement()) /// /// counter.Count // Evaluates to 100000 @@ -3770,8 +3771,8 @@ namespace Microsoft.FSharp.Core /// /// /// - /// let t: System.Type = typeof - /// t.FullName // Evaluates to System.Int32 + /// let t = typeof<int> // Gets the System.Type + /// t.FullName // Evaluates to "System.Int32" /// /// /// @@ -3806,8 +3807,8 @@ namespace Microsoft.FSharp.Core /// /// /// - /// typeof> // Evaluates to Microsoft.FSharp.Collections.FSharpList`1[System.Int32] - /// typedefof> // Evaluates to Microsoft.FSharp.Collections.FSharpList`1[T] /// + /// typeof<list<int>> // Evaluates to Microsoft.FSharp.Collections.FSharpList`1[System.Int32] + /// typedefof<list<int>> // Evaluates to Microsoft.FSharp.Collections.FSharpList`1[T] /// /// /// /// @@ -3819,11 +3820,13 @@ namespace Microsoft.FSharp.Core /// /// /// - /// sizeof // Evaluates to 1 - /// sizeof // Evaluates to 1 - /// sizeof // Evaluates to 4 - /// sizeof // Evaluates to 8 - /// sizeof // Evaluates to 2 + /// 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 /// /// /// @@ -4091,7 +4094,11 @@ namespace Microsoft.FSharp.Core /// /// The cosine of the input. /// - /// + /// + /// + + /// + /// /// [] val inline cos : value:^T -> ^T when ^T : (static member Cos : ^T -> ^T) and default ^T : float @@ -4102,7 +4109,11 @@ namespace Microsoft.FSharp.Core /// /// The hyperbolic cosine of the input. /// - /// + /// + /// + + /// + /// /// [] val inline cosh : value:^T -> ^T when ^T : (static member Cosh : ^T -> ^T) and default ^T : float @@ -4113,7 +4124,11 @@ namespace Microsoft.FSharp.Core /// /// The sine of the input. /// - /// + /// + /// + + /// + /// /// [] val inline sin : value:^T -> ^T when ^T : (static member Sin : ^T -> ^T) and default ^T : float @@ -4124,7 +4139,11 @@ namespace Microsoft.FSharp.Core /// /// The hyperbolic sine of the input. /// - /// + /// + /// + + /// + /// /// [] val inline sinh : value:^T -> ^T when ^T : (static member Sinh : ^T -> ^T) and default ^T : float @@ -4135,7 +4154,11 @@ namespace Microsoft.FSharp.Core /// /// The tangent of the input. /// - /// + /// + /// + + /// + /// /// [] val inline tan : value:^T -> ^T when ^T : (static member Tan : ^T -> ^T) and default ^T : float @@ -4146,7 +4169,11 @@ namespace Microsoft.FSharp.Core /// /// The hyperbolic tangent of the input. /// - /// + /// + /// + + /// + /// /// [] val inline tanh : value:^T -> ^T when ^T : (static member Tanh : ^T -> ^T) and default ^T : float @@ -4157,7 +4184,11 @@ namespace Microsoft.FSharp.Core /// /// The truncated value. /// - /// + /// + /// + + /// + /// /// [] val inline truncate : value:^T -> ^T when ^T : (static member Truncate : ^T -> ^T) and default ^T : float @@ -4169,7 +4200,11 @@ namespace Microsoft.FSharp.Core /// /// 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 @@ -4180,7 +4215,11 @@ namespace Microsoft.FSharp.Core /// /// The base raised to the exponent. /// - /// + /// + /// + + /// + /// /// [] val inline pown : x:^T -> n:int -> ^T when ^T : (static member One : ^T) @@ -4197,7 +4236,11 @@ namespace Microsoft.FSharp.Core /// /// The converted byte /// - /// + /// + /// + + /// + /// /// [] val inline byte : value:^T -> byte when ^T : (static member op_Explicit : ^T -> byte) and default ^T : int @@ -4211,7 +4254,11 @@ namespace Microsoft.FSharp.Core /// /// The converted sbyte /// - /// + /// + /// + + /// + /// /// [] val inline sbyte : value:^T -> sbyte when ^T : (static member op_Explicit : ^T -> sbyte) and default ^T : int @@ -4225,7 +4272,11 @@ namespace Microsoft.FSharp.Core /// /// The converted int16 /// - /// + /// + /// + + /// + /// /// [] val inline int16 : value:^T -> int16 when ^T : (static member op_Explicit : ^T -> int16) and default ^T : int @@ -4239,7 +4290,11 @@ namespace Microsoft.FSharp.Core /// /// The converted uint16 /// - /// + /// + /// + + /// + /// /// [] val inline uint16 : value:^T -> uint16 when ^T : (static member op_Explicit : ^T -> uint16) and default ^T : int @@ -4253,7 +4308,11 @@ namespace Microsoft.FSharp.Core /// /// The converted int /// - /// + /// + /// + + /// + /// /// [] val inline int : value:^T -> int when ^T : (static member op_Explicit : ^T -> int) and default ^T : int @@ -4267,7 +4326,11 @@ namespace Microsoft.FSharp.Core /// /// The converted int /// - /// + /// + /// + + /// + /// /// [] val inline uint: value:^T -> uint when ^T: (static member op_Explicit: ^T -> uint) and default ^T: uint @@ -4278,7 +4341,11 @@ namespace Microsoft.FSharp.Core /// /// The converted enum type. /// - /// + /// + /// + + /// + /// /// [] val inline enum : value:int32 -> ^U when ^U : enum @@ -4292,7 +4359,11 @@ namespace Microsoft.FSharp.Core /// /// The converted int32 /// - /// + /// + /// + + /// + /// /// [] val inline int32 : value:^T -> int32 when ^T : (static member op_Explicit : ^T -> int32) and default ^T : int @@ -4306,7 +4377,11 @@ namespace Microsoft.FSharp.Core /// /// The converted uint32 /// - /// + /// + /// + + /// + /// /// [] val inline uint32 : value:^T -> uint32 when ^T : (static member op_Explicit : ^T -> uint32) and default ^T : int @@ -4320,7 +4395,11 @@ namespace Microsoft.FSharp.Core /// /// The converted int64 /// - /// + /// + /// + + /// + /// /// [] val inline int64 : value:^T -> int64 when ^T : (static member op_Explicit : ^T -> int64) and default ^T : int @@ -4334,7 +4413,11 @@ namespace Microsoft.FSharp.Core /// /// The converted uint64 /// - /// + /// + /// + + /// + /// /// [] val inline uint64 : value:^T -> uint64 when ^T : (static member op_Explicit : ^T -> uint64) and default ^T : int @@ -4348,7 +4431,11 @@ namespace Microsoft.FSharp.Core /// /// The converted float32 /// - /// + /// + /// + + /// + /// /// [] val inline float32 : value:^T -> float32 when ^T : (static member op_Explicit : ^T -> float32) and default ^T : int @@ -4362,7 +4449,11 @@ namespace Microsoft.FSharp.Core /// /// The converted float /// - /// + /// + /// + + /// + /// /// [] val inline float : value:^T -> float when ^T : (static member op_Explicit : ^T -> float) and default ^T : int @@ -4375,7 +4466,11 @@ namespace Microsoft.FSharp.Core /// /// The converted nativeint /// - /// + /// + /// + + /// + /// /// [] val inline nativeint : value:^T -> nativeint when ^T : (static member op_Explicit : ^T -> nativeint) and default ^T : int @@ -4388,7 +4483,11 @@ namespace Microsoft.FSharp.Core /// /// The converted unativeint /// - /// + /// + /// + + /// + /// /// [] val inline unativeint : value:^T -> unativeint when ^T : (static member op_Explicit : ^T -> unativeint) and default ^T : int @@ -4401,7 +4500,11 @@ namespace Microsoft.FSharp.Core /// /// The converted string. /// - /// + /// + /// + + /// + /// /// [] val inline string : value:'T -> string @@ -4415,7 +4518,11 @@ namespace Microsoft.FSharp.Core /// /// The converted decimal. /// - /// + /// + /// + + /// + /// /// [] val inline decimal : value:^T -> decimal when ^T : (static member op_Explicit : ^T -> decimal) and default ^T : int @@ -4428,7 +4535,11 @@ namespace Microsoft.FSharp.Core /// /// The converted char. /// - /// + /// + /// + + /// + /// /// [] val inline char : value:^T -> char when ^T : (static member op_Explicit : ^T -> char) and default ^T : int @@ -4439,7 +4550,11 @@ namespace Microsoft.FSharp.Core /// /// A tuple containing the key and value. /// - /// + /// + /// + + /// + /// /// [] val ( |KeyValue| ): keyValuePair:KeyValuePair<'Key,'Value> -> 'Key * 'Value From 02ae3f319645cdf69dfe3f5b2df19f387ccef47d Mon Sep 17 00:00:00 2001 From: Don Syme Date: Mon, 11 Oct 2021 11:54:50 +0100 Subject: [PATCH 4/7] Update prim-types.fsi --- src/fsharp/FSharp.Core/prim-types.fsi | 141 +++++++++++++------------- 1 file changed, 70 insertions(+), 71 deletions(-) diff --git a/src/fsharp/FSharp.Core/prim-types.fsi b/src/fsharp/FSharp.Core/prim-types.fsi index 67c7855df41..536115a913e 100644 --- a/src/fsharp/FSharp.Core/prim-types.fsi +++ b/src/fsharp/FSharp.Core/prim-types.fsi @@ -3246,9 +3246,9 @@ namespace Microsoft.FSharp.Core /// /// /// - // max 1 2 // Evaluates to 2 - // max [1;2;3] [1;2;4] // Evaluates to [1;2;4] - // max "zoo" "alpha" // Evaluates to "zoo" + /// max 1 2 // Evaluates to 2 + /// max [1;2;3] [1;2;4] // Evaluates to [1;2;4] + /// max "zoo" "alpha" // Evaluates to "zoo" /// /// /// @@ -3264,9 +3264,9 @@ namespace Microsoft.FSharp.Core /// /// /// - // min 1 2 // Evaluates to 1 - // min [1;2;3] [1;2;4] // Evaluates to [1;2;3] - // min "zoo" "alpha" // Evaluates to "alpha" + /// min 1 2 // Evaluates to 1 + /// min [1;2;3] [1;2;4] // Evaluates to [1;2;3] + /// min "zoo" "alpha" // Evaluates to "alpha" /// /// /// @@ -3279,7 +3279,7 @@ namespace Microsoft.FSharp.Core /// /// /// - // ignore 55555 // Evaluates to () + /// ignore 55555 // Evaluates to () /// /// /// @@ -4094,7 +4094,7 @@ namespace Microsoft.FSharp.Core /// /// The cosine of the input. /// - /// + /// /// /// @@ -4109,7 +4109,7 @@ namespace Microsoft.FSharp.Core /// /// The hyperbolic cosine of the input. /// - /// + /// /// /// @@ -4124,9 +4124,9 @@ namespace Microsoft.FSharp.Core /// /// The sine of the input. /// - /// + /// /// - + /// /// /// /// @@ -4139,7 +4139,7 @@ namespace Microsoft.FSharp.Core /// /// The hyperbolic sine of the input. /// - /// + /// /// /// @@ -4154,14 +4154,14 @@ namespace Microsoft.FSharp.Core /// /// 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 /// @@ -4169,14 +4169,14 @@ namespace Microsoft.FSharp.Core /// /// 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. /// @@ -4184,9 +4184,9 @@ namespace Microsoft.FSharp.Core /// /// The truncated value. /// - /// + /// /// - + /// /// /// /// @@ -4200,9 +4200,9 @@ namespace Microsoft.FSharp.Core /// /// The base raised to the exponent. /// - /// + /// /// - + /// /// /// /// @@ -4215,9 +4215,9 @@ namespace Microsoft.FSharp.Core /// /// The base raised to the exponent. /// - /// + /// /// - + /// /// /// /// @@ -4236,9 +4236,9 @@ namespace Microsoft.FSharp.Core /// /// The converted byte /// - /// + /// /// - + /// /// /// /// @@ -4254,9 +4254,9 @@ namespace Microsoft.FSharp.Core /// /// The converted sbyte /// - /// + /// /// - + /// /// /// /// @@ -4272,9 +4272,9 @@ namespace Microsoft.FSharp.Core /// /// The converted int16 /// - /// + /// /// - + /// /// /// /// @@ -4290,9 +4290,9 @@ namespace Microsoft.FSharp.Core /// /// The converted uint16 /// - /// + /// /// - + /// /// /// /// @@ -4308,9 +4308,9 @@ namespace Microsoft.FSharp.Core /// /// The converted int /// - /// + /// /// - + /// /// /// /// @@ -4326,9 +4326,9 @@ namespace Microsoft.FSharp.Core /// /// The converted int /// - /// + /// /// - + /// /// /// /// @@ -4341,9 +4341,9 @@ namespace Microsoft.FSharp.Core /// /// The converted enum type. /// - /// + /// /// - + /// /// /// /// @@ -4359,9 +4359,9 @@ namespace Microsoft.FSharp.Core /// /// The converted int32 /// - /// + /// /// - + /// /// /// /// @@ -4377,9 +4377,9 @@ namespace Microsoft.FSharp.Core /// /// The converted uint32 /// - /// + /// /// - + /// /// /// /// @@ -4395,14 +4395,14 @@ namespace Microsoft.FSharp.Core /// /// 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() @@ -4413,14 +4413,14 @@ namespace Microsoft.FSharp.Core /// /// 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() @@ -4431,14 +4431,14 @@ namespace Microsoft.FSharp.Core /// /// 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() @@ -4449,14 +4449,14 @@ namespace Microsoft.FSharp.Core /// /// 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 @@ -4466,9 +4466,9 @@ namespace Microsoft.FSharp.Core /// /// The converted nativeint /// - /// + /// /// - + /// /// /// /// @@ -4483,14 +4483,14 @@ namespace Microsoft.FSharp.Core /// /// 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. /// @@ -4500,14 +4500,14 @@ namespace Microsoft.FSharp.Core /// /// 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() @@ -4518,14 +4518,14 @@ namespace Microsoft.FSharp.Core /// /// 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 @@ -4535,14 +4535,14 @@ namespace Microsoft.FSharp.Core /// /// 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 /// @@ -4550,9 +4550,9 @@ namespace Microsoft.FSharp.Core /// /// A tuple containing the key and value. /// - /// + /// /// - + /// /// /// /// @@ -4614,7 +4614,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 = From 267b21919a53794ffebc15c4ae6e4a46aae7606e Mon Sep 17 00:00:00 2001 From: Don Syme Date: Mon, 11 Oct 2021 12:32:14 +0100 Subject: [PATCH 5/7] Update prim-types.fsi --- src/fsharp/FSharp.Core/prim-types.fsi | 584 +++++++++++++------------- 1 file changed, 296 insertions(+), 288 deletions(-) diff --git a/src/fsharp/FSharp.Core/prim-types.fsi b/src/fsharp/FSharp.Core/prim-types.fsi index 536115a913e..2bb91802ea2 100644 --- a/src/fsharp/FSharp.Core/prim-types.fsi +++ b/src/fsharp/FSharp.Core/prim-types.fsi @@ -2635,7 +2635,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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 /// @@ -2651,7 +2651,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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 subtraction operator /// @@ -2665,7 +2665,7 @@ namespace Microsoft.FSharp.Core /// 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 + 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 /// @@ -2679,7 +2679,7 @@ namespace Microsoft.FSharp.Core /// 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 + 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 /// @@ -2693,7 +2693,7 @@ namespace Microsoft.FSharp.Core /// 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 + 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 /// @@ -2707,7 +2707,7 @@ namespace Microsoft.FSharp.Core /// 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 + 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 /// @@ -2724,7 +2724,7 @@ namespace Microsoft.FSharp.Core /// /// Evaluates to 9 /// - val inline (&&&): x:^T -> y:^T -> ^T when ^T : (static member (&&&) : ^T * ^T -> ^T) and default ^T : int + val inline (&&&): x: ^T -> y: ^T -> ^T when ^T : (static member (&&&) : ^T * ^T -> ^T) and default ^T : int /// Overloaded bitwise-OR operator /// @@ -2741,7 +2741,7 @@ namespace Microsoft.FSharp.Core /// /// Evaluates to 15 /// - val inline (|||) : x:^T -> y:^T -> ^T when ^T : (static member (|||) : ^T * ^T -> ^T) and default ^T : int + val inline (|||) : x: ^T -> y: ^T -> ^T when ^T : (static member (|||) : ^T * ^T -> ^T) and default ^T : int /// Overloaded bitwise-XOR operator /// @@ -2758,7 +2758,7 @@ namespace Microsoft.FSharp.Core /// /// Evaluates to 6 /// - val inline (^^^) : x:^T -> y:^T -> ^T when ^T : (static member (^^^) : ^T * ^T -> ^T) and default ^T : int + 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 /// @@ -2774,7 +2774,7 @@ namespace Microsoft.FSharp.Core /// /// Evaluates to 206 /// - val inline (<<<) : value:^T -> shift:int32 -> ^T when ^T : (static member (<<<) : ^T * int32 -> ^T) and default ^T : int + 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 /// @@ -2792,7 +2792,7 @@ namespace Microsoft.FSharp.Core /// Evaluates to 3 /// /// - val inline (>>>) : value:^T -> shift:int32 -> ^T when ^T : (static member (>>>) : ^T * int32 -> ^T) and default ^T : int + val inline (>>>) : value: ^T -> shift: int32 -> ^T when ^T : (static member (>>>) : ^T * int32 -> ^T) and default ^T : int /// Overloaded bitwise-NOT operator /// @@ -2808,7 +2808,7 @@ namespace Microsoft.FSharp.Core /// Evaluates to 195 /// /// - 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 prefix-plus operator /// @@ -2818,7 +2818,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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 /// @@ -2835,7 +2835,7 @@ namespace Microsoft.FSharp.Core /// /// /// - val inline ( < ) : x:'T -> y:'T -> bool when 'T : comparison + val inline (<): x: 'T -> y: 'T -> bool when 'T : comparison /// Structural greater-than /// @@ -2852,7 +2852,7 @@ namespace Microsoft.FSharp.Core /// /// /// - val inline ( > ) : x:'T -> y:'T -> bool when 'T : comparison + val inline (>): x: 'T -> y: 'T -> bool when 'T : comparison /// Structural greater-than-or-equal /// @@ -2869,7 +2869,7 @@ namespace Microsoft.FSharp.Core /// /// /// - val inline ( >= ) : x:'T -> y:'T -> bool when 'T : comparison + val inline (>=): x: 'T -> y: 'T -> bool when 'T : comparison /// Structural less-than-or-equal comparison /// @@ -2886,7 +2886,7 @@ namespace Microsoft.FSharp.Core /// /// /// - val inline ( <= ) : x:'T -> y:'T -> bool when 'T : comparison + val inline (<=): x: 'T -> y: 'T -> bool when 'T : comparison /// Structural equality /// @@ -2900,10 +2900,11 @@ namespace Microsoft.FSharp.Core /// 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 + val inline (=): x: 'T -> y: 'T -> bool when 'T : equality /// Structural inequality /// @@ -2920,7 +2921,7 @@ namespace Microsoft.FSharp.Core /// /// /// - val inline ( <> ) : x:'T -> y:'T -> bool when 'T : equality + val inline (<>) : x:'T -> y:'T -> bool when 'T : equality /// Compose two functions, the function on the left being applied first /// @@ -2938,7 +2939,7 @@ namespace Microsoft.FSharp.Core /// /// /// - val inline (>>): func1:('T1 -> 'T2) -> func2:('T2 -> 'T3) -> ('T1 -> 'T3) + val inline (>>): func1: ('T1 -> 'T2) -> func2: ('T2 -> 'T3) -> ('T1 -> 'T3) /// Compose two functions, the function on the right being applied first /// @@ -2956,7 +2957,7 @@ namespace Microsoft.FSharp.Core /// /// /// - val inline (<<): func2:('T2 -> 'T3) -> func1:('T1 -> 'T2) -> ('T1 -> 'T3) + 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 /// @@ -2972,7 +2973,7 @@ namespace Microsoft.FSharp.Core /// /// /// - val inline (|>): arg:'T1 -> func:('T1 -> 'U) -> 'U + 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 /// @@ -2989,7 +2990,7 @@ namespace Microsoft.FSharp.Core /// /// /// - val inline (||>): arg1:'T1 * arg2:'T2 -> func:('T1 -> 'T2 -> 'U) -> 'U + 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 /// @@ -3007,7 +3008,7 @@ namespace Microsoft.FSharp.Core /// /// /// - val inline (|||>): arg1:'T1 * arg2:'T2 * arg3:'T3 -> func:('T1 -> 'T2 -> 'T3 -> 'U) -> 'U + 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 /// @@ -3023,7 +3024,7 @@ namespace Microsoft.FSharp.Core /// /// /// - val inline (<|): func:('T -> 'U) -> arg1:'T -> 'U + 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 /// @@ -3040,7 +3041,7 @@ namespace Microsoft.FSharp.Core /// /// /// - val inline (<||): func:('T1 -> 'T2 -> 'U) -> arg1:'T1 * arg2:'T2 -> 'U + 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 /// @@ -3058,7 +3059,7 @@ namespace Microsoft.FSharp.Core /// /// /// - val inline (<|||): func:('T1 -> 'T2 -> 'T3 -> 'U) -> arg1:'T1 * arg2:'T2 * arg3:'T3 -> 'U + 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 /// @@ -3083,7 +3084,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -3101,7 +3102,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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. [] @@ -3116,25 +3117,26 @@ namespace Microsoft.FSharp.Core /// /// /// open System.IO - /// exception AintGotNoFileException of string + /// exception FileNotFoundException of string /// /// let readFile (filename: string) = /// if not (File.Exists(filename)) then - /// raise(AintGotNoFileException(filename)) + /// raise(FileNotFoundException(filename)) /// File.ReadAllText(filename) /// - /// readFile "/this-file-doest-exist" // Throws an AintGotNoFileException + /// 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. @@ -3155,7 +3157,7 @@ namespace Microsoft.FSharp.Core /// /// [] - val inline reraise : unit -> 'T + val inline reraise: unit -> 'T /// Builds a object. /// @@ -3173,7 +3175,7 @@ namespace Microsoft.FSharp.Core /// /// /// - val Failure : message:string -> exn + val Failure: message: string -> exn /// Matches objects whose runtime type is precisely /// @@ -3184,7 +3186,7 @@ namespace Microsoft.FSharp.Core /// /// [] - val (|Failure|_|) : error:exn -> string option + val (|Failure|_|): error: exn -> string option /// Return the first element of a tuple, fst (a,b) = a. /// @@ -3199,7 +3201,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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. /// @@ -3214,7 +3216,7 @@ namespace Microsoft.FSharp.Core /// /// [] - val inline snd : tuple:('T1 * 'T2) -> 'T2 + val inline snd: tuple: ('T1 * 'T2) -> 'T2 /// Generic comparison. /// @@ -3235,7 +3237,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -3253,7 +3255,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -3271,7 +3273,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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. /// @@ -3284,7 +3286,7 @@ namespace Microsoft.FSharp.Core /// /// [] - val inline ignore : value:'T -> unit + val inline ignore: value: 'T -> unit /// Unbox a strongly typed value. /// @@ -3302,7 +3304,7 @@ namespace Microsoft.FSharp.Core /// /// [] - val inline unbox : value:obj -> 'T + val inline unbox: value: obj -> 'T /// Boxes a strongly typed value. /// @@ -3320,7 +3322,7 @@ namespace Microsoft.FSharp.Core /// /// [] - val inline box : value:'T -> obj + val inline box: value: 'T -> obj /// Try to unbox a strongly typed value. /// @@ -3338,7 +3340,7 @@ namespace Microsoft.FSharp.Core /// /// [] - val inline tryUnbox : value:obj -> 'T option + val inline tryUnbox: value: obj -> 'T option /// Determines whether the given value is null. /// @@ -3354,23 +3356,15 @@ namespace Microsoft.FSharp.Core /// /// [] - 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. /// /// The value to check. /// /// True when value is not null, false otherwise. - /// - /// - /// - /// IsNotNull null // Evaluates to false - /// IsNotNull "Not null" // Evaluates to true - /// - /// - /// [] - val inline internal isNotNull : value:'T -> bool when 'T : null + val inline internal isNotNull: value: 'T -> bool when 'T : null /// Throw a exception. /// @@ -3384,12 +3378,12 @@ namespace Microsoft.FSharp.Core /// failwith "Oh no" // Throws an exception /// true // Never reaches this /// - /// failingFunction() // Throws a System.Exception + /// 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. @@ -3403,17 +3397,18 @@ namespace Microsoft.FSharp.Core /// /// 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" + /// 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') + /// 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 /// @@ -3433,7 +3428,7 @@ namespace Microsoft.FSharp.Core /// /// [] - val inline nullArg : argumentName:string -> 'T + val inline nullArg: argumentName: string -> 'T /// Throw a exception /// @@ -3457,7 +3452,7 @@ namespace Microsoft.FSharp.Core /// /// [] - val inline invalidOp : message:string -> 'T + val inline invalidOp: message: string -> 'T /// The identity function /// @@ -3473,7 +3468,7 @@ namespace Microsoft.FSharp.Core /// /// [] - val id : x:'T -> 'T + val id: x: 'T -> 'T /// Create a mutable reference cell /// @@ -3491,7 +3486,7 @@ namespace Microsoft.FSharp.Core /// /// [] - val ref : value:'T -> 'T ref + val ref: value: 'T -> 'T ref /// Assign to a mutable reference cell /// @@ -3507,7 +3502,7 @@ namespace Microsoft.FSharp.Core /// /// /// - val ( := ) : cell:'T ref -> value:'T -> unit + val (:=): cell: 'T ref -> value: 'T -> unit /// Dereference a mutable reference cell /// @@ -3523,7 +3518,7 @@ namespace Microsoft.FSharp.Core /// /// /// - val ( ! ) : cell:'T ref -> 'T + val (!): cell: 'T ref -> 'T /// Decrement a mutable reference cell containing an integer /// @@ -3538,7 +3533,7 @@ namespace Microsoft.FSharp.Core /// /// [] - val decr: cell:int ref -> unit + val decr: cell: int ref -> unit /// Increment a mutable reference cell containing an integer /// @@ -3553,7 +3548,7 @@ namespace Microsoft.FSharp.Core /// /// [] - val incr: cell:int ref -> unit + val incr: cell: int ref -> unit /// Concatenate two lists. /// @@ -3570,7 +3565,7 @@ namespace Microsoft.FSharp.Core /// /// /// - val (@): list1:'T list -> list2:'T list -> 'T list + val (@): list1: 'T list -> list2: 'T list -> 'T list /// Negate a logical value. Not True equals False and not False equals True /// @@ -3588,7 +3583,7 @@ namespace Microsoft.FSharp.Core /// /// [] - val inline not : value:bool -> bool + val inline not: value: bool -> bool /// Builds a sequence using sequence expression syntax /// @@ -3598,13 +3593,12 @@ namespace Microsoft.FSharp.Core /// /// /// - /// let list1 = [1;2;3;4] - /// let seq1 = seq list1 // Casts the list<int> to a seq<int> + /// 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 . @@ -3626,7 +3620,7 @@ namespace Microsoft.FSharp.Core /// /// [] - val exit: exitcode:int -> 'T when default 'T : obj + val exit: exitcode: int -> 'T when default 'T : obj /// Equivalent to [] @@ -3674,7 +3668,7 @@ namespace Microsoft.FSharp.Core /// /// /// - val inline (..) : start:^T -> finish:^T -> seq< ^T > + val inline (..): start: ^T -> finish: ^T -> seq< ^T > when ^T : (static member (+) : ^T * ^T -> ^T) and ^T : (static member One : ^T) and ^T : equality @@ -3693,11 +3687,11 @@ namespace Microsoft.FSharp.Core /// /// [1..2..6] // Evaluates to [1; 3; 5] /// [1.1..0.2..1.5] // Evaluates to [1.1; 1.3; 1.5] - /// ['a'..char(2)..'g'] // Evaluates to ['a'; 'c'; 'e'; 'g'] + /// ['a'..'e'] // Evaluates to ['a'; 'b'; 'c'; 'd'; 'e'] /// /// /// - val inline (.. ..) : start:^T -> step:^Step -> finish:^T -> seq< ^T > + 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 @@ -3714,32 +3708,45 @@ namespace Microsoft.FSharp.Core /// /// /// + /// open System.Linq + /// + /// /// A counter object, supporting unlocked and locked increment /// type TestCounter () = /// let mutable count = 0 - /// member this.PlainOldIncrement() = count <- count + 1 - /// member this.ThreadSafeIncrement() = + /// + /// /// 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 /// - /// open System.Linq /// let counter = TestCounter() - /// // Create a parallel sequence to that uses all our CPUs + /// + /// // Create a parallel sequence to that uses all our CPUs /// (seq {1..100000}).AsParallel() - /// .ForAll(fun _ -> counter.PlainOldIncrement()) + /// .ForAll(fun _ -> counter.IncrementWithoutLock()) /// - /// counter.Count // Evaluates to a random number between 1-100000 + /// // Evaluates to a number between 1-100000, non-deterministically because there is no locking + /// counter.Count /// - /// let counter = TestCounter() + /// let counter2 = TestCounter() + /// /// // Create a parallel sequence to that uses all our CPUs /// (seq {1..100000}).AsParallel() - /// .ForAll(fun _ -> counter.ThreadSafeIncrement()) + /// .ForAll(fun _ -> counter2.IncrementWithLock()) /// - /// counter.Count // Evaluates to 100000 + /// // 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 @@ -3751,21 +3758,19 @@ namespace Microsoft.FSharp.Core /// The resulting value. /// /// + /// The following code appends 10 lines to test.txt, then closes the StreamWriter when finished. /// /// open System.IO /// - /// let writeHellos (writer: StreamWriter) = + /// using (File.AppendText "test.txt") (fun writer -> /// for i in 1 .. 10 do - /// writer.WriteLine("Hello World {0}", i) + /// writer.WriteLine("Hello World {0}", i)) /// - /// using (File.AppendText "test.txt") writeHellos - /// // Appends 10 hellos to test.txt, then closes the StreamWriter when finished /// /// /// [] - 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. /// @@ -3790,15 +3795,15 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -3807,8 +3812,8 @@ namespace Microsoft.FSharp.Core /// /// /// - /// typeof<list<int>> // Evaluates to Microsoft.FSharp.Collections.FSharpList`1[System.Int32] - /// typedefof<list<int>> // Evaluates to Microsoft.FSharp.Collections.FSharpList`1[T] /// + /// typeof<int list;> // Evaluates to Microsoft.FSharp.Collections.FSharpList`1[System.Int32] + /// typedefof<int list;> // Evaluates to Microsoft.FSharp.Collections.FSharpList`1[T] /// /// /// /// @@ -3825,8 +3830,7 @@ namespace Microsoft.FSharp.Core /// 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 + /// sizeof<nativeint> // Evaluates to 4 or 8 (32-bit or 64-bit) depending on your platform /// /// /// @@ -3851,7 +3855,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -3866,8 +3870,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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. /// @@ -3883,7 +3886,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -3899,7 +3902,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -3916,7 +3919,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -3932,7 +3935,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -3951,7 +3954,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -3967,7 +3970,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -3985,7 +3988,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -4001,7 +4004,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -4017,7 +4020,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -4035,7 +4038,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -4052,7 +4055,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -4070,7 +4073,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -4086,7 +4089,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -4096,12 +4099,12 @@ namespace Microsoft.FSharp.Core /// /// /// - + /// /// /// /// [] - 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 /// @@ -4111,12 +4114,12 @@ namespace Microsoft.FSharp.Core /// /// /// - + /// /// /// /// [] - 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 /// @@ -4131,7 +4134,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -4146,7 +4149,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -4161,7 +4164,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -4176,7 +4179,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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. /// @@ -4191,7 +4194,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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. /// @@ -4206,7 +4209,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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. /// @@ -4222,10 +4225,11 @@ namespace Microsoft.FSharp.Core /// /// [] - 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() @@ -4243,7 +4247,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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() @@ -4261,7 +4265,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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() @@ -4279,7 +4283,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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() @@ -4297,7 +4301,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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() @@ -4315,7 +4319,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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() @@ -4333,7 +4337,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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. /// @@ -4348,7 +4352,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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() @@ -4366,7 +4370,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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() @@ -4384,7 +4388,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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() @@ -4402,7 +4406,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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() @@ -4420,7 +4424,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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() @@ -4438,7 +4442,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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() @@ -4456,7 +4460,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -4473,7 +4477,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -4490,7 +4494,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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. /// @@ -4507,7 +4511,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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() @@ -4525,7 +4529,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -4542,7 +4546,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -4557,7 +4561,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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. @@ -4625,7 +4629,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 /// @@ -4633,7 +4637,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 /// @@ -4644,7 +4648,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. /// @@ -4654,7 +4658,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. /// @@ -4664,7 +4668,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 /// @@ -4674,7 +4678,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. /// @@ -4683,7 +4687,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. /// @@ -4692,7 +4696,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 /// @@ -4705,7 +4709,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. /// @@ -4718,7 +4722,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. /// @@ -4731,7 +4735,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. /// @@ -4744,7 +4748,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. /// @@ -4756,7 +4760,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. /// @@ -4768,7 +4772,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. /// @@ -4780,7 +4784,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 /// @@ -4792,7 +4796,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 /// @@ -4806,7 +4810,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 /// @@ -4820,7 +4824,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 /// @@ -4834,7 +4838,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. /// @@ -4847,7 +4851,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. /// @@ -4860,7 +4864,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. /// @@ -4873,7 +4877,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 /// @@ -4888,7 +4892,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 /// @@ -4902,7 +4906,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 /// @@ -4916,7 +4920,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 /// @@ -4930,7 +4934,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 /// @@ -4944,7 +4948,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 /// @@ -4957,7 +4961,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 /// @@ -4970,7 +4974,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 /// @@ -4983,7 +4987,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 /// @@ -4996,7 +5000,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 /// @@ -5009,7 +5013,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 /// @@ -5022,7 +5026,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 /// @@ -5034,7 +5038,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 /// @@ -5046,7 +5050,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 /// @@ -5058,7 +5062,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 /// @@ -5070,7 +5074,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 /// @@ -5083,7 +5087,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 /// @@ -5096,7 +5100,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 /// @@ -5109,7 +5113,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 /// @@ -5122,7 +5126,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 /// @@ -5134,7 +5138,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 /// @@ -5146,7 +5150,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 /// @@ -5158,7 +5162,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 /// @@ -5170,7 +5174,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 /// @@ -5182,7 +5186,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 /// @@ -5194,7 +5198,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 /// @@ -5205,7 +5209,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 /// @@ -5216,7 +5220,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 /// @@ -5227,7 +5231,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 /// @@ -5238,7 +5242,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 /// @@ -5252,7 +5256,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 /// @@ -5261,207 +5265,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 = @@ -5494,7 +5498,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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. @@ -5503,7 +5507,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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. @@ -5512,7 +5516,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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. @@ -5527,7 +5531,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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 /// @@ -5538,7 +5542,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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 /// @@ -5549,7 +5553,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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 /// @@ -5560,7 +5564,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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 /// @@ -5582,7 +5586,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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 /// @@ -5594,7 +5598,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -5606,7 +5610,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -5618,7 +5622,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -5629,7 +5633,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 = @@ -5641,7 +5645,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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) /// @@ -5652,7 +5656,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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) /// @@ -5663,7 +5667,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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) /// @@ -5674,7 +5678,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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 @@ -5688,7 +5692,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -5702,7 +5706,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -5716,7 +5720,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -5730,7 +5734,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -5744,7 +5748,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -5758,7 +5762,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -5772,7 +5776,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -5786,7 +5790,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -5800,7 +5804,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -5813,7 +5817,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -5826,7 +5830,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -5840,7 +5844,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -5861,7 +5865,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. /// @@ -5869,13 +5873,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. /// @@ -5908,12 +5912,16 @@ 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. /// From 4169aaed4321830e32788288076d9b32ec4334fe Mon Sep 17 00:00:00 2001 From: Don Syme Date: Mon, 11 Oct 2021 12:58:52 +0100 Subject: [PATCH 6/7] Update prim-types.fsi --- src/fsharp/FSharp.Core/prim-types.fsi | 573 +++++++++++++------------- 1 file changed, 285 insertions(+), 288 deletions(-) diff --git a/src/fsharp/FSharp.Core/prim-types.fsi b/src/fsharp/FSharp.Core/prim-types.fsi index 2bb91802ea2..67c395c75ef 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 InvokeFas : 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 @@ -2635,7 +2632,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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 /// @@ -2651,7 +2648,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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 subtraction operator /// @@ -2665,7 +2662,7 @@ namespace Microsoft.FSharp.Core /// 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 + 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 /// @@ -2679,7 +2676,7 @@ namespace Microsoft.FSharp.Core /// 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 + 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 /// @@ -2693,7 +2690,7 @@ namespace Microsoft.FSharp.Core /// 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 + 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 /// @@ -2707,7 +2704,7 @@ namespace Microsoft.FSharp.Core /// 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 + 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 /// @@ -2741,7 +2738,7 @@ namespace Microsoft.FSharp.Core /// /// Evaluates to 15 /// - val inline (|||) : x: ^T -> y: ^T -> ^T when ^T : (static member (|||) : ^T * ^T -> ^T) and default ^T : int + val inline (|||): x: ^T -> y: ^T -> ^T when ^T : (static member (|||) : ^T * ^T -> ^T) and default ^T : int /// Overloaded bitwise-XOR operator /// @@ -2774,7 +2771,7 @@ namespace Microsoft.FSharp.Core /// /// Evaluates to 206 /// - val inline (<<<) : value: ^T -> shift: int32 -> ^T when ^T : (static member (<<<) : ^T * int32 -> ^T) and default ^T : int + 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 /// @@ -2792,7 +2789,7 @@ namespace Microsoft.FSharp.Core /// Evaluates to 3 /// /// - val inline (>>>) : value: ^T -> shift: int32 -> ^T when ^T : (static member (>>>) : ^T * int32 -> ^T) and default ^T : int + val inline (>>>): value: ^T -> shift: int32 -> ^T when ^T : (static member (>>>) : ^T * int32 -> ^T) and default ^T : int /// Overloaded bitwise-NOT operator /// @@ -2808,7 +2805,7 @@ namespace Microsoft.FSharp.Core /// Evaluates to 195 /// /// - 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 prefix-plus operator /// @@ -2818,7 +2815,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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 /// @@ -2921,7 +2918,7 @@ namespace Microsoft.FSharp.Core /// /// /// - val inline (<>) : x:'T -> y:'T -> bool when 'T : equality + val inline (<>): x:'T -> y:'T -> bool when 'T : equality /// Compose two functions, the function on the left being applied first /// @@ -3237,7 +3234,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -3255,7 +3252,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -3273,7 +3270,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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. /// @@ -3356,7 +3353,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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. /// @@ -3364,7 +3361,7 @@ 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. /// @@ -5293,7 +5290,7 @@ namespace Microsoft.FSharp.Core /// 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 [] From 808a318eeb844110bddb38bc9a0f357fedbad99f Mon Sep 17 00:00:00 2001 From: Don Syme Date: Mon, 11 Oct 2021 13:30:21 +0100 Subject: [PATCH 7/7] Update prim-types.fsi --- src/fsharp/FSharp.Core/prim-types.fsi | 229 +++++++++++++------------- 1 file changed, 114 insertions(+), 115 deletions(-) diff --git a/src/fsharp/FSharp.Core/prim-types.fsi b/src/fsharp/FSharp.Core/prim-types.fsi index 67c395c75ef..f4bb2eccc87 100644 --- a/src/fsharp/FSharp.Core/prim-types.fsi +++ b/src/fsharp/FSharp.Core/prim-types.fsi @@ -2071,7 +2071,7 @@ namespace Microsoft.FSharp.Core /// The third arg. /// /// The function result. - static member InvokeFas : 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. @@ -2137,7 +2137,7 @@ namespace Microsoft.FSharp.Core /// 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 /// @@ -2648,7 +2648,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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 subtraction operator /// @@ -2662,7 +2662,7 @@ namespace Microsoft.FSharp.Core /// 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 + 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 /// @@ -2676,7 +2676,7 @@ namespace Microsoft.FSharp.Core /// 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 + 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 /// @@ -2690,7 +2690,7 @@ namespace Microsoft.FSharp.Core /// 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 + 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 /// @@ -2704,7 +2704,7 @@ namespace Microsoft.FSharp.Core /// 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 + 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 /// @@ -2721,7 +2721,7 @@ namespace Microsoft.FSharp.Core /// /// Evaluates to 9 /// - val inline (&&&): x: ^T -> y: ^T -> ^T when ^T : (static member (&&&) : ^T * ^T -> ^T) and default ^T : int + val inline (&&&): x: ^T -> y: ^T -> ^T when ^T: (static member (&&&): ^T * ^T -> ^T) and default ^T: int /// Overloaded bitwise-OR operator /// @@ -2738,7 +2738,7 @@ namespace Microsoft.FSharp.Core /// /// Evaluates to 15 /// - val inline (|||): x: ^T -> y: ^T -> ^T when ^T : (static member (|||) : ^T * ^T -> ^T) and default ^T : int + val inline (|||): x: ^T -> y: ^T -> ^T when ^T: (static member (|||): ^T * ^T -> ^T) and default ^T: int /// Overloaded bitwise-XOR operator /// @@ -2755,7 +2755,7 @@ namespace Microsoft.FSharp.Core /// /// Evaluates to 6 /// - val inline (^^^) : x: ^T -> y: ^T -> ^T when ^T : (static member (^^^) : ^T * ^T -> ^T) and default ^T : int + 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 /// @@ -2789,7 +2789,7 @@ namespace Microsoft.FSharp.Core /// Evaluates to 3 /// /// - val inline (>>>): value: ^T -> shift: int32 -> ^T when ^T : (static member (>>>) : ^T * int32 -> ^T) and default ^T : int + val inline (>>>): value: ^T -> shift: int32 -> ^T when ^T: (static member (>>>): ^T * int32 -> ^T) and default ^T: int /// Overloaded bitwise-NOT operator /// @@ -2805,7 +2805,7 @@ namespace Microsoft.FSharp.Core /// Evaluates to 195 /// /// - 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 prefix-plus operator /// @@ -2815,7 +2815,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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 /// @@ -2849,7 +2849,7 @@ namespace Microsoft.FSharp.Core /// /// /// - val inline (>): x: 'T -> y: 'T -> bool when 'T : comparison + val inline (>): x: 'T -> y: 'T -> bool when 'T: comparison /// Structural greater-than-or-equal /// @@ -2883,7 +2883,7 @@ namespace Microsoft.FSharp.Core /// /// /// - val inline (<=): x: 'T -> y: 'T -> bool when 'T : comparison + val inline (<=): x: 'T -> y: 'T -> bool when 'T: comparison /// Structural equality /// @@ -2901,7 +2901,7 @@ namespace Microsoft.FSharp.Core /// /// /// - val inline (=): x: 'T -> y: 'T -> bool when 'T : equality + val inline (=): x: 'T -> y: 'T -> bool when 'T: equality /// Structural inequality /// @@ -3617,7 +3617,7 @@ namespace Microsoft.FSharp.Core /// /// [] - val exit: exitcode: int -> 'T when default 'T : obj + val exit: exitcode: int -> 'T when default 'T: obj /// Equivalent to [] @@ -3666,11 +3666,11 @@ namespace Microsoft.FSharp.Core /// /// 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 + 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 /// @@ -3689,12 +3689,12 @@ namespace Microsoft.FSharp.Core /// /// 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 + 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. /// @@ -3743,7 +3743,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -3852,7 +3852,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -3883,7 +3883,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -3916,7 +3916,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -3932,7 +3932,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -3951,7 +3951,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -3967,7 +3967,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -4001,7 +4001,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -4017,7 +4017,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -4052,7 +4052,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -4070,7 +4070,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -4101,7 +4101,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -4131,7 +4131,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -4146,7 +4146,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -4161,7 +4161,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -4176,7 +4176,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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. /// @@ -4191,7 +4191,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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. /// @@ -4206,7 +4206,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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. /// @@ -4223,10 +4223,10 @@ namespace Microsoft.FSharp.Core /// [] 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 + 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() @@ -4244,7 +4244,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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() @@ -4262,7 +4262,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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() @@ -4280,7 +4280,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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() @@ -4298,7 +4298,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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() @@ -4316,7 +4316,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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() @@ -4349,7 +4349,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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() @@ -4367,7 +4367,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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() @@ -4385,7 +4385,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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() @@ -4421,7 +4421,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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() @@ -4439,7 +4439,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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() @@ -4457,7 +4457,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -4474,7 +4474,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -4491,7 +4491,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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. /// @@ -4526,7 +4526,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -4543,7 +4543,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -4874,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 /// @@ -4889,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 /// @@ -4903,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 /// @@ -4917,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 /// @@ -4931,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 /// @@ -4945,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 /// @@ -4958,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 /// @@ -4971,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 /// @@ -4984,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 /// @@ -4997,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 /// @@ -5010,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 /// @@ -5023,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 /// @@ -5035,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 /// @@ -5047,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 /// @@ -5059,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 /// @@ -5071,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 /// @@ -5084,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 /// @@ -5097,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 /// @@ -5110,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 /// @@ -5123,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 /// @@ -5135,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 /// @@ -5306,7 +5306,7 @@ namespace Microsoft.FSharp.Core /// 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 [] @@ -5528,7 +5528,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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 /// @@ -5539,7 +5539,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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 /// @@ -5550,7 +5550,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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 /// @@ -5561,7 +5561,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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 /// @@ -5572,7 +5572,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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 /// @@ -5583,7 +5583,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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 /// @@ -5595,7 +5595,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -5607,7 +5607,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -5619,7 +5619,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 /// @@ -5630,7 +5630,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 = @@ -5642,7 +5642,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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) /// @@ -5653,7 +5653,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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) /// @@ -5664,7 +5664,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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) /// @@ -5675,7 +5675,7 @@ namespace Microsoft.FSharp.Core /// /// /// - 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 @@ -5689,7 +5689,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -5703,7 +5703,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -5717,7 +5717,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -5731,7 +5731,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -5745,7 +5745,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -5759,7 +5759,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -5773,7 +5773,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -5787,7 +5787,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -5801,7 +5801,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -5814,7 +5814,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -5827,7 +5827,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -5841,8 +5841,7 @@ namespace Microsoft.FSharp.Core /// /// [] - 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 @@ -5924,7 +5923,7 @@ namespace Microsoft.FSharp.Control /// /// 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>