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);
}
