Option (FSharp.Core)

Option Module

Namespace: FSharp.Core
Assembly: FSharp.Core.dll

Contains operations for working with options.

Functions and values

Function or value	Description
`Option.bind binder option` Full Usage: `Option.bind binder option` Parameters: binder : `'T -> 'U option` - A function that takes the value of type T from an option and transforms it into an option containing a value of type U. option : `'T option` - The input option. Returns: `'U option` An option of the output type of the binder. Modifiers: inline Type parameters: 'T, 'U	`bind f inp` evaluates to `match inp with None -> None \| Some x -> f x` binder : `'T -> 'U option` A function that takes the value of type T from an option and transforms it into an option containing a value of type U. option : `'T option` The input option. Returns: `'U option` An option of the output type of the binder. Example `let tryParse (input: string) = match System.Int32.TryParse input with \| true, v -> Some v \| false, _ -> None None \|> Option.bind tryParse // evaluates to None Some "42" \|> Option.bind tryParse // evaluates to Some 42 Some "Forty-two" \|> Option.bind tryParse // evaluates to None` val tryParse: input: string -> int option val input: string Multiple items val string: value: 'T -> string -------------------- type string = System.String namespace System [<Struct>] type Int32 = member CompareTo: value: int -> int + 1 overload member Equals: obj: int -> bool + 1 overload member GetHashCode: unit -> int member GetTypeCode: unit -> TypeCode member ToString: unit -> string + 3 overloads member TryFormat: utf8Destination: Span<byte> * bytesWritten: byref<int> * ?format: ReadOnlySpan<char> * ?provider: IFormatProvider -> bool + 1 overload static member Abs: value: int -> int static member BigMul: left: int * right: int -> int64 static member Clamp: value: int * min: int * max: int -> int static member CopySign: value: int * sign: int -> int ... <summary>Represents a 32-bit signed integer.</summary> System.Int32.TryParse(s: string, result: byref<int>) : bool System.Int32.TryParse(s: System.ReadOnlySpan<char>, result: byref<int>) : bool System.Int32.TryParse(utf8Text: System.ReadOnlySpan<byte>, result: byref<int>) : bool System.Int32.TryParse(s: string, provider: System.IFormatProvider, result: byref<int>) : bool System.Int32.TryParse(s: System.ReadOnlySpan<char>, provider: System.IFormatProvider, result: byref<int>) : bool System.Int32.TryParse(utf8Text: System.ReadOnlySpan<byte>, provider: System.IFormatProvider, result: byref<int>) : bool System.Int32.TryParse(s: string, style: System.Globalization.NumberStyles, provider: System.IFormatProvider, result: byref<int>) : bool System.Int32.TryParse(s: System.ReadOnlySpan<char>, style: System.Globalization.NumberStyles, provider: System.IFormatProvider, result: byref<int>) : bool System.Int32.TryParse(utf8Text: System.ReadOnlySpan<byte>, style: System.Globalization.NumberStyles, provider: System.IFormatProvider, result: byref<int>) : bool val v: int union case Option.Some: Value: 'T -> Option<'T> union case Option.None: Option<'T> module Option from Microsoft.FSharp.Core val bind: binder: ('T -> 'U option) -> option: 'T option -> 'U option
`Option.contains value option` Full Usage: `Option.contains value option` Parameters: value : `'T` - The value to test for equality. option : `'T option` - The input option. Returns: `bool` True if the option is `Some` and contains a value equal to value, otherwise false. Modifiers: inline Type parameters: 'T	Evaluates to true if option is `Some` and its value is equal to value. value : `'T` The value to test for equality. option : `'T option` The input option. Returns: `bool` True if the option is `Some` and contains a value equal to value, otherwise false. Example `(99, None) \|\|> Option.contains // evaluates to false (99, Some 99) \|\|> Option.contains // evaluates to true (99, Some 100) \|\|> Option.contains // evaluates to false` union case Option.None: Option<'T> module Option from Microsoft.FSharp.Core val contains: value: 'T -> option: 'T option -> bool (requires equality) union case Option.Some: Value: 'T -> Option<'T>
`Option.count option` Full Usage: `Option.count option` Parameters: option : `'T option` - The input option. Returns: `int` A zero if the option is None, a one otherwise. Modifiers: inline Type parameters: 'T	`count inp` evaluates to `match inp with None -> 0 \| Some _ -> 1`. option : `'T option` The input option. Returns: `int` A zero if the option is None, a one otherwise. Example `None \|> Option.count // evaluates to 0 Some 99 \|> Option.count // evaluates to 1` union case Option.None: Option<'T> module Option from Microsoft.FSharp.Core val count: option: 'T option -> int union case Option.Some: Value: 'T -> Option<'T>
`Option.defaultValue value option` Full Usage: `Option.defaultValue value option` Parameters: value : `'T` - The specified default value. option : `'T option` - The input option. Returns: `'T` The option if the option is Some, else the default value. Modifiers: inline Type parameters: 'T	Gets the value of the option if the option is `Some`, otherwise returns the specified default value. Identical to the built-in defaultArg operator, except with the arguments swapped. value : `'T` The specified default value. option : `'T option` The input option. Returns: `'T` The option if the option is Some, else the default value. Example `(99, None) \|\|> Option.defaultValue // evaluates to 99 (99, Some 42) \|\|> Option.defaultValue // evaluates to 42` union case Option.None: Option<'T> module Option from Microsoft.FSharp.Core val defaultValue: value: 'T -> option: 'T option -> 'T union case Option.Some: Value: 'T -> Option<'T>
`Option.defaultWith defThunk option` Full Usage: `Option.defaultWith defThunk option` Parameters: defThunk : `unit -> 'T` - A thunk that provides a default value when evaluated. option : `'T option` - The input option. Returns: `'T` The option if the option is Some, else the result of evaluating defThunk. Modifiers: inline Type parameters: 'T	Gets the value of the option if the option is `Some`, otherwise evaluates defThunk and returns the result. defThunk is not evaluated unless option is `None`. defThunk : `unit -> 'T` A thunk that provides a default value when evaluated. option : `'T option` The input option. Returns: `'T` The option if the option is Some, else the result of evaluating defThunk. Example `None \|> Option.defaultWith (fun () -> 99) // evaluates to 99 Some 42 \|> Option.defaultWith (fun () -> 99) // evaluates to 42` union case Option.None: Option<'T> module Option from Microsoft.FSharp.Core val defaultWith: defThunk: (unit -> 'T) -> option: 'T option -> 'T union case Option.Some: Value: 'T -> Option<'T>
`Option.exists predicate option` Full Usage: `Option.exists predicate option` Parameters: predicate : `'T -> bool` - A function that evaluates to a boolean when given a value from the option type. option : `'T option` - The input option. Returns: `bool` False if the option is None, otherwise it returns the result of applying the predicate to the option value. Modifiers: inline Type parameters: 'T	`exists p inp` evaluates to `match inp with None -> false \| Some x -> p x`. predicate : `'T -> bool` A function that evaluates to a boolean when given a value from the option type. option : `'T option` The input option. Returns: `bool` False if the option is None, otherwise it returns the result of applying the predicate to the option value. Example `None \|> Option.exists (fun x -> x >= 5) // evaluates to false Some 42 \|> Option.exists (fun x -> x >= 5) // evaluates to true Some 4 \|> Option.exists (fun x -> x >= 5) // evaluates to false` union case Option.None: Option<'T> module Option from Microsoft.FSharp.Core val exists: predicate: ('T -> bool) -> option: 'T option -> bool val x: int union case Option.Some: Value: 'T -> Option<'T>
`Option.filter predicate option` Full Usage: `Option.filter predicate option` Parameters: predicate : `'T -> bool` - A function that evaluates whether the value contained in the option should remain, or be filtered out. option : `'T option` - The input option. Returns: `'T option` The input if the predicate evaluates to true; otherwise, None. Modifiers: inline Type parameters: 'T	`filter f inp` evaluates to `match inp with None -> None \| Some x -> if f x then Some x else None`. predicate : `'T -> bool` A function that evaluates whether the value contained in the option should remain, or be filtered out. option : `'T option` The input option. Returns: `'T option` The input if the predicate evaluates to true; otherwise, None. Example `None \|> Option.filter (fun x -> x >= 5) // evaluates to None Some 42 \|> Option.filter (fun x -> x >= 5) // evaluates to Some 42 Some 4 \|> Option.filter (fun x -> x >= 5) // evaluates to None` union case Option.None: Option<'T> module Option from Microsoft.FSharp.Core val filter: predicate: ('T -> bool) -> option: 'T option -> 'T option val x: int union case Option.Some: Value: 'T -> Option<'T>
`Option.flatten option` Full Usage: `Option.flatten option` Parameters: option : `'T option option` - The input option. Returns: `'T option` The input value if the value is Some; otherwise, None. Modifiers: inline Type parameters: 'T	`flatten inp` evaluates to `match inp with None -> None \| Some x -> x` `flatten` is equivalent to `bind id`. option : `'T option option` The input option. Returns: `'T option` The input value if the value is Some; otherwise, None. Example `(None: int option option) \|> Option.flatten // evaluates to None (Some ((None: int option))) \|> Option.flatten // evaluates to None (Some (Some 42)) \|> Option.flatten // evaluates to Some 42` union case Option.None: Option<'T> Multiple items val int: value: 'T -> int (requires member op_Explicit) -------------------- type int = int32 -------------------- type int<'Measure> = int type 'T option = Option<'T> module Option from Microsoft.FSharp.Core val flatten: option: 'T option option -> 'T option union case Option.Some: Value: 'T -> Option<'T>
`Option.fold folder state option` Full Usage: `Option.fold folder state option` Parameters: folder : `'State -> 'T -> 'State` - A function to update the state data when given a value from an option. state : `'State` - The initial state. option : `'T option` - The input option. Returns: `'State` The original state if the option is None, otherwise it returns the updated state with the folder and the option value. Modifiers: inline Type parameters: 'T, 'State	`fold f s inp` evaluates to `match inp with None -> s \| Some x -> f s x`. folder : `'State -> 'T -> 'State` A function to update the state data when given a value from an option. state : `'State` The initial state. option : `'T option` The input option. Returns: `'State` The original state if the option is None, otherwise it returns the updated state with the folder and the option value. Example `(0, None) \|\|> Option.fold (fun accum x -> accum + x * 2) // evaluates to 0 (0, Some 1) \|\|> Option.fold (fun accum x -> accum + x * 2) // evaluates to 2 (10, Some 1) \|\|> Option.fold (fun accum x -> accum + x * 2) // evaluates to 12` union case Option.None: Option<'T> module Option from Microsoft.FSharp.Core val fold<'T,'State> : folder: ('State -> 'T -> 'State) -> state: 'State -> option: 'T option -> 'State val accum: int val x: int union case Option.Some: Value: 'T -> Option<'T>
`Option.foldBack folder option state` Full Usage: `Option.foldBack folder option state` Parameters: folder : `'T -> 'State -> 'State` - A function to update the state data when given a value from an option. option : `'T option` - The input option. state : `'State` - The initial state. Returns: `'State` The original state if the option is None, otherwise it returns the updated state with the folder and the option value. Modifiers: inline Type parameters: 'T, 'State	`fold f inp s` evaluates to `match inp with None -> s \| Some x -> f x s`. folder : `'T -> 'State -> 'State` A function to update the state data when given a value from an option. option : `'T option` The input option. state : `'State` The initial state. Returns: `'State` The original state if the option is None, otherwise it returns the updated state with the folder and the option value. Example `(None, 0) \|\|> Option.foldBack (fun x accum -> accum + x * 2) // evaluates to 0 (Some 1, 0) \|\|> Option.foldBack (fun x accum -> accum + x * 2) // evaluates to 2 (Some 1, 10) \|\|> Option.foldBack (fun x accum -> accum + x * 2) // evaluates to 12` union case Option.None: Option<'T> module Option from Microsoft.FSharp.Core val foldBack: folder: ('T -> 'State -> 'State) -> option: 'T option -> state: 'State -> 'State val x: int val accum: int union case Option.Some: Value: 'T -> Option<'T>
`Option.forall predicate option` Full Usage: `Option.forall predicate option` Parameters: predicate : `'T -> bool` - A function that evaluates to a boolean when given a value from the option type. option : `'T option` - The input option. Returns: `bool` True if the option is None, otherwise it returns the result of applying the predicate to the option value. Modifiers: inline Type parameters: 'T	`forall p inp` evaluates to `match inp with None -> true \| Some x -> p x`. predicate : `'T -> bool` A function that evaluates to a boolean when given a value from the option type. option : `'T option` The input option. Returns: `bool` True if the option is None, otherwise it returns the result of applying the predicate to the option value. Example `None \|> Option.forall (fun x -> x >= 5) // evaluates to true Some 42 \|> Option.forall (fun x -> x >= 5) // evaluates to true Some 4 \|> Option.forall (fun x -> x >= 5) // evaluates to false` union case Option.None: Option<'T> module Option from Microsoft.FSharp.Core val forall: predicate: ('T -> bool) -> option: 'T option -> bool val x: int union case Option.Some: Value: 'T -> Option<'T>
`Option.get option` Full Usage: `Option.get option` Parameters: option : `'T option` - The input option. Returns: `'T` The value within the option.	Gets the value associated with the option. option : `'T option` The input option. Returns: `'T` The value within the option. Example `Some 42 \|> Option.get // evaluates to 42 (None: int option) \|> Option.get // throws exception!` union case Option.Some: Value: 'T -> Option<'T> module Option from Microsoft.FSharp.Core val get: option: 'T option -> 'T union case Option.None: Option<'T> Multiple items val int: value: 'T -> int (requires member op_Explicit) -------------------- type int = int32 -------------------- type int<'Measure> = int type 'T option = Option<'T>
`Option.isNone option` Full Usage: `Option.isNone option` Parameters: option : `'T option` - The input option. Returns: `bool` True if the option is None. Modifiers: inline Type parameters: 'T	Returns true if the option is None. option : `'T option` The input option. Returns: `bool` True if the option is None. Example `None \|> Option.isNone // evaluates to true Some 42 \|> Option.isNone // evaluates to false` union case Option.None: Option<'T> module Option from Microsoft.FSharp.Core val isNone: option: 'T option -> bool union case Option.Some: Value: 'T -> Option<'T>
`Option.isSome option` Full Usage: `Option.isSome option` Parameters: option : `'T option` - The input option. Returns: `bool` True if the option is not None. Modifiers: inline Type parameters: 'T	Returns true if the option is not None. option : `'T option` The input option. Returns: `bool` True if the option is not None. Example `None \|> Option.isSome // evaluates to false Some 42 \|> Option.isSome // evaluates to true` union case Option.None: Option<'T> module Option from Microsoft.FSharp.Core val isSome: option: 'T option -> bool union case Option.Some: Value: 'T -> Option<'T>
`Option.iter action option` Full Usage: `Option.iter action option` Parameters: action : `'T -> unit` - A function to apply to the option value. option : `'T option` - The input option. Modifiers: inline Type parameters: 'T	`iter f inp` executes `match inp with None -> () \| Some x -> f x`. action : `'T -> unit` A function to apply to the option value. option : `'T option` The input option. Example `None \|> Option.iter (printfn "%s") // does nothing Some "Hello world" \|> Option.iter (printfn "%s") // prints "Hello world"` union case Option.None: Option<'T> module Option from Microsoft.FSharp.Core val iter: action: ('T -> unit) -> option: 'T option -> unit val printfn: format: Printf.TextWriterFormat<'T> -> 'T union case Option.Some: Value: 'T -> Option<'T>
`Option.map mapping option` Full Usage: `Option.map mapping option` Parameters: mapping : `'T -> 'U` - A function to apply to the option value. option : `'T option` - The input option. Returns: `'U option` An option of the input value after applying the mapping function, or None if the input is None. Modifiers: inline Type parameters: 'T, 'U	`map f inp` evaluates to `match inp with None -> None \| Some x -> Some (f x)`. mapping : `'T -> 'U` A function to apply to the option value. option : `'T option` The input option. Returns: `'U option` An option of the input value after applying the mapping function, or None if the input is None. Example `None \|> Option.map (fun x -> x * 2) // evaluates to None Some 42 \|> Option.map (fun x -> x * 2) // evaluates to Some 84` union case Option.None: Option<'T> module Option from Microsoft.FSharp.Core val map: mapping: ('T -> 'U) -> option: 'T option -> 'U option val x: int union case Option.Some: Value: 'T -> Option<'T>
`Option.map2 mapping option1 option2` Full Usage: `Option.map2 mapping option1 option2` Parameters: mapping : `'T1 -> 'T2 -> 'U` - A function to apply to the option values. option1 : `'T1 option` - The first option. option2 : `'T2 option` - The second option. Returns: `'U option` An option of the input values after applying the mapping function, or None if either input is None. Modifiers: inline Type parameters: 'T1, 'T2, 'U	`map f option1 option2` evaluates to `match option1, option2 with Some x, Some y -> Some (f x y) \| _ -> None`. mapping : `'T1 -> 'T2 -> 'U` A function to apply to the option values. option1 : `'T1 option` The first option. option2 : `'T2 option` The second option. Returns: `'U option` An option of the input values after applying the mapping function, or None if either input is None. Example `(None, None) \|\|> Option.map2 (fun x y -> x + y) // evaluates to None (Some 5, None) \|\|> Option.map2 (fun x y -> x + y) // evaluates to None (None, Some 10) \|\|> Option.map2 (fun x y -> x + y) // evaluates to None (Some 5, Some 10) \|\|> Option.map2 (fun x y -> x + y) // evaluates to Some 15` union case Option.None: Option<'T> module Option from Microsoft.FSharp.Core val map2: mapping: ('T1 -> 'T2 -> 'U) -> option1: 'T1 option -> option2: 'T2 option -> 'U option val x: int val y: int union case Option.Some: Value: 'T -> Option<'T>
`Option.map3 mapping option1 option2 option3` Full Usage: `Option.map3 mapping option1 option2 option3` Parameters: mapping : `'T1 -> 'T2 -> 'T3 -> 'U` - A function to apply to the option values. option1 : `'T1 option` - The first option. option2 : `'T2 option` - The second option. option3 : `'T3 option` - The third option. Returns: `'U option` An option of the input values after applying the mapping function, or None if any input is None. Modifiers: inline Type parameters: 'T1, 'T2, 'T3, 'U	`map f option1 option2 option3` evaluates to `match option1, option2, option3 with Some x, Some y, Some z -> Some (f x y z) \| _ -> None`. mapping : `'T1 -> 'T2 -> 'T3 -> 'U` A function to apply to the option values. option1 : `'T1 option` The first option. option2 : `'T2 option` The second option. option3 : `'T3 option` The third option. Returns: `'U option` An option of the input values after applying the mapping function, or None if any input is None. Example `(None, None, None) \|\|\|> Option.map3 (fun x y z -> x + y + z) // evaluates to None (Some 100, None, None) \|\|\|> Option.map3 (fun x y z -> x + y + z) // evaluates to None (None, Some 100, None) \|\|\|> Option.map3 (fun x y z -> x + y + z) // evaluates to None (None, None, Some 100) \|\|\|> Option.map3 (fun x y z -> x + y + z) // evaluates to None (Some 5, Some 100, Some 10) \|\|\|> Option.map3 (fun x y z -> x + y + z) // evaluates to Some 115` union case Option.None: Option<'T> module Option from Microsoft.FSharp.Core val map3: mapping: ('T1 -> 'T2 -> 'T3 -> 'U) -> option1: 'T1 option -> option2: 'T2 option -> option3: 'T3 option -> 'U option val x: int val y: int val z: int union case Option.Some: Value: 'T -> Option<'T>
`Option.ofNullable value` Full Usage: `Option.ofNullable value` Parameters: value : `Nullable<'T>` - The input nullable value. Returns: `'T option` The result option. Modifiers: inline Type parameters: 'T	Convert a Nullable value to an option. value : `Nullable<'T>` The input nullable value. Returns: `'T option` The result option. Example `System.Nullable<int>() \|> Option.ofNullable // evaluates to None System.Nullable(42) \|> Option.ofNullable // evaluates to Some 42` namespace System Multiple items [<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> -------------------- 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> -------------------- System.Nullable () System.Nullable(value: 'T) : System.Nullable<'T> Multiple items val int: value: 'T -> int (requires member op_Explicit) -------------------- type int = int32 -------------------- type int<'Measure> = int module Option from Microsoft.FSharp.Core val ofNullable: value: System.Nullable<'T> -> 'T option (requires default constructor and value type and 'T :> System.ValueType)
`Option.ofObj value` Full Usage: `Option.ofObj value` Parameters: value : `'T` - The input value. Returns: `'T option` The result option. Modifiers: inline Type parameters: 'T	Convert a potentially null value to an option. value : `'T` The input value. Returns: `'T option` The result option. Example `(null: string) \|> Option.ofObj // evaluates to None "not a null string" \|> Option.ofObj // evaluates to (Some "not a null string")` Multiple items val string: value: 'T -> string -------------------- type string = System.String module Option from Microsoft.FSharp.Core val ofObj: value: 'T -> 'T option (requires 'T: null)
`Option.ofValueOption voption` Full Usage: `Option.ofValueOption voption` Parameters: voption : `'T voption` - The input value option. Returns: `'T option` The resulting option. Modifiers: inline Type parameters: 'T	Convert a value option to an option. voption : `'T voption` The input value option. Returns: `'T option` The resulting option. Example `ValueSome 42 \|> Option.ofValueOption // evaluates to Some 42 (ValueNone: int voption) \|> Option.ofValueOption // evaluates to None` union case ValueOption.ValueSome: 'T -> ValueOption<'T> module Option from Microsoft.FSharp.Core union case ValueOption.ValueNone: ValueOption<'T> Multiple items val int: value: 'T -> int (requires member op_Explicit) -------------------- type int = int32 -------------------- type int<'Measure> = int type 'T voption = ValueOption<'T>
`Option.orElse ifNone option` Full Usage: `Option.orElse ifNone option` Parameters: ifNone : `'T option` - The value to use if option is `None`. option : `'T option` - The input option. Returns: `'T option` The option if the option is Some, else the alternate option. Modifiers: inline Type parameters: 'T	Returns option if it is `Some`, otherwise returns ifNone. ifNone : `'T option` The value to use if option is `None`. option : `'T option` The input option. Returns: `'T option` The option if the option is Some, else the alternate option. Example `((None: int Option), None) \|\|> Option.orElse // evaluates to None (Some 99, None) \|\|> Option.orElse // evaluates to Some 99 (None, Some 42) \|\|> Option.orElse // evaluates to Some 42 (Some 99, Some 42) \|\|> Option.orElse // evaluates to Some 42` union case Option.None: Option<'T> Multiple items val int: value: 'T -> int (requires member op_Explicit) -------------------- type int = int32 -------------------- type int<'Measure> = int module Option from Microsoft.FSharp.Core val orElse: ifNone: 'T option -> option: 'T option -> 'T option union case Option.Some: Value: 'T -> Option<'T>
`Option.orElseWith ifNoneThunk option` Full Usage: `Option.orElseWith ifNoneThunk option` Parameters: ifNoneThunk : `unit -> 'T option` - A thunk that provides an alternate option when evaluated. option : `'T option` - The input option. Returns: `'T option` The option if the option is Some, else the result of evaluating ifNoneThunk. Modifiers: inline Type parameters: 'T	Returns option if it is `Some`, otherwise evaluates ifNoneThunk and returns the result. ifNoneThunk is not evaluated unless option is `None`. ifNoneThunk : `unit -> 'T option` A thunk that provides an alternate option when evaluated. option : `'T option` The input option. Returns: `'T option` The option if the option is Some, else the result of evaluating ifNoneThunk. Example `(None: int Option) \|> Option.orElseWith (fun () -> None) // evaluates to None None \|> Option.orElseWith (fun () -> (Some 99)) // evaluates to Some 99 Some 42 \|> Option.orElseWith (fun () -> None) // evaluates to Some 42 Some 42 \|> Option.orElseWith (fun () -> (Some 99)) // evaluates to Some 42` union case Option.None: Option<'T> Multiple items val int: value: 'T -> int (requires member op_Explicit) -------------------- type int = int32 -------------------- type int<'Measure> = int module Option from Microsoft.FSharp.Core val orElseWith: ifNoneThunk: (unit -> 'T option) -> option: 'T option -> 'T option union case Option.Some: Value: 'T -> Option<'T>
`Option.toArray option` Full Usage: `Option.toArray option` Parameters: option : `'T option` - The input option. Returns: `'T array` The result array. Modifiers: inline Type parameters: 'T	Convert the option to an array of length 0 or 1. option : `'T option` The input option. Returns: `'T array` The result array. Example `(None: int option) \|> Option.toArray // evaluates to [\|\|] Some 42 \|> Option.toArray // evaluates to [\|42\|]` union case Option.None: Option<'T> Multiple items val int: value: 'T -> int (requires member op_Explicit) -------------------- type int = int32 -------------------- type int<'Measure> = int type 'T option = Option<'T> module Option from Microsoft.FSharp.Core val toArray: option: 'T option -> 'T array union case Option.Some: Value: 'T -> Option<'T>
`Option.toList option` Full Usage: `Option.toList option` Parameters: option : `'T option` - The input option. Returns: `'T list` The result list. Modifiers: inline Type parameters: 'T	Convert the option to a list of length 0 or 1. option : `'T option` The input option. Returns: `'T list` The result list. Example `(None: int option) \|> Option.toList // evaluates to [] Some 42 \|> Option.toList // evaluates to [42]` union case Option.None: Option<'T> Multiple items val int: value: 'T -> int (requires member op_Explicit) -------------------- type int = int32 -------------------- type int<'Measure> = int type 'T option = Option<'T> module Option from Microsoft.FSharp.Core val toList: option: 'T option -> 'T list union case Option.Some: Value: 'T -> Option<'T>
`Option.toNullable option` Full Usage: `Option.toNullable option` Parameters: option : `'T option` - The input option. Returns: `Nullable<'T>` The result value. Modifiers: inline Type parameters: 'T	Convert the option to a Nullable value. option : `'T option` The input option. Returns: `Nullable<'T>` The result value. Example `(None: int option) \|> Option.toNullable // evaluates to new System.Nullable<int>() Some 42 \|> Option.toNullable // evaluates to new System.Nullable(42)` union case Option.None: Option<'T> Multiple items val int: value: 'T -> int (requires member op_Explicit) -------------------- type int = int32 -------------------- type int<'Measure> = int type 'T option = Option<'T> module Option from Microsoft.FSharp.Core val toNullable: option: 'T option -> System.Nullable<'T> (requires default constructor and value type and 'T :> System.ValueType) union case Option.Some: Value: 'T -> Option<'T>
`Option.toObj value` Full Usage: `Option.toObj value` Parameters: value : `'T option` - The input value. Returns: `'T` The result value, which is null if the input was None. Modifiers: inline Type parameters: 'T	Convert an option to a potentially null value. value : `'T option` The input value. Returns: `'T` The result value, which is null if the input was None. Example `(None: string option) \|> Option.toObj // evaluates to null Some "not a null string" \|> Option.toObj // evaluates to "not a null string"` union case Option.None: Option<'T> Multiple items val string: value: 'T -> string -------------------- type string = System.String type 'T option = Option<'T> module Option from Microsoft.FSharp.Core val toObj: value: 'T option -> 'T (requires 'T: null) union case Option.Some: Value: 'T -> Option<'T>
`Option.toValueOption option` Full Usage: `Option.toValueOption option` Parameters: option : `'T option` - The input option. Returns: `'T voption` The resulting value option. Modifiers: inline Type parameters: 'T	Convert an option to a value option. option : `'T option` The input option. Returns: `'T voption` The resulting value option. Example `Some 42 \|> Option.toValueOption // evaluates to ValueSome 42 (None: int option) \|> Option.toValueOption // evaluates to ValueNone` union case Option.Some: Value: 'T -> Option<'T> module Option from Microsoft.FSharp.Core union case Option.None: Option<'T> Multiple items val int: value: 'T -> int (requires member op_Explicit) -------------------- type int = int32 -------------------- type int<'Measure> = int type 'T option = Option<'T>

Option Module

Functions and values

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example