bind f inp evaluates to match inp with None -> None | Some x -> f x
'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.
'T option
The input option.
'U option
An option of the output type of the binder.
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
Evaluates to true if option is Some and its value is equal to value.
'T
The value to test for equality.
'T option
The input option.
bool
True if the option is Some and contains a value equal to value, otherwise false.
(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>
count inp evaluates to match inp with None -> 0 | Some _ -> 1.
'T option
The input option.
int
A zero if the option is None, a one otherwise.
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>
Gets the value of the option if the option is Some, otherwise returns the specified default value.
'T
The specified default value.
'T option
The input option.
'T
The option if the option is Some, else the default value.
(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>
Gets the value of the option if the option is Some, otherwise evaluates defThunk and returns the result.
unit -> 'T
A thunk that provides a default value when evaluated.
'T option
The input option.
'T
The option if the option is Some, else the result of evaluating defThunk.
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>
exists p inp evaluates to match inp with None -> false | Some x -> p x.
'T -> bool
A function that evaluates to a boolean when given a value from the option type.
'T option
The input option.
bool
False if the option is None, otherwise it returns the result of applying the predicate to the option value.
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>
filter f inp evaluates to match inp with None -> None | Some x -> if f x then Some x else None.
'T -> bool
A function that evaluates whether the value contained in the option should remain, or be filtered out.
'T option
The input option.
'T option
The input if the predicate evaluates to true; otherwise, None.
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>
flatten inp evaluates to match inp with None -> None | Some x -> x
'T option option
The input option.
'T option
The input value if the value is Some; otherwise, None.
(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>
fold f s inp evaluates to match inp with None -> s | Some x -> f s x.
'State -> 'T -> 'State
A function to update the state data when given a value from an option.
'State
The initial state.
'T option
The input option.
'State
The original state if the option is None, otherwise it returns the updated state with the folder and the option value.
(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>
fold f inp s evaluates to match inp with None -> s | Some x -> f x s.
'T -> 'State -> 'State
A function to update the state data when given a value from an option.
'T option
The input option.
'State
The initial state.
'State
The original state if the option is None, otherwise it returns the updated state with the folder and the option value.
(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>
forall p inp evaluates to match inp with None -> true | Some x -> p x.
'T -> bool
A function that evaluates to a boolean when given a value from the option type.
'T option
The input option.
bool
True if the option is None, otherwise it returns the result of applying the predicate to the option value.
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>
Gets the value associated with the option.
'T option
The input option.
'T
The value within the option.
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>
Returns true if the option is None.
'T option
The input option.
bool
True if the option is None.
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>
Returns true if the option is not None.
'T option
The input option.
bool
True if the option is not None.
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>
iter f inp executes match inp with None -> () | Some x -> f x.
'T -> unit
A function to apply to the option value.
'T option
The input option.
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>
map f inp evaluates to match inp with None -> None | Some x -> Some (f x).
'T -> 'U
A function to apply to the option value.
'T option
The input option.
'U option
An option of the input value after applying the mapping function, or None if the input is None.
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>
map f option1 option2 evaluates to match option1, option2 with Some x, Some y -> Some (f x y) | _ -> None.
'T1 -> 'T2 -> 'U
A function to apply to the option values.
'T1 option
The first option.
'T2 option
The second option.
'U option
An option of the input values after applying the mapping function, or None if either input is None.
(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>
map f option1 option2 option3 evaluates to match option1, option2, option3 with Some x, Some y, Some z -> Some (f x y z) | _ -> None.
'T1 -> 'T2 -> 'T3 -> 'U
A function to apply to the option values.
'T1 option
The first option.
'T2 option
The second option.
'T3 option
The third option.
'U option
An option of the input values after applying the mapping function, or None if any input is None.
(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>
Convert a Nullable value to an option.
Nullable<'T>
The input nullable value.
'T option
The result option.
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
--------------------
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>
--------------------
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)
Convert a potentially null value to an option.
'T
The input value.
'T option
The result option.
(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)
Convert a value option to an option.
'T voption
The input value option.
'T option
The resulting option.
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>
Returns option if it is Some, otherwise returns ifNone.
'T option
The value to use if option is None.
'T option
The input option.
'T option
The option if the option is Some, else the alternate option.
((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>
Returns option if it is Some, otherwise evaluates ifNoneThunk and returns the result.
unit -> 'T option
A thunk that provides an alternate option when evaluated.
'T option
The input option.
'T option
The option if the option is Some, else the result of evaluating ifNoneThunk.
(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>
Convert the option to an array of length 0 or 1.
'T option
The input option.
'T array
The result array.
(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>
Convert the option to a list of length 0 or 1.
'T option
The input option.
'T list
The result list.
(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>
Convert the option to a Nullable value.
'T option
The input option.
Nullable<'T>
The result value.
(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>
Convert an option to a potentially null value.
'T option
The input value.
'T
The result value, which is null if the input was None.
(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>
Convert an option to a value option.
'T option
The input option.
'T voption
The resulting value option.
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>
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4