public Either <TResult, TRight> Select <TResult>(Func <TLeft, TResult> selector) { Require.NotNull(selector, nameof(selector)); return(IsLeft ? Either <TResult, TRight> .OfLeft(selector(Left)) : Either <TResult, TRight> .OfRight(Right));; }
public static void cast1() { var exp = new Obj("left"); var either = Either <Obj, string> .OfLeft(exp); Assert.Equal(exp, (Obj)either); }
public Either <TResult, TRight> Gather <TResult>(Either <Func <TLeft, TResult>, TRight> applicative) { Require.NotNull(applicative, nameof(applicative)); return(IsLeft && applicative.IsLeft ? Either <TResult, TRight> .OfLeft(applicative.Left(Left)) : Either <TResult, TRight> .OfRight(Right)); }
public static void RightOrNone1() { var either = Either <Obj, Obj> .OfLeft(new Obj("left")); var result = either.RightOrNone(); Assert.True(result.IsNone); }
public static void OfLeft1() { var either = Either <Obj, Obj> .OfLeft(new Obj("left")); Assert.NotNull(either); Assert.True(either.IsLeft); Assert.False(either.IsRight); }
public static Either <TResult, TRight> Select <TSource, TResult, TRight>( this Either <TSource, TRight> @this, Func <TSource, TResult> selector) { Require.NotNull(@this, nameof(@this)); Require.NotNull(selector, nameof(selector)); return(@this.Bind(val => Either <TResult, TRight> .OfLeft(selector(val)))); }
public static void ToString1() { var value = new Obj("Value"); var either = Either <Obj, Obj> .OfLeft(value); Assert.Contains("Left", either.ToString(), StringComparison.OrdinalIgnoreCase); Assert.Contains(value.ToString(), either.ToString(), StringComparison.OrdinalIgnoreCase); }
public static void ToLeft1() { var exp = new Obj("left"); var either = Either <Obj, Obj> .OfLeft(exp); var left = either.ToLeft(); Assert.Equal(exp, left); }
public static void SwapUnchecked1() { var exp = new Obj("left"); var either = Either <Obj, Obj> .OfLeft(exp); var swapped = either.SwapUnchecked(); Assert.True(swapped.IsRight); Assert.True(swapped.ContainsRight(exp)); }
public static void Map1a() { bool notCalled = true; Func <Either <int, int> > fun = () => { notCalled = false; return(Either <int, int> .OfLeft(1)); }; var q = Either.Map(Enumerable.Repeat(fun, 1), f => f()); Assert.True(notCalled); q.OnLeft(x => Assert.CalledOnNext(x, ref notCalled)); q.OnRight(x => Assert.Fail()); }
public static void Deconstruct1() { var exp = new Obj(); var either = Either <Obj, int> .OfLeft(exp); var(isLeft, left, right) = either; Assert.True(isLeft); Assert.Same(exp, left); Assert.Equal(default(int), right); }
public Either <TResult, TRight> ZipWith <TSecond, TResult>( Either <TSecond, TRight> second, Func <TLeft, TSecond, TResult> zipper) { Require.NotNull(zipper, nameof(zipper)); Require.NotNull(second, nameof(second)); return(IsLeft && second.IsLeft ? Either <TResult, TRight> .OfLeft(zipper(Left, second.Left)) : Either <TResult, TRight> .OfRight(Right)); }
public static void WhereImpl1a() { bool notCalled = true; Func <Either <bool, int> > fun = () => { notCalled = false; return(Either <bool, int> .OfLeft(true)); }; var q = Enumerable.Repeat(fun, 1).WhereImpl(f => f()); Assert.True(notCalled); q.OnLeft(x => Assert.CalledOnNext(x, ref notCalled)); q.OnRight(x => Assert.Fail()); }
public static void Zip1a() { IEnumerable <int> first = new ThrowingEnumerable <int>(); var second = Enumerable.Range(0, 1); Func <int, int, Either <int, int> > resultSelector = (i, j) => Either <int, int> .OfLeft(i + j); var q = Assert.DoesNotThrow(() => Either.Zip(first, second, resultSelector)); q.OnLeft(x => Assert.ThrowsOnNext(x)); q.OnRight(x => Assert.Fail()); }
public static void LeftOrNone2() { var value = new Obj("left"); var either = Either <Obj, Obj> .OfLeft(value); var exp = Maybe.Of(value); var result = either.LeftOrNone(); Assert.True(result.IsSome); Assert.True(result.Contains(value)); }
public Either <TResult, TRight> SelectMany <TMiddle, TResult>( Func <TLeft, Either <TMiddle, TRight> > selector, Func <TLeft, TMiddle, TResult> resultSelector) { Require.NotNull(selector, nameof(selector)); Require.NotNull(resultSelector, nameof(resultSelector)); if (IsRight) { return(Either <TResult, TRight> .OfRight(Right)); } var middle = selector(Left); if (middle == null || middle.IsRight) { return(Either <TResult, TRight> .OfRight(Right)); } return(Either <TResult, TRight> .OfLeft(resultSelector(Left, middle.Left))); }
public static Either <TLeft, TRight> OfLeft <TLeft>(TLeft leftValue) => Either <TLeft, TRight> .OfLeft(leftValue);
public Either <TResult, TRight> ReplaceBy <TResult>(TResult value) => IsLeft ? Either <TResult, TRight> .OfLeft(value) : Either <TResult, TRight> .OfRight(Right);
public static void ToRight2() { var either = Either <Obj, Obj> .OfLeft(new Obj("left")); Assert.Throws <InvalidCastException>(() => either.ToRight()); }
public static void ToString2() { var either = Either <Obj, Obj> .OfLeft(null); Assert.Contains("Left", either.ToString(), StringComparison.OrdinalIgnoreCase); }
public static void cast4() { var either = Either <Obj, string> .OfLeft(new Obj("left")); Assert.Throws <InvalidCastException>(() => (string)either); }