Contents
- Either <L, R>
- Bottom = new Either<L, R>()
- GetObjectData (SerializationInfo info, StreamingContext context)
- Case
- Either (IEnumerable<EitherData<L, R>> either)
- GetEnumerator ()
- State
- IsRight
- IsLeft
- IsBottom
- Match <Ret> (Func<R, Ret> Right, Func<L, Ret> Left, Func<Ret> Bottom = null)
- MatchUnsafe <Ret> (Func<R, Ret> Right, Func<L, Ret> Left, Func<Ret> Bottom = null)
- Match (Action<R> Right, Action<L> Left, Action Bottom = null)
- MatchAsync <R2> (Func<R, R2> Right, Func<L, Task<R2>> LeftAsync)
- MatchAsync <R2> (Func<R, Task<R2>> RightAsync, Func<L, R2> Left)
- MatchAsync <R2> (Func<R, Task<R2>> RightAsync, Func<L, Task<R2>> LeftAsync)
- IfLeft (Func<R> Left)
- IfLeft (Func<L, R> leftMap)
- IfLeft (R rightValue)
- IfLeft (Action<L> Left)
- IfRight (Action<R> Right)
- IfRight (L leftValue)
- IfRight (Func<L> Right)
- IfRight (Func<R, L> rightMap)
- Right (Action<R> right)
- Right <Ret> (Func<R, Ret> right)
- ToString ()
- GetHashCode ()
- CompareTo (object obj)
- Equals (object obj)
- ToList ()
- ToArray ()
- RightToList ()
- RightToArray ()
- LeftToList ()
- LeftToArray ()
- ToSeq ()
- RightToSeq ()
- LeftToSeq ()
- RightAsEnumerable ()
- LeftAsEnumerable ()
- ToValidation ()
- ToOption ()
- ToEff (Func<L, Common.Error> Left)
- ToAff (Func<L, Common.Error> Left)
- ToAsync ()
- ToEitherUnsafe ()
- ToTryOption ()
- < (Either<L, R> lhs, EitherLeft<L> rhs)
- <= (Either<L, R> lhs, EitherLeft<L> rhs)
- > (Either<L, R> lhs, EitherLeft<L> rhs)
- >= (Either<L, R> lhs, EitherLeft<L> rhs)
- < (Either<L, R> lhs, EitherRight<R> rhs)
- <= (Either<L, R> lhs, EitherRight<R> rhs)
- > (Either<L, R> lhs, EitherRight<R> rhs)
- >= (Either<L, R> lhs, EitherRight<R> rhs)
- < (EitherLeft<L> lhs, Either<L, R> rhs)
- <= (EitherLeft<L> lhs, Either<L, R> rhs)
- > (EitherLeft<L> lhs, Either<L, R>rhs)
- >= (EitherLeft<L> lhs, Either<L, R> rhs)
- < (EitherRight<R> lhs, Either<L, R> rhs)
- <= (EitherRight<R> lhs, Either<L, R> rhs)
- > (EitherRight<R> lhs, Either<L, R> rhs)
- >= (EitherRight<R> lhs, Either<L, R> rhs)
- < (Either<L, R> lhs, Either<L, R> rhs)
- <= (Either<L, R> lhs, Either<L, R> rhs)
- > (Either<L, R> lhs, Either<L, R> rhs)
- >= (Either<L, R> lhs, Either<L, R> rhs)
- == (Either<L, R> lhs, EitherLeft<L> rhs)
- == (Either<L, R> lhs, EitherRight<R> rhs)
- == (EitherLeft<L> lhs, Either<L, R> rhs)
- == (EitherRight<R> lhs, Either<L, R> rhs)
- == (Either<L, R> lhs, Either<L, R> rhs)
- != (Either<L, R> lhs, EitherLeft<L> rhs)
- != (Either<L, R> lhs, EitherRight<R> rhs)
- != (EitherLeft<L> lhs, Either<L, R> rhs)
- != (EitherRight<R> lhs, Either<L, R> rhs)
- != (Either<L, R> lhs, Either<L, R> rhs)
- | (Either<L, R> lhs, Either<L, R> rhs)
- | (Either<L, R> lhs, EitherRight<R> rhs)
- | (Either<L, R> lhs, EitherLeft<L> rhs)
- true (Either<L, R> value)
- false (Either<L, R> value)
- CompareTo (Either<L, R> other)
- CompareTo (EitherLeft<L> other)
- CompareTo (EitherRight<R> other)
- CompareTo (R other)
- CompareTo (L other)
- Equals (R other)
- Equals (L other)
- Equals (Either<L, R> other)
- Equals (EitherLeft<L> other)
- Equals (EitherRight<R> other)
- MatchUntyped <TResult> (Func<object, TResult> Right, Func<object, TResult> Left)
- GetUnderlyingRightType ()
- GetUnderlyingLeftType ()
- Right (R value)
- Left (L value)
- MatchUntyped <R1> (Func<object, R1> Some, Func<R1> None)
- GetUnderlyingType ()
- Count ()
- Swap ()
- Iter (Action<R> Right)
- BiIter (Action<R> Right, Action<L> Left)
- ForAll (Func<R, bool> Right)
- BiForAll (Func<R, bool> Right, Func<L, bool> Left)
- Fold <S> (S state, Func<S, R, S> Right)
- BiFold <S> (S state, Func<S, R, S> Right, Func<S, L, S> Left)
- Exists (Func<R, bool> pred)
- BiExists (Func<R, bool> Right, Func<L, bool> Left)
- Do (Action<R> f)
- Map <Ret> (Func<R, Ret> mapper)
- MapLeft <Ret> (Func<L, Ret> mapper)
- BiMap <Ret> (Func<R, Ret> Right, Func<L, Ret> Left)
- BiMap <L2, R2> (Func<R, R2> Right, Func<L, L2> Left)
- Bind <B> (Func<R, Either<L, B>> f)
- BiBind <B> (Func<R, Either<L, B>> Right, Func<L, Either<L, B>> Left)
- BindLeft <B> (Func<L, Either<B, R>> f)
- Filter (Func<R, bool> pred)
- Where (Func<R, bool> pred)
- Select <U> (Func<R, U> map)
- SelectMany <U, V> (Func<R, Either<L, U>> bind, Func<R, U, V> project)
- Join <U, K, V> ( Either<L, U> inner, Func<R, K> outerKeyMap, Func<U, K> innerKeyMap, Func<R, U, V> project)
- EitherContext <L, R, Ret>
- EitherUnitContext <L, R>
- EitherExtensions
- Flatten <L, R> (this Either<L, Either<L, R>> ma)
- Plus <NUM, L, R> (this Either<L, R> x, Either<L, R> y)
- Subtract <NUM, L, R> (this Either<L, R> x, Either<L, R> y)
- Product <NUM, L, R> (this Either<L, R> x, Either<L, R> y)
- Divide <NUM, L, R> (this Either<L, R> x, Either<L, R> y)
- Apply <L, A, B> (this Either<L, Func<A, B>> fab, Either<L, A> fa)
- Apply <L, A, B> (this Func<A, B> fab, Either<L, A> fa)
- Apply <L, A, B, C> (this Either<L, Func<A, B, C>> fabc, Either<L, A> fa, Either<L, B> fb)
- Apply <L, A, B, C> (this Func<A, B, C> fabc, Either<L, A> fa, Either<L, B> fb)
- Apply <L, A, B, C> (this Either<L, Func<A, B, C>> fabc, Either<L, A> fa)
- Apply <L, A, B, C> (this Func<A, B, C> fabc, Either<L, A> fa)
- Apply <L, A, B, C> (this Either<L, Func<A, Func<B, C>>> fabc, Either<L, A> fa)
- Apply <L, A, B, C> (this Func<A, Func<B, C>> fabc, Either<L, A> fa)
- Action <L, A, B> (this Either<L, A> fa, Either<L, B> fb)
- Lefts <L, R> (this IEnumerable<Either<L, R>> self)
- Lefts <L, R> (this Seq<Either<L, R>> self)
- Rights <L, R> (this IEnumerable<Either<L, R>> self)
- Rights <L, R> (this Seq<Either<L, R>> self)
- Partition <L, R> (this IEnumerable<Either<L, R>> self)
- Partition <L, R> (this Seq<Either<L, R>> self)
- Sum <NUM, L, R> (this Either<L, R> self)
- Sum <L> (this Either<L, int> self)
- ParMap <L, T1, T2, R> (this Either<L, T1> self, Func<T1, T2, R> func)
- ParMap <L, T1, T2, T3, R> (this Either<L, T1> self, Func<T1, T2, T3, R> func)
- MatchAsync <L, R, R2> (this Either<L, Task<R>> self, Func<R, R2> Right, Func<L, R2> Left)
- MapAsync <L, R, R2> (this Either<L, R> self, Func<R, Task<R2>> map)
- MapAsync <L, R, R2> (this Task<Either<L, R>> self, Func<R, Task<R2>> map)
- MapAsync <L, R, R2> (this Task<Either<L, R>> self, Func<R, R2> map)
- MapAsync <L, R, R2> (this Either<L, Task<R>> self, Func<R, R2> map)
- MapAsync <L, R, R2> (this Either<L, Task<R>> self, Func<R, Task<R2>> map)
- BindAsync <L, R, R2> (this Either<L, R> self, Func<R, Task<Either<L, R2>>> bind)
- BindAsync <L, R, R2> (this Task<Either<L, R>> self, Func<R, Task<Either<L, R2>>> bind)
- BindAsync <L, R, R2> (this Task<Either<L, R>> self, Func<R, Either<L, R2>> bind)
- BindAsync <L, R, R2> (this Either<L, Task<R>> self, Func<R, Either<L, R2>> bind)
- BindAsync <L, R, R2> (this Either<L, Task<R>> self, Func<R, Task<Either<L, R2>>> bind)
- IterAsync <L, R> (this Task<Either<L, R>> self, Action<R> action)
- IterAsync <L, R> (this Either<L, Task<R>> self, Action<R> action)
- CountAsync <L, R> (this Task<Either<L, R>> self)
- SumAsync <L> (this Task<Either<L, int>> self)
- SumAsync <L> (this Either<L, Task<int>> self)
- FoldAsync <L, R, S> (this Task<Either<L, R>> self, S state, Func<S, R, S> folder)
- FoldAsync <L, R, S> (this Either<L, Task<R>> self, S state, Func<S, R, S> folder)
- ForAllAsync <L, R> (this Task<Either<L, R>> self, Func<R, bool> pred)
- ForAllAsync <L, R> (this Either<L, Task<R>> self, Func<R, bool> pred)
- ExistsAsync <L, R> (this Task<Either<L, R>> self, Func<R, bool> pred)
- ExistsAsync <L, R> (this Either<L, Task<R>> self, Func<R, bool> pred)
- ToEff <R> (this Either<Error, R> ma)
- ToAff <R> (this Either<Error, R> ma)
- ToEff <R> (this Either<Exception, R> ma)
- ToAff <R> (this Either<Exception, R> ma)
- ToEff <R> (this Either<string, R> ma)
- ToAff <R> (this Either<string, R> ma)
- EitherGuardExtensions
- ToEither <L> (this Guard<L> ma)
- SelectMany <L, B> (this Guard<L> ma, Func<Unit, Either<L, B>> f)
- SelectMany <L, B, C> (this Guard<L> ma, Func<Unit, Either<L, B>> bind, Func<Unit, B, C> project)
- SelectMany <L, A> (this Either<L, A> ma, Func<A, Guard<L>> f)
- SelectMany <L, A, C> (this Either<L, A> ma, Func<A, Guard<L>> bind, Func<A, Unit, C> project)
- Prelude
- flatten <L, R> (Either<L, Either<L, R>> ma)
- plus <NUM, L, R> (Either<L, R> x, Either<L, R> y)
- subtract <NUM, L, R> (Either<L, R> x, Either<L, R> y)
- product <NUM, L, R> (Either<L, R> x, Either<L, R> y)
- divide <NUM, L, R> (Either<L, R> x, Either<L, R> y)
- apply <L, A, B> (Either<L, Func<A, B>> fab, Either<L, A> fa)
- apply <L, A, B> (Func<A, B> fab, Either<L, A> fa)
- apply <L, A, B, C> (Either<L, Func<A, B, C>> fabc, Either<L, A> fa, Either<L, B> fb)
- apply <L, A, B, C> (Func<A, B, C> fabc, Either<L, A> fa, Either<L, B> fb)
- apply <L, A, B, C> (Either<L, Func<A, B, C>> fabc, Either<L, A> fa)
- apply <L, A, B, C> (Func<A, B, C> fabc, Either<L, A> fa)
- apply <L, A, B, C> (Either<L, Func<A, Func<B, C>>> fabc, Either<L, A> fa)
- apply <L, A, B, C> (Func<A, Func<B, C>> fabc, Either<L, A> fa)
- action <L, A, B> (Either<L, A> fa, Either<L, B> fb)
- isRight <L, R> (Either<L, R> value)
- isLeft <L, R> (Either<L, R> value)
- Right <L, R> (R value)
- Right <R> (R value)
- Left <L, R> (L value)
- Left <L> (L value)
- Right <L, R> (R? value)
- Left <L, R> (L? value)
- ifLeft <L, R> (Either<L, R> either, Func<R> Left)
- ifLeft <L, R> (Either<L, R> either, Func<L, R> leftMap)
- ifLeft <L, R> (Either<L, R> either, R rightValue)
- ifLeft <L, R> (Either<L, R> either, Action<L> Left)
- ifRight <L, R> (Either<L, R> either, Action<R> Right)
- ifRight <L, R> (Either<L, R> either, L leftValue)
- ifRight <L, R> (Either<L, R> either, Func<L> Left)
- ifRight <L, R> (Either<L, R> either, Func<R, L> leftMap)
- match <L, R, Ret> (Either<L, R> either, Func<R, Ret> Right, Func<L, Ret> Left)
- match <L, R> (Either<L, R> either, Action<R> Right, Action<L> Left)
- fold <S, L, R> (Either<L, R> either, S state, Func<S, R, S> folder)
- bifold <L, R, S> (Either<L, R> either, S state, Func<S, R, S> Right, Func<S, L, S> Left)
- forall <L, R> (Either<L, R> either, Func<R, bool> pred)
- biforall <L, R> (Either<L, R> either, Func<R, bool> Right, Func<L, bool> Left)
- count <L, R> (Either<L, R> either)
- exists <L, R> (Either<L, R> either, Func<R, bool> pred)
- biexists <L, R> (Either<L, R> either, Func<R, bool> Right, Func<L, bool> Left)
- map <L, R, Ret> (Either<L, R> either, Func<R, Ret> mapper)
- bimap <L, R, LRet, RRet> (Either<L, R> either, Func<R, RRet> Right, Func<L, LRet> Left)
- parmap <L, T1, T2, R> (Either<L, T1> either, Func<T1, T2, R> func)
- parmap <L, T1, T2, T3, R> (Either<L, T1> either, Func<T1, T2, T3, R> func)
- filter <L, R> (Either<L, R> either, Func<R, bool> pred)
- bind <L, R, Ret> (Either<L, R> either, Func<R, Either<L, Ret>> binder)
- Match <L, R, Ret> (this IEnumerable<Either<L, R>> list, Func<R, Ret> Right, Func<L, Ret> Left )
- match <L, R, Ret> (IEnumerable<Either<L, R>> list, Func<R, Ret> Right, Func<L, Ret> Left )
- rightToList <L, R> (Either<L, R> either)
- rightToArray <L, R> (Either<L, R> either)
- leftToList <L, R> (Either<L, R> either)
- leftToArray <L, R> (Either<L, R> either)
- rightToQuery <L, R> (Either<L, R> either)
- leftToQuery <L, R> (Either<L, R> either)
- lefts <L, R> (IEnumerable<Either<L, R>> self)
- lefts <L, R> (Seq<Either<L, R>> self)
- rights <L, R> (IEnumerable<Either<L, R>> self)
- rights <L, R> (Seq<Either<L, R>> self)
- partition <L, R> (IEnumerable<Either<L, R>> self)
- partition <L, R> (Seq<Either<L, R>> self)
- IEnumerableEitherTransExt
- BiForAllT <L, R> (this IEnumerable<Either<L, R>> self, Func<R, bool> Right, Func<L, bool> Left)
- BiFoldT <L, R, S> (this IEnumerable<Either<L, R>> self, S state, Func<S, R, S> Right, Func<S, L, S> Left)
- BiExistsT <L, R> (this IEnumerable<Either<L, R>> self, Func<R, bool> Right, Func<L, bool> Left)
- MapLeftT <L, R, Ret> (this IEnumerable<Either<L, R>> self, Func<L, Ret> mapper)
- BiMapT <L, R, LRet, RRet> (this IEnumerable<Either<L, R>> self, Func<R, RRet> Right, Func<L, LRet> Left)
- Prelude
- biforallT <L, R> (IEnumerable<Either<L, R>> self, Func<R, bool> Right, Func<L, bool> Left)
- bifoldT <L, R, S> (IEnumerable<Either<L, R>> self, S state, Func<S, R, S> Right, Func<S, L, S> Left)
- biexistsT <L, R> (IEnumerable<Either<L, R>> self, Func<R, bool> Right, Func<L, bool> Left)
- mapLeftT <L, R, Ret> (IEnumerable<Either<L, R>> self, Func<L, Ret> mapper)
- bimapT <L, R, LRet, RRet> (IEnumerable<Either<L, R>> self, Func<R, RRet> Right, Func<L, LRet> Left)
- TaskEitherAsyncExtensions
- ToAsync <L, R> (this Task<Either<L, R>> ma)
- Plus <NUM, L, R> (this Task<Either<L, R>> x, Task<Either<L, R>> y)
- Subtract <NUM, L, R> (this Task<Either<L, R>> x, Task<Either<L, R>> y)
- Product <NUM, L, R> (this Task<Either<L, R>> x, Task<Either<L, R>> y)
- Divide <NUM, L, R> (this Task<Either<L, R>> x, Task<Either<L, R>> y)
- Apply <L, A, B> (this Task<Either<L, Func<A, B>>> fab, Task<Either<L, A>> fa)
- Apply <L, A, B> (this Func<A, B> fab, Task<Either<L, A>> fa)
- Apply <L, A, B, C> (this Task<Either<L, Func<A, B, C>>> fabc, Task<Either<L, A>> fa, Task<Either<L, B>> fb)
- Apply <L, A, B, C> (this Func<A, B, C> fabc, Task<Either<L, A>> fa, Task<Either<L, B>> fb)
- Apply <L, A, B, C> (this Task<Either<L, Func<A, B, C>>> fabc, Task<Either<L, A>> fa)
- Apply <L, A, B, C> (this Func<A, B, C> fabc, Task<Either<L, A>> fa)
- Apply <L, A, B, C> (this Task<Either<L, Func<A, Func<B, C>>>> fabc, Task<Either<L, A>> fa)
- Apply <L, A, B, C> (this Func<A, Func<B, C>> fabc, Task<Either<L, A>> fa)
- Action <L, A, B> (this Task<Either<L, A>> fa, Task<Either<L, B>> fb)
Either L R Holds one of two values 'Left' or 'Right'. Usually 'Left' is considered 'wrong' or 'in error', and 'Right' is, well, right. So when the Either is in a Left state, it cancels computations like bind or map, etc. So you can see Left as an 'early out, with a message'. Unlike Option that has None as its alternative value (i.e. it has an 'early out, but no message').
NOTE: If you use Filter or Where (or 'where' in a LINQ expression) with Either, then the Either will be put into a 'Bottom' state if the predicate returns false. When it's in this state it is neither Right nor Left. And any usage could trigger a BottomException. So be aware of the issue of filtering Either.
Also note, when the Either is in a Bottom state, some operations on it will continue to give valid results or return another Either in the Bottom state and not throw. This is so a filtered Either doesn't needlessly break expressions.
Parameters
| type | L | Left |
| type | R | Right |
Fields
field Either<L, R> Bottom = new Either<L, R>() Source #
Properties
Reference version for use in pattern-matching
Left = result is L Right = result is R Bottom = result is null
property bool IsBottom Source #
Is the Either in a Bottom state? When the Either is filtered, both Right and Left are meaningless.
If you use Filter or Where (or 'where' in a LINQ expression) with Either, then the Either will be put into a 'Bottom' state if the predicate returns false. When it's in this state it is neither Right nor Left. And any usage could trigger a BottomException. So be aware of the issue of filtering Either.
Also note, when the Either is in a Bottom state, some operations on it will continue to give valid results or return another Either in the Bottom state and not throw. This is so a filtered Either doesn't needlessly break expressions.
Constructors
Methods
method void GetObjectData (SerializationInfo info, StreamingContext context) Source #
method IEnumerator<EitherData<L, R>> GetEnumerator () Source #
method Ret Match <Ret> (Func<R, Ret> Right, Func<L, Ret> Left, Func<Ret> Bottom = null) Source #
Invokes the Right or Left function depending on the state of the Either
Parameters
| type | Ret | Return type |
| param | Right | Function to invoke if in a Right state |
| param | Left | Function to invoke if in a Left state |
| returns | The return value of the invoked function | |
method Ret MatchUnsafe <Ret> (Func<R, Ret> Right, Func<L, Ret> Left, Func<Ret> Bottom = null) Source #
Invokes the Right or Left function depending on the state of the Either
Parameters
| type | Ret | Return type |
| param | Right | Function to invoke if in a Right state |
| param | Left | Function to invoke if in a Left state |
| returns | The return value of the invoked function | |
method Unit Match (Action<R> Right, Action<L> Left, Action Bottom = null) Source #
Invokes the Right or Left action depending on the state of the Either
Parameters
| param | Right | Action to invoke if in a Right state |
| param | Left | Action to invoke if in a Left state |
| returns | Unit | |
method Task<R2> MatchAsync <R2> (Func<R, R2> Right, Func<L, Task<R2>> LeftAsync) Source #
Match the two states of the Either and return a promise for a non-null R2.
Parameters
| returns | A promise to return a non-null R2 | |
method Task<R2> MatchAsync <R2> (Func<R, Task<R2>> RightAsync, Func<L, R2> Left) Source #
Match the two states of the Either and return a promise for a non-null R2.
Parameters
| returns | A promise to return a non-null R2 | |
method Task<R2> MatchAsync <R2> (Func<R, Task<R2>> RightAsync, Func<L, Task<R2>> LeftAsync) Source #
Match the two states of the Either and return a promise for a non-null R2.
Parameters
| returns | A promise to return a non-null R2 | |
method R IfLeft (Func<R> Left) Source #
Executes the Left function if the Either is in a Left state. Returns the Right value if the Either is in a Right state.
Parameters
| param | Left | Function to generate a Right value if in the Left state |
| returns | Returns an unwrapped Right value | |
method R IfLeft (Func<L, R> leftMap) Source #
Executes the leftMap function if the Either is in a Left state. Returns the Right value if the Either is in a Right state.
Parameters
| param | leftMap | Function to generate a Right value if in the Left state |
| returns | Returns an unwrapped Right value | |
method R IfLeft (R rightValue) Source #
Returns the rightValue if the Either is in a Left state. Returns the Right value if the Either is in a Right state.
Parameters
| param | rightValue | Value to return if in the Left state |
| returns | Returns an unwrapped Right value | |
method Unit IfLeft (Action<L> Left) Source #
Executes the Left action if the Either is in a Left state.
Parameters
| param | Left | Function to generate a Right value if in the Left state |
| returns | Returns an unwrapped Right value | |
method Unit IfRight (Action<R> Right) Source #
Invokes the Right action if the Either is in a Right state, otherwise does nothing
Parameters
| param | Right | Action to invoke |
| returns | Unit | |
method L IfRight (L leftValue) Source #
Returns the leftValue if the Either is in a Right state. Returns the Left value if the Either is in a Left state.
Parameters
| param | leftValue | Value to return if in the Left state |
| returns | Returns an unwrapped Left value | |
method L IfRight (Func<L> Right) Source #
Returns the result of Right() if the Either is in a Right state. Returns the Left value if the Either is in a Left state.
Parameters
| param | Right | Function to generate a Left value if in the Right state |
| returns | Returns an unwrapped Left value | |
method L IfRight (Func<R, L> rightMap) Source #
Returns the result of rightMap if the Either is in a Right state. Returns the Left value if the Either is in a Left state.
Parameters
| param | rightMap | Function to generate a Left value if in the Right state |
| returns | Returns an unwrapped Left value | |
method EitherUnitContext<L, R> Right (Action<R> right) Source #
Match Right and return a context. You must follow this with .Left(...) to complete the match
Parameters
| param | right | Action to invoke if the Either is in a Right state |
| returns | Context that must have Left() called upon it. | |
method EitherContext<L, R, Ret> Right <Ret> (Func<R, Ret> right) Source #
Match Right and return a context. You must follow this with .Left(...) to complete the match
Parameters
| param | right | Action to invoke if the Either is in a Right state |
| returns | Context that must have Left() called upon it. | |
method string ToString () Source #
Return a string representation of the Either
Parameters
| returns | String representation of the Either | |
method int GetHashCode () Source #
Returns a hash code of the wrapped value of the Either
Parameters
| returns | Hash code | |
method bool Equals (object obj) Source #
Equality check
Parameters
| param | obj | Object to test for equality |
| returns | True if equal | |
method Lst<R> ToList () Source #
Project the Either into a Lst R
Parameters
| returns | If the Either is in a Right state, a Lst of R with one item. A zero length Lst R otherwise | |
method Arr<R> ToArray () Source #
Project the Either into an ImmutableArray R
Parameters
| returns | If the Either is in a Right state, a ImmutableArray of R with one item. A zero length ImmutableArray of R otherwise | |
method Lst<R> RightToList () Source #
Project the Either into a Lst R
Parameters
| returns | If the Either is in a Right state, a Lst of R with one item. A zero length Lst R otherwise | |
method Arr<R> RightToArray () Source #
Project the Either into an ImmutableArray R
Parameters
| returns | If the Either is in a Right state, a ImmutableArray of R with one item. A zero length ImmutableArray of R otherwise | |
method Lst<L> LeftToList () Source #
Project the Either into a Lst L
Parameters
| returns | If the Either is in a Left state, a Lst of L with one item. A zero length Lst L otherwise | |
method Arr<L> LeftToArray () Source #
Project the Either into an ImmutableArray L
Parameters
| returns | If the Either is in a Left state, a ImmutableArray of L with one item. A zero length ImmutableArray of L otherwise | |
method Seq<R> RightToSeq () Source #
Convert either to sequence of 0 or 1 right values
method Seq<R> RightAsEnumerable () Source #
Project the Either into a IEnumerable R
Parameters
| returns | If the Either is in a Right state, a IEnumerable of R with one item. A zero length IEnumerable R otherwise | |
method Seq<L> LeftAsEnumerable () Source #
Project the Either into a IEnumerable L
Parameters
| returns | If the Either is in a Left state, a IEnumerable of L with one item. A zero length IEnumerable L otherwise | |
method Validation<L, R> ToValidation () Source #
method Option<R> ToOption () Source #
Convert the Either to an Option
Parameters
| returns | Some(Right) or None | |
method Eff<R> ToEff (Func<L, Common.Error> Left) Source #
Convert to an Eff
Parameters
| param | Left | Map the left value to the Eff Error |
| returns | Eff monad | |
method Aff<R> ToAff (Func<L, Common.Error> Left) Source #
Convert to an Aff
Parameters
| param | Left | Map the left value to the Eff Error |
| returns | Aff monad | |
method EitherUnsafe<L, R> ToEitherUnsafe () Source #
Convert the Either to an EitherUnsafe
Parameters
| returns | EitherUnsafe | |
method TryOption<R> ToTryOption () Source #
Convert the Either to an TryOption
Parameters
| returns | Some(Right) or None | |
method TResult MatchUntyped <TResult> (Func<object, TResult> Right, Func<object, TResult> Left) Source #
Match the Right and Left values but as objects. This can be useful to avoid reflection.
method Type GetUnderlyingRightType () Source #
Find out the underlying Right type
method Type GetUnderlyingLeftType () Source #
Find out the underlying Left type
method R1 MatchUntyped <R1> (Func<object, R1> Some, Func<R1> None) Source #
method Type GetUnderlyingType () Source #
Counts the Either
Parameters
| type | L | Left |
| type | R | Right |
| param | self | Either to count |
| returns | 1 if the Either is in a Right state, 0 otherwise. | |
method Either<R, L> Swap () Source #
Flips the left and right tagged values
Parameters
| returns | Either with the types swapped | |
method Unit Iter (Action<R> Right) Source #
Iterate the Either action is invoked if in the Right state
method Unit BiIter (Action<R> Right, Action<L> Left) Source #
Iterate the Either action is invoked if in the Right state
method bool ForAll (Func<R, bool> Right) Source #
Invokes a predicate on the value of the Either if it's in the Right state
Parameters
| type | L | Left |
| type | R | Right |
| param | self | Either to forall |
| param | Right | Predicate |
| returns | True if the Either is in a Left state. True if the Either is in a Right state and the predicate returns True. False otherwise. | |
method bool BiForAll (Func<R, bool> Right, Func<L, bool> Left) Source #
Invokes a predicate on the value of the Either if it's in the Right state
Parameters
| type | L | Left |
| type | R | Right |
| param | self | Either to forall |
| param | Right | Predicate |
| param | Left | Predicate |
| returns | True if either Predicate returns true | |
method S Fold <S> (S state, Func<S, R, S> Right) Source #
Either 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:
Parameters
| type | S | Aggregate state type |
| param | state | Initial state |
| param | Right | Folder function, applied if structure is in a Right state |
| returns | The aggregate state | |
method S BiFold <S> (S state, Func<S, R, S> Right, Func<S, L, S> Left) Source #
Either 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:
Parameters
| type | S | Aggregate state type |
| param | state | Initial state |
| param | Right | Folder function, applied if Either is in a Right state |
| param | Left | Folder function, applied if Either is in a Left state |
| returns | The aggregate state | |
method bool Exists (Func<R, bool> pred) Source #
Invokes a predicate on the value of the Either if it's in the Right state
Parameters
| type | L | Left |
| type | R | Right |
| param | self | Either to check existence of |
| param | pred | Predicate |
| returns | True if the Either is in a Right state and the predicate returns True. False otherwise. | |
method bool BiExists (Func<R, bool> Right, Func<L, bool> Left) Source #
Invokes a predicate on the value of the Either
Parameters
| type | L | Left |
| type | R | Right |
| param | self | Either to check existence of |
| param | Right | Right predicate |
| param | Left | Left predicate |
| returns | True if the predicate returns True. False otherwise or if the Either is in a bottom state. | |
method Either<L, R> Do (Action<R> f) Source #
Impure iteration of the bound values in the structure
Parameters
| returns | Returns the original unmodified structure | |
method Either<L, Ret> Map <Ret> (Func<R, Ret> mapper) Source #
Maps the value in the Either if it's in a Right state
Parameters
| type | L | Left |
| type | R | Right |
| type | Ret | Mapped Either type |
| param | self | Either to map |
| param | mapper | Map function |
| returns | Mapped Either | |
method Either<Ret, R> MapLeft <Ret> (Func<L, Ret> mapper) Source #
Maps the value in the Either if it's in a Left state
Parameters
| type | L | Left |
| type | R | Right |
| type | Ret | Mapped Either type |
| param | self | Either to map |
| param | mapper | Map function |
| returns | Mapped Either | |
method Either<L, Ret> BiMap <Ret> (Func<R, Ret> Right, Func<L, Ret> Left) Source #
Bi-maps the value in the Either into a Right state
Parameters
| type | L | Left |
| type | R | Right |
| type | LRet | Left return |
| type | RRet | Right return |
| param | self | Either to map |
| param | Right | Right map function |
| param | Left | Left map function |
| returns | Mapped Either | |
method Either<L2, R2> BiMap <L2, R2> (Func<R, R2> Right, Func<L, L2> Left) Source #
Bi-maps the value in the Either if it's in a Right state
Parameters
| type | L | Left |
| type | R | Right |
| type | LRet | Left return |
| type | RRet | Right return |
| param | self | Either to map |
| param | Right | Right map function |
| param | Left | Left map function |
| returns | Mapped Either | |
method Either<L, B> Bind <B> (Func<R, Either<L, B>> f) Source #
Monadic bind
Parameters
| type | L | Left |
| type | R | Right |
| type | B | |
| param | self | |
| param | f | |
| returns | Bound Either | |
method Either<L, B> BiBind <B> (Func<R, Either<L, B>> Right, Func<L, Either<L, B>> Left) Source #
Bi-bind. Allows mapping of both monad states
method Either<B, R> BindLeft <B> (Func<L, Either<B, R>> f) Source #
Bind left. Binds the left path of the monad only
method Either<L, R> Filter (Func<R, bool> pred) Source #
Filter the Either
This may give unpredictable results for a filtered value. The Either won't return true for IsLeft or IsRight. IsBottom is True if the value is filtered and that should be checked for.
Parameters
| type | L | Left |
| type | R | Right |
| param | self | Either to filter |
| param | pred | Predicate function |
| returns | If the Either is in the Left state it is returned as-is. If in the Right state the predicate is applied to the Right value. If the predicate returns True the Either is returned as-is. If the predicate returns False the Either is returned in a 'Bottom' state. | |
method Either<L, R> Where (Func<R, bool> pred) Source #
Filter the Either
This may give unpredictable results for a filtered value. The Either won't return true for IsLeft or IsRight. IsBottom is True if the value is filtered and that should be checked for.
Parameters
| type | L | Left |
| type | R | Right |
| param | self | Either to filter |
| param | pred | Predicate function |
| returns | If the Either is in the Left state it is returned as-is. If in the Right state the predicate is applied to the Right value. If the predicate returns True the Either is returned as-is. If the predicate returns False the Either is returned in a 'Bottom' state. IsLeft will return True, but the value of Left = default(L) | |
method Either<L, U> Select <U> (Func<R, U> map) Source #
Maps the value in the Either if it's in a Right state
Parameters
| type | L | Left |
| type | TR | Right |
| type | UR | Mapped Either type |
| param | self | Either to map |
| param | map | Map function |
| returns | Mapped Either | |
method Either<L, V> SelectMany <U, V> (Func<R, Either<L, U>> bind, Func<R, U, V> project) Source #
Monadic bind function
Parameters
| returns | Bound Either | |
Operators
operator < (Either<L, R> lhs, EitherLeft<L> 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 <= (Either<L, R> lhs, EitherLeft<L> 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 > (Either<L, R> lhs, EitherLeft<L> 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 >= (Either<L, R> lhs, EitherLeft<L> 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 < (Either<L, R> lhs, EitherRight<R> 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 <= (Either<L, R> lhs, EitherRight<R> 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 > (Either<L, R> lhs, EitherRight<R> 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 >= (Either<L, R> lhs, EitherRight<R> 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 < (EitherLeft<L> lhs, Either<L, R> 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 <= (EitherLeft<L> lhs, Either<L, R> 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 > (EitherLeft<L> lhs, Either<L, R>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 >= (EitherLeft<L> lhs, Either<L, R> 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 < (EitherRight<R> lhs, Either<L, R> 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 <= (EitherRight<R> lhs, Either<L, R> 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 > (EitherRight<R> lhs, Either<L, R> 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 >= (EitherRight<R> lhs, Either<L, R> 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 < (Either<L, R> lhs, Either<L, R> 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 <= (Either<L, R> lhs, Either<L, R> 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 > (Either<L, R> lhs, Either<L, R> 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 >= (Either<L, R> lhs, Either<L, R> 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 | (Either<L, R> lhs, Either<L, R> rhs) Source #
Override of the Or operator to be a Left coalescing operator
operator | (Either<L, R> lhs, EitherRight<R> rhs) Source #
Override of the Or operator to be a Left coalescing operator
operator | (Either<L, R> lhs, EitherLeft<L> rhs) Source #
Override of the Or operator to be a Left coalescing operator
struct EitherContext <L, R, Ret> Source #
Context for the fluent Either matching
struct EitherUnitContext <L, R> Source #
Context for the fluent Either matching
class EitherExtensions Source #
Extension methods for Either
Methods
method Either<L, R> Plus <NUM, L, R> (this Either<L, R> x, Either<L, R> y) Source #
Add the bound values of x and y, uses an Add type-class to provide the add operation for type A. For example x.Add<TInteger,int>(y)
Parameters
| type | NUM | Num of A |
| type | A | Bound value type |
| param | x | Left hand side of the operation |
| param | y | Right hand side of the operation |
| returns | An option with y added to x | |
method Either<L, R> Subtract <NUM, L, R> (this Either<L, R> x, Either<L, R> y) Source #
Find the subtract between the two bound values of x and y, uses a Subtract type-class to provide the subtract operation for type A. For example x.Subtract<TInteger,int>(y)
Parameters
| type | NUM | Num of A |
| type | A | Bound value type |
| param | x | Left hand side of the operation |
| param | y | Right hand side of the operation |
| returns | An option with the subtract between x and y | |
method Either<L, R> Product <NUM, L, R> (this Either<L, R> x, Either<L, R> y) Source #
Find the product between the two bound values of x and y, uses a Product type-class to provide the product operation for type A. For example x.Product<TInteger,int>(y)
Parameters
| type | NUM | Num of A |
| type | A | Bound value type |
| param | x | Left hand side of the operation |
| param | y | Right hand side of the operation |
| returns | An option with the product of x and y | |
method Either<L, R> Divide <NUM, L, R> (this Either<L, R> x, Either<L, R> y) Source #
Divide the two bound values of x and y, uses a Divide type-class to provide the divide operation for type A. For example x.Divide<TDouble,double>(y)
Parameters
| type | NUM | Num of A |
| type | A | Bound value type |
| param | x | Left hand side of the operation |
| param | y | Right hand side of the operation |
| returns | An option x / y | |
method Either<L, B> Apply <L, A, B> (this Either<L, Func<A, B>> fab, Either<L, A> fa) Source #
Apply
Parameters
| param | fab | Function to apply the applicative to |
| param | fa | Applicative to apply |
| returns | Applicative of type FB derived from Applicative of B | |
method Either<L, B> Apply <L, A, B> (this Func<A, B> fab, Either<L, A> fa) Source #
Apply
Parameters
| param | fab | Function to apply the applicative to |
| param | fa | Applicative to apply |
| returns | Applicative of type FB derived from Applicative of B | |
method Either<L, C> Apply <L, A, B, C> (this Either<L, Func<A, B, C>> fabc, Either<L, A> fa, Either<L, B> fb) Source #
Apply
Parameters
| param | fab | Function to apply the applicative to |
| param | fa | Applicative a to apply |
| param | fb | Applicative b to apply |
| returns | Applicative of type FC derived from Applicative of C | |
method Either<L, C> Apply <L, A, B, C> (this Func<A, B, C> fabc, Either<L, A> fa, Either<L, B> fb) Source #
Apply
Parameters
| param | fab | Function to apply the applicative to |
| param | fa | Applicative a to apply |
| param | fb | Applicative b to apply |
| returns | Applicative of type FC derived from Applicative of C | |
method Either<L, Func<B, C>> Apply <L, A, B, C> (this Either<L, Func<A, B, C>> fabc, Either<L, A> fa) Source #
Apply
Parameters
| param | fab | Function to apply the applicative to |
| param | fa | Applicative to apply |
| returns | Applicative of type f(b -> c) derived from Applicative of Func<B, C> | |
method Either<L, Func<B, C>> Apply <L, A, B, C> (this Func<A, B, C> fabc, Either<L, A> fa) Source #
Apply
Parameters
| param | fab | Function to apply the applicative to |
| param | fa | Applicative to apply |
| returns | Applicative of type f(b -> c) derived from Applicative of Func<B, C> | |
method Either<L, Func<B, C>> Apply <L, A, B, C> (this Either<L, Func<A, Func<B, C>>> fabc, Either<L, A> fa) Source #
Apply
Parameters
| param | fab | Function to apply the applicative to |
| param | fa | Applicative to apply |
| returns | Applicative of type f(b -> c) derived from Applicative of Func<B, C> | |
method Either<L, Func<B, C>> Apply <L, A, B, C> (this Func<A, Func<B, C>> fabc, Either<L, A> fa) Source #
Apply
Parameters
| param | fab | Function to apply the applicative to |
| param | fa | Applicative to apply |
| returns | Applicative of type f(b -> c) derived from Applicative of Func<B, C> | |
method Either<L, B> Action <L, A, B> (this Either<L, A> fa, Either<L, B> fb) Source #
Evaluate fa, then fb, ignoring the result of fa
Parameters
| param | fa | Applicative to evaluate first |
| param | fb | Applicative to evaluate second and then return |
| returns | Applicative of type Option | |
method IEnumerable<L> Lefts <L, R> (this IEnumerable<Either<L, R>> self) Source #
Extracts from a list of 'Either' all the 'Left' elements. All the 'Left' elements are extracted in order.
Parameters
| type | L | Left |
| type | R | Right |
| param | self | Either list |
| returns | An enumerable of L | |
method Seq<L> Lefts <L, R> (this Seq<Either<L, R>> self) Source #
Extracts from a list of 'Either' all the 'Left' elements. All the 'Left' elements are extracted in order.
Parameters
| type | L | Left |
| type | R | Right |
| param | self | Either list |
| returns | An enumerable of L | |
method IEnumerable<R> Rights <L, R> (this IEnumerable<Either<L, R>> self) Source #
Extracts from a list of 'Either' all the 'Right' elements. All the 'Right' elements are extracted in order.
Parameters
| type | L | Left |
| type | R | Right |
| param | self | Either list |
| returns | An enumerable of L | |
method Seq<R> Rights <L, R> (this Seq<Either<L, R>> self) Source #
Extracts from a list of 'Either' all the 'Right' elements. All the 'Right' elements are extracted in order.
Parameters
| type | L | Left |
| type | R | Right |
| param | self | Either list |
| returns | An enumerable of L | |
method (IEnumerable<L> Lefts, IEnumerable<R> Rights) Partition <L, R> (this IEnumerable<Either<L, R>> self) Source #
Partitions a list of 'Either' into two lists. All the 'Left' elements are extracted, in order, to the first component of the output. Similarly the 'Right' elements are extracted to the second component of the output.
Parameters
| type | L | Left |
| type | R | Right |
| param | self | Either list |
| returns | A tuple containing the an enumerable of L and an enumerable of R | |
method (Seq<L> Lefts, Seq<R> Rights) Partition <L, R> (this Seq<Either<L, R>> self) Source #
Partitions a list of 'Either' into two lists. All the 'Left' elements are extracted, in order, to the first component of the output. Similarly the 'Right' elements are extracted to the second component of the output.
Parameters
| type | L | Left |
| type | R | Right |
| param | self | Either list |
| returns | A tuple containing the an enumerable of L and an enumerable of R | |
method R Sum <NUM, L, R> (this Either<L, R> self) Source #
Sum of the Either
Parameters
| type | L | Left |
| param | self | Either to count |
| returns | 0 if Left, or value of Right | |
method int Sum <L> (this Either<L, int> self) Source #
Sum of the Either
Parameters
| type | L | Left |
| param | self | Either to count |
| returns | 0 if Left, or value of Right | |
method Either<L, Func<T2, R>> ParMap <L, T1, T2, R> (this Either<L, T1> self, Func<T1, T2, R> func) Source #
Partial application map
method Either<L, Func<T2, Func<T3, R>>> ParMap <L, T1, T2, T3, R> (this Either<L, T1> self, Func<T1, T2, T3, R> func) Source #
Partial application map
method Task<R2> MatchAsync <L, R, R2> (this Either<L, Task<R>> self, Func<R, R2> Right, Func<L, R2> Left) Source #
Match the two states of the Either and return a promise of a non-null R2.
method Task<Either<L, R2>> MapAsync <L, R, R2> (this Either<L, R> self, Func<R, Task<R2>> map) Source #
method Task<Either<L, R2>> MapAsync <L, R, R2> (this Task<Either<L, R>> self, Func<R, Task<R2>> map) Source #
method Task<Either<L, R2>> MapAsync <L, R, R2> (this Task<Either<L, R>> self, Func<R, R2> map) Source #
method Task<Either<L, R2>> MapAsync <L, R, R2> (this Either<L, Task<R>> self, Func<R, R2> map) Source #
method Task<Either<L, R2>> MapAsync <L, R, R2> (this Either<L, Task<R>> self, Func<R, Task<R2>> map) Source #
method Task<Either<L, R2>> BindAsync <L, R, R2> (this Either<L, R> self, Func<R, Task<Either<L, R2>>> bind) Source #
method Task<Either<L, R2>> BindAsync <L, R, R2> (this Task<Either<L, R>> self, Func<R, Task<Either<L, R2>>> bind) Source #
method Task<Either<L, R2>> BindAsync <L, R, R2> (this Task<Either<L, R>> self, Func<R, Either<L, R2>> bind) Source #
method Task<Either<L, R2>> BindAsync <L, R, R2> (this Either<L, Task<R>> self, Func<R, Either<L, R2>> bind) Source #
method Task<Either<L, R2>> BindAsync <L, R, R2> (this Either<L, Task<R>> self, Func<R, Task<Either<L, R2>>> bind) Source #
method Task<int> CountAsync <L, R> (this Task<Either<L, R>> self) Source #
method Task<S> FoldAsync <L, R, S> (this Task<Either<L, R>> self, S state, Func<S, R, S> folder) Source #
method Task<S> FoldAsync <L, R, S> (this Either<L, Task<R>> self, S state, Func<S, R, S> folder) Source #
method Task<bool> ForAllAsync <L, R> (this Task<Either<L, R>> self, Func<R, bool> pred) Source #
method Task<bool> ForAllAsync <L, R> (this Either<L, Task<R>> self, Func<R, bool> pred) Source #
method Task<bool> ExistsAsync <L, R> (this Task<Either<L, R>> self, Func<R, bool> pred) Source #
method Task<bool> ExistsAsync <L, R> (this Either<L, Task<R>> self, Func<R, bool> pred) Source #
method Eff<R> ToEff <R> (this Either<Error, R> ma) Source #
Convert to an Eff
Parameters
| returns | Eff monad | |
method Aff<R> ToAff <R> (this Either<Error, R> ma) Source #
Convert to an Aff
Parameters
| returns | Aff monad | |
method Eff<R> ToEff <R> (this Either<Exception, R> ma) Source #
Convert to an Eff
Parameters
| returns | Eff monad | |
method Aff<R> ToAff <R> (this Either<Exception, R> ma) Source #
Convert to an Aff
Parameters
| returns | Aff monad | |
class EitherGuardExtensions Source #
Methods
method Either<L, B> SelectMany <L, B> (this Guard<L> ma, Func<Unit, Either<L, B>> f) Source #
method Either<L, C> SelectMany <L, B, C> (this Guard<L> ma, Func<Unit, Either<L, B>> bind, Func<Unit, B, C> project) Source #
method Either<L, Unit> SelectMany <L, A> (this Either<L, A> ma, Func<A, Guard<L>> f) Source #
method Either<L, C> SelectMany <L, A, C> (this Either<L, A> ma, Func<A, Guard<L>> bind, Func<A, Unit, C> project) Source #
Methods
method Either<L, R> plus <NUM, L, R> (Either<L, R> x, Either<L, R> y) Source #
Add the bound values of x and y, uses an Add type-class to provide the add operation for type A. For example x.Add<TInteger,int>(y)
Parameters
| type | NUM | Num of A |
| type | A | Bound value type |
| param | x | Left hand side of the operation |
| param | y | Right hand side of the operation |
| returns | An option with y added to x | |
method Either<L, R> subtract <NUM, L, R> (Either<L, R> x, Either<L, R> y) Source #
Find the subtract between the two bound values of x and y, uses a Subtract type-class to provide the subtract operation for type A. For example x.Subtract<TInteger,int>(y)
Parameters
| type | NUM | Num of A |
| type | A | Bound value type |
| param | x | Left hand side of the operation |
| param | y | Right hand side of the operation |
| returns | An option with the subtract between x and y | |
method Either<L, R> product <NUM, L, R> (Either<L, R> x, Either<L, R> y) Source #
Find the product between the two bound values of x and y, uses a Product type-class to provide the product operation for type A. For example x.Product<TInteger,int>(y)
Parameters
| type | NUM | Num of A |
| type | A | Bound value type |
| param | x | Left hand side of the operation |
| param | y | Right hand side of the operation |
| returns | An option with the product of x and y | |
method Either<L, R> divide <NUM, L, R> (Either<L, R> x, Either<L, R> y) Source #
Divide the two bound values of x and y, uses a Divide type-class to provide the divide operation for type A. For example x.Divide<TDouble,double>(y)
Parameters
| type | NUM | Num of A |
| type | A | Bound value type |
| param | x | Left hand side of the operation |
| param | y | Right hand side of the operation |
| returns | An option x / y | |
method Either<L, B> apply <L, A, B> (Either<L, Func<A, B>> fab, Either<L, A> fa) Source #
Apply
Parameters
| param | fab | Function to apply the applicative to |
| param | fa | Applicative to apply |
| returns | Applicative of type FB derived from Applicative of B | |
method Either<L, B> apply <L, A, B> (Func<A, B> fab, Either<L, A> fa) Source #
Apply
Parameters
| param | fab | Function to apply the applicative to |
| param | fa | Applicative to apply |
| returns | Applicative of type FB derived from Applicative of B | |
method Either<L, C> apply <L, A, B, C> (Either<L, Func<A, B, C>> fabc, Either<L, A> fa, Either<L, B> fb) Source #
Apply
Parameters
| param | fab | Function to apply the applicative to |
| param | fa | Applicative a to apply |
| param | fb | Applicative b to apply |
| returns | Applicative of type FC derived from Applicative of C | |
method Either<L, C> apply <L, A, B, C> (Func<A, B, C> fabc, Either<L, A> fa, Either<L, B> fb) Source #
Apply
Parameters
| param | fab | Function to apply the applicative to |
| param | fa | Applicative a to apply |
| param | fb | Applicative b to apply |
| returns | Applicative of type FC derived from Applicative of C | |
method Either<L, Func<B, C>> apply <L, A, B, C> (Either<L, Func<A, B, C>> fabc, Either<L, A> fa) Source #
Apply
Parameters
| param | fab | Function to apply the applicative to |
| param | fa | Applicative to apply |
| returns | Applicative of type f(b -> c) derived from Applicative of Func<B, C> | |
method Either<L, Func<B, C>> apply <L, A, B, C> (Func<A, B, C> fabc, Either<L, A> fa) Source #
Apply
Parameters
| param | fab | Function to apply the applicative to |
| param | fa | Applicative to apply |
| returns | Applicative of type f(b -> c) derived from Applicative of Func<B, C> | |
method Either<L, Func<B, C>> apply <L, A, B, C> (Either<L, Func<A, Func<B, C>>> fabc, Either<L, A> fa) Source #
Apply
Parameters
| param | fab | Function to apply the applicative to |
| param | fa | Applicative to apply |
| returns | Applicative of type f(b -> c) derived from Applicative of Func<B, C> | |
method Either<L, Func<B, C>> apply <L, A, B, C> (Func<A, Func<B, C>> fabc, Either<L, A> fa) Source #
Apply
Parameters
| param | fab | Function to apply the applicative to |
| param | fa | Applicative to apply |
| returns | Applicative of type f(b -> c) derived from Applicative of Func<B, C> | |
method Either<L, B> action <L, A, B> (Either<L, A> fa, Either<L, B> fb) Source #
Evaluate fa, then fb, ignoring the result of fa
Parameters
| param | fa | Applicative to evaluate first |
| param | fb | Applicative to evaluate second and then return |
| returns | Applicative of type Option | |
method bool isRight <L, R> (Either<L, R> value) Source #
Returns the state of the Either provided
Parameters
| type | L | Left |
| type | R | Right |
| param | value | Either to check |
| returns | True if the Either is in a Right state | |
method bool isLeft <L, R> (Either<L, R> value) Source #
Returns the state of the Either provided
Parameters
| type | L | Left |
| type | R | Right |
| param | value | Either to check |
| returns | True if the Either is in a Left state | |
method Either<L, R> Right <L, R> (R value) Source #
Either constructor Constructs an Either in a Right state
Parameters
| type | L | Left |
| type | R | Right |
| param | value | Right value |
| returns | A new Either instance | |
method EitherRight<R> Right <R> (R value) Source #
Constructs an EitherRight which can be implicitly cast to an Either<_, R>
Parameters
| type | R | Right |
| param | value | Right value |
| returns | A new EitherRight instance | |
method Either<L, R> Left <L, R> (L value) Source #
Either constructor Constructs an Either in a Left state
Parameters
| type | L | Left |
| type | R | Right |
| param | value | Left value |
| returns | A new Either instance | |
method EitherLeft<L> Left <L> (L value) Source #
Constructs an EitherLeft which can be implicitly cast to an Either<L, _>
Parameters
| type | L | Left |
| param | value | Right value |
| returns | A new EitherLeft instance | |
method Either<L, R> Right <L, R> (R? value) Source #
Either constructor from Nullable Constructs an Either in a Right state or throws a ValueIsNullException if the value is null
Parameters
| type | L | Left |
| type | R | Right |
| param | value | Right value |
| returns | A new Either instance | |
method Either<L, R> Left <L, R> (L? value) Source #
Either constructor from Nullable Constructs an Either in a Left state or throws a ValueIsNullException if the value is null
Parameters
| type | L | Left |
| type | R | Right |
| param | value | Left value |
| returns | A new Either instance | |
method R ifLeft <L, R> (Either<L, R> either, Func<R> Left) Source #
Executes the Left function if the Either is in a Left state. Returns the Right value if the Either is in a Right state.
Parameters
| param | Left | Function to generate a Right value if in the Left state |
| returns | Returns an unwrapped Right value | |
method R ifLeft <L, R> (Either<L, R> either, Func<L, R> leftMap) Source #
Executes the leftMap function if the Either is in a Left state. Returns the Right value if the Either is in a Right state.
Parameters
| param | leftMap | Function to generate a Right value if in the Left state |
| returns | Returns an unwrapped Right value | |
method R ifLeft <L, R> (Either<L, R> either, R rightValue) Source #
Returns the rightValue if the Either is in a Left state. Returns the Right value if the Either is in a Right state.
Parameters
| param | rightValue | Value to return if in the Left state |
| returns | Returns an unwrapped Right value | |
method Unit ifLeft <L, R> (Either<L, R> either, Action<L> Left) Source #
Executes the Left action if the Either is in a Left state.
Parameters
| param | Left | Function to generate a Right value if in the Left state |
| returns | Returns an unwrapped Right value | |
method Unit ifRight <L, R> (Either<L, R> either, Action<R> Right) Source #
Invokes the Right action if the Either is in a Right state, otherwise does nothing
Parameters
| param | Right | Action to invoke |
| returns | Unit | |
method L ifRight <L, R> (Either<L, R> either, L leftValue) Source #
Returns the leftValue if the Either is in a Right state. Returns the Left value if the Either is in a Left state.
Parameters
| param | leftValue | Value to return if in the Left state |
| returns | Returns an unwrapped Left value | |
method L ifRight <L, R> (Either<L, R> either, Func<L> Left) Source #
Returns the result of Left() if the Either is in a Right state. Returns the Left value if the Either is in a Left state.
Parameters
| param | Left | Function to generate a Left value if in the Right state |
| returns | Returns an unwrapped Left value | |
method L ifRight <L, R> (Either<L, R> either, Func<R, L> leftMap) Source #
Returns the result of leftMap if the Either is in a Right state. Returns the Left value if the Either is in a Left state.
Parameters
| param | leftMap | Function to generate a Left value if in the Right state |
| returns | Returns an unwrapped Left value | |
method Ret match <L, R, Ret> (Either<L, R> either, Func<R, Ret> Right, Func<L, Ret> Left) Source #
Invokes the Right or Left function depending on the state of the Either provided
Parameters
| type | L | Left |
| type | R | Right |
| type | Ret | Return type |
| param | either | Either to match |
| param | Right | Function to invoke if in a Right state |
| param | Left | Function to invoke if in a Left state |
| returns | The return value of the invoked function | |
method Unit match <L, R> (Either<L, R> either, Action<R> Right, Action<L> Left) Source #
Invokes the Right or Left action depending on the state of the Either provided
Parameters
| type | L | Left |
| type | R | Right |
| param | either | Either to match |
| param | Right | Action to invoke if in a Right state |
| param | Left | Action to invoke if in a Left state |
| returns | Unit | |
method S fold <S, L, R> (Either<L, R> either, S state, Func<S, R, S> folder) Source #
Either 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:
Parameters
| type | S | Aggregate state type |
| param | state | Initial state |
| param | folder | Folder function, applied if structure is in a Right state |
| returns | The aggregate state | |
method S bifold <L, R, S> (Either<L, R> either, S state, Func<S, R, S> Right, Func<S, L, S> Left) Source #
Either 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:
Parameters
| type | S | Aggregate state type |
| param | state | Initial state |
| param | Right | Folder function, applied if Either is in a Right state |
| param | Left | Folder function, applied if Either is in a Left state |
| returns | The aggregate state | |
method bool forall <L, R> (Either<L, R> either, Func<R, bool> pred) Source #
Invokes a predicate on the value of the Either if it's in the Right state
Parameters
| type | L | Left |
| type | R | Right |
| param | either | Either to forall |
| param | pred | Predicate |
| returns | True if the Either is in a Left state. True if the Either is in a Right state and the predicate returns True. False otherwise. | |
method bool biforall <L, R> (Either<L, R> either, Func<R, bool> Right, Func<L, bool> Left) Source #
Invokes a predicate on the value of the Either if it's in the Right state
Parameters
| type | L | Left |
| type | R | Right |
| param | self | Either to forall |
| param | Right | Right predicate |
| param | Left | Left predicate |
| returns | True if the predicate returns True. True if the Either is in a bottom state. | |
method int count <L, R> (Either<L, R> either) Source #
Counts the Either
Parameters
| type | L | Left |
| type | R | Right |
| param | either | Either to count |
| returns | 1 if the Either is in a Right state, 0 otherwise. | |
method bool exists <L, R> (Either<L, R> either, Func<R, bool> pred) Source #
Invokes a predicate on the value of the Either if it's in the Right state
Parameters
| type | L | Left |
| type | R | Right |
| param | either | Either to check existence of |
| param | pred | Predicate |
| returns | True if the Either is in a Right state and the predicate returns True. False otherwise. | |
method bool biexists <L, R> (Either<L, R> either, Func<R, bool> Right, Func<L, bool> Left) Source #
Invokes a predicate on the value of the Either
Parameters
| type | L | Left |
| type | R | Right |
| param | self | Either to check existence of |
| param | Right | Right predicate |
| param | Left | Left predicate |
| returns | True if the predicate returns True. False otherwise or if the Either is in a bottom state. | |
method Either<L, Ret> map <L, R, Ret> (Either<L, R> either, Func<R, Ret> mapper) Source #
Maps the value in the Either if it's in a Right state
Parameters
| type | L | Left |
| type | R | Right |
| type | Ret | Mapped Either type |
| param | either | Either to map |
| param | mapper | Map function |
| returns | Mapped Either | |
method Either<LRet, RRet> bimap <L, R, LRet, RRet> (Either<L, R> either, Func<R, RRet> Right, Func<L, LRet> Left) Source #
Bi-maps the value in the Either if it's in a Right state
Parameters
| type | L | Left |
| type | R | Right |
| type | LRet | Left return |
| type | RRet | Right return |
| param | self | Either to map |
| param | Right | Right map function |
| param | Left | Left map function |
| returns | Mapped Either | |
method Either<L, Func<T2, R>> parmap <L, T1, T2, R> (Either<L, T1> either, Func<T1, T2, R> func) Source #
Partial application map
method Either<L, Func<T2, Func<T3, R>>> parmap <L, T1, T2, T3, R> (Either<L, T1> either, Func<T1, T2, T3, R> func) Source #
Partial application map
method Either<L, R> filter <L, R> (Either<L, R> either, Func<R, bool> pred) Source #
Filter the Either
This may give unpredictable results for a filtered value. The Either won't return true for IsLeft or IsRight. IsBottom is True if the value is filtered and that should be checked for.
Parameters
| type | L | Left |
| type | R | Right |
| param | self | Either to filter |
| param | pred | Predicate function |
| returns | If the Either is in the Left state it is returned as-is. If in the Right state the predicate is applied to the Right value. If the predicate returns True the Either is returned as-is. If the predicate returns False the Either is returned in a 'Bottom' state. | |
method Either<L, Ret> bind <L, R, Ret> (Either<L, R> either, Func<R, Either<L, Ret>> binder) Source #
Monadic bind function https://en.wikipedia.org/wiki/Monad_(functional_programming)
Parameters
| type | L | Left |
| type | R | Right |
| type | Ret | |
| param | either | |
| param | binder | |
| returns | Bound Either | |
method IEnumerable<Ret> Match <L, R, Ret> (this IEnumerable<Either<L, R>> list, Func<R, Ret> Right, Func<L, Ret> Left ) Source #
Match over a sequence of Eithers
Parameters
| type | L | Left |
| type | R | Right |
| type | Ret | Mapped type |
| param | list | Sequence to match over |
| param | Right | Right match function |
| param | Left | Left match function |
| returns | Sequence of mapped values | |
method IEnumerable<Ret> match <L, R, Ret> (IEnumerable<Either<L, R>> list, Func<R, Ret> Right, Func<L, Ret> Left ) Source #
Match over a sequence of Eithers
Parameters
| type | L | Left |
| type | R | Right |
| type | Ret | Mapped type |
| param | list | Sequence to match over |
| param | Right | Right match function |
| param | Left | Left match function |
| returns | Sequence of mapped values | |
method Lst<R> rightToList <L, R> (Either<L, R> either) Source #
Project the Either into a Lst R
Parameters
| type | L | Left |
| type | R | Right |
| param | either | Either to project |
| returns | If the Either is in a Right state, a Lst of R with one item. A zero length Lst R otherwise | |
method Arr<R> rightToArray <L, R> (Either<L, R> either) Source #
Project the Either into an ImmutableArray R
Parameters
| type | L | Left |
| type | R | Right |
| param | either | Either to project |
| returns | If the Either is in a Right state, a ImmutableArray of R with one item. A zero length ImmutableArray of R otherwise | |
method Lst<L> leftToList <L, R> (Either<L, R> either) Source #
Project the Either into a Lst L
Parameters
| type | L | Left |
| type | R | Right |
| param | either | Either to project |
| returns | If the Either is in a Left state, a Lst of L with one item. A zero length Lst L otherwise | |
method Arr<L> leftToArray <L, R> (Either<L, R> either) Source #
Project the Either into an array of L
Parameters
| type | L | Left |
| type | R | Right |
| param | either | Either to project |
| returns | If the Either is in a Right state, an array of L with one item. A zero length array of L otherwise | |
method IQueryable<R> rightToQuery <L, R> (Either<L, R> either) Source #
Project the Either into an IQueryable of R
Parameters
| type | L | Left |
| type | R | Right |
| param | either | Either to project |
| returns | If the Either is in a Right state, an IQueryable of R with one item. A zero length IQueryable R otherwise | |
method IQueryable<L> leftToQuery <L, R> (Either<L, R> either) Source #
Project the Either into an IQueryable of L
Parameters
| type | L | Left |
| type | R | Right |
| param | either | Either to project |
| returns | If the Either is in a Left state, an IQueryable of L with one item. A zero length IQueryable L otherwise | |
method IEnumerable<L> lefts <L, R> (IEnumerable<Either<L, R>> self) Source #
Extracts from a list of 'Either' all the 'Left' elements. All the 'Left' elements are extracted in order.
Parameters
| type | L | Left |
| type | R | Right |
| param | self | Either list |
| returns | An enumerable of L | |
method Seq<L> lefts <L, R> (Seq<Either<L, R>> self) Source #
Extracts from a list of 'Either' all the 'Left' elements. All the 'Left' elements are extracted in order.
Parameters
| type | L | Left |
| type | R | Right |
| param | self | Either list |
| returns | An enumerable of L | |
method IEnumerable<R> rights <L, R> (IEnumerable<Either<L, R>> self) Source #
Extracts from a list of 'Either' all the 'Right' elements. All the 'Right' elements are extracted in order.
Parameters
| type | L | Left |
| type | R | Right |
| param | self | Either list |
| returns | An enumerable of L | |
method Seq<R> rights <L, R> (Seq<Either<L, R>> self) Source #
Extracts from a list of 'Either' all the 'Right' elements. All the 'Right' elements are extracted in order.
Parameters
| type | L | Left |
| type | R | Right |
| param | self | Either list |
| returns | An enumerable of L | |
method (IEnumerable<L> Lefts, IEnumerable<R> Rights) partition <L, R> (IEnumerable<Either<L, R>> self) Source #
Partitions a list of 'Either' into two lists. All the 'Left' elements are extracted, in order, to the first component of the output. Similarly the 'Right' elements are extracted to the second component of the output.
Parameters
| type | L | Left |
| type | R | Right |
| param | self | Either list |
| returns | A tuple containing the an enumerable of L and an enumerable of R | |
method (Seq<L> Lefts, Seq<R> Rights) partition <L, R> (Seq<Either<L, R>> self) Source #
Partitions a list of 'Either' into two lists. All the 'Left' elements are extracted, in order, to the first component of the output. Similarly the 'Right' elements are extracted to the second component of the output.
Parameters
| type | L | Left |
| type | R | Right |
| param | self | Either list |
| returns | A tuple containing the an enumerable of L and an enumerable of R | |
class IEnumerableEitherTransExt Source #
Methods
method bool BiForAllT <L, R> (this IEnumerable<Either<L, R>> self, Func<R, bool> Right, Func<L, bool> Left) Source #
method S BiFoldT <L, R, S> (this IEnumerable<Either<L, R>> self, S state, Func<S, R, S> Right, Func<S, L, S> Left) Source #
method bool BiExistsT <L, R> (this IEnumerable<Either<L, R>> self, Func<R, bool> Right, Func<L, bool> Left) Source #
Methods
method bool biforallT <L, R> (IEnumerable<Either<L, R>> self, Func<R, bool> Right, Func<L, bool> Left) Source #
method S bifoldT <L, R, S> (IEnumerable<Either<L, R>> self, S state, Func<S, R, S> Right, Func<S, L, S> Left) Source #
method bool biexistsT <L, R> (IEnumerable<Either<L, R>> self, Func<R, bool> Right, Func<L, bool> Left) Source #
class TaskEitherAsyncExtensions Source #
Methods
method EitherAsync<L, R> Plus <NUM, L, R> (this Task<Either<L, R>> x, Task<Either<L, R>> y) Source #
Add the bound values of x and y, uses an Add type-class to provide the add operation for type A. For example x.Add<TInteger,int>(y)
Parameters
| type | NUM | Num of A |
| type | A | Bound value type |
| param | x | Left hand side of the operation |
| param | y | Right hand side of the operation |
| returns | An option with y added to x | |
method EitherAsync<L, R> Subtract <NUM, L, R> (this Task<Either<L, R>> x, Task<Either<L, R>> y) Source #
Find the subtract between the two bound values of x and y, uses a Subtract type-class to provide the subtract operation for type A. For example x.Subtract<TInteger,int>(y)
Parameters
| type | NUM | Num of A |
| type | A | Bound value type |
| param | x | Left hand side of the operation |
| param | y | Right hand side of the operation |
| returns | An option with the subtract between x and y | |
method EitherAsync<L, R> Product <NUM, L, R> (this Task<Either<L, R>> x, Task<Either<L, R>> y) Source #
Find the product between the two bound values of x and y, uses a Product type-class to provide the product operation for type A. For example x.Product<TInteger,int>(y)
Parameters
| type | NUM | Num of A |
| type | A | Bound value type |
| param | x | Left hand side of the operation |
| param | y | Right hand side of the operation |
| returns | An option with the product of x and y | |
method EitherAsync<L, R> Divide <NUM, L, R> (this Task<Either<L, R>> x, Task<Either<L, R>> y) Source #
Divide the two bound values of x and y, uses a Divide type-class to provide the divide operation for type A. For example x.Divide<TDouble,double>(y)
Parameters
| type | NUM | Num of A |
| type | A | Bound value type |
| param | x | Left hand side of the operation |
| param | y | Right hand side of the operation |
| returns | An option x / y | |
method EitherAsync<L, B> Apply <L, A, B> (this Task<Either<L, Func<A, B>>> fab, Task<Either<L, A>> fa) Source #
Apply
Parameters
| param | fab | Function to apply the applicative to |
| param | fa | Applicative to apply |
| returns | Applicative of type FB derived from Applicative of B | |
method EitherAsync<L, B> Apply <L, A, B> (this Func<A, B> fab, Task<Either<L, A>> fa) Source #
Apply
Parameters
| param | fab | Function to apply the applicative to |
| param | fa | Applicative to apply |
| returns | Applicative of type FB derived from Applicative of B | |
method EitherAsync<L, C> Apply <L, A, B, C> (this Task<Either<L, Func<A, B, C>>> fabc, Task<Either<L, A>> fa, Task<Either<L, B>> fb) Source #
Apply
Parameters
| param | fab | Function to apply the applicative to |
| param | fa | Applicative a to apply |
| param | fb | Applicative b to apply |
| returns | Applicative of type FC derived from Applicative of C | |
method EitherAsync<L, C> Apply <L, A, B, C> (this Func<A, B, C> fabc, Task<Either<L, A>> fa, Task<Either<L, B>> fb) Source #
Apply
Parameters
| param | fab | Function to apply the applicative to |
| param | fa | Applicative a to apply |
| param | fb | Applicative b to apply |
| returns | Applicative of type FC derived from Applicative of C | |
method EitherAsync<L, Func<B, C>> Apply <L, A, B, C> (this Task<Either<L, Func<A, B, C>>> fabc, Task<Either<L, A>> fa) Source #
Apply
Parameters
| param | fab | Function to apply the applicative to |
| param | fa | Applicative to apply |
| returns | Applicative of type f(b -> c) derived from Applicative of Func<B, C> | |
method EitherAsync<L, Func<B, C>> Apply <L, A, B, C> (this Func<A, B, C> fabc, Task<Either<L, A>> fa) Source #
Apply
Parameters
| param | fab | Function to apply the applicative to |
| param | fa | Applicative to apply |
| returns | Applicative of type f(b -> c) derived from Applicative of Func<B, C> | |
method EitherAsync<L, Func<B, C>> Apply <L, A, B, C> (this Task<Either<L, Func<A, Func<B, C>>>> fabc, Task<Either<L, A>> fa) Source #
Apply
Parameters
| param | fab | Function to apply the applicative to |
| param | fa | Applicative to apply |
| returns | Applicative of type f(b -> c) derived from Applicative of Func<B, C> | |