Export (0) Print
Expand All
Expand Minimize

Core.LanguagePrimitives Module (F#)

Language primitives associated with the F# language

Namespace/Module Path: Microsoft.FSharp.Core

Assembly: FSharp.Core (in FSharp.Core.dll)

module LanguagePrimitives

Module

Description

module ErrorStrings

For internal use only

module HashCompare

The F# compiler emits calls to some of the functions in this module as part of the compiled form of some language constructs

module IntrinsicFunctions

The F# compiler emits calls to some of the functions in this module as part of the compiled form of some language constructs

module IntrinsicOperators

The F# compiler emits calls to some of the functions in this module as part of the compiled form of some language constructs

Value

Description

AdditionDynamic : 'T1 -> 'T2 -> 'U

A compiler intrinsic that implements dynamic invocations to the + operator.

CheckedAdditionDynamic : 'T1 -> 'T2 -> 'U

A compiler intrinsic that implements dynamic invocations to the checked + operator.

CheckedMultiplyDynamic : 'T1 -> 'T2 -> 'U

A compiler intrinsic that implements dynamic invocations to the checked + operator.

DecimalWithMeasure : decimal -> decimal<'u>

Creates a decimal value with units-of-measure

DivideByInt : ^T -> int -> ^T

Divides a value by an integer.

DivideByIntDynamic : 'T -> int -> 'T

A compiler intrinsic that implements dynamic invocations for the DivideByInt primitive.

EnumOfValue : 'T -> enum

Creates an enumeration value from an underlying value.

EnumToValue : 'Enum -> 'T

Gets the underlying value for an enumeration value.

FastGenericComparer : IComparer<'T>

Creates an F# comparer object for the given type

FastGenericEqualityComparer : IEqualityComparer<'T>

Create an F# hash/equality object for the given type

FastLimitedGenericEqualityComparer : int -> IEqualityComparer<'T>

Create an F# hash/equality object for the given type using node-limited hashing when hashing F# records, lists and union types.

Float32WithMeasure : float -> float<'u>

Creates a float32 value with units-of-measure.

FloatWithMeasure : float32 -> float32<'u>

Creates a float value with units-of-measure.

GenericComparer : IComparer

A static F# comparer object.

GenericComparison : 'T -> 'T -> int

Compares two values.

GenericComparisonWithComparer : IComparer -> 'T -> 'T -> int

Compare two values. May be called as a recursive case from an implementation of IComparable<T> to ensure consistent NaN comparison semantics.

GenericEquality : 'T -> 'T -> bool

Compares two values for equality using partial equivalence relation semantics ([nan] <> [nan]).

GenericEqualityComparer : IEqualityComparer

Returns an F# comparer object suitable for hashing and equality. This hashing behavior of the returned comparer is not limited by an overall node count when hashing F# records, lists and union types.

GenericEqualityER : 'T -> 'T -> bool

Compares two values for equality using equivalence relation semantics ([nan] = [nan]).

GenericEqualityERComparer : IEqualityComparer

Return an F# comparer object suitable for hashing and equality. This hashing behavior of the returned comparer is not limited by an overall node count when hashing F# records, lists and union types. This equality comparer has equivalence relation semantics ([nan] = [nan]).

GenericEqualityWithComparer : IEqualityComparer -> 'T -> 'T -> bool

Compare two values for equality

GenericGreaterOrEqual : 'T -> 'T -> bool

Compares two values

GenericGreaterThan : 'T -> 'T -> bool

Compares two values

GenericHash : 'T -> int

Hashes a value according to its structure. This hash is not limited by an overall node count when hashing F# records, lists and union types.

GenericHashWithComparer : IEqualityComparer -> 'T -> int

Recursively hashes a part of a value according to its structure.

GenericLessOrEqual : 'T -> 'T -> bool

Compares two values

GenericLessThan : 'T -> 'T -> bool

Compares two values

GenericLimitedHash : int -> 'T -> int

Hashes a value according to its structure. Use the given limit to restrict the hash when hashing F# records, lists and union types.

GenericMaximum : 'T -> 'T -> 'T

Takes the maximum of two values structurally according to the order given by GenericComparison.

GenericMinimum : 'T -> 'T -> 'T

Takes the minimum of two values structurally according to the order given by GenericComparison.

GenericOne : ^T

Resolves to the one value for any primitive numeric type or any type with a static member called One.

GenericOneDynamic : unit -> 'T

Resolves to the one value for any primitive numeric type or any type with a static member called One..

GenericZero : ^T

Resolves to the zero value for any primitive numeric type or any type with a static member called Zero.

GenericZeroDynamic : unit -> 'T

Resolves to the zero value for any primitive numeric type or any type with a static member called Zero.

Int16WithMeasure : int16 -> int16<'u>

Creates an int16 value with units-of-measure

Int32WithMeasure : int32 -> int32<'u>

Creates an int32 value with units-of-measure

Int64WithMeasure : int64 -> int64<'u>

Creates an int64 value with units-of-measure

MultiplyDynamic : 'T1 -> 'T2 -> 'U

A compiler intrinsic that implements dynamic invocations to the + operator.

ParseInt32 : string -> int32

Parses an int32 according to the rules used by the overloaded int32 conversion operator when applied to strings

ParseInt64 : string -> int64

Parses an int64 according to the rules used by the overloaded int64 conversion operator when applied to strings

ParseUInt32 : string -> uint32

Parses an uint32 according to the rules used by the overloaded uint32 conversion operator when applied to strings

ParseUInt64 : string -> uint64

Parses an uint64 according to the rules used by the overloaded uint64 conversion operator when applied to strings

PhysicalEquality : 'T -> 'T -> bool

Reference/physical equality. True if boxed versions of the inputs are reference-equal, OR if both are primitive numeric types and the implementation of Equals for the type of the first argument returns true on the boxed versions of the inputs.

PhysicalHash : 'T -> int

The physical hash. Hashes on the object identity, except for value types, where we hash on the contents.

SByteWithMeasure : sbyte -> sbyte<'u>

Creates an sbyte value with units-of-measure

Windows 8, Windows 7, Windows Server 2012, Windows Server 2008 R2

F# Core Library Versions

Supported in: 2.0, 4.0, Portable

Show:
© 2014 Microsoft