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

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)

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

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

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

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"

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

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']

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])

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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']

Concatenate two strings. The operator '+' may also be used.

s1 : string

s2 : string

Returns: string

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

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

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

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

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

Overloaded prefix-plus operator

value : ^T

The input value.

Returns: ^T

The result of the operation.

Overloaded unary negation.

n : ^T

The value to negate.

Returns: ^T

The result of the operation.

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

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

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

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

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

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

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

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

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

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

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

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'

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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"

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

The identity function

x : 'T

The input value.

Returns: 'T

The same value.

Example

 id 12     //  Evaulates to 12
 id "abc"  //  Evaulates to "abc"

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 ()

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

Equivalent to Double.PositiveInfinity

Returns: float

Equivalent to Single.PositiveInfinity

Returns: float32

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

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

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

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

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"

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

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

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.

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

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

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

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"

An internal, library-only compiler intrinsic for compile-time generation of a RuntimeMethodHandle.

arg0 : 'T -> 'TResult

Returns: RuntimeMethodHandle

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"

Returns the name of the given symbol.

arg0 : 'T

Returns: string

Example

 let myVariableName = "This value doesn't matter"
 nameof(myVariableName)   //  Evaluates to "myVariableName"

Equivalent to Double.NaN

Returns: float

Equivalent to Single.NaN

Returns: float32

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

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')

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

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"

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

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

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

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

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) }

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

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

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

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

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

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

Reads the value of the property Console.Error.

Returns: TextWriter

Reads the value of the property Console.In.

Returns: TextReader

Reads the value of the property Console.Out.

Returns: TextWriter

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"

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

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

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

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

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]        ///

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"

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

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

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

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

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

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

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))

Matches Exception objects whose runtime type is precisely Exception

error : exn

The input exception.

Returns: string option

A string option.

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"