public async Task WithReferences() { int MatchSome(int some) => some + 1; int MatchNone(None none) => 0; var source = AsyncMaybe <int> .Some(1); var result = await source.Match(some : MatchSome, none : MatchNone); Assert.Equal(2, result); }
public async Task OnSome_WithLambdaReturningAsyncNone_ReturnsSelf() { const int expected = 34; // ReSharper disable once ConvertClosureToMethodGroup var source = await AsyncMaybe <int> .Some(expected).OrAsync(() => Task.FromResult(AsyncMaybe <int> .None())); var result = source.MustBeSome(); Assert.Equal(expected, result); }
public async Task NoneValue_WithLambdas() { var some = 0; var none = 0; var source = AsyncMaybe <int> .None(); await source.Match(_ => { some++; return(TaskCache.CompletedTask); }, _ => { none++; return(TaskCache.CompletedTask); }); Assert.Equal(0, some); Assert.Equal(1, none); }
public async Task WhenFirstIsNone_AndSecondIsSome_UsingLambda_ReturnsNone() { var first = AsyncMaybe <int> .None(); const int secondValue = 6589; var second = AsyncMaybe <int> .Some(secondValue); var result = await first.Zip(second, (f, s) => (first : f, second : s)); result.MustBeNone(); }
public async Task WhenSome_ReturnsSingleItemEnumerable() { const int expectedValue = 230023; var source = AsyncMaybe <int> .Some(expectedValue); var result = await source.ToEnumerable(); var value = Assert.Single(result); Assert.Equal(expectedValue, value); }
public async Task WithNullZipper_ThrowsException() { var first = AsyncMaybe <int> .None(); var second = AsyncMaybe <int> .None(); var third = AsyncMaybe <int> .None(); // ReSharper disable once AssignNullToNotNullAttribute await Assert.ThrowsAsync <ArgumentNullException>(async() => await first.Zip <int, int, int, object>(second, third, null)); }
public async Task WithReferences() { int MatchSome(int some) => some + 1; Task <int> MatchNone() => Task.FromResult(0); var source = AsyncMaybe <int> .Some(1); var result = await source.Match(some : MatchSome, noneAsync : MatchNone); Assert.Equal(2, result); }
public async Task WithLambdas() { var some = 0; var none = 0; var source = AsyncMaybe <int> .Some(1); await source.Match(_ => { some++; }, _ => { none++; }); Assert.Equal(1, some); Assert.Equal(0, none); }
public async Task WithReferences() { Task <int> MatchSome(int some) => Task.FromResult(some + 1); Task <int> MatchNone(None none) => Task.FromResult(0); var source = AsyncMaybe <int> .Some(1); var result = await source.MatchAsync(MatchSome, MatchNone); Assert.Equal(2, result); }
public async Task OnNone_WithMethodReferenceReturningAsyncSome_ReturnsOther() { const int expected = 34; Task <AsyncMaybe <int> > Other() => Task.FromResult(AsyncMaybe <int> .Some(expected)); var source = await AsyncMaybe <int> .None().OrAsync(otherAsync: Other); var result = source.MustBeSome(); Assert.Equal(expected, result); }
public async Task WhenFirstIsSome_AndSecondIsNone_AndThirdIsSome_ReturnsNone() { var first = AsyncMaybe <int> .Some(451); var second = AsyncMaybe <int> .None(); var third = AsyncMaybe <int> .Some(123); var result = await first.Zip(second, third, (f, s, t) => (f, s, t)); result.MustBeNone(); }
public async Task OnNone_WithLambda_ReturnsOther() { const int expected = 79; var source = Maybe <int> .None(); var other = AsyncMaybe <int> .Some(expected); var result = await source.OrAsync(() => other); var value = result.MustBeSome(); Assert.Equal(expected, value); }
public async Task OnSome_ReturnsSource() { const int expected = 5; var source = Maybe <int> .Some(expected); var other = AsyncMaybe <int> .Some(79); var result = await source.OrAsync(other); var value = result.MustBeSome(); Assert.Equal(expected, value); }
public async Task WithSomeLambda_AndNoneReference() { var some = 0; var none = 0; void MatchNone() => none++; var source = AsyncMaybe <int> .Some(1); await source.Match(value => { some++; }, none : MatchNone); Assert.Equal(1, some); Assert.Equal(0, none); }
public async Task FromMaybeSome() { var expectedValue = new object(); Maybe <object> source = Maybe <object> .Some(expectedValue); AsyncMaybe <object> implicitAsync = source; var isSome = await implicitAsync.IsSome; var value = await implicitAsync.OrFail(); Assert.True(isSome); Assert.Same(expectedValue, value); }
public async Task WithSomeReference_AndNoneLambda() { var some = 0; var none = 0; void MatchSome(int value) => some++; var source = AsyncMaybe <int> .Some(1); await source.Match(some : MatchSome, none : () => { none++; }); Assert.Equal(1, some); Assert.Equal(0, none); }
public async Task OnNone_WithMethodReference_ReturnsOther() { const int expected = 79; AsyncMaybe <int> Other() => AsyncMaybe <int> .Some(expected); var source = Maybe <int> .None(); var result = await source.OrAsync(Other); var value = result.MustBeSome(); Assert.Equal(expected, value); }
public async Task WhenAllAreSome_ReturnsSome() { const int firstValue = 23; var first = AsyncMaybe <int> .Some(firstValue); const int secondValue = 6589; var second = AsyncMaybe <int> .Some(secondValue); var result = await first.ZipAsync(second, (f, s) => Task.FromResult((first: f, second: s))); var value = result.MustBeSome(); Assert.Equal(firstValue, value.first); Assert.Equal(secondValue, value.second); }
public async Task WhenFirstIsSome_AndSecondIsSome_UsingLambda_ReturnsSome() { const int firstValue = 23; var first = AsyncMaybe <int> .Some(firstValue); const int secondValue = 6589; var second = AsyncMaybe <int> .Some(secondValue); var result = await first.Zip(second, (f, s) => (first : f, second : s)); var value = result.MustBeSome(); Assert.Equal(firstValue, value.first); Assert.Equal(secondValue, value.second); }
public async Task WithReferences() { var some = 0; var none = 0; void MatchSome(int value) => some++; void MatchNone() => none++; var source = AsyncMaybe <int> .Some(1); await source.Match(some : MatchSome, none : MatchNone); Assert.Equal(1, some); Assert.Equal(0, none); }
public async Task WhenFirstIsSome_AndSecondIsSome_UsingMethodReference_ReturnsSome() { const int firstValue = 23; var first = AsyncMaybe <int> .Some(firstValue); const int secondValue = 6589; var second = AsyncMaybe <int> .Some(secondValue); ValueTuple <int, int> Zipper(int f, int s) => (f, s); var result = await first.Zip(second, Zipper); var value = result.MustBeSome(); Assert.Equal(firstValue, value.Item1); Assert.Equal(secondValue, value.Item2); }
public async Task WhenAllAreSome_UsingMethodReference_ReturnsSome() { const int firstValue = 23; var first = AsyncMaybe <int> .Some(firstValue); const int secondValue = 6589; var second = AsyncMaybe <int> .Some(secondValue); Task <ValueTuple <int, int> > Zipper(int f, int s) => Task.FromResult((f, s)); var result = await first.ZipAsync(second, Zipper); var value = result.MustBeSome(); Assert.Equal(firstValue, value.Item1); Assert.Equal(secondValue, value.Item2); }
public async Task WithSomeReference_AndNoneLambda() { var some = 0; var none = 0; Task MatchSome(int _) { some++; return(TaskCache.CompletedTask); } var source = AsyncMaybe <int> .Some(1); await source.Match(someAsync : MatchSome, noneAsync : _ => { none++; return(TaskCache.CompletedTask); }); Assert.Equal(1, some); Assert.Equal(0, none); }
public async Task WhenAnyIsNone_ReturnsNone() { AsyncMaybe <int> CreateMaybe(int flag) => flag == 0 ? AsyncMaybe <int> .None() : AsyncMaybe <int> .Some(flag); const int numberOfSources = 4; const int numberOfStates = 2; const int expectedSomeInvocations = 1; var someInvocations = 0; var expectedNoneInvocations = (int)Math.Pow(numberOfStates, numberOfSources) - expectedSomeInvocations; var noneInvocations = 0; foreach (var a in Enumerable.Range(0, 2)) { foreach (var b in Enumerable.Range(0, 2)) { foreach (var c in Enumerable.Range(0, 2)) { foreach (var d in Enumerable.Range(0, 2)) { var first = CreateMaybe(a); var second = CreateMaybe(b); var third = CreateMaybe(c); var fourth = CreateMaybe(d); if (await first.IsSome && await second.IsSome && await third.IsSome && await fourth.IsSome) { someInvocations++; continue; } var result = await first.ZipAsync(second, third, fourth, (v1, v2, v3, v4) => Task.FromResult((v1, v2, v3, v4))); result.MustBeNone(); noneInvocations++; } } } } Assert.Equal(expectedNoneInvocations, noneInvocations); Assert.Equal(expectedSomeInvocations, someInvocations); }
public async Task WhenAllAreSome_ReturnsSome() { const int firstValue = 23; var first = AsyncMaybe <int> .Some(firstValue); const int secondValue = 6589; var second = AsyncMaybe <int> .Some(secondValue); const int thirdValue = 236589; var third = AsyncMaybe <int> .Some(thirdValue); var result = await first.ZipAsync(second, third, (v1, v2, v3) => Task.FromResult((v1, v2, v3))); var value = result.MustBeSome(); Assert.Equal(firstValue, value.Item1); Assert.Equal(secondValue, value.Item2); Assert.Equal(thirdValue, value.Item3); }
public async Task WhenFirstIsSome_AndSecondIsSome_AndThirdIsSome_ReturnsSome() { const int firstValue = 23; var first = AsyncMaybe <int> .Some(firstValue); const int secondValue = 6589; var second = AsyncMaybe <int> .Some(secondValue); const int thirdValue = 2136589; var third = AsyncMaybe <int> .Some(thirdValue); var result = await first.Zip(second, third, (f, s, t) => (first : f, second : s, third : t)); var value = result.MustBeSome(); Assert.Equal(firstValue, value.first); Assert.Equal(secondValue, value.second); Assert.Equal(thirdValue, value.third); }
public async Task WithAsyncNoneNone_ReturnsNone() { var source = await AsyncMaybe <int> .None().Map(it => AsyncMaybe <int> .None()).Flatten(); source.MustBeNone(); }
public async Task WithNoneSome_ReturnsNone() { var source = await AsyncMaybe <int> .None().Map(it => Maybe <int> .Some(1)).Flatten(); source.MustBeNone(); }
public static async Task <T> OrFail <T>(this AsyncMaybe <T> source) { return((await source.ToTask()).OrFail()); }
public async Task Async_OnNone_WithFunction_ThrowsException() { var source = AsyncMaybe <int> .None(); await Assert.ThrowsAsync <ExpectedException>(() => source.OrThrowAsync(() => Task.FromResult <Exception>(new ExpectedException()))); }