Core.Operators Module (F#)

module Checked

This module contains the basic arithmetic operations with overflow checks.

module Unchecked

This module contains basic operations which do not apply runtime and/or static checks

( ! ) : 'T ref -> 'T

Dereference a mutable reference cell.

( &&& ) : ^T -> ^T -> ^T

Overloaded bitwise AND operator.

( ** ) : ^T -> ^U -> ^T

Overloaded exponentiation operator.

( - ) : ^T1 -> ^T2 -> ^T3

Overloaded subtraction operator.

( .. .. ) : ^T -> ^Step -> ^T -> seq<^T>

The standard overloaded skip range operator, e.g. [n..skip..m] for lists, seq {n..skip..m} for sequences.

( := ) : 'T ref -> 'T -> unit

Assigns to a mutable reference cell.

( << ) : ('T2 -> 'T3) -> ('T1 -> 'T2) -> 'T1 -> 'T3

Composes two functions, the function on the right being applied first.

( <= ) : 'T -> 'T -> bool

Structural less-than-or-equal comparison.

( <| ) : ('T -> 'U) -> 'T -> 'U

Apply a function to a value, the value being on the right, the function on the left.

( <||| ) : ('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.

( > ) : 'T -> 'T -> bool

Structural greater-than.

( >> ) : ('T1 -> 'T2) -> ('T2 -> 'T3) -> 'T1 -> 'T3

Compose two functions, the function on the left being applied first.

( @ ) : 'T list -> 'T list -> 'T list

Concatenates two lists.

( ^^^ ) : ^T -> ^T -> ^T

Overloaded bitwise XOR operator.

( ||> ) : '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.

( |||> ) : '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.

( ~- ) : ^T -> ^T

Overloaded unary negation.

abs : ^T -> ^T

Absolute value of the given number.

asin : ^T -> ^T

Inverse sine of the given number.

atan2 : ^T1 -> ^T2 -> 'T2

Inverse tangent of x/y where x and y are specified separately.

byte : ^T -> byte

Converts the argument to byte. This is a direct conversion for all primitive numeric types. For strings, the input is converted using Parse with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type.

char : ^T -> char

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.

cos : ^T -> ^T

Cosine of the given number.

decimal : ^T -> decimal

Converts the argument to Decimal using a direct conversion for all primitive numeric types. For strings, the input is converted using Parse with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type.

defaultArg : 'T option -> 'T -> 'T

Used to specify a default value for an optional argument in the implementation of a function.

exit : int -> 'T

Exit the current hardware isolated process, if security settings permit, otherwise raise an exception. Calls Exit.

Failure : string -> exn

Builds a Exception object.

float : ^T -> float

Converts the argument to 64-bit float. This is a direct conversion for all primitive numeric types. For strings, the input is converted using Parse with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type.

floor : ^T -> ^T

Floor of the given number.

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 behavior of the function can be adjusted on a type-by-type basis by implementing GetHashCode for each type.

ignore : 'T -> unit

Ignore the passed value. This is often used to throw away results of a computation.

infinity : float

Equivalent to PositiveInfinity.

int : ^T -> int

Converts the argument to signed 32-bit integer. This is a direct conversion for all primitive numeric types. For strings, the input is converted using Parse with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type.

int32 : ^T -> int32

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 Parse) with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type.

invalidArg : string -> string -> 'T

Throw a ArgumentException exception.

limitedHash : int -> 'T -> int

A generic hash function. This function has the same behavior 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 behavior of the function can be adjusted on a type-by-type basis by implementing GetHashCode for each type.

log : ^T -> ^T

Natural logarithm of the given number.

max : 'T -> 'T -> 'T

Maximum based on generic comparison.

nan : float

Equivalent to NaN.

nativeint : ^T -> nativeint

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.

nullArg : string -> 'T

Throw an ArgumentNullException exception.

raise : Exception -> 'T

Raises an exception.

reraise : unit -> 'T

Rethrows an exception. This should only be used when handling an exception.

sbyte : ^T -> sbyte

Converts the argument to signed byte. This is a direct conversion for all primitive numeric types. For strings, the input is converted using Parse with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type.

sign : ^T -> int

Sign of the given number.

sinh : ^T -> ^T

Hyperbolic sine of the given number.

snd : 'T1 * 'T2 -> 'T2

Return the second element of a tuple, snd (a,b) = b.

stderr : TextWriter

Reads the value of the property Error.

stdout : TextWriter

Reads the value of the property Out.

tan : ^T -> ^T

Tangent of the given number.

truncate : ^T -> ^T

Overloaded truncate operator.

typeof : Type

Generate a Type runtime representation of a static type. The static type is still maintained on the value returned.

uint32 : ^T -> uint32

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 Parse with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type.

unativeint : ^T -> nativeint

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.

using : 'T -> ('T -> 'U) -> 'U

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.

( |Failure|_| ) : exn -> string option

Matches Exception objects whose runtime type is precisely Exception.