public static EitherUnsafe <L, A> ToEitherUnsafe <A, L>(this Try <A> self, Func <Exception, L> Fail) { var res = self.Try(); return(res.IsFaulted ? EitherUnsafe <L, A> .Left(Fail(res.Exception)) : EitherUnsafe <L, A> .Right(res.Value)); }
public static EitherUnsafe <Exception, A> ToEitherUnsafe <A>(this Try <A> self) { var res = self.Try(); return(res.IsFaulted ? EitherUnsafe <Exception, A> .Left(res.Exception) : EitherUnsafe <Exception, A> .Right(res.Value)); }
/// <summary> /// 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 filterd and that /// should be checked. /// </summary> /// <typeparam name="L">Left</typeparam> /// <typeparam name="R">Right</typeparam> /// <param name="self">Either to filter</param> /// <param name="pred">Predicate function</param> /// <returns>If the Either is in the Left state it is returned as-is. /// If in the Left state the predicate is applied to the Left 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.</returns> public static EitherUnsafe <L, R> Filter <L, R>(this EitherUnsafe <L, R> self, Func <L, bool> pred) => self.IsBottom ? self : self.MatchUnsafe( Right: (R r) => EitherUnsafe <L, R> .Right(r), Left: (L t) => pred(t) ? EitherUnsafe <L, R> .Left(t) : new EitherUnsafe <L, R>(true) );
public static EitherUnsafe <L, VR> SelectMany <L, TR, UR, VR>(this EitherUnsafe <L, TR> self, Func <TR, EitherUnsafe <L, UR> > bind, Func <TR, UR, VR> project ) => matchUnsafe(self, Right: t => matchUnsafe(bind(t), Right: u => EitherUnsafe <L, VR> .Right(project(t, u)), Left: l => EitherUnsafe <L, VR> .Left(l) ), Left: l => EitherUnsafe <L, VR> .Left(l) );
public static EitherUnsafe <L, UR> Select <L, TR, UR>(this EitherUnsafe <L, TR> self, Func <TR, UR> map) => matchUnsafe(self, Right: t => EitherUnsafe <L, UR> .Right(map(t)), Left: l => EitherUnsafe <L, UR> .Left(l) );
public EitherUnsafe <L2, R2> BiMap(EitherUnsafe <L, R> ma, Func <L, L2> fa, Func <R, R2> fb) => default(MEitherUnsafe <L, R>).MatchUnsafe(ma, Left: a => EitherUnsafe <L2, R2> .Left(Check.NullReturn(fa(a))), Right: b => EitherUnsafe <L2, R2> .Right(Check.NullReturn(fb(b))), Bottom: () => EitherUnsafe <L2, R2> .Bottom);
public static Task <EitherUnsafe <L, A> > ToEitherUnsafe <A, L>(this TryAsync <A> self, Func <Exception, L> Fail) => self.Match( Succ: v => EitherUnsafe <L, A> .Right(v), Fail: x => EitherUnsafe <L, A> .Left(Fail(x)));
public static Task <EitherUnsafe <Exception, A> > ToEitherUnsafe <A>(this TryAsync <A> self) => self.Match( Succ: v => EitherUnsafe <Exception, A> .Right(v), Fail: x => EitherUnsafe <Exception, A> .Left(x));
/// <summary> /// 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 filterd and that /// should be checked. /// </summary> /// <typeparam name="L">Left</typeparam> /// <typeparam name="R">Right</typeparam> /// <param name="self">Either to filter</param> /// <param name="pred">Predicate function</param> /// <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)</returns> public static EitherUnsafe <L, R> Filter <L, R>(this EitherUnsafe <L, R> self, Func <R, bool> pred) => self.IsBottom ? self : matchUnsafe(self, Right: t => pred(t) ? EitherUnsafe <L, R> .Right(t) : new EitherUnsafe <L, R>(true), Left: l => EitherUnsafe <L, R> .Left(l));
/// <summary> /// Monadic bind function /// https://en.wikipedia.org/wiki/Monad_(functional_programming) /// </summary> /// <typeparam name="L">Left</typeparam> /// <typeparam name="R">Right</typeparam> /// <typeparam name="Ret"></typeparam> /// <param name="self"></param> /// <param name="binder"></param> /// <returns>Bound Either</returns> public static EitherUnsafe <Ret, R> Bind <L, R, Ret>(this EitherUnsafe <L, R> self, Func <L, EitherUnsafe <Ret, R> > binder) => self.IsBottom ? new EitherUnsafe <Ret, R>(true) : self.IsLeft ? binder(self.LeftValue) : EitherUnsafe <Ret, R> .Right(self.RightValue);
/// <summary> /// Bi-filter the Either /// </summary> /// <remarks> /// 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. /// </remarks> /// <typeparam name="L">Left</typeparam> /// <typeparam name="R">Right</typeparam> /// <param name="self">Either to filter</param> /// <param name="pred">Predicate function</param> /// <returns> /// If the Either is in the Left state then the Left predicate is run against it. /// If the Either is in the Right state then the Right predicate is run against it. /// If the predicate returns False the Either is returned in a 'Bottom' state.</returns> public static EitherUnsafe <L, R> Filter <L, R>(this EitherUnsafe <L, R> self, Func <R, bool> Right, Func <L, bool> Left) => self.IsBottom ? self : matchUnsafe(self, Right: r => Right(r) ? EitherUnsafe <L, R> .Right(r) : new EitherUnsafe <L, R>(true), Left: l => Left(l) ? EitherUnsafe <L, R> .Left(l) : new EitherUnsafe <L, R>(true));
public EitherUnsafe <L, R2> Map(EitherUnsafe <L, R> ma, Func <R, R2> f) => default(MEitherUnsafe <L, R>).MatchUnsafe(ma, Left: EitherUnsafe <L, R2> .Left, Right: b => EitherUnsafe <L, R2> .Right(f(b)), Bottom: () => EitherUnsafe <L, R2> .Bottom);