| Value | Description |
|---|
val ( ! ) : 'T ref -> 'T |
Dereference a mutable reference cell
|
val ( % ) : overloaded |
Overloaded modulo operator
|
val ( &&& ) : overloaded |
Overloaded logical-AND operator
|
val ( * ) : overloaded |
Overloaded multiplication operator
|
val ( ** ) : overloaded |
Overloaded power operator.
|
val ( + ) : overloaded |
Overloaded addition operator
|
val ( - ) : overloaded |
Overloaded subtraction operator
|
val ( .. ) : overloaded |
The standard overloaded range operator, e.g. [n..m] for lists, seq {n..m} for sequences
|
val ( .. .. ) : overloaded |
The standard overloaded skip range operator, e.g. [n..skip..m] for lists, seq {n..skip..m} for sequences
|
val ( / ) : overloaded |
Overloaded division operator
|
val ( := ) : 'T ref -> 'T -> unit |
Assign to a mutable reference cell
|
val ( < ) : 'T -> 'T -> bool |
Structural less-than comparison
|
val ( << ) : ('U -> 'V) -> ('T -> 'U) -> ('T -> 'V) |
Compose two functions, the function on the right being applied first
|
val ( <<< ) : overloaded |
Overloaded byte-shift left operator by a specified number of bits
|
val ( <= ) : 'T -> 'T -> bool |
Structural less-than-or-equal comparison
|
val ( <> ) : 'T -> 'T -> bool |
Structural inequality
|
val ( <| ) : ('T -> 'U) -> 'T -> 'U |
Apply a function to a value, the value being on the right, the function on the left
|
val ( <|| ) : ('T1 -> 'T2 -> 'U) -> 'T1 * 'T2 -> 'U |
Apply a function to two values, the values being a pair on the right, the function on the left
|
val ( <||| ) : ('T1 -> 'T2 -> 'T3 -> 'U) -> 'T1 * 'T2 * 'T3 -> 'U |
Apply a function to three values, the values being a triple on the right, the function on the left
|
val ( = ) : 'T -> 'T -> bool |
Structural equality
|
val ( > ) : 'T -> 'T -> bool |
Structural greater-than
|
val ( >= ) : 'T -> 'T -> bool |
Structural greater-than-or-equal
|
val ( >> ) : ('T -> 'U) -> ('U -> 'V) -> ('T -> 'V) |
Compose two functions, the function on the left being applied first
|
val ( >>> ) : overloaded |
Overloaded byte-shift right operator by a specified number of bits
|
val ( @ ) : 'T list -> 'T list -> 'T list |
Concatenate two lists.
|
val ( ^ ) : string -> string -> string |
Concatenate two strings. The overlaoded operator '+' may also be used.
|
val ( ^^^ ) : overloaded |
Overloaded logical-XOR operator
|
val ( |> ) : 'T -> ('T -> 'U) -> 'U |
Apply a function to a value, the value being on the left, the function on the right
|
val ( ||> ) : 'T1 * 'T2 -> ('T1 -> 'T2 -> 'U) -> 'U |
Apply a function to two values, the values being a pair on the left, the function on the right
|
val ( ||| ) : overloaded |
Overloaded logical-OR operator
|
val ( |||> ) : 'T1 * 'T2 * 'T3 -> ('T1 -> 'T2 -> 'T3 -> 'U) -> 'U |
Apply a function to three values, the values being a triple on the left, the function on the right
|
val ( ~+ ) : overloaded |
Overloaded prefix=plus operator
|
val ( ~- ) : overloaded |
Overloaded unary negation.
|
val ( ~~~ ) : overloaded |
Overloaded logical-NOT operator
|
val abs : overloaded |
Absolute value of the given number
|
val acos : overloaded |
Inverse cosine of the given number
|
val asin : overloaded |
Inverse sine of the given number
|
val atan : overloaded |
Inverse tangent of the given number
|
val atan2 : overloaded |
Inverse tangent of x/y where x and y are specified separately
|
val box : 'T -> obj |
Boxes a strongly typed value.
|
val byte : overloaded |
Converts the argument to byte. This is a direct conversion for all
primitive numeric types. For strings, the input is converted using Byte.Parse() on strings and otherwise requires a ToByte method on the input type
|
val ceil : overloaded |
Ceiling of the given number
|
val char : overloaded |
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 types a static member ToChar must exist on the type.
|
val compare : 'T -> 'T -> int |
Generic comparison
|
val cos : overloaded |
Cosine of the given number
|
val cosh : overloaded |
Hyperbolic cosine of the given number
|
val decimal : overloaded |
Converts the argument to System.Decimal using a direct conversion for all
primitive numeric types and requiring a ToDecimal method otherwise
|
val decr : int ref -> unit |
Decrement a mutable reference cell containing an integer
|
val defaultArg : 'T option -> 'T -> 'T |
Used to specify a default value for an optional argument in the implementation of a function
|
val double : overloaded |
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 and invokes a ToDouble method on the input type
|
val enum : int32 -> 'U (requires enum) |
Converts the argument to a particular enum type.
|
val exp : overloaded |
Exponential of the given number
|
val failwith : string -> 'T |
Throw a FailureException exception
|
val float : overloaded |
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 and invokes a ToDouble method on the input type
|
val float32 : overloaded |
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 and invokes a ToSingle method on the input type
|
val floor : overloaded |
Floor of the given number
|
val fst : ('T1 * 'T2) -> 'T1 |
Return the first element of a tuple, fst (a,b) = a.
|
val hash : 'T -> int |
A generic hash function, designed to return equal hash values for items that are
equal according to the "=" operator. By default it will use structural hashing
for F# union, record and tuple types, hashing the complete contents of the
type. The exact behaviour of the function can be adjusted on a
type-by-type basis by implementing GetHashCode for each type.
|
val id : 'T -> 'T |
The identity function
|
val ignore : 'T -> unit |
Ignore the passed value. This is often used to throw away results of a computation.
|
val incr : int ref -> unit |
Increment a mutable reference cell containing an integer
|
val infinity : float |
Equivalent to System.Double.PositiveInfinity
|
val infinityf : float32 |
Equivalent to System.Single.PositiveInfinity
|
val int : overloaded |
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 and invokes a ToInt32 method on the input type
|
val int16 : overloaded |
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 and invokes a ToInt16 method on the input type
|
val int32 : overloaded |
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 and invokes a ToInt32 method on the input type
|
val int64 : overloaded |
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 and invokes a ToInt64 method on the input type
|
val invalidArg : string -> string -> 'T |
Throw an ArgumentException exception
|
val invalidOp : string -> 'T |
Throw an InvalidOperationException exception
|
val limitedHash : int -> 'T -> int |
A generic hash function. This function has the same behaviour as 'hash',
however the default structural hashing for F# union, record and tuple
types stops when the given limit of nodes is reached. The exact behaviour of
the function can be adjusted on a type-by-type basis by implementing
GetHashCode for each type.
|
val lock : 'lock -> (unit -> 'T) -> 'T (requires reference type) |
Execute the function as a mutual-exlcusion region using the input value as a lock.
|
val log : overloaded |
Natural logarithm of the given number
|
val log10 : overloaded |
Logarithm to base 10 of the given number
|
val max : 'T -> 'T -> 'T |
Maximum based on generic comparison
|
val min : 'T -> 'T -> 'T |
Minimum based on generic comparison
|
val nan : float |
Equivalent to System.Double.NaN
|
val nanf : float32 |
Equivalent to System.Single.NaN
|
val nativeint : overloaded |
Converts the argument to signed native integer. This is a direct conversion for all
primitive numeric types and ToIntPtr method otherwise)
|
val not : bool -> bool |
Negate a logical value. not true equals false and not false equals true
|
val nullArg : string -> 'T |
Throw an ArgumentNullException exception
|
val pown : overloaded |
Overloaded power operator. If n > 0 then equivalent to x*...*x for n occurrences of x.
|
val raise : Exception -> 'T |
Raises an exception
|
val ref : 'T -> 'T ref |
Create a mutable reference cell
|
[<NoDynamicInvocationAttribute ()>]
val rethrow : unit -> 'T |
Rethrows an exception. This should only be used when handling an exception
|
val round : overloaded |
Round the given number
|
val sbyte : overloaded |
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 and invokes a ToSByte method on the input type
|
val sign : overloaded |
Sign of the given number
|
val sin : overloaded |
Sine of the given number
|
val single : overloaded |
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 and invokes a ToSingle method on the input type
|
val sinh : overloaded |
Hyperbolic sine of the given number
|
[<RequiresExplicitTypeArgumentsAttribute ()>]
val sizeof<'T> : int |
Returns the internal size of a type in bytes. For example, sizeof<int> returns 4.
|
val snd : ('T1 * 'T2) -> 'T2 |
Return the second element of a tuple, snd (a,b) = b.
|
val sqrt : overloaded |
Square root of the given number
|
val stderr<'T> : TextWriter |
Reads the value of the property System.Console.Error.
|
val stdin<'T> : TextReader |
Reads the value of the property System.Console.In.
|
val stdout<'T> : TextWriter |
Reads the value of the property System.Console.Out.
|
val string : 'T -> string |
Converts the argument to a string using ToString.
For standard integer and floating point values the ToString conversion uses CultureInfo.InvariantCulture.
Note, native integer ToString does not support specifying CultureInfo.
|
val tan : overloaded |
Tangent of the given number
|
val tanh : overloaded |
Hyperbolic tangent of the given number
|
[<RequiresExplicitTypeArgumentsAttribute ()>]
val typedefof<'T> : Type |
Generate a System.Type representation for a type definition. If the
input type is a generic type instantiation then return the
generic type definition associated with all such instantiations.
|
[<RequiresExplicitTypeArgumentsAttribute ()>]
val typeof<'T> : Type |
Generate a System.Type runtime represenation of a static type.
The static type is still maintained on the value returned.
|
val uint16 : overloaded |
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 and invokes a ToUInt16 method on the input type
|
val uint32 : overloaded |
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 and invokes a ToUInt32 method on the input type
|
val uint64 : overloaded |
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 and invokes a ToUInt64 method on the input type
|
val unativeint : overloaded |
Converts the argument to unsigned native integer using a direct conversion for all
primitive numeric types and requiring a ToUintPtr method otherwise
|
val unbox : obj -> 'T |
Unboxes a strongly typed value. This is the inverse of box, unbox<t>(box<t> a) equals a.
|
val using : 'T -> ('T -> 'U) -> 'U (requires 'T :> IDisposable) |
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.
|