Operators (fsharp-core-docs)

Operators Module

Namespace: FSharp.Core
Assembly: FSharp.Core.dll

Basic F# Operators. This module is automatically opened in all F# code.

Nested modules

Modules	Description
ArrayExtensions	Contains extension methods to allow the use of F# indexer notation with arrays. This module is automatically opened in all F# code.
Checked	This module contains the basic arithmetic operations with overflow checks.
NonStructuralComparison	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.
OperatorIntrinsics	A module of compiler intrinsic functions for efficient implementations of F# integer ranges and dynamic invocations of other F# operators
Unchecked	This module contains basic operations which do not apply runtime and/or static checks

Functions and values

Function or value	Description
`x y` Full Usage: `x y` Parameters: x : `^T` - The input base. y : `^U` - The input exponent. Returns: `^T` The base raised to the exponent. Modifiers: inline Type parameters: ^T, ^U	Overloaded power operator. x : `^T` The input base. y : `^U` The input exponent. Returns: `^T` The base raised to the exponent. Example `2.0 ** 3 // evaluates to 8.0`
`!cell` Full Usage: `!cell` Parameters: cell : `'T ref` - The cell to dereference. Returns: `'T` The value contained in the cell.	Dereference a mutable reference cell cell : `'T ref` The cell to dereference. Returns: `'T` The value contained in the cell. Example `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 count: int ref Multiple items val ref: value: 'T -> 'T ref -------------------- type 'T ref = Ref<'T> property Ref.Value: int with get, set
`x % y` Full Usage: `x % y` Parameters: x : `^T1` - The first parameter. y : `^T2` - The second parameter. Returns: `^T3` The result of the operation. Modifiers: inline Type parameters: ^T1, ^T2, ^T3	Overloaded modulo operator x : `^T1` The first parameter. y : `^T2` The second parameter. Returns: `^T3` The result of the operation. Example `29 % 5 // Evaluates to 4`
`x &&& y` Full Usage: `x &&& y` Parameters: x : `^T` - The first parameter. y : `^T` - The second parameter. Returns: `^T` The result of the operation. Modifiers: inline Type parameters: ^T	Overloaded bitwise-AND operator x : `^T` The first parameter. y : `^T` The second parameter. Returns: `^T` The result of the operation. Example `let a = 13 // 00000000000000000000000000001101 let b = 11 // 00000000000000000000000000001011 let c = a &&& b // 00000000000000000000000000001001` val a: int val b: int val c: int Evaluates to 9
`x * y` Full Usage: `x * y` Parameters: x : `^T1` - The first parameter. y : `^T2` - The second parameter. Returns: `^T3` The result of the operation. Modifiers: inline Type parameters: ^T1, ^T2, ^T3	Overloaded multiplication operator x : `^T1` The first parameter. y : `^T2` The second parameter. Returns: `^T3` The result of the operation. Example `8 * 6 // Evaluates to 48`
`x + y` Full Usage: `x + y` Parameters: x : `^T1` - The first parameter. y : `^T2` - The second parameter. Returns: `^T3` The result of the operation. Modifiers: inline Type parameters: ^T1, ^T2, ^T3	Overloaded addition operator x : `^T1` The first parameter. y : `^T2` The second parameter. Returns: `^T3` The result of the operation. Example `2 + 2 // Evaluates to 4 "Hello " + "Word" // Evaluates to "Hello World"`
`x - y` Full Usage: `x - y` Parameters: x : `^T1` - The first parameter. y : `^T2` - The second parameter. Returns: `^T3` The result of the operation. Modifiers: inline Type parameters: ^T1, ^T2, ^T3	Overloaded subtraction operator x : `^T1` The first parameter. y : `^T2` The second parameter. Returns: `^T3` The result of the operation. Example `10 - 2 // Evaluates to 8`
`(....) start step finish` Full Usage: `(....) start step finish` Parameters: start : `^T` - The start value of the range. step : `^Step` - The step value of the range. finish : `^T` - The end value of the range. Returns: `seq<^T>` The sequence spanning the range using the specified step size. Modifiers: inline Type parameters: ^T, ^Step	The standard overloaded skip range operator, e.g. `[n..skip..m]` for lists, `seq {n..skip..m}` for sequences start : `^T` The start value of the range. step : `^Step` The step value of the range. finish : `^T` The end value of the range. Returns: `seq<^T>` The sequence spanning the range using the specified step size. Example `[1..2..6] // Evaluates to [1; 3; 5] [1.1..0.2..1.5] // Evaluates to [1.1; 1.3; 1.5] ['a'..'e'] // Evaluates to ['a'; 'b'; 'c'; 'd'; 'e']`
`(..) start finish` Full Usage: `(..) start finish` Parameters: start : `^T` - The start value of the range. finish : `^T` - The end value of the range. Returns: `seq<^T>` The sequence spanning the range. Modifiers: inline Type parameters: ^T	The standard overloaded range operator, e.g. `[n..m]` for lists, `seq {n..m}` for sequences start : `^T` The start value of the range. finish : `^T` The end value of the range. Returns: `seq<^T>` The sequence spanning the range. Example `[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])`
`x / y` Full Usage: `x / y` Parameters: x : `^T1` - The first parameter. y : `^T2` - The second parameter. Returns: `^T3` The result of the operation. Modifiers: inline Type parameters: ^T1, ^T2, ^T3	Overloaded division operator x : `^T1` The first parameter. y : `^T2` The second parameter. Returns: `^T3` The result of the operation. Example `16 / 2 // Evaluates to 8`
`cell := value` Full Usage: `cell := value` Parameters: cell : `'T ref` - The cell to mutate. value : `'T` - The value to set inside the cell.	Assign to a mutable reference cell cell : `'T ref` The cell to mutate. value : `'T` The value to set inside the cell. Example `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 count: int ref Multiple items val ref: value: 'T -> 'T ref -------------------- type 'T ref = Ref<'T> property Ref.Value: int with get, set
`x < y` Full Usage: `x < y` Parameters: x : `'T` - The first parameter. y : `'T` - The second parameter. Returns: `bool` The result of the comparison. Modifiers: inline Type parameters: 'T	Structural less-than comparison x : `'T` The first parameter. y : `'T` The second parameter. Returns: `bool` The result of the comparison. Example `1 < 5 // Evaluates to true 5 < 5 // Evaluates to false (1, "a") < (1, "z") // Evaluates to true`
`func2 << func1` Full Usage: `func2 << func1` Parameters: func2 : `'T2 -> 'T3` - The second function to apply. func1 : `'T1 -> 'T2` - The first function to apply. Returns: `'T1 -> 'T3` The composition of the input functions. Modifiers: inline Type parameters: 'T2, 'T3, 'T1	Compose two functions, the function on the right being applied first func2 : `'T2 -> 'T3` The second function to apply. func1 : `'T1 -> 'T2` The first function to apply. Returns: `'T1 -> 'T3` The composition of the input functions. Example `let addOne x = x + 1 let doubleIt x = x * 2 let doubleThenAdd = addOne << doubleIt doubleThenAdd 3` val addOne: x: int -> int val x: int val doubleIt: x: int -> int val doubleThenAdd: (int -> int)
`value <<< shift` Full Usage: `value <<< shift` Parameters: value : `^T` - The input value. shift : `int32` - The amount to shift. Returns: `^T` The result of the operation. Modifiers: inline Type parameters: ^T	Overloaded byte-shift left operator by a specified number of bits value : `^T` The input value. shift : `int32` The amount to shift. Returns: `^T` The result of the operation. Example `let a = 13 // 00000000000000000000000000001101 let c = a <<< 4 // 00000000000000000000000011010000` val a: int val c: int Evaluates to 208
`x <= y` Full Usage: `x <= y` Parameters: x : `'T` - The first parameter. y : `'T` - The second parameter. Returns: `bool` The result of the comparison. Modifiers: inline Type parameters: 'T	Structural less-than-or-equal comparison x : `'T` The first parameter. y : `'T` The second parameter. Returns: `bool` The result of the comparison. Example `5 <= 1 // Evaluates to false 5 <= 5 // Evaluates to true [1; 5] <= [1; 6] // Evaluates to true`
`x <> y` Full Usage: `x <> y` Parameters: x : `'T` - The first parameter. y : `'T` - The second parameter. Returns: `bool` The result of the comparison. Modifiers: inline Type parameters: 'T	Structural inequality x : `'T` The first parameter. y : `'T` The second parameter. Returns: `bool` The result of the comparison. Example `5 <> 5 // Evaluates to false 5 <> 6 // Evaluates to true [1; 2] <> [1; 2] // Evaluates to false`
`func <\| arg1` Full Usage: `func <\| arg1` Parameters: func : `'T -> 'U` - The function. arg1 : `'T` - The argument. Returns: `'U` The function result. Modifiers: inline Type parameters: 'T, 'U	Apply a function to a value, the value being on the right, the function on the left func : `'T -> 'U` The function. arg1 : `'T` The argument. Returns: `'U` The function result. Example `let doubleIt x = x * 2 doubleIt <\| 3 // Evaluates to 6` val doubleIt: x: int -> int val x: int
`(<\|\|) func (arg1, arg2)` Full Usage: `(<\|\|) func (arg1, arg2)` Parameters: func : `'T1 -> 'T2 -> 'U` - The function. arg1 : `'T1` - The first argument. arg2 : `'T2` - The second argument. Returns: `'U` The function result. Modifiers: inline Type parameters: 'T1, 'T2, 'U	Apply a function to two values, the values being a pair on the right, the function on the left func : `'T1 -> 'T2 -> 'U` The function. arg1 : `'T1` The first argument. arg2 : `'T2` The second argument. Returns: `'U` The function result. Example `let sum x y = x + y sum <\|\| (3, 4) // Evaluates to 7` val sum: x: int -> y: int -> int val x: int val y: int
`(<\|\|\|) func (arg1, arg2, arg3)` Full Usage: `(<\|\|\|) func (arg1, arg2, arg3)` Parameters: func : `'T1 -> 'T2 -> 'T3 -> 'U` - The function. arg1 : `'T1` - The first argument. arg2 : `'T2` - The second argument. arg3 : `'T3` - The third argument. Returns: `'U` The function result. Modifiers: inline Type parameters: 'T1, 'T2, 'T3, 'U	Apply a function to three values, the values being a triple on the right, the function on the left func : `'T1 -> 'T2 -> 'T3 -> 'U` The function. arg1 : `'T1` The first argument. arg2 : `'T2` The second argument. arg3 : `'T3` The third argument. Returns: `'U` The function result. Example `let sum3 x y z = x + y + z sum3 <\|\|\| (3, 4, 5) // Evaluates to 12` val sum3: x: int -> y: int -> z: int -> int val x: int val y: int val z: int
`x = y` Full Usage: `x = y` Parameters: x : `'T` - The first parameter. y : `'T` - The second parameter. Returns: `bool` The result of the comparison. Modifiers: inline Type parameters: 'T	Structural equality x : `'T` The first parameter. y : `'T` The second parameter. Returns: `bool` The result of the comparison. Example `5 = 5 // Evaluates to true 5 = 6 // Evaluates to false [1; 2] = [1; 2] // Evaluates to true (1, 5) = (1, 6) // Evaluates to false`
`x > y` Full Usage: `x > y` Parameters: x : `'T` - The first parameter. y : `'T` - The second parameter. Returns: `bool` The result of the comparison. Modifiers: inline Type parameters: 'T	Structural greater-than x : `'T` The first parameter. y : `'T` The second parameter. Returns: `bool` The result of the comparison. Example `5 > 1 // Evaluates to true 5 > 5 // Evaluates to false (1, "a") > (1, "z") // Evaluates to false`
`x >= y` Full Usage: `x >= y` Parameters: x : `'T` - The first parameter. y : `'T` - The second parameter. Returns: `bool` The result of the comparison. Modifiers: inline Type parameters: 'T	Structural greater-than-or-equal x : `'T` The first parameter. y : `'T` The second parameter. Returns: `bool` The result of the comparison. Example `5 >= 1 // Evaluates to true 5 >= 5 // Evaluates to true [1; 5] >= [1; 6] // Evaluates to false`
`func1 >> func2` Full Usage: `func1 >> func2` Parameters: func1 : `'T1 -> 'T2` - The first function to apply. func2 : `'T2 -> 'T3` - The second function to apply. Returns: `'T1 -> 'T3` The composition of the input functions. Modifiers: inline Type parameters: 'T1, 'T2, 'T3	Compose two functions, the function on the left being applied first func1 : `'T1 -> 'T2` The first function to apply. func2 : `'T2 -> 'T3` The second function to apply. Returns: `'T1 -> 'T3` The composition of the input functions. Example `let addOne x = x + 1 let doubleIt x = x * 2 let addThenDouble = addOne >> doubleIt addThenDouble 3 // Evaluates to 8` val addOne: x: int -> int val x: int val doubleIt: x: int -> int val addThenDouble: (int -> int)
`value >>> shift` Full Usage: `value >>> shift` Parameters: value : `^T` - The input value. shift : `int32` - The amount to shift. Returns: `^T` The result of the operation. Modifiers: inline Type parameters: ^T	Overloaded byte-shift right operator by a specified number of bits value : `^T` The input value. shift : `int32` The amount to shift. Returns: `^T` The result of the operation. Example `let a = 206 // 00000000000000000000000011010000 let c1 = a >>> 2 // 00000000000000000000000000110100 // Evaluates to 51 let c2 = a >>> 6 // 00000000000000000000000000000011 Evaluates to 3` val a: int val c1: int val c2: int
`list1 @ list2` Full Usage: `list1 @ list2` Parameters: list1 : `'T list` - The first list. list2 : `'T list` - The second list. Returns: `'T list` The concatenation of the lists.	Concatenate two lists. list1 : `'T list` The first list. list2 : `'T list` The second list. Returns: `'T list` The concatenation of the lists. Example `let l1 = ['a'; 'b'; 'c'] let l2 = ['d'; 'e'; 'f'] l1 @ l2 // Evalulates to ['a'; 'b'; 'c'; 'd'; 'e'; 'f']` val l1: char list val l2: char list
`s1 ^ s2` Full Usage: `s1 ^ s2` Parameters: s1 : `string` s2 : `string` Returns: `string`	Concatenate two strings. The operator '+' may also be used. s1 : `string` s2 : `string` Returns: `string`
`x ^^^ y` Full Usage: `x ^^^ y` Parameters: x : `^T` - The first parameter. y : `^T` - The second parameter. Returns: `^T` The result of the operation. Modifiers: inline Type parameters: ^T	Overloaded bitwise-XOR operator x : `^T` The first parameter. y : `^T` The second parameter. Returns: `^T` The result of the operation. Example `let a = 13 // 00000000000000000000000000001101 let b = 11 // 00000000000000000000000000001011 let c = a ^^^ b // 00000000000000000000000000000110` val a: int val b: int val c: int Evaluates to 6
`arg \|> func` Full Usage: `arg \|> func` Parameters: arg : `'T1` - The argument. func : `'T1 -> 'U` - The function. Returns: `'U` The function result. Modifiers: inline Type parameters: 'T1, 'U	Apply a function to a value, the value being on the left, the function on the right arg : `'T1` The argument. func : `'T1 -> 'U` The function. Returns: `'U` The function result. Example `let doubleIt x = x * 2 3 \|> doubleIt // Evaluates to 6` val doubleIt: x: int -> int val x: int
`(\|\|>) (arg1, arg2) func` Full Usage: `(\|\|>) (arg1, arg2) func` Parameters: arg1 : `'T1` - The first argument. arg2 : `'T2` - The second argument. func : `'T1 -> 'T2 -> 'U` - The function. Returns: `'U` The function result. Modifiers: inline Type parameters: 'T1, 'T2, 'U	Apply a function to two values, the values being a pair on the left, the function on the right arg1 : `'T1` The first argument. arg2 : `'T2` The second argument. func : `'T1 -> 'T2 -> 'U` The function. Returns: `'U` The function result. Example `let sum x y = x + y (3, 4) \|\|> sum // Evaluates to 7` val sum: x: int -> y: int -> int val x: int val y: int
`x \|\|\| y` Full Usage: `x \|\|\| y` Parameters: x : `^T` - The first parameter. y : `^T` - The second parameter. Returns: `^T` The result of the operation. Modifiers: inline Type parameters: ^T	Overloaded bitwise-OR operator x : `^T` The first parameter. y : `^T` The second parameter. Returns: `^T` The result of the operation. Example `let a = 13 // 00000000000000000000000000001101 let b = 11 // 00000000000000000000000000001011 let c = a \|\|\| b // 00000000000000000000000000001111` val a: int val b: int val c: int Evaluates to 15
`(\|\|\|>) (arg1, arg2, arg3) func` Full Usage: `(\|\|\|>) (arg1, arg2, arg3) func` Parameters: arg1 : `'T1` - The first argument. arg2 : `'T2` - The second argument. arg3 : `'T3` - The third argument. func : `'T1 -> 'T2 -> 'T3 -> 'U` - The function. Returns: `'U` The function result. Modifiers: inline Type parameters: 'T1, 'T2, 'T3, 'U	Apply a function to three values, the values being a triple on the left, the function on the right arg1 : `'T1` The first argument. arg2 : `'T2` The second argument. arg3 : `'T3` The third argument. func : `'T1 -> 'T2 -> 'T3 -> 'U` The function. Returns: `'U` The function result. Example `let sum3 x y z = x + y + z (3, 4, 5) \|\|\|> sum3 // Evaluates to 12` val sum3: x: int -> y: int -> z: int -> int val x: int val y: int val z: int
`~+value` Full Usage: `~+value` Parameters: value : `^T` - The input value. Returns: `^T` The result of the operation. Modifiers: inline Type parameters: ^T	Overloaded prefix-plus operator value : `^T` The input value. Returns: `^T` The result of the operation.
`~-n` Full Usage: `~-n` Parameters: n : `^T` - The value to negate. Returns: `^T` The result of the operation. Modifiers: inline Type parameters: ^T	Overloaded unary negation. n : `^T` The value to negate. Returns: `^T` The result of the operation.
`~~~value` Full Usage: `~~~value` Parameters: value : `^T` - The input value. Returns: `^T` The result of the operation. Modifiers: inline Type parameters: ^T	Overloaded bitwise-NOT operator value : `^T` The input value. Returns: `^T` The result of the operation. Example `let byte1 = 60uy // 00111100 let byte2 = ~~~b1 // 11000011` val byte1: byte val byte2: int Evaluates to 195
`Failure message` Full Usage: `Failure message` Parameters: message : `string` - The message for the Exception. Returns: `exn` A System.Exception.	Builds a Exception object. message : `string` The message for the Exception. Returns: `exn` A System.Exception. Example `let throwException() = raise(Failure("Oh no!!!")) true // Never gets here throwException() // Throws a generic Exception class` val throwException: unit -> bool val raise: exn: System.Exception -> 'T Multiple items val Failure: message: string -> exn -------------------- active recognizer Failure: exn -> string option
``not`` value Full Usage: ``not`` value Parameters: value : `bool` - The value to negate. Returns: `bool` The result of the negation. Modifiers: inline	Negate a logical value. Not True equals False and not False equals True value : `bool` The value to negate. Returns: `bool` The result of the negation. Example `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 fileDoesNotExist: (string -> bool) namespace System namespace System.IO type File = static member AppendAllLines: path: string * contents: IEnumerable<string> -> unit + 1 overload static member AppendAllLinesAsync: path: string * contents: IEnumerable<string> * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload static member AppendAllText: path: string * contents: string -> unit + 1 overload static member AppendAllTextAsync: path: string * contents: string * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload static member AppendText: path: string -> StreamWriter static member Copy: sourceFileName: string * destFileName: string -> unit + 1 overload static member Create: path: string -> FileStream + 2 overloads static member CreateSymbolicLink: path: string * pathToTarget: string -> FileSystemInfo static member CreateText: path: string -> StreamWriter static member Decrypt: path: string -> unit ... <summary>Provides static methods for the creation, copying, deletion, moving, and opening of a single file, and aids in the creation of <see cref="T:System.IO.FileStream" /> objects.</summary> System.IO.File.Exists(path: string) : bool
`abs value` Full Usage: `abs value` Parameters: value : `^T` - The input value. Returns: `^T` The absolute value of the input. Modifiers: inline Type parameters: ^T	Absolute value of the given number. value : `^T` The input value. Returns: `^T` The absolute value of the input. Example `abs -12 // Evaluates to 12 abs -15.0 // Evaluates to 15.0` val abs: value: 'T -> 'T (requires member Abs)
`acos value` Full Usage: `acos value` Parameters: value : `^T` - The input value. Returns: `^T` The inverse cosine of the input. Modifiers: inline Type parameters: ^T	Inverse cosine of the given number value : `^T` The input value. Returns: `^T` The inverse cosine of the input. Example `let angleFromAdjacent adjacent hypotenuse = acos(adjacent / hypotenuse) angleFromAdjacent 8.0 10.0 // Evaluates to 0.6435011088` val angleFromAdjacent: adjacent: float -> hypotenuse: float -> float val adjacent: float val hypotenuse: float val acos: value: 'T -> 'T (requires member Acos)
`asin value` Full Usage: `asin value` Parameters: value : `^T` - The input value. Returns: `^T` The inverse sine of the input. Modifiers: inline Type parameters: ^T	Inverse sine of the given number value : `^T` The input value. Returns: `^T` The inverse sine of the input. Example `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 angleFromOpposite: opposite: float -> hypotenuse: float -> float val opposite: float val hypotenuse: float val asin: value: 'T -> 'T (requires member Asin)
`atan value` Full Usage: `atan value` Parameters: value : `^T` - The input value. Returns: `^T` The inverse tangent of the input. Modifiers: inline Type parameters: ^T	Inverse tangent of the given number value : `^T` The input value. Returns: `^T` The inverse tangent of the input. Example `let angleFrom opposite adjacent = atan(opposite / adjacent) angleFrom 5.0 5.0 // Evaluates to 0.7853981634` val angleFrom: opposite: float -> adjacent: float -> float val opposite: float val adjacent: float val atan: value: 'T -> 'T (requires member Atan)
`atan2 y x` Full Usage: `atan2 y x` Parameters: y : `^T1` - The y input value. x : `^T1` - The x input value. Returns: `'T2` The inverse tangent of the input ratio. Modifiers: inline Type parameters: ^T1, 'T2	Inverse tangent of `x/y` where `x` and `y` are specified separately y : `^T1` The y input value. x : `^T1` The x input value. Returns: `'T2` The inverse tangent of the input ratio. Example `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 angleFromPlaneAtXY: x: float -> y: float -> float val x: float val y: float val atan2: y: 'T1 -> x: 'T1 -> 'T2 (requires member Atan2) namespace System type Math = static member Abs: value: decimal -> decimal + 7 overloads static member Acos: d: float -> float static member Acosh: d: float -> float static member Asin: d: float -> float static member Asinh: d: float -> float static member Atan: d: float -> float static member Atan2: y: float * x: float -> float static member Atanh: d: float -> float static member BigMul: a: int * b: int -> int64 + 2 overloads static member BitDecrement: x: float -> float ... <summary>Provides constants and static methods for trigonometric, logarithmic, and other common mathematical functions.</summary> field System.Math.PI: float = 3.14159265359
`box value` Full Usage: `box value` Parameters: value : `'T` - The value to box. Returns: `obj` The boxed object. Modifiers: inline Type parameters: 'T	Boxes a strongly typed value. value : `'T` The value to box. Returns: `obj` The boxed object. Example `let x: int = 123 let obj1 = box x // obj1 is a generic object type unbox<int> obj1 // Evaluates to 123 (int) unbox<double> obj1 // Throws System.InvalidCastException` val x: int Multiple items val int: value: 'T -> int (requires member op_Explicit) -------------------- type int = int32 -------------------- type int<'Measure> = int val obj1: obj val box: value: 'T -> obj val unbox: value: obj -> 'T Multiple items val double: value: 'T -> double (requires member op_Explicit) -------------------- type double = System.Double -------------------- type double<'Measure> = float<'Measure>
`byte value` Full Usage: `byte value` Parameters: value : `^T` - The input value. Returns: `byte` The converted byte Modifiers: inline Type parameters: ^T	Converts the argument to byte. This is a direct conversion for all primitive numeric types. For strings, the input is converted using `Byte.Parse()` with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type. value : `^T` The input value. Returns: `byte` The converted byte Example `byte 'A' // evaluates to 65uy byte 0xff // evaluates to 255uy byte -10 // evaluates to 246uy` Multiple items val byte: value: 'T -> byte (requires member op_Explicit) -------------------- type byte = System.Byte -------------------- type byte<'Measure> = byte
`ceil value` Full Usage: `ceil value` Parameters: value : `^T` - The input value. Returns: `^T` The ceiling of the input. Modifiers: inline Type parameters: ^T	Ceiling of the given number value : `^T` The input value. Returns: `^T` The ceiling of the input. Example `ceil 12.1 // Evaluates to 13.0 ceil -1.9 // Evaluates to -1.0` val ceil: value: 'T -> 'T (requires member Ceiling)
`char value` Full Usage: `char value` Parameters: value : `^T` - The input value. Returns: `char` The converted char. Modifiers: inline Type parameters: ^T	Converts the argument to character. Numeric inputs are converted according to the UTF-16 encoding for characters. String inputs must be exactly one character long. For other input types the operation requires an appropriate static conversion method on the input type. value : `^T` The input value. Returns: `char` The converted char. Example `char "A" // evaluates to 'A' char 0x41 // evaluates to 'A' char 65 // evaluates to 'A'` Multiple items val char: value: 'T -> char (requires member op_Explicit) -------------------- type char = System.Char
`compare e1 e2` Full Usage: `compare e1 e2` Parameters: e1 : `'T` - The first value. e2 : `'T` - The second value. Returns: `int` The result of the comparison. Modifiers: inline Type parameters: 'T	Generic comparison. e1 : `'T` The first value. e2 : `'T` The second value. Returns: `int` The result of the comparison. Example `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 compare: e1: 'T -> e2: 'T -> int (requires comparison)
`cos value` Full Usage: `cos value` Parameters: value : `^T` - The input value. Returns: `^T` The cosine of the input. Modifiers: inline Type parameters: ^T	Cosine of the given number value : `^T` The input value. Returns: `^T` The cosine of the input. Example `cos (0.0 * System.Math.PI) // evaluates to 1.0 cos (0.5 * System.Math.PI) // evaluates to 6.123233996e-17 cos (1.0 * System.Math.PI) // evaluates to -1.0` val cos: value: 'T -> 'T (requires member Cos) namespace System type Math = static member Abs: value: decimal -> decimal + 7 overloads static member Acos: d: float -> float static member Acosh: d: float -> float static member Asin: d: float -> float static member Asinh: d: float -> float static member Atan: d: float -> float static member Atan2: y: float * x: float -> float static member Atanh: d: float -> float static member BigMul: a: int * b: int -> int64 + 2 overloads static member BitDecrement: x: float -> float ... <summary>Provides constants and static methods for trigonometric, logarithmic, and other common mathematical functions.</summary> field System.Math.PI: float = 3.14159265359 <summary>Represents the ratio of the circumference of a circle to its diameter, specified by the constant, π.</summary>
`cosh value` Full Usage: `cosh value` Parameters: value : `^T` - The input value. Returns: `^T` The hyperbolic cosine of the input. Modifiers: inline Type parameters: ^T	Hyperbolic cosine of the given number value : `^T` The input value. Returns: `^T` The hyperbolic cosine of the input. Example `cosh -1.0 // evaluates to 1.543080635 cosh 0.0 // evaluates to 1.0 cosh 1.0 // evaluates to 1.543080635` val cosh: value: 'T -> 'T (requires member Cosh)
`decimal value` Full Usage: `decimal value` Parameters: value : `^T` - The input value. Returns: `decimal` The converted decimal. Modifiers: inline Type parameters: ^T	Converts the argument to System.Decimal using a direct conversion for all primitive numeric types. For strings, the input is converted using `UInt64.Parse()` with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type. value : `^T` The input value. Returns: `decimal` The converted decimal. Example `decimal "42.23" // evaluates to 42.23M decimal 0xff // evaluates to 255M decimal -10 // evaluates to -10M` Multiple items val decimal: value: 'T -> decimal (requires member op_Explicit) -------------------- type decimal = System.Decimal -------------------- type decimal<'Measure> = decimal
`decr cell` Full Usage: `decr cell` Parameters: cell : `int ref` - The reference cell.	Decrement a mutable reference cell containing an integer cell : `int ref` The reference cell. Example `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 count: int ref Multiple items val ref: value: 'T -> 'T ref -------------------- type 'T ref = Ref<'T> val decr: cell: int ref -> unit property Ref.Value: int with get, set
`defaultArg arg defaultValue` Full Usage: `defaultArg arg defaultValue` Parameters: arg : `'T option` - An option representing the argument. defaultValue : `'T` - The default value of the argument. Returns: `'T` The argument value. If it is None, the defaultValue is returned.	Used to specify a default value for an optional argument in the implementation of a function arg : `'T option` An option representing the argument. defaultValue : `'T` The default value of the argument. Returns: `'T` The argument value. If it is None, the defaultValue is returned. Example `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` Multiple items type Vector = new: x: double * y: double * ?z: double -> Vector member X: double member Y: double member Z: double -------------------- new: x: double * y: double * ?z: double -> Vector val x: double Multiple items val double: value: 'T -> double (requires member op_Explicit) -------------------- type double = System.Double -------------------- type double<'Measure> = float<'Measure> val y: double val z: double option val z: double val defaultArg: arg: 'T option -> defaultValue: 'T -> 'T val this: Vector member Vector.X: double member Vector.Y: double member Vector.Z: double val v1: Vector property Vector.Z: double with get val v2: Vector
`defaultValueArg arg defaultValue` Full Usage: `defaultValueArg arg defaultValue` Parameters: arg : `'T voption` - A value option representing the argument. defaultValue : `'T` - The default value of the argument. Returns: `'T` The argument value. If it is None, the defaultValue is returned.	Used to specify a default value for an optional argument in the implementation of a function arg : `'T voption` A value option representing the argument. defaultValue : `'T` The default value of the argument. Returns: `'T` The argument value. If it is None, the defaultValue is returned. Example `let arg1 = ValueSome(5) defaultValueArg arg1 6 // Evaluates to 5 defaultValueArg ValueNone 6 // Evaluates to 6` val arg1: int voption union case ValueOption.ValueSome: 'T -> ValueOption<'T> val defaultValueArg: arg: 'T voption -> defaultValue: 'T -> 'T union case ValueOption.ValueNone: ValueOption<'T>
`enum value` Full Usage: `enum value` Parameters: value : `int32` - The input value. Returns: `^U` The converted enum type. Modifiers: inline Type parameters: ^U	Converts the argument to a particular enum type. value : `int32` The input value. Returns: `^U` The converted enum type. Example `type Color = \| Red = 1 \| Green = 2 \| Blue = 3 let c: Color = enum 3 // c evaluates to Blue` [<Struct>] type Color = \| Red = 1 \| Green = 2 \| Blue = 3 Color.Red: Color = 1 Color.Green: Color = 2 Color.Blue: Color = 3 val c: Color val enum: value: int32 -> 'U (requires enum)
`exit exitcode` Full Usage: `exit exitcode` Parameters: exitcode : `int` - The exit code to use. Returns: `'T` Never returns.	Exit the current hardware isolated process, if security settings permit, otherwise raise an exception. Calls Environment.Exit. exitcode : `int` The exit code to use. Returns: `'T` Never returns. Example `[<EntryPoint>] let main argv = if argv.Length = 0 then eprintfn "You must provide arguments" exit(-1) // Causes program to quit with an error code printfn "Argument count: %i" argv.Length 0` Multiple items type EntryPointAttribute = inherit Attribute new: unit -> EntryPointAttribute -------------------- new: unit -> EntryPointAttribute val main: argv: string array -> int val argv: string array property System.Array.Length: int with get <summary>Gets the total number of elements in all the dimensions of the <see cref="T:System.Array" />.</summary> <exception cref="T:System.OverflowException">The array is multidimensional and contains more than <see cref="F:System.Int32.MaxValue">Int32.MaxValue</see> elements.</exception> <returns>The total number of elements in all the dimensions of the <see cref="T:System.Array" />; zero if there are no elements in the array.</returns> val eprintfn: format: Printf.TextWriterFormat<'T> -> 'T val exit: exitcode: int -> 'T val printfn: format: Printf.TextWriterFormat<'T> -> 'T
`exp value` Full Usage: `exp value` Parameters: value : `^T` - The input value. Returns: `^T` The exponential of the input. Modifiers: inline Type parameters: ^T	Exponential of the given number value : `^T` The input value. Returns: `^T` The exponential of the input. Example `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 exp: value: 'T -> 'T (requires member Exp)
`failwith message` Full Usage: `failwith message` Parameters: message : `string` - The exception message. Returns: `'T` Never returns. Modifiers: inline Type parameters: 'T	Throw a Exception exception. message : `string` The exception message. Returns: `'T` Never returns. Example `let failingFunction() = failwith "Oh no" // Throws an exception true // Never reaches this failingFunction() // Throws a System.Exception` val failingFunction: unit -> bool val failwith: message: string -> 'T
`float value` Full Usage: `float value` Parameters: value : `^T` - The input value. Returns: `float` The converted float Modifiers: inline Type parameters: ^T	Converts the argument to 64-bit float. This is a direct conversion for all primitive numeric types. For strings, the input is converted using `Double.Parse()` with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type. value : `^T` The input value. Returns: `float` The converted float Example `float 'A' // evaluates to 65.0 float 0xff // evaluates to 255.0 float -10 // evaluates to -10.0` Multiple items val float: value: 'T -> float (requires member op_Explicit) -------------------- type float = System.Double -------------------- type float<'Measure> = float
`float32 value` Full Usage: `float32 value` Parameters: value : `^T` - The input value. Returns: `float32` The converted float32 Modifiers: inline Type parameters: ^T	Converts the argument to 32-bit float. This is a direct conversion for all primitive numeric types. For strings, the input is converted using `Single.Parse()` with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type. value : `^T` The input value. Returns: `float32` The converted float32 Example `float32 'A' // evaluates to 65.0f float32 0xff // evaluates to 255.0f float32 -10 // evaluates to -10.0f` Multiple items val float32: value: 'T -> float32 (requires member op_Explicit) -------------------- type float32 = System.Single -------------------- type float32<'Measure> = float32
`floor value` Full Usage: `floor value` Parameters: value : `^T` - The input value. Returns: `^T` The floor of the input. Modifiers: inline Type parameters: ^T	Floor of the given number value : `^T` The input value. Returns: `^T` The floor of the input. Example `floor 12.1 // Evaluates to 12.0 floor -1.9 // Evaluates to -2.0` val floor: value: 'T -> 'T (requires member Floor)
`fst tuple` Full Usage: `fst tuple` Parameters: tuple : `'T1 * 'T2` - The input tuple. Returns: `'T1` The first value. Modifiers: inline Type parameters: 'T1, 'T2	Return the first element of a tuple, `fst (a,b) = a`. tuple : `'T1 * 'T2` The input tuple. Returns: `'T1` The first value. Example `fst ("first", 2) // Evaluates to "first"` val fst: tuple: ('T1 * 'T2) -> 'T1
`hash obj` Full Usage: `hash obj` Parameters: obj : `'T` - The input object. Returns: `int` The computed hash. Modifiers: inline Type parameters: 'T	A generic hash function, designed to return equal hash values for items that are equal according to the "=" operator. By default it will use structural hashing for F# union, record and tuple types, hashing the complete contents of the type. The exact behaviour of the function can be adjusted on a type-by-type basis by implementing GetHashCode for each type. obj : `'T` The input object. Returns: `int` The computed hash. Example `hash "Bob Jones" // Evaluates to -325251320` val hash: obj: 'T -> int (requires equality)
`id x` Full Usage: `id x` Parameters: x : `'T` - The input value. Returns: `'T` The same value.	The identity function x : `'T` The input value. Returns: `'T` The same value. Example `id 12 // Evaulates to 12 id "abc" // Evaulates to "abc"` val id: x: 'T -> 'T
`ignore value` Full Usage: `ignore value` Parameters: value : `'T` - The value to ignore. Modifiers: inline Type parameters: 'T	Ignore the passed value. This is often used to throw away results of a computation. value : `'T` The value to ignore. Example `ignore 55555 // Evaluates to ()` val ignore: value: 'T -> unit
`incr cell` Full Usage: `incr cell` Parameters: cell : `int ref` - The reference cell.	Increment a mutable reference cell containing an integer cell : `int ref` The reference cell. Example `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 count: int ref Multiple items val ref: value: 'T -> 'T ref -------------------- type 'T ref = Ref<'T> val incr: cell: int ref -> unit property Ref.Value: int with get, set
`infinity` Full Usage: `infinity` Returns: `float`	Equivalent to Double.PositiveInfinity Returns: `float`
`infinityf` Full Usage: `infinityf` Returns: `float32`	Equivalent to Single.PositiveInfinity Returns: `float32`
`int value` Full Usage: `int value` Parameters: value : `^T` - The input value. Returns: `int` The converted int Modifiers: inline Type parameters: ^T	Converts the argument to signed 32-bit integer. This is a direct conversion for all primitive numeric types. For strings, the input is converted using `Int32.Parse()` with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type. value : `^T` The input value. Returns: `int` The converted int Example `int 'A' // evaluates to 65 int 0xff // evaluates to 255 int -10 // evaluates to -10` Multiple items val int: value: 'T -> int (requires member op_Explicit) -------------------- type int = int32 -------------------- type int<'Measure> = int
`int16 value` Full Usage: `int16 value` Parameters: value : `^T` - The input value. Returns: `int16` The converted int16 Modifiers: inline Type parameters: ^T	Converts the argument to signed 16-bit integer. This is a direct conversion for all primitive numeric types. For strings, the input is converted using `Int16.Parse()` with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type. value : `^T` The input value. Returns: `int16` The converted int16 Example `int16 'A' // evaluates to 65s int16 0xff // evaluates to 255s int16 -10 // evaluates to -10s` Multiple items val int16: value: 'T -> int16 (requires member op_Explicit) -------------------- type int16 = System.Int16 -------------------- type int16<'Measure> = int16
`int32 value` Full Usage: `int32 value` Parameters: value : `^T` - The input value. Returns: `int32` The converted int32 Modifiers: inline Type parameters: ^T	Converts the argument to signed 32-bit integer. This is a direct conversion for all primitive numeric types. For strings, the input is converted using `Int32.Parse()` with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type. value : `^T` The input value. Returns: `int32` The converted int32 Example `int32 'A' // evaluates to 65 int32 0xff // evaluates to 255 int32 -10 // evaluates to -10` Multiple items val int32: value: 'T -> int32 (requires member op_Explicit) -------------------- type int32 = System.Int32 -------------------- type int32<'Measure> = int<'Measure>
`int64 value` Full Usage: `int64 value` Parameters: value : `^T` - The input value. Returns: `int64` The converted int64 Modifiers: inline Type parameters: ^T	Converts the argument to signed 64-bit integer. This is a direct conversion for all primitive numeric types. For strings, the input is converted using `Int64.Parse()` with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type. value : `^T` The input value. Returns: `int64` The converted int64 Example `int64 'A' // evaluates to 65L int64 0xff // evaluates to 255L int64 -10 // evaluates to -10L` Multiple items val int64: value: 'T -> int64 (requires member op_Explicit) -------------------- type int64 = System.Int64 -------------------- type int64<'Measure> = int64
`invalidArg argumentName message` Full Usage: `invalidArg argumentName message` Parameters: argumentName : `string` - The argument name. message : `string` - The exception message. Returns: `'T` Never returns. Modifiers: inline Type parameters: 'T	Throw a ArgumentException exception with the given argument name and message. argumentName : `string` The argument name. message : `string` The exception message. Returns: `'T` Never returns. Example `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"` val fullName: firstName: string -> lastName: string -> string val firstName: string val lastName: string module String from Microsoft.FSharp.Core val invalidArg: argumentName: string -> message: string -> 'T val nameof: 'T -> string Throws `System.ArgumentException: First name can't be null or blank (Parameter 'firstName')`
`invalidOp message` Full Usage: `invalidOp message` Parameters: message : `string` - The exception message. Returns: `'T` The result value. Modifiers: inline Type parameters: 'T	Throw a InvalidOperationException exception message : `string` The exception message. Returns: `'T` The result value. Example `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` Multiple items type FileReader = new: fileName: string -> FileReader member Open: unit -> unit -------------------- new: fileName: string -> FileReader val fileName: string Multiple items val string: value: 'T -> string -------------------- type string = System.String val mutable isOpen: bool val this: FileReader val invalidOp: message: string -> 'T val reader: FileReader member FileReader.Open: unit -> unit
`isNull value` Full Usage: `isNull value` Parameters: value : `'T` - The value to check. Returns: `bool` True when value is null, false otherwise. Modifiers: inline Type parameters: 'T	Determines whether the given value is null. value : `'T` The value to check. Returns: `bool` True when value is null, false otherwise. Example `isNull null // Evaluates to true isNull "Not null" // Evaluates to false` val isNull: value: 'T -> bool (requires 'T: null)
`limitedHash limit obj` Full Usage: `limitedHash limit obj` Parameters: limit : `int` - The limit of nodes. obj : `'T` - The input object. Returns: `int` The computed hash. Modifiers: inline Type parameters: 'T	A generic hash function. This function has the same behaviour as 'hash', however the default structural hashing for F# union, record and tuple types stops when the given limit of nodes is reached. The exact behaviour of the function can be adjusted on a type-by-type basis by implementing GetHashCode for each type. limit : `int` The limit of nodes. obj : `'T` The input object. Returns: `int` The computed hash.
`lock lockObject action` Full Usage: `lock lockObject action` Parameters: lockObject : `'Lock` - The object to be locked. action : `unit -> 'T` - The action to perform during the lock. Returns: `'T` The resulting value. Modifiers: inline Type parameters: 'Lock, 'T	Execute the function as a mutual-exclusion region using the input value as a lock. lockObject : `'Lock` The object to be locked. action : `unit -> 'T` The action to perform during the lock. Returns: `'T` The resulting value. Example open System.Linq /// A counter object, supporting unlocked and locked increment type TestCounter () = let mutable count = 0 /// Increment the counter, unlocked member this.IncrementWithoutLock() = count <- count + 1 /// Increment the counter, locked member this.IncrementWithLock() = lock this (fun () -> count <- count + 1) /// Get the count member this.Count = count let counter = TestCounter() // Create a parallel sequence to that uses all our CPUs (seq {1..100000}).AsParallel() .ForAll(fun _ -> counter.IncrementWithoutLock()) // Evaluates to a number between 1-100000, non-deterministically because there is no locking counter.Count let counter2 = TestCounter() // Create a parallel sequence to that uses all our CPUs (seq {1..100000}).AsParallel() .ForAll(fun _ -> counter2.IncrementWithLock()) // Evaluates to 100000 deterministically because the increment to the counter object is locked counter2.Count namespace System namespace System.Linq Multiple items type TestCounter = new: unit -> TestCounter member IncrementWithLock: unit -> unit member IncrementWithoutLock: unit -> unit member Count: int A counter object, supporting unlocked and locked increment -------------------- new: unit -> TestCounter val mutable count: int val this: TestCounter val lock: lockObject: 'Lock -> action: (unit -> 'T) -> 'T (requires reference type) val counter: TestCounter Multiple items val seq: sequence: seq<'T> -> seq<'T> -------------------- type seq<'T> = System.Collections.Generic.IEnumerable<'T> member TestCounter.IncrementWithoutLock: unit -> unit Increment the counter, unlocked property TestCounter.Count: int with get Get the count val counter2: TestCounter member TestCounter.IncrementWithLock: unit -> unit Increment the counter, locked
`log value` Full Usage: `log value` Parameters: value : `^T` - The input value. Returns: `^T` The natural logarithm of the input. Modifiers: inline Type parameters: ^T	Natural logarithm of the given number value : `^T` The input value. Returns: `^T` The natural logarithm of the input. Example `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 logBase: baseNumber: float -> value: float -> float val baseNumber: float val value: float val log: value: 'T -> 'T (requires member Log)
`log10 value` Full Usage: `log10 value` Parameters: value : `^T` - The input value. Returns: `^T` The logarithm to base 10 of the input. Modifiers: inline Type parameters: ^T	Logarithm to base 10 of the given number value : `^T` The input value. Returns: `^T` The logarithm to base 10 of the input. Example `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 log10: value: 'T -> 'T (requires member Log10)
`max e1 e2` Full Usage: `max e1 e2` Parameters: e1 : `'T` - The first value. e2 : `'T` - The second value. Returns: `'T` The maximum value. Modifiers: inline Type parameters: 'T	Maximum based on generic comparison e1 : `'T` The first value. e2 : `'T` The second value. Returns: `'T` The maximum value. Example `max 1 2 // Evaluates to 2 max [1;2;3] [1;2;4] // Evaluates to [1;2;4] max "zoo" "alpha" // Evaluates to "zoo"` val max: e1: 'T -> e2: 'T -> 'T (requires comparison)
`methodhandleof arg1` Full Usage: `methodhandleof arg1` Parameters: arg0 : `'T -> 'TResult` Returns: `RuntimeMethodHandle`	An internal, library-only compiler intrinsic for compile-time generation of a RuntimeMethodHandle. arg0 : `'T -> 'TResult` Returns: `RuntimeMethodHandle`
`min e1 e2` Full Usage: `min e1 e2` Parameters: e1 : `'T` - The first value. e2 : `'T` - The second value. Returns: `'T` The minimum value. Modifiers: inline Type parameters: 'T	Minimum based on generic comparison e1 : `'T` The first value. e2 : `'T` The second value. Returns: `'T` The minimum value. Example `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 min: e1: 'T -> e2: 'T -> 'T (requires comparison)
`nameof arg1` Full Usage: `nameof arg1` Parameters: arg0 : `'T` Returns: `string` Modifiers: inline Type parameters: 'T	Returns the name of the given symbol. arg0 : `'T` Returns: `string` Example `let myVariableName = "This value doesn't matter" nameof(myVariableName) // Evaluates to "myVariableName"` val myVariableName: string val nameof: 'T -> string
`nan` Full Usage: `nan` Returns: `float`	Equivalent to Double.NaN Returns: `float`
`nanf` Full Usage: `nanf` Returns: `float32`	Equivalent to Single.NaN Returns: `float32`
`nativeint value` Full Usage: `nativeint value` Parameters: value : `^T` - The input value. Returns: `nativeint` The converted nativeint Modifiers: inline Type parameters: ^T	Converts the argument to signed native integer. This is a direct conversion for all primitive numeric types. Otherwise the operation requires an appropriate static conversion method on the input type. value : `^T` The input value. Returns: `nativeint` The converted nativeint Example `nativeint 'A' // evaluates to 65n nativeint 0xff // evaluates to 255n nativeint -10 // evaluates to -10n` Multiple items val nativeint: value: 'T -> nativeint (requires member op_Explicit) -------------------- type nativeint = System.IntPtr -------------------- type nativeint<'Measure> = nativeint
`nullArg argumentName` Full Usage: `nullArg argumentName` Parameters: argumentName : `string` - The argument name. Returns: `'T` Never returns. Modifiers: inline Type parameters: 'T	Throw a ArgumentNullException exception argumentName : `string` The argument name. Returns: `'T` Never returns. Example `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 fullName: firstName: string -> lastName: string -> string val firstName: string val lastName: string val nullArg: argumentName: string -> 'T val nameof: 'T -> string
`pown x n` Full Usage: `pown x n` Parameters: x : `^T` - The input base. n : `int` - The input exponent. Returns: `^T` The base raised to the exponent. Modifiers: inline Type parameters: ^T	Overloaded power operator. If `n > 0` then equivalent to `x...x` for `n` occurrences of `x`. x : `^T` The input base. n : `int` The input exponent. Returns: `^T` The base raised to the exponent. Example `pown 2.0 3 // evaluates to 8.0` val pown: x: 'T -> n: int -> 'T (requires member One and member ( * ) and member (/))
`raise exn` Full Usage: `raise exn` Parameters: exn : `Exception` - The exception to raise. Returns: `'T` The result value. Modifiers: inline Type parameters: 'T	Raises an exception exn : `Exception` The exception to raise. Returns: `'T` The result value. Example `open System.IO exception FileNotFoundException of string let readFile (fileName: string) = if not (File.Exists(fileName)) then raise(FileNotFoundException(fileName)) File.ReadAllText(fileName) readFile "/this-file-doest-exist"` namespace System namespace System.IO exception FileNotFoundException of string Multiple items val string: value: 'T -> string -------------------- type string = System.String val readFile: fileName: string -> string val fileName: string type File = static member AppendAllLines: path: string * contents: IEnumerable<string> -> unit + 1 overload static member AppendAllLinesAsync: path: string * contents: IEnumerable<string> * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload static member AppendAllText: path: string * contents: string -> unit + 1 overload static member AppendAllTextAsync: path: string * contents: string * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload static member AppendText: path: string -> StreamWriter static member Copy: sourceFileName: string * destFileName: string -> unit + 1 overload static member Create: path: string -> FileStream + 2 overloads static member CreateSymbolicLink: path: string * pathToTarget: string -> FileSystemInfo static member CreateText: path: string -> StreamWriter static member Decrypt: path: string -> unit ... <summary>Provides static methods for the creation, copying, deletion, moving, and opening of a single file, and aids in the creation of <see cref="T:System.IO.FileStream" /> objects.</summary> File.Exists(path: string) : bool val raise: exn: System.Exception -> 'T File.ReadAllText(path: string) : string File.ReadAllText(path: string, encoding: System.Text.Encoding) : string When executed, raises a `FileNotFoundException`.
`ref value` Full Usage: `ref value` Parameters: value : `'T` - The value to contain in the cell. Returns: `'T ref` The created reference cell.	Create a mutable reference cell value : `'T` The value to contain in the cell. Returns: `'T ref` The created reference cell. Example `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 count: int ref Multiple items val ref: value: 'T -> 'T ref -------------------- type 'T ref = Ref<'T> property Ref.Value: int with get, set
`reraise ()` Full Usage: `reraise ()` Parameters: () : `unit` Returns: `'T` The result value. Modifiers: inline Type parameters: 'T	Rethrows an exception. This should only be used when handling an exception () : `unit` Returns: `'T` The result value. Example `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 readFile: fileName: string -> 'a val fileName: string Multiple items val string: value: 'T -> string -------------------- type string = System.String val ex: exn val eprintfn: format: Printf.TextWriterFormat<'T> -> 'T val reraise: unit -> 'T
`round value` Full Usage: `round value` Parameters: value : `^T` - The input value. Returns: `^T` The nearest integer to the input value. Modifiers: inline Type parameters: ^T	Round the given number value : `^T` The input value. Returns: `^T` The nearest integer to the input value. Example `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 round: value: 'T -> 'T (requires member Round)
`sbyte value` Full Usage: `sbyte value` Parameters: value : `^T` - The input value. Returns: `sbyte` The converted sbyte Modifiers: inline Type parameters: ^T	Converts the argument to signed byte. This is a direct conversion for all primitive numeric types. For strings, the input is converted using `SByte.Parse()` with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type. value : `^T` The input value. Returns: `sbyte` The converted sbyte Example `sbyte 'A' // evaluates to 65y sbyte 0xff // evaluates to -1y sbyte -10 // evaluates to -10y` Multiple items val sbyte: value: 'T -> sbyte (requires member op_Explicit) -------------------- type sbyte = System.SByte -------------------- type sbyte<'Measure> = sbyte
`seq sequence` Full Usage: `seq sequence` Parameters: sequence : `seq<'T>` - The input sequence. Returns: `seq<'T>` The result sequence.	Builds a sequence using sequence expression syntax sequence : `seq<'T>` The input sequence. Returns: `seq<'T>` The result sequence. Example `seq { for i in 0..10 do yield (i, i*i) }` Multiple items val seq: sequence: seq<'T> -> seq<'T> -------------------- type seq<'T> = System.Collections.Generic.IEnumerable<'T> val i: int
`sign value` Full Usage: `sign value` Parameters: value : `^T` - The input value. Returns: `int` -1, 0, or 1 depending on the sign of the input. Modifiers: inline Type parameters: ^T	Sign of the given number value : `^T` The input value. Returns: `int` -1, 0, or 1 depending on the sign of the input. Example `sign -12.0 // Evaluates to -1 sign 43 // Evaluates to 1` val sign: value: 'T -> int (requires member Sign)
`sin value` Full Usage: `sin value` Parameters: value : `^T` - The input value. Returns: `^T` The sine of the input. Modifiers: inline Type parameters: ^T	Sine of the given number value : `^T` The input value. Returns: `^T` The sine of the input. Example `sin (0.0 * System.Math.PI) // evaluates to 0.0 sin (0.5 * System.Math.PI) // evaluates to 1.0 sin (1.0 * System.Math.PI) // evaluates to 1.224646799e-16` val sin: value: 'T -> 'T (requires member Sin) namespace System type Math = static member Abs: value: decimal -> decimal + 7 overloads static member Acos: d: float -> float static member Acosh: d: float -> float static member Asin: d: float -> float static member Asinh: d: float -> float static member Atan: d: float -> float static member Atan2: y: float * x: float -> float static member Atanh: d: float -> float static member BigMul: a: int * b: int -> int64 + 2 overloads static member BitDecrement: x: float -> float ... <summary>Provides constants and static methods for trigonometric, logarithmic, and other common mathematical functions.</summary> field System.Math.PI: float = 3.14159265359 <summary>Represents the ratio of the circumference of a circle to its diameter, specified by the constant, π.</summary>
`sinh value` Full Usage: `sinh value` Parameters: value : `^T` - The input value. Returns: `^T` The hyperbolic sine of the input. Modifiers: inline Type parameters: ^T	Hyperbolic sine of the given number value : `^T` The input value. Returns: `^T` The hyperbolic sine of the input. Example `sinh -1.0 // evaluates to -1.175201194 sinh 0.0 // evaluates to 0.0 sinh 1.0 // evaluates to 1.175201194` val sinh: value: 'T -> 'T (requires member Sinh)
`sizeof` Full Usage: `sizeof` Returns: `int` Modifiers: inline Type parameters: 'T	Returns the internal size of a type in bytes. For example, `sizeof<int>` returns 4. Returns: `int` Example `sizeof<bool> // Evaluates to 1 sizeof<byte> // Evaluates to 1 sizeof<int> // Evaluates to 4 sizeof<double> // Evaluates to 8 sizeof<struct(byte * byte)> // Evaluates to 2 sizeof<nativeint> // Evaluates to 4 or 8 (32-bit or 64-bit) depending on your platform` val sizeof<'T> : int type bool = System.Boolean Multiple items val byte: value: 'T -> byte (requires member op_Explicit) -------------------- type byte = System.Byte -------------------- type byte<'Measure> = byte Multiple items val int: value: 'T -> int (requires member op_Explicit) -------------------- type int = int32 -------------------- type int<'Measure> = int Multiple items val double: value: 'T -> double (requires member op_Explicit) -------------------- type double = System.Double -------------------- type double<'Measure> = float<'Measure> Multiple items val nativeint: value: 'T -> nativeint (requires member op_Explicit) -------------------- type nativeint = System.IntPtr -------------------- type nativeint<'Measure> = nativeint
`snd tuple` Full Usage: `snd tuple` Parameters: tuple : `'T1 * 'T2` - The input tuple. Returns: `'T2` The second value. Modifiers: inline Type parameters: 'T1, 'T2	Return the second element of a tuple, `snd (a,b) = b`. tuple : `'T1 * 'T2` The input tuple. Returns: `'T2` The second value. Example `snd ("first", 2) // Evaluates to 2` val snd: tuple: ('T1 * 'T2) -> 'T2
`sqrt value` Full Usage: `sqrt value` Parameters: value : `^T` - The input value. Returns: `^U` The square root of the input. Modifiers: inline Type parameters: ^T, ^U	Square root of the given number value : `^T` The input value. Returns: `^U` The square root of the input. Example `sqrt 2.0 // Evaluates to 1.414213562 sqrt 100.0 // Evaluates to 10.0` val sqrt: value: 'T -> 'U (requires member Sqrt)
`stderr` Full Usage: `stderr` Returns: `TextWriter`	Reads the value of the property Console.Error. Returns: `TextWriter`
`stdin` Full Usage: `stdin` Returns: `TextReader`	Reads the value of the property Console.In. Returns: `TextReader`
`stdout` Full Usage: `stdout` Returns: `TextWriter`	Reads the value of the property Console.Out. Returns: `TextWriter`
`string value` Full Usage: `string value` Parameters: value : `'T` - The input value. Returns: `string` The converted string. Modifiers: inline Type parameters: 'T	Converts the argument to a string using `ToString`. For standard integer and floating point values and any type that implements `IFormattableToString` conversion uses `CultureInfo.InvariantCulture`. value : `'T` The input value. Returns: `string` The converted string. Example `string 'A' // evaluates to "A" string 0xff // evaluates to "255" string -10 // evaluates to "-10"` Multiple items val string: value: 'T -> string -------------------- type string = System.String
`tan value` Full Usage: `tan value` Parameters: value : `^T` - The input value. Returns: `^T` The tangent of the input. Modifiers: inline Type parameters: ^T	Tangent of the given number value : `^T` The input value. Returns: `^T` The tangent of the input. Example `tan (-0.5 * System.Math.PI) // evaluates to -1.633123935e+16 tan (0.0 * System.Math.PI) // evaluates to 0.0 tan (0.5 * System.Math.PI) // evaluates to 1.633123935e+16` val tan: value: 'T -> 'T (requires member Tan) namespace System type Math = static member Abs: value: decimal -> decimal + 7 overloads static member Acos: d: float -> float static member Acosh: d: float -> float static member Asin: d: float -> float static member Asinh: d: float -> float static member Atan: d: float -> float static member Atan2: y: float * x: float -> float static member Atanh: d: float -> float static member BigMul: a: int * b: int -> int64 + 2 overloads static member BitDecrement: x: float -> float ... <summary>Provides constants and static methods for trigonometric, logarithmic, and other common mathematical functions.</summary> field System.Math.PI: float = 3.14159265359 <summary>Represents the ratio of the circumference of a circle to its diameter, specified by the constant, π.</summary>
`tanh value` Full Usage: `tanh value` Parameters: value : `^T` - The input value. Returns: `^T` The hyperbolic tangent of the input. Modifiers: inline Type parameters: ^T	Hyperbolic tangent of the given number value : `^T` The input value. Returns: `^T` The hyperbolic tangent of the input. Example `tanh -1.0 // evaluates to -0.761594156 tanh 0.0 // evaluates to 0.0 tanh 1.0 // evaluates to 0.761594156` val tanh: value: 'T -> 'T (requires member Tanh)
`truncate value` Full Usage: `truncate value` Parameters: value : `^T` - The input value. Returns: `^T` The truncated value. Modifiers: inline Type parameters: ^T	Overloaded truncate operator. value : `^T` The input value. Returns: `^T` The truncated value. Example `truncate 23.92 // evaluates to 23.0 truncate 23.92f // evaluates to 23.0f` val truncate: value: 'T -> 'T (requires member Truncate)
`tryUnbox value` Full Usage: `tryUnbox value` Parameters: value : `obj` - The boxed value. Returns: `'T option` The unboxed result as an option. Modifiers: inline Type parameters: 'T	Try to unbox a strongly typed value. value : `obj` The boxed value. Returns: `'T option` The unboxed result as an option. Example `let x: int = 123 let obj1 = box x // obj1 is a generic object type tryUnbox<int> obj1 // Evaluates to Some(123) tryUnbox<double> obj1 // Evaluates to None` val x: int Multiple items val int: value: 'T -> int (requires member op_Explicit) -------------------- type int = int32 -------------------- type int<'Measure> = int val obj1: obj val box: value: 'T -> obj val tryUnbox: value: obj -> 'T option Multiple items val double: value: 'T -> double (requires member op_Explicit) -------------------- type double = System.Double -------------------- type double<'Measure> = float<'Measure>
`typedefof` Full Usage: `typedefof` Returns: `Type` Modifiers: inline Type parameters: 'T	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. Returns: `Type` Example typeof<int list;> // Evaluates to Microsoft.FSharp.Collections.FSharpList`1[System.Int32] typedefof<int list;> // Evaluates to Microsoft.FSharp.Collections.FSharpList`1[T] /// val typeof<'T> : System.Type Multiple items val int: value: 'T -> int (requires member op_Explicit) -------------------- type int = int32 -------------------- type int<'Measure> = int type 'T list = List<'T> val typedefof<'T> : System.Type
`typeof` Full Usage: `typeof` Returns: `Type` Modifiers: inline Type parameters: 'T	Generate a System.Type runtime representation of a static type. Returns: `Type` Example `let t = typeof<int> // Gets the System.Type t.FullName // Evaluates to "System.Int32"` val t: System.Type val typeof<'T> : System.Type Multiple items val int: value: 'T -> int (requires member op_Explicit) -------------------- type int = int32 -------------------- type int<'Measure> = int property System.Type.FullName: string with get
`uint value` Full Usage: `uint value` Parameters: value : `^T` - The input value. Returns: `uint` The converted int Modifiers: inline Type parameters: ^T	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()` with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type. value : `^T` The input value. Returns: `uint` The converted int Example `uint 'A' // evaluates to 65u uint 0xff // evaluates to 255u uint -10 // evaluates to 4294967286u` Multiple items val uint: value: 'T -> uint (requires member op_Explicit) -------------------- type uint = uint32 -------------------- type uint<'Measure> = uint
`uint16 value` Full Usage: `uint16 value` Parameters: value : `^T` - The input value. Returns: `uint16` The converted uint16 Modifiers: inline Type parameters: ^T	Converts the argument to unsigned 16-bit integer. This is a direct conversion for all primitive numeric types. For strings, the input is converted using `UInt16.Parse()` with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type. value : `^T` The input value. Returns: `uint16` The converted uint16 Example `uint16 'A' // evaluates to 65us uint16 0xff // evaluates to 255s uint16 -10 // evaluates to 65526us` Multiple items val uint16: value: 'T -> uint16 (requires member op_Explicit) -------------------- type uint16 = System.UInt16 -------------------- type uint16<'Measure> = uint16
`uint32 value` Full Usage: `uint32 value` Parameters: value : `^T` - The input value. Returns: `uint32` The converted uint32 Modifiers: inline Type parameters: ^T	Converts the argument to unsigned 32-bit integer. This is a direct conversion for all primitive numeric types. For strings, the input is converted using `UInt32.Parse()` with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type. value : `^T` The input value. Returns: `uint32` The converted uint32 Example `uint32 'A' // evaluates to 65u uint32 0xff // evaluates to 255u uint32 -10 // evaluates to 4294967286u` Multiple items val uint32: value: 'T -> uint32 (requires member op_Explicit) -------------------- type uint32 = System.UInt32 -------------------- type uint32<'Measure> = uint<'Measure>
`uint64 value` Full Usage: `uint64 value` Parameters: value : `^T` - The input value. Returns: `uint64` The converted uint64 Modifiers: inline Type parameters: ^T	Converts the argument to unsigned 64-bit integer. This is a direct conversion for all primitive numeric types. For strings, the input is converted using `UInt64.Parse()` with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type. value : `^T` The input value. Returns: `uint64` The converted uint64 Example `uint64 'A' // evaluates to 65UL uint64 0xff // evaluates to 255UL uint64 -10 // evaluates to 18446744073709551606UL` Multiple items val uint64: value: 'T -> uint64 (requires member op_Explicit) -------------------- type uint64 = System.UInt64 -------------------- type uint64<'Measure> = uint64
`unativeint value` Full Usage: `unativeint value` Parameters: value : `^T` - The input value. Returns: `unativeint` The converted unativeint Modifiers: inline Type parameters: ^T	Converts the argument to unsigned native integer using a direct conversion for all primitive numeric types. Otherwise the operation requires an appropriate static conversion method on the input type. value : `^T` The input value. Returns: `unativeint` The converted unativeint Example `unativeint 'A' // evaluates to 65un unativeint 0xff // evaluates to 255un unativeint -10 // evaluates to 18446744073709551606un` Multiple items val unativeint: value: 'T -> unativeint (requires member op_Explicit) -------------------- type unativeint = System.UIntPtr -------------------- type unativeint<'Measure> = unativeint
`unbox value` Full Usage: `unbox value` Parameters: value : `obj` - The boxed value. Returns: `'T` The unboxed result. Modifiers: inline Type parameters: 'T	Unbox a strongly typed value. value : `obj` The boxed value. Returns: `'T` The unboxed result. Example `let x: int = 123 let obj1 = box x // obj1 is a generic object type unbox<int> obj1 // Evaluates to 123 (int) unbox<double> obj1 // Throws System.InvalidCastException` val x: int Multiple items val int: value: 'T -> int (requires member op_Explicit) -------------------- type int = int32 -------------------- type int<'Measure> = int val obj1: obj val box: value: 'T -> obj val unbox: value: obj -> 'T Multiple items val double: value: 'T -> double (requires member op_Explicit) -------------------- type double = System.Double -------------------- type double<'Measure> = float<'Measure>
`using resource action` Full Usage: `using resource action` Parameters: resource : `'T` - The resource to be disposed after action is called. action : `'T -> 'U` - The action that accepts the resource. Returns: `'U` The resulting value.	Clean up resources associated with the input object after the completion of the given function. Cleanup occurs even when an exception is raised by the protected code. resource : `'T` The resource to be disposed after action is called. action : `'T -> 'U` The action that accepts the resource. Returns: `'U` The resulting value. Example The following code appends 10 lines to test.txt, then closes the StreamWriter when finished. `open System.IO using (File.AppendText "test.txt") (fun writer -> for i in 1 .. 10 do writer.WriteLine("Hello World {0}", i))` namespace System namespace System.IO val using: resource: 'T -> action: ('T -> 'U) -> 'U (requires 'T :> System.IDisposable) type File = static member AppendAllLines: path: string * contents: IEnumerable<string> -> unit + 1 overload static member AppendAllLinesAsync: path: string * contents: IEnumerable<string> * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload static member AppendAllText: path: string * contents: string -> unit + 1 overload static member AppendAllTextAsync: path: string * contents: string * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload static member AppendText: path: string -> StreamWriter static member Copy: sourceFileName: string * destFileName: string -> unit + 1 overload static member Create: path: string -> FileStream + 2 overloads static member CreateSymbolicLink: path: string * pathToTarget: string -> FileSystemInfo static member CreateText: path: string -> StreamWriter static member Decrypt: path: string -> unit ... <summary>Provides static methods for the creation, copying, deletion, moving, and opening of a single file, and aids in the creation of <see cref="T:System.IO.FileStream" /> objects.</summary> File.AppendText(path: string) : StreamWriter val writer: StreamWriter val i: int32 TextWriter.WriteLine() : unit (+0 other overloads) TextWriter.WriteLine(value: uint64) : unit (+0 other overloads) TextWriter.WriteLine(value: uint32) : unit (+0 other overloads) TextWriter.WriteLine(value: System.Text.StringBuilder) : unit (+0 other overloads) TextWriter.WriteLine(value: float32) : unit (+0 other overloads) TextWriter.WriteLine(value: obj) : unit (+0 other overloads) TextWriter.WriteLine(value: int64) : unit (+0 other overloads) TextWriter.WriteLine(value: int) : unit (+0 other overloads) TextWriter.WriteLine(value: float) : unit (+0 other overloads) TextWriter.WriteLine(value: decimal) : unit (+0 other overloads)

Active patterns

Active pattern Description

Active pattern	Description
`(\|Failure\|_\|) error` Full Usage: `(\|Failure\|_\|) error` Parameters: error : `exn` - The input exception. Returns: `string option` A string option.	Matches Exception objects whose runtime type is precisely Exception error : `exn` The input exception. Returns: `string option` A string option.
`(\|KeyValue\|) keyValuePair` Full Usage: `(\|KeyValue\|) keyValuePair` Parameters: keyValuePair : `KeyValuePair<'Key, 'Value>` - The input key/value pair. Returns: `'Key * 'Value` A tuple containing the key and value.	An active pattern to match values of type KeyValuePair keyValuePair : `KeyValuePair<'Key, 'Value>` The input key/value pair. Returns: `'Key * 'Value` A tuple containing the key and value. Example `let kv = System.Collections.Generic.KeyValuePair(42, "the answer") match kv with // evaluates to "found it" \| KeyValue (42, v) -> "found it" \| KeyValue (k, v) -> "keep waiting"` val kv: System.Collections.Generic.KeyValuePair<int,string> namespace System namespace System.Collections namespace System.Collections.Generic Multiple items [<Struct>] type KeyValuePair<'TKey,'TValue> = new: key: 'TKey * value: 'TValue -> unit member Deconstruct: key: byref<'TKey> * value: byref<'TValue> -> unit member ToString: unit -> string member Key: 'TKey member Value: 'TValue <summary>Defines a key/value pair that can be set or retrieved.</summary> <typeparam name="TKey">The type of the key.</typeparam> <typeparam name="TValue">The type of the value.</typeparam> -------------------- type KeyValuePair = static member Create<'TKey,'TValue> : key: 'TKey * value: 'TValue -> KeyValuePair<'TKey,'TValue> <summary>Creates instances of the <see cref="T:System.Collections.Generic.KeyValuePair`2" /> struct.</summary> -------------------- System.Collections.Generic.KeyValuePair () System.Collections.Generic.KeyValuePair(key: 'TKey, value: 'TValue) : System.Collections.Generic.KeyValuePair<'TKey,'TValue> active recognizer KeyValue: System.Collections.Generic.KeyValuePair<'Key,'Value> -> 'Key * 'Value val v: string val k: int


                
                  
                    
                      (|Failure|_|) error

Full Usage: (|Failure|_|) error

Parameters:

error : exn - The input exception.

Returns: string option A string option.

Matches Exception objects whose runtime type is precisely Exception

error : exn: The input exception.

Returns: string option: A string option.


                
                  
                    
                      (|KeyValue|) keyValuePair

Full Usage: (|KeyValue|) keyValuePair

Parameters:

keyValuePair : KeyValuePair<'Key, 'Value> - The input key/value pair.

Returns: 'Key * 'Value A tuple containing the key and value.

An active pattern to match values of type KeyValuePair

keyValuePair : KeyValuePair<'Key, 'Value>: The input key/value pair.

Returns: 'Key * 'Value: A tuple containing the key and value.

Example

 let kv = System.Collections.Generic.KeyValuePair(42, "the answer")
 match kv with // evaluates to "found it"
 | KeyValue (42, v) -> "found it"
 | KeyValue (k, v) -> "keep waiting"

val kv: System.Collections.Generic.KeyValuePair<int,string>

namespace System

namespace System.Collections

namespace System.Collections.Generic

Multiple items
[<Struct>] type KeyValuePair<'TKey,'TValue> = new: key: 'TKey * value: 'TValue -> unit member Deconstruct: key: byref<'TKey> * value: byref<'TValue> -> unit member ToString: unit -> string member Key: 'TKey member Value: 'TValue
<summary>Defines a key/value pair that can be set or retrieved.</summary>
<typeparam name="TKey">The type of the key.</typeparam>
<typeparam name="TValue">The type of the value.</typeparam>

--------------------
type KeyValuePair = static member Create<'TKey,'TValue> : key: 'TKey * value: 'TValue -> KeyValuePair<'TKey,'TValue>
<summary>Creates instances of the <see cref="T:System.Collections.Generic.KeyValuePair`2" /> struct.</summary>

--------------------
System.Collections.Generic.KeyValuePair ()
System.Collections.Generic.KeyValuePair(key: 'TKey, value: 'TValue) : System.Collections.Generic.KeyValuePair<'TKey,'TValue>

active recognizer KeyValue: System.Collections.Generic.KeyValuePair<'Key,'Value> -> 'Key * 'Value

val v: string

val k: int