Nullable (FSharp.Core)

Converts the argument to byte. This is a direct conversion for all primitive numeric types. The operation requires an appropriate static conversion method on the input type.

value : Nullable<^T>: The input value.

Returns: Nullable<byte>: The converted byte

 open System
 open FSharp.Linq.NullableOperators

 Nullable.byte (Nullable<int>())  // evaluates to Nullable<byte>()
 Nullable.byte (Nullable<int>(3))  // evaluates to Nullable(3uy)

namespace System

namespace Microsoft.FSharp

namespace Microsoft.FSharp.Linq

module NullableOperators from Microsoft.FSharp.Linq

Multiple items
type Nullable = static member Compare<'T (requires default constructor and value type and 'T :> ValueType)> : n1: Nullable<'T> * n2: Nullable<'T> -> int static member Equals<'T (requires default constructor and value type and 'T :> ValueType)> : n1: Nullable<'T> * n2: Nullable<'T> -> bool static member GetUnderlyingType: nullableType: Type -> Type static member GetValueRefOrDefaultRef<'T (requires default constructor and value type and 'T :> ValueType)> : nullable: byref<Nullable<'T>> -> inref<'T>
<summary>Supports a value type that can be assigned <see langword="null" />. This class cannot be inherited.</summary>

--------------------
[<Struct>] type Nullable<'T (requires default constructor and value type and 'T :> ValueType)> = new: value: 'T -> unit member Equals: other: obj -> bool member GetHashCode: unit -> int member GetValueOrDefault: unit -> 'T + 1 overload member ToString: unit -> string static member op_Explicit: value: Nullable<'T> -> 'T static member op_Implicit: value: 'T -> Nullable<'T> member HasValue: bool member Value: 'T
<summary>Represents a value type that can be assigned <see langword="null" />.</summary>
<typeparam name="T">The underlying value type of the <see cref="T:System.Nullable`1" /> generic type.</typeparam>

--------------------
Nullable ()
Nullable(value: 'T) : Nullable<'T>

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int

Converts the argument to character. Numeric inputs are converted according to the UTF-16 encoding for characters. The operation requires an appropriate static conversion method on the input type.

value : Nullable<^T>: The input value.

Returns: Nullable<char>: The converted char.

 open System
 open FSharp.Linq.NullableOperators

 Nullable.char (Nullable<int>())  // evaluates to Nullable<char>()
 Nullable.char (Nullable<int>(64))  // evaluates to Nullable<char>('@')

namespace System

namespace Microsoft.FSharp

namespace Microsoft.FSharp.Linq

module NullableOperators from Microsoft.FSharp.Linq

--------------------
Nullable ()
Nullable(value: 'T) : Nullable<'T>

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int

Converts the argument to System.Decimal using a direct conversion for all primitive numeric types. The operation requires an appropriate static conversion method on the input type.

value : Nullable<^T>: The input value.

Returns: Nullable<decimal>: The converted decimal.

 open System
 open FSharp.Linq.NullableOperators

 Nullable.decimal (Nullable<int>())  // evaluates to Nullable<decimal>()
 Nullable.decimal (Nullable<int>(3))  // evaluates to Nullable<decimal>(3.0M)

namespace System

namespace Microsoft.FSharp

namespace Microsoft.FSharp.Linq

module NullableOperators from Microsoft.FSharp.Linq

--------------------
Nullable ()
Nullable(value: 'T) : Nullable<'T>

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int

Converts the argument to 64-bit float. This is a direct conversion for all primitive numeric types. The operation requires an appropriate static conversion method on the input type.

value : Nullable<^T>: The input value.

Returns: Nullable<double>: The converted float

 open System
 open FSharp.Linq.NullableOperators

 Nullable.double (Nullable<int>())  // evaluates to Nullable<double>()
 Nullable.double (Nullable<int>(3))  // evaluates to Nullable<double>(3.0)

namespace System

namespace Microsoft.FSharp

namespace Microsoft.FSharp.Linq

module NullableOperators from Microsoft.FSharp.Linq

--------------------
Nullable ()
Nullable(value: 'T) : Nullable<'T>

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int

Converts the argument to a particular enum type.

value : Nullable<int32>: The input value.

Returns: Nullable<^U>: The converted enum type.

 open System
 open FSharp.Linq.NullableOperators

 Nullable.enum<DayOfWeek> (Nullable<int>())  // evaluates to Nullable<uint>()
 Nullable.enum<DayOfWeek> (Nullable<int>(3))  // evaluates to Nullable<DayOfWeek>(Wednesday)

namespace System

namespace Microsoft.FSharp

namespace Microsoft.FSharp.Linq

module NullableOperators from Microsoft.FSharp.Linq

--------------------
Nullable ()
Nullable(value: 'T) : Nullable<'T>

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int

Converts the argument to 64-bit float. This is a direct conversion for all primitive numeric types. The operation requires an appropriate static conversion method on the input type.

value : Nullable<^T>: The input value.

Returns: Nullable<float>: The converted float

 open System
 open FSharp.Linq.NullableOperators

 Nullable.float (Nullable<int>())  // evaluates to Nullable<float>()
 Nullable.float (Nullable<int>(3))  // evaluates to Nullable<float>(3.0)

namespace System

namespace Microsoft.FSharp

namespace Microsoft.FSharp.Linq

module NullableOperators from Microsoft.FSharp.Linq

--------------------
Nullable ()
Nullable(value: 'T) : Nullable<'T>

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int

Converts the argument to 32-bit float. This is a direct conversion for all primitive numeric types. The operation requires an appropriate static conversion method on the input type.

value : Nullable<^T>: The input value.

Returns: Nullable<float32>: The converted float32

 open System
 open FSharp.Linq.NullableOperators

 Nullable.float32 (Nullable<int>())  // evaluates to Nullable<float32>()
 Nullable.float32 (Nullable<int>(3))  // evaluates to Nullable<float32>(3.0f)

namespace System

namespace Microsoft.FSharp

namespace Microsoft.FSharp.Linq

module NullableOperators from Microsoft.FSharp.Linq

--------------------
Nullable ()
Nullable(value: 'T) : Nullable<'T>

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int

Converts the argument to signed 32-bit integer. This is a direct conversion for all primitive numeric types. The operation requires an appropriate static conversion method on the input type.

value : Nullable<^T>: The input value.

Returns: Nullable<int>: The converted int

 open System
 open FSharp.Linq.NullableOperators

 Nullable.int (Nullable<int64>())  // evaluates to Nullable<int>()
 Nullable.int (Nullable<int64>(3))  // evaluates to Nullable(3)

namespace System

namespace Microsoft.FSharp

namespace Microsoft.FSharp.Linq

module NullableOperators from Microsoft.FSharp.Linq

--------------------
Nullable ()
Nullable(value: 'T) : Nullable<'T>

Multiple items
val int64: value: 'T -> int64 (requires member op_Explicit)

--------------------
type int64 = Int64

--------------------
type int64<'Measure> = int64

Converts the argument to signed 16-bit integer. This is a direct conversion for all primitive numeric types. The operation requires an appropriate static conversion method on the input type.

value : Nullable<^T>: The input value.

Returns: Nullable<int16>: The converted int16

 open System
 open FSharp.Linq.NullableOperators

 Nullable.int16 (Nullable<int>())  // evaluates to Nullable<int16>()
 Nullable.int16 (Nullable<int>(3))  // evaluates to Nullable(3s)

namespace System

namespace Microsoft.FSharp

namespace Microsoft.FSharp.Linq

module NullableOperators from Microsoft.FSharp.Linq

--------------------
Nullable ()
Nullable(value: 'T) : Nullable<'T>

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int

Converts the argument to signed 32-bit integer. This is a direct conversion for all primitive numeric types. The operation requires an appropriate static conversion method on the input type.

value : Nullable<^T>: The input value.

Returns: Nullable<int32>: The converted int32

 open System
 open FSharp.Linq.NullableOperators

 Nullable.int32 (Nullable<int64>())  // evaluates to Nullable<int32>()
 Nullable.int32 (Nullable<int64>(3))  // evaluates to Nullable(3)

namespace System

namespace Microsoft.FSharp

namespace Microsoft.FSharp.Linq

module NullableOperators from Microsoft.FSharp.Linq

--------------------
Nullable ()
Nullable(value: 'T) : Nullable<'T>

Multiple items
val int64: value: 'T -> int64 (requires member op_Explicit)

--------------------
type int64 = Int64

--------------------
type int64<'Measure> = int64

Converts the argument to signed 64-bit integer. This is a direct conversion for all primitive numeric types. The operation requires an appropriate static conversion method on the input type.

value : Nullable<^T>: The input value.

Returns: Nullable<int64>: The converted int64

 open System
 open FSharp.Linq.NullableOperators

 Nullable.int64 (Nullable<int>())  // evaluates to Nullable<int64>()
 Nullable.int64 (Nullable<int>(3))  // evaluates to Nullable<int64>(3L)

namespace System

namespace Microsoft.FSharp

namespace Microsoft.FSharp.Linq

module NullableOperators from Microsoft.FSharp.Linq

--------------------
Nullable ()
Nullable(value: 'T) : Nullable<'T>

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int

Converts the argument to signed byte. This is a direct conversion for all primitive numeric types. The operation requires an appropriate static conversion method on the input type.

value : Nullable<^T>: The input value.

Returns: Nullable<int8>: The converted sbyte

 open System
 open FSharp.Linq.NullableOperators

 Nullable.int8 (Nullable<int>())  // evaluates to Nullable<sbyte>()
 Nullable.int8 (Nullable<int>(3))  // evaluates to Nullable(3y)

namespace System

namespace Microsoft.FSharp

namespace Microsoft.FSharp.Linq

module NullableOperators from Microsoft.FSharp.Linq

--------------------
Nullable ()
Nullable(value: 'T) : Nullable<'T>

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int

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 : Nullable<^T>: The input value.

Returns: Nullable<nativeint>: The converted nativeint

 open System
 open FSharp.Linq.NullableOperators

 Nullable.nativeint (Nullable<int>())  // evaluates to Nullable<nativeint>()
 Nullable.nativeint (Nullable<int>(3))  // evaluates to Nullable<nativeint>(3n)

namespace System

namespace Microsoft.FSharp

namespace Microsoft.FSharp.Linq

module NullableOperators from Microsoft.FSharp.Linq

--------------------
Nullable ()
Nullable(value: 'T) : Nullable<'T>

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int

Converts the argument to signed byte. This is a direct conversion for all primitive numeric types. The operation requires an appropriate static conversion method on the input type.

value : Nullable<^T>: The input value.

Returns: Nullable<sbyte>: The converted sbyte

 open System
 open FSharp.Linq.NullableOperators

 Nullable.sbyte (Nullable<int>())  // evaluates to Nullable<sbyte>()
 Nullable.sbyte (Nullable<int>(3))  // evaluates to Nullable(3y)

namespace System

namespace Microsoft.FSharp

namespace Microsoft.FSharp.Linq

module NullableOperators from Microsoft.FSharp.Linq

--------------------
Nullable ()
Nullable(value: 'T) : Nullable<'T>

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int

Converts the argument to 32-bit float. This is a direct conversion for all primitive numeric types. The operation requires an appropriate static conversion method on the input type.

value : Nullable<^T>: The input value.

Returns: Nullable<single>: The converted float32

 open System
 open FSharp.Linq.NullableOperators

 Nullable.single (Nullable<int>())  // evaluates to Nullable<float32>()
 Nullable.single (Nullable<int>(3))  // evaluates to Nullable<float32>(3.0f)

namespace System

namespace Microsoft.FSharp

namespace Microsoft.FSharp.Linq

module NullableOperators from Microsoft.FSharp.Linq

--------------------
Nullable ()
Nullable(value: 'T) : Nullable<'T>

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int

Converts the argument to an unsigned 32-bit integer. This is a direct conversion for all primitive numeric types. The operation requires an appropriate static conversion method on the input type.

value : Nullable<^T>: The input value.

Returns: Nullable<uint>: The converted unsigned integer

 open System
 open FSharp.Linq.NullableOperators

 Nullable.uint (Nullable<int>())  // evaluates to Nullable<uint>()
 Nullable.uint (Nullable<int>(3))  // evaluates to Nullable(3u)

namespace System

namespace Microsoft.FSharp

namespace Microsoft.FSharp.Linq

module NullableOperators from Microsoft.FSharp.Linq

--------------------
Nullable ()
Nullable(value: 'T) : Nullable<'T>

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int

Converts the argument to unsigned 16-bit integer. This is a direct conversion for all primitive numeric types. The operation requires an appropriate static conversion method on the input type.

value : Nullable<^T>: The input value.

Returns: Nullable<uint16>: The converted uint16

 open System
 open FSharp.Linq.NullableOperators

 Nullable.uint16 (Nullable<int>())  // evaluates to Nullable<uint16>()
 Nullable.uint16 (Nullable<int>(3))  // evaluates to Nullable(3us)

namespace System

namespace Microsoft.FSharp

namespace Microsoft.FSharp.Linq

module NullableOperators from Microsoft.FSharp.Linq

--------------------
Nullable ()
Nullable(value: 'T) : Nullable<'T>

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int

Converts the argument to unsigned 32-bit integer. This is a direct conversion for all primitive numeric types. The operation requires an appropriate static conversion method on the input type.

value : Nullable<^T>: The input value.

Returns: Nullable<uint32>: The converted uint32

 open System
 open FSharp.Linq.NullableOperators

 Nullable.uint32 (Nullable<int>())  // evaluates to Nullable<uint32>()
 Nullable.uint32 (Nullable<int>(3))  // evaluates to Nullable(3u)

namespace System

namespace Microsoft.FSharp

namespace Microsoft.FSharp.Linq

module NullableOperators from Microsoft.FSharp.Linq

--------------------
Nullable ()
Nullable(value: 'T) : Nullable<'T>

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int

Converts the argument to unsigned 64-bit integer. This is a direct conversion for all primitive numeric types. The operation requires an appropriate static conversion method on the input type.

value : Nullable<^T>: The input value.

Returns: Nullable<uint64>: The converted uint64

 open System
 open FSharp.Linq.NullableOperators

 Nullable.uint64 (Nullable<int>())  // evaluates to Nullable<uint64>()
 Nullable.uint64 (Nullable<int>(3))  // evaluates to Nullable<uint64>(3UL)

namespace System

namespace Microsoft.FSharp

namespace Microsoft.FSharp.Linq

module NullableOperators from Microsoft.FSharp.Linq

--------------------
Nullable ()
Nullable(value: 'T) : Nullable<'T>

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int

Converts the argument to byte. This is a direct conversion for all primitive numeric types. The operation requires an appropriate static conversion method on the input type.

value : Nullable<^T>: The input value.

Returns: Nullable<uint8>: The converted byte

 open System
 open FSharp.Linq.NullableOperators

 Nullable.uint8 (Nullable<int>())  // evaluates to Nullable<byte>()
 Nullable.uint8 (Nullable<int>(3))  // evaluates to Nullable(3uy)

namespace System

namespace Microsoft.FSharp

namespace Microsoft.FSharp.Linq

module NullableOperators from Microsoft.FSharp.Linq

--------------------
Nullable ()
Nullable(value: 'T) : Nullable<'T>

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int

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 : Nullable<^T>: The input value.

Returns: Nullable<unativeint>: The converted unativeint

 open System
 open FSharp.Linq.NullableOperators

 Nullable.unativeint (Nullable<int>())  // evaluates to Nullable<unativeint>()
 Nullable.unativeint (Nullable<int>(3))  // evaluates to Nullable<unativeint>(3un)

namespace System

namespace Microsoft.FSharp

namespace Microsoft.FSharp.Linq

module NullableOperators from Microsoft.FSharp.Linq

--------------------
Nullable ()
Nullable(value: 'T) : Nullable<'T>

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int