Option monads support either an A (success) value, or a None (no-value) option. You can think of this as an alternative to using
null to represent a lack of a value. null unfortunately still allows you to . into the interface of the decalred type, which means
there's a ticking time-bomb in every reference type.
C# does now have the nullable references feature, which goes some way to removing the need for an optional type, however there's still edge
cases that mean the reference types are problematic. It's also useful to build generic types and say this is an Option<A> - I don't care
if it's a value-type or reference-type, it's optional.
And finally, there's the automatic checking of None values when using Option<A> in LINQ expressions, or if you call Map. This makes
working with optional values, and the implications for all of the code that works with it, fully declarative.
Here we have two flavours of Option:
Option<A>the default optional monad. It does not allownullin itsSomecase.OptionUnsafe<A>as above, but it does allownullin itsSomecase.
You can construct a Some using the constructor functions in the Prelude:
Option<int> ma = Some(123);
Option<int> mb = None;
Contents
- Option <A>
- None = default
- Option (IEnumerable<A> option)
- GetObjectData (SerializationInfo info, StreamingContext context)
- Case
- Equals (Option<A> other)
- Equals <EqA> (Option<A> other)
- CompareTo (Option<A> other)
- CompareTo <OrdA> (Option<A> other)
- | (Option<A> lhs, Option<A> rhs)
- < (Option<A> lhs, Option<A> rhs)
- <= (Option<A> lhs, Option<A> rhs)
- > (Option<A> lhs, Option<A> rhs)
- >= (Option<A> lhs, Option<A> rhs)
- == (Option<A> lhs, Option<A> rhs)
- != (Option<A> lhs, Option<A> rhs)
- true (Option<A> value)
- false (Option<A> value)
- Equals (object? obj)
- GetHashCode ()
- CompareTo (object? obj)
- ToString ()
- IsSome
- IsNone
- Do (Action<A> f)
- Select <B> (Func<A, B> f)
- Map <B> (Func<A, B> f)
- Traverse <F, B> (Func<A, K<F, B>> f)
- TraverseM <M, B> (Func<A, K<M, B>> f)
- Bind <B> (Func<A, Option<B>> f)
- Bind <B> (Func<A, K<Option, B>> f)
- BiBind <B> (Func<A, Option<B>> Some, Func<Option<B>> None)
- SelectMany <B, C> ( Func<A, Option<B>> bind, Func<A, B, C> project)
- SelectMany <C> ( Func<A, Fail<Unit>> bind, Func<A, Unit, C> project)
- MatchUntyped <R> (Func<object?, R> Some, Func<R> None)
- GetUnderlyingType ()
- ToSpan ()
- ToArray ()
- ToList ()
- ToSeq ()
- AsEnumerable ()
- ToIterable ()
- ToEff ()
- ToIO ()
- ToEff (Error Fail)
- ToFin ()
- ToFin (Error Fail)
- ToEither <L> (L defaultLeftValue)
- ToEither <L> ()
- ToEither <L> (Func<L> Left)
- ToValidation <L> (Func<L> Fail)
- ToValidation <L> (L Fail)
- ToValidation <L> ()
- Some (Action<A> f)
- Some <B> (Func<A, B> f)
- Match <B> (Func<A, B> Some, Func<B> None)
- Match <B> (Func<A, B> Some, B None)
- Match (Action<A> Some, Action None)
- IfSome (Action<A> f)
- IfSome (Func<A, Unit> f)
- IfNone (Func<A> None)
- IfNone (Action None)
- IfNone (A noneValue)
- Fold <S> (S state, Func<S, A, S> folder)
- FoldBack <S> (S state, Func<S, A, S> folder)
- BiFold <S> (S state, Func<S, A, S> Some, Func<S, Unit, S> None)
- BiFold <S> (S state, Func<S, A, S> Some, Func<S, S> None)
- BiMap <B> (Func<A, B> Some, Func<Unit, B> None)
- BiMap <B> (Func<A, B> Some, Func<B> None)
- Count ()
- ForAll (Func<A, bool> pred)
- BiForAll (Func<A, bool> Some, Func<Unit, bool> None)
- BiForAll (Func<A, bool> Some, Func<bool> None)
- Exists (Func<A, bool> pred)
- BiExists (Func<A, bool> Some, Func<Unit, bool> None)
- BiExists (Func<A, bool> Some, Func<bool> None)
- Iter (Action<A> Some)
- BiIter (Action<A> Some, Action<Unit> None)
- BiIter (Action<A> Some, Action None)
- Filter (Func<A, bool> pred)
- Where (Func<A, bool> pred)
- ParMap <B, C> (Func<A, B, C> func)
- ParMap <B, C, D> (Func<A, B, C, D> func)
- Bind <B> (Func<A, Pure<B>> f)
- Bind <B> (Func<A, Fail<Unit>> f)
- SelectMany <B, C> (Func<A, Pure<B>> bind, Func<A, B, C> project)
- Combine (Option<A> rhs)
- Empty
- Option
Sub modules
| Extensions |
| Operators |
| Prelude |
| Shared |
| Trait |
Discriminated union type. Can be in one of two states:
Some(a)
None
Parameters
| type | A | Bound value |
Fields
field Option<A> None = default Source #
None
Properties
Constructors
Methods
method void GetObjectData (SerializationInfo info, StreamingContext context) Source #
method bool Equals (Option<A> other) Source #
Uses the EqDefault instance to do an equality check on the bound value.
To use anything other than the default call oa.Equals〈EqA〉(ob)
where EqA is an instance derived from Eq〈A〉
This uses the EqDefault instance for comparison of the bound A values.
The EqDefault instance wraps up the .NET EqualityComparer.Default
behaviour.
Parameters
| param | other | The |
| returns |
| |
method bool Equals <EqA> (Option<A> other) Source #
Uses the EqA instance to do an equality check on the bound value.
Parameters
| param | other | The |
| returns |
| |
method int CompareTo (Option<A> other) Source #
Uses the OrdDefault instance to do an ordering comparison on the bound
value. To use anything other than the default call this.Compare〈OrdA〉(this, other),
where OrdA is an instance derived from Ord〈A〉
Parameters
| param | other | The |
method int CompareTo <OrdA> (Option<A> other) Source #
Uses the Ord instance provided to do an ordering comparison on the bound
value.
Parameters
| param | other | The |
method bool Equals (object? obj) Source #
DO NOT USE - Use the Structural equality variant of this method Equals〈EQ, A〉(y)
method int GetHashCode () Source #
Calculate the hash-code from the bound value, unless the Option is in a None state, in which case the hash-code will be 0
Parameters
| returns | Hash-code from the bound value, unless the Option is in a None state, in which case the hash-code will be 0 | |
method string ToString () Source #
Get a string representation of the Option
Parameters
| returns | String representation of the Option | |
method Option<A> Do (Action<A> f) Source #
Impure iteration of the bound value in the structure
Parameters
| returns | Returns the original unmodified structure | |
method Option<B> Select <B> (Func<A, B> f) Source #
Projection from one value to another
Parameters
| type | B | Resulting functor value type |
| param | f | Projection function |
| returns | Mapped functor | |
method Option<B> Map <B> (Func<A, B> f) Source #
Projection from one value to another
Parameters
| type | B | Resulting functor value type |
| param | f | Projection function |
| returns | Mapped functor | |
method K<F, Option<B>> Traverse <F, B> (Func<A, K<F, B>> f) Source #
Map each element of a structure to an action, evaluate these actions from left to right, and collect the results.
Parameters
| type | F | Applicative functor trait |
| type | B | Bound value (output) |
| param | f | |
| param | ta | Traversable structure |
method K<M, Option<B>> TraverseM <M, B> (Func<A, K<M, B>> f) Source #
Map each element of a structure to an action, evaluate these actions from left to right, and collect the results.
Parameters
| type | M | Monad trait |
| type | B | Bound value (output) |
| param | f | |
| param | ta | Traversable structure |
method Option<B> BiBind <B> (Func<A, Option<B>> Some, Func<Option<B>> None) Source #
Bi-bind. Allows mapping of both monad states
method Option<C> SelectMany <B, C> ( Func<A, Option<B>> bind, Func<A, B, C> project) Source #
Monad bind operation
method Option<C> SelectMany <C> ( Func<A, Fail<Unit>> bind, Func<A, Unit, C> project) Source #
Monad bind operation
method R MatchUntyped <R> (Func<object?, R> Some, Func<R> None) Source #
Match operation with an untyped value for Some. This can be useful for serialisation and dealing with the IOptional interface
Parameters
| type | R | The return type |
| param | Some | Operation to perform if the option is in a Some state |
| param | None | Operation to perform if the option is in a None state |
| returns | The result of the match operation | |
method Type GetUnderlyingType () Source #
Get the Type of the bound value
Parameters
| returns | Type of the bound value | |
method ReadOnlySpan<A> ToSpan () Source #
If the Option is in a Some state then the span will contain one itemm otherwise empty.
Parameters
| returns | ||
method Arr<A> ToArray () Source #
Convert the Option to an enumerable of zero or one items
Parameters
| returns | An enumerable of zero or one items | |
method Lst<A> ToList () Source #
Convert the Option to an immutable list of zero or one items
Parameters
| returns | An immutable list of zero or one items | |
method Seq<A> ToSeq () Source #
Convert the Option to an enumerable sequence of zero or one items
Parameters
| returns | An enumerable sequence of zero or one items | |
method IEnumerable<A> AsEnumerable () Source #
Convert the Option to an enumerable of zero or one items
Parameters
| returns | An enumerable of zero or one items | |
method Iterable<A> ToIterable () Source #
Convert the Option to an enumerable of zero or one items
Parameters
| returns | An enumerable of zero or one items | |
method Eff<A> ToEff () Source #
Convert the structure to an Eff
Parameters
| returns | An Eff representation of the structure | |
method OptionT<IO, A> ToIO () Source #
Convert to an Option transformer with embedded IO
Parameters
| returns | ||
method Eff<A> ToEff (Error Fail) Source #
Convert the structure to an Eff
Parameters
| param | Fail | Default value if the structure is in a None state |
| returns | An Eff representation of the structure | |
method Fin<A> ToFin () Source #
Convert the structure to a Fin
Parameters
| returns | A Fin representation of the structure | |
method Fin<A> ToFin (Error Fail) Source #
Convert the structure to a Fin
Parameters
| param | Fail | Default value if the structure is in a None state |
| returns | A Fin representation of the structure | |
method Either<L, A> ToEither <L> (L defaultLeftValue) Source #
Convert the structure to an Either
Parameters
| param | defaultLeftValue | Default value if the structure is in a None state |
| returns | An Either representation of the structure | |
method Either<L, A> ToEither <L> (Func<L> Left) Source #
Convert the structure to an Either
Parameters
| param | Left | Function to invoke to get a default value if the structure is in a None state |
| returns | An Either representation of the structure | |
method Validation<L, A> ToValidation <L> (Func<L> Fail) Source #
Convert the structure to a Validation
Parameters
| param | Fail | Function to invoke to get a default value if the structure is in a None state |
| returns | An Validation representation of the structure | |
method Validation<L, A> ToValidation <L> (L Fail) Source #
Convert the structure to a Validation
Parameters
| param | Fail | Default value if the structure is in a None state |
| returns | An Validation representation of the structure | |
method Validation<L, A> ToValidation <L> () Source #
Convert the structure to a Validation
Parameters
| returns | An Validation representation of the structure | |
method SomeUnitContext<A> Some (Action<A> f) Source #
Fluent pattern matching. Provide a Some handler and then follow on fluently with .None(...) to complete the matching operation. This is for dispatching actions, use Some〈A, B〉(...) to return a value from the match operation.
Parameters
| param | f | The |
method SomeContext<A, B> Some <B> (Func<A, B> f) Source #
Fluent pattern matching. Provide a Some handler and then follow on fluently with .None(...) to complete the matching operation. This is for returning a value from the match operation, to dispatch an action instead, use Some〈A〉(...)
Parameters
| type | B | Match operation return value type |
| param | f | The |
| returns | The result of the match operation | |
method B Match <B> (Func<A, B> Some, Func<B> None) Source #
Match the two states of the Option and return a non-null R.
Parameters
| type | B | Return type |
| param | Some | Some match operation. Must not return null. |
| param | None | None match operation. Must not return null. |
| returns | A non-null B | |
method B Match <B> (Func<A, B> Some, B None) Source #
Match the two states of the Option and return a non-null R.
Parameters
| type | B | Return type |
| param | Some | Some match operation. Must not return null. |
| param | None | None match operation. Must not return null. |
| returns | A non-null B | |
method Unit Match (Action<A> Some, Action None) Source #
Match the two states of the Option
Parameters
| param | Some | Some match operation |
| param | None | None match operation |
method Unit IfSome (Action<A> f) Source #
Invokes the action if Option is in the Some state, otherwise nothing happens.
Parameters
| param | f | Action to invoke if Option is in the Some state |
method Unit IfSome (Func<A, Unit> f) Source #
Invokes the f function if Option is in the Some state, otherwise nothing happens.
Parameters
| param | f | Function to invoke if Option is in the Some state |
method A IfNone (Func<A> None) Source #
Returns the result of invoking the None() operation if the optional is in a None state, otherwise the bound Some(x) value is returned.
Will not accept a null return value from the None operation
Parameters
| param | None | Operation to invoke if the structure is in a None state |
| returns | Result of invoking the None() operation if the optional is in a None state, otherwise the bound Some(x) value is returned. | |
method Unit IfNone (Action None) Source #
Invokes the action if Option is in the None state, otherwise nothing happens.
Parameters
| param | f | Action to invoke if Option is in the None state |
method A IfNone (A noneValue) Source #
Returns the noneValue if the optional is in a None state, otherwise the bound Some(x) value is returned.
Will not accept a null noneValue
Parameters
| param | noneValue | Value to return if in a None state |
| returns | noneValue if the optional is in a None state, otherwise the bound Some(x) value is returned | |
method S Fold <S> (S state, Func<S, A, S> folder) Source #
Option types are like lists of 0 or 1 items, and therefore follow the same rules when folding.
In the case of lists, 'Fold', when applied to a binary operator, a starting value(typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right:
Note that, since the head of the resulting expression is produced by an application of the operator to the first element of the list, 'Fold' can produce a terminating expression from an infinite list.
Parameters
| type | S | Aggregate state type |
| param | state | Initial state |
| param | folder | Folder function, applied if Option is in a Some state |
| returns | The aggregate state | |
method S FoldBack <S> (S state, Func<S, A, S> folder) Source #
Option types are like lists of 0 or 1 items, and therefore follow the same rules when folding.
In the case of lists, 'Fold', when applied to a binary operator, a starting value(typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right:
Note that, since the head of the resulting expression is produced by an application of the operator to the first element of the list, 'Fold' can produce a terminating expression from an infinite list.
Parameters
| type | S | Aggregate state type |
| param | state | Initial state |
| param | folder | Folder function, applied if Option is in a Some state |
| returns | The aggregate state | |
method S BiFold <S> (S state, Func<S, A, S> Some, Func<S, Unit, S> None) Source #
Option types are like lists of 0 or 1 items, and therefore follow the same rules when folding.
In the case of lists, 'Fold', when applied to a binary operator, a starting value(typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right:
Note that, since the head of the resulting expression is produced by an application of the operator to the first element of the list, 'Fold' can produce a terminating expression from an infinite list.
Parameters
| type | S | Aggregate state type |
| param | state | Initial state |
| param | Some | Folder function, applied if Option is in a Some state |
| param | None | Folder function, applied if Option is in a None state |
| returns | The aggregate state | |
method S BiFold <S> (S state, Func<S, A, S> Some, Func<S, S> None) Source #
Option types are like lists of 0 or 1 items, and therefore follow the same rules when folding.
In the case of lists, 'Fold', when applied to a binary operator, a starting value(typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right:
Note that, since the head of the resulting expression is produced by an application of the operator to the first element of the list, 'Fold' can produce a terminating expression from an infinite list.
Parameters
| type | S | Aggregate state type |
| param | state | Initial state |
| param | Some | Folder function, applied if Option is in a Some state |
| param | None | Folder function, applied if Option is in a None state |
| returns | The aggregate state | |
method Option<B> BiMap <B> (Func<A, B> Some, Func<Unit, B> None) Source #
Projection from one value to another
Parameters
| type | B | Resulting functor value type |
| param | Some | Projection function |
| param | None | Projection function |
| returns | Mapped functor | |
method Option<B> BiMap <B> (Func<A, B> Some, Func<B> None) Source #
Projection from one value to another
Parameters
| type | B | Resulting functor value type |
| param | Some | Projection function |
| param | None | Projection function |
| returns | Mapped functor | |
Return the number of bound values in this structure:
None = 0
Some = 1
Parameters
| returns | ||
method bool ForAll (Func<A, bool> pred) Source #
Apply a predicate to the bound value. If the Option is in a None state then True is returned (because the predicate applies for-all values). If the Option is in a Some state the value is the result of running applying the bound value to the predicate supplied.
Parameters
| param | pred | |
| returns | If the Option is in a None state then True is returned (because the predicate applies for-all values). If the Option is in a Some state the value is the result of running applying the bound value to the predicate supplied. | |
method bool BiForAll (Func<A, bool> Some, Func<Unit, bool> None) Source #
Apply a predicate to the bound value. If the Option is in a None state then True is returned if invoking None returns True. If the Option is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.
Parameters
| param | Some | Predicate to apply if in a Some state |
| param | None | Predicate to apply if in a None state |
| returns | If the Option is in a None state then True is returned if invoking None returns True. If the Option is in a Some state the value is the result of running applying the bound value to the Some predicate supplied. | |
method bool BiForAll (Func<A, bool> Some, Func<bool> None) Source #
Apply a predicate to the bound value. If the Option is in a None state then True is returned if invoking None returns True. If the Option is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.
Parameters
| param | Some | Predicate to apply if in a Some state |
| param | None | Predicate to apply if in a None state |
| returns | If the Option is in a None state then True is returned if invoking None returns True. If the Option is in a Some state the value is the result of running applying the bound value to the Some predicate supplied. | |
method bool Exists (Func<A, bool> pred) Source #
Apply a predicate to the bound value. If the Option is in a None state then False is returned. If the Option is in a Some state the value is the result of running applying the bound value to the predicate supplied.
Parameters
| param | pred | |
| returns | If the Option is in a None state then False is returned. If the Option is in a Some state the value is the result of running applying the bound value to the predicate supplied. | |
method bool BiExists (Func<A, bool> Some, Func<Unit, bool> None) Source #
Apply a predicate to the bound value. If the Option is in a None state then True is returned if invoking None returns True. If the Option is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.
Parameters
| param | pred | |
| returns | If the Option is in a None state then True is returned if invoking None returns True. If the Option is in a Some state the value is the result of running applying the bound value to the Some predicate supplied. | |
method bool BiExists (Func<A, bool> Some, Func<bool> None) Source #
Apply a predicate to the bound value. If the Option is in a None state then True is returned if invoking None returns True. If the Option is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.
Parameters
| param | pred | |
| returns | If the Option is in a None state then True is returned if invoking None returns True. If the Option is in a Some state the value is the result of running applying the bound value to the Some predicate supplied. | |
method Unit Iter (Action<A> Some) Source #
Invoke an action for the bound value (if in a Some state)
Parameters
| param | Some | Action to invoke |
method Unit BiIter (Action<A> Some, Action<Unit> None) Source #
Invoke an action depending on the state of the Option
Parameters
| param | Some | Action to invoke if in a Some state |
| param | None | Action to invoke if in a None state |
method Unit BiIter (Action<A> Some, Action None) Source #
Invoke an action depending on the state of the Option
Parameters
| param | Some | Action to invoke if in a Some state |
| param | None | Action to invoke if in a None state |
method Option<A> Filter (Func<A, bool> pred) Source #
Apply a predicate to the bound value (if in a Some state)
Parameters
| param | pred | Predicate to apply |
| returns | Some(x) if the Option is in a Some state and the predicate returns True. None otherwise. | |
method Option<A> Where (Func<A, bool> pred) Source #
Apply a predicate to the bound value (if in a Some state)
Parameters
| param | pred | Predicate to apply |
| returns | Some(x) if the Option is in a Some state and the predicate returns True. None otherwise. | |
method Option<Func<B, Func<C, D>>> ParMap <B, C, D> (Func<A, B, C, D> func) Source #
Partial application map
method Option<B> Bind <B> (Func<A, Pure<B>> f) Source #
Monadic bind
Parameters
| param | f | Bind function |
method Option<B> Bind <B> (Func<A, Fail<Unit>> f) Source #
Monadic bind
Parameters
| param | f | Bind function |
method Option<C> SelectMany <B, C> (Func<A, Pure<B>> bind, Func<A, B, C> project) Source #
Monadic bind and project
Parameters
| param | bind | Bind function |
| param | project | Project function |
Operators
operator < (Option<A> lhs, Option<A> rhs) Source #
Comparison operator
Parameters
| param | lhs | The left hand side of the operation |
| param | rhs | The right hand side of the operation |
| returns | True if lhs〈 rhs | |
operator <= (Option<A> lhs, Option<A> rhs) Source #
Comparison operator
Parameters
| param | lhs | The left hand side of the operation |
| param | rhs | The right hand side of the operation |
| returns | True if lhs〈= rhs | |
operator > (Option<A> lhs, Option<A> rhs) Source #
Comparison operator
Parameters
| param | lhs | The left hand side of the operation |
| param | rhs | The right hand side of the operation |
| returns | True if lhs 〉rhs | |
operator >= (Option<A> lhs, Option<A> rhs) Source #
Comparison operator
Parameters
| param | lhs | The left hand side of the operation |
| param | rhs | The right hand side of the operation |
| returns | True if lhs 〉= rhs | |
operator == (Option<A> lhs, Option<A> rhs) Source #
Equality operator
This uses the EqDefault instance for comparison of the bound A values. The EqDefault instance wraps up the .NET EqualityComparer.Default behaviour. For more control over equality you can call:
equals〈EQ, A〉(lhs, rhs);
Where EQ is a struct derived from Eq〈A〉. For example:
equals〈EqString, string〉(lhs, rhs);
equals〈EqArray〈int〉, int[]〉(lhs, rhs);
Parameters
| param | lhs | Left hand side of the operation |
| param | rhs | Right hand side of the operation |
| returns | True if the values are equal | |
operator != (Option<A> lhs, Option<A> rhs) Source #
Non-equality operator
This uses the EqDefault instance for comparison of the A value. The EqDefault trait wraps up the .NET EqualityComparer.Default behaviour. For more control over equality you can call:
!equals〈EQ, A〉(lhs, rhs);
Where EQ is a struct derived from Eq〈A〉. For example:
!equals〈EqString, string〉(lhs, rhs);
!equals〈EqArray〈int〉, int[]〉(lhs, rhs);
Parameters
| param | lhs | Left hand side of the operation |
| param | rhs | Right hand side of the operation |
| returns | True if the values are equal | |