From b98c5753db820de9d78a376f13d1cc8f2d8024f7 Mon Sep 17 00:00:00 2001 From: Marcin Jahn <10273406+marcinjahn@users.noreply.github.com> Date: Sat, 12 Apr 2025 20:33:41 +0200 Subject: [PATCH 1/4] Add Tap* extensions to Maybe --- .../Extensions/TapNoValueTests.Task.Left.cs | 22 ++++++++++ .../Extensions/TapNoValueTests.Task.Right.cs | 26 +++++++++++ .../Extensions/TapNoValueTests.Task.cs | 28 ++++++++++++ .../TapNoValueTests.ValueTask.Left.cs | 23 ++++++++++ .../TapNoValueTests.ValueTask.Right.cs | 27 ++++++++++++ .../Extensions/TapNoValueTests.ValueTask.cs | 29 ++++++++++++ .../MaybeTests/Extensions/TapNoValueTests.cs | 21 +++++++++ .../Extensions/TapTests.Task.Left.cs | 31 +++++++++++++ .../Extensions/TapTests.Task.Right.cs | 40 +++++++++++++++++ .../MaybeTests/Extensions/TapTests.Task.cs | 43 ++++++++++++++++++ .../Extensions/TapTests.ValueTask.Left.cs | 32 ++++++++++++++ .../Extensions/TapTests.ValueTask.Right.cs | 40 +++++++++++++++++ .../Extensions/TapTests.ValueTask.cs | 44 +++++++++++++++++++ .../MaybeTests/Extensions/TapTests.cs | 27 ++++++++++++ .../Maybe/Extensions/Tap.Task.Left.cs | 28 ++++++++++++ .../Maybe/Extensions/Tap.Task.Right.cs | 26 +++++++++++ .../Maybe/Extensions/Tap.Task.cs | 31 +++++++++++++ .../Maybe/Extensions/Tap.ValueTask.Left.cs | 33 ++++++++++++++ .../Maybe/Extensions/Tap.ValueTask.Right.cs | 30 +++++++++++++ .../Maybe/Extensions/Tap.ValueTask.cs | 31 +++++++++++++ .../Maybe/Extensions/Tap.cs | 25 +++++++++++ .../Maybe/Extensions/TapNoValue.Task.Left.cs | 30 +++++++++++++ .../Maybe/Extensions/TapNoValue.Task.Right.cs | 26 +++++++++++ .../Maybe/Extensions/TapNoValue.Task.cs | 30 +++++++++++++ .../Extensions/TapNoValue.ValueTask.Left.cs | 33 ++++++++++++++ .../Extensions/TapNoValue.ValueTask.Right.cs | 31 +++++++++++++ .../Maybe/Extensions/TapNoValue.ValueTask.cs | 33 ++++++++++++++ .../Maybe/Extensions/TapNoValue.cs | 25 +++++++++++ 28 files changed, 845 insertions(+) create mode 100644 CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.Left.cs create mode 100644 CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.Right.cs create mode 100644 CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.cs create mode 100644 CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.Left.cs create mode 100644 CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.Right.cs create mode 100644 CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.cs create mode 100644 CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.cs create mode 100644 CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.Left.cs create mode 100644 CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.Right.cs create mode 100644 CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.cs create mode 100644 CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.Left.cs create mode 100644 CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.Right.cs create mode 100644 CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.cs create mode 100644 CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.cs create mode 100644 CSharpFunctionalExtensions/Maybe/Extensions/Tap.Task.Left.cs create mode 100644 CSharpFunctionalExtensions/Maybe/Extensions/Tap.Task.Right.cs create mode 100644 CSharpFunctionalExtensions/Maybe/Extensions/Tap.Task.cs create mode 100644 CSharpFunctionalExtensions/Maybe/Extensions/Tap.ValueTask.Left.cs create mode 100644 CSharpFunctionalExtensions/Maybe/Extensions/Tap.ValueTask.Right.cs create mode 100644 CSharpFunctionalExtensions/Maybe/Extensions/Tap.ValueTask.cs create mode 100644 CSharpFunctionalExtensions/Maybe/Extensions/Tap.cs create mode 100644 CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.Task.Left.cs create mode 100644 CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.Task.Right.cs create mode 100644 CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.Task.cs create mode 100644 CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.ValueTask.Left.cs create mode 100644 CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.ValueTask.Right.cs create mode 100644 CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.ValueTask.cs create mode 100644 CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.cs diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.Left.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.Left.cs new file mode 100644 index 00000000..a7faa793 --- /dev/null +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.Left.cs @@ -0,0 +1,22 @@ +using System.Threading.Tasks; +using FluentAssertions; +using Xunit; + +namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions +{ + public class TapNoValueTests_Task_Left : MaybeTestBase + { + [Fact] + public async Task TapNoValue_Task_Left_executes_action_when_no_value() + { + string property = null; + + Maybe maybe = null; + + var returnedMaybe = await maybe.AsTask().TapNoValue(() => property = "Some value"); + + property.Should().Be("Some value"); + returnedMaybe.Should().BeSameAs(maybe); + } + } +} diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.Right.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.Right.cs new file mode 100644 index 00000000..5a3cec62 --- /dev/null +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.Right.cs @@ -0,0 +1,26 @@ +using System.Threading.Tasks; +using FluentAssertions; +using Xunit; + +namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions +{ + public class TapNoValueTests_Task_Right : MaybeTestBase + { + [Fact] + public async Task TapNoValue_Task_Right_executes_action_when_no_value() + { + string property = null; + + Maybe maybe = null; + + var returnedMaybe = await maybe.TapNoValue(() => + { + property = "Some value"; + return Task.CompletedTask; + }); + + property.Should().Be("Some value"); + returnedMaybe.Should().BeSameAs(maybe); + } + } +} diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.cs new file mode 100644 index 00000000..49e5c95d --- /dev/null +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.cs @@ -0,0 +1,28 @@ +using System.Threading.Tasks; +using FluentAssertions; +using Xunit; + +namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions +{ + public class TapNoValueTests_Task : MaybeTestBase + { + [Fact] + public async Task TapNoValue_Task_executes_action_when_no_value() + { + string property = null; + + Maybe maybe = null; + + var returnedMaybe = await maybe + .AsTask() + .TapNoValue(() => + { + property = "Some value"; + return Task.CompletedTask; + }); + + property.Should().Be("Some value"); + returnedMaybe.Should().BeSameAs(maybe); + } + } +} diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.Left.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.Left.cs new file mode 100644 index 00000000..451420fb --- /dev/null +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.Left.cs @@ -0,0 +1,23 @@ +using System.Threading.Tasks; +using CSharpFunctionalExtensions.ValueTasks; +using FluentAssertions; +using Xunit; + +namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions +{ + public class TapNoValueTests_ValueTask_Left : MaybeTestBase + { + [Fact] + public async Task TapNoValue_ValueTask_Left_executes_action_when_no_value() + { + string property = null; + + Maybe maybe = null; + + var returnedMaybe = await maybe.AsValueTask().TapNoValue(() => property = "Some value"); + + property.Should().Be("Some value"); + returnedMaybe.Should().BeSameAs(maybe); + } + } +} diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.Right.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.Right.cs new file mode 100644 index 00000000..b87da282 --- /dev/null +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.Right.cs @@ -0,0 +1,27 @@ +using System.Threading.Tasks; +using CSharpFunctionalExtensions.ValueTasks; +using FluentAssertions; +using Xunit; + +namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions +{ + public class TapNoValueTests_ValueTask_Right : MaybeTestBase + { + [Fact] + public async Task TapNoValue_ValueTask_Right_executes_action_when_no_value() + { + string property = null; + + Maybe maybe = null; + + var returnedMaybe = await maybe.TapNoValue(() => + { + property = "Some value"; + return ValueTask.CompletedTask; + }); + + property.Should().Be("Some value"); + returnedMaybe.Should().BeSameAs(maybe); + } + } +} diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.cs new file mode 100644 index 00000000..a040dd65 --- /dev/null +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.cs @@ -0,0 +1,29 @@ +using System.Threading.Tasks; +using CSharpFunctionalExtensions.ValueTasks; +using FluentAssertions; +using Xunit; + +namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions +{ + public class TapNoValueTests_ValueTask : MaybeTestBase + { + [Fact] + public async Task TapNoValue_ValueTask_executes_action_when_no_value() + { + string property = null; + + Maybe maybe = null; + + var returnedMaybe = await maybe + .AsValueTask() + .TapNoValue(() => + { + property = "Some value"; + return ValueTask.CompletedTask; + }); + + property.Should().Be("Some value"); + returnedMaybe.Should().BeSameAs(maybe); + } + } +} diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.cs new file mode 100644 index 00000000..5bfbcd25 --- /dev/null +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.cs @@ -0,0 +1,21 @@ +using FluentAssertions; +using Xunit; + +namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions +{ + public class TapNoValueTests : MaybeTestBase + { + [Fact] + public void TapNoValue_executes_action_when_no_value() + { + string property = null; + + Maybe maybe = null; + + var returnedMaybe = maybe.TapNoValue(() => property = "Some value"); + + property.Should().Be("Some value"); + returnedMaybe.Should().BeSameAs(maybe); + } + } +} diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.Left.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.Left.cs new file mode 100644 index 00000000..a37d4e07 --- /dev/null +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.Left.cs @@ -0,0 +1,31 @@ +using System.Threading.Tasks; +using FluentAssertions; +using Xunit; + +namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions +{ + public class TapTests_Task_Left : MaybeTestBase + { + [Fact] + public async Task Tap_Task_Lef_does_not_execute_action_if_no_value() + { + Maybe maybe = null; + + var returnedMaybe = await maybe.AsTask().Tap(value => maybe = T.Value); + + maybe.HasNoValue.Should().BeTrue(); + returnedMaybe.Should().BeSameAs(maybe); + } + + [Fact] + public async Task Tap_Task_Lef_executes_action_if_value() + { + Maybe maybe = T.Value; + + var returnedMaybe = await maybe.AsTask().Tap(value => value.Should().Be(T.Value)); + + maybe.Value.Should().Be(T.Value); + returnedMaybe.Should().BeSameAs(maybe); + } + } +} diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.Right.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.Right.cs new file mode 100644 index 00000000..83f2957c --- /dev/null +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.Right.cs @@ -0,0 +1,40 @@ +using System.Threading.Tasks; +using FluentAssertions; +using Xunit; + +namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions +{ + public class TapTests_Task_Right : MaybeTestBase + { + [Fact] + public async Task Tap_Task_Right_does_not_execute_action_if_no_value() + { + Maybe maybe = null; + + var returnedMaybe = await maybe.Tap(value => + { + maybe = T.Value; + return Task.CompletedTask; + }); + + maybe.HasNoValue.Should().BeTrue(); + returnedMaybe.Should().BeSameAs(maybe); + } + + [Fact] + public async Task Tap_Task_Right_executes_action_if_value() + { + Maybe maybe = T.Value; + + + var returnedMaybe = await maybe.Tap(value => + { + value.Should().Be(T.Value); + return Task.CompletedTask; + }); + + maybe.Value.Should().Be(T.Value); + returnedMaybe.Should().BeSameAs(maybe); + } + } +} diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.cs new file mode 100644 index 00000000..cc458fe1 --- /dev/null +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.cs @@ -0,0 +1,43 @@ +using System.Threading.Tasks; +using FluentAssertions; +using Xunit; + +namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions +{ + public class TapTests_Task : MaybeTestBase + { + [Fact] + public async Task Tap_Task_does_not_execute_action_if_no_value() + { + Maybe maybe = null; + + var returnedMaybe = await maybe + .AsTask() + .Tap(value => + { + maybe = T.Value; + return Task.CompletedTask; + }); + + maybe.HasNoValue.Should().BeTrue(); + returnedMaybe.Should().BeSameAs(maybe); + } + + [Fact] + public async Task Tap_Task_executes_action_if_value() + { + Maybe maybe = T.Value; + + var returnedMaybe = await maybe + .AsTask() + .Tap(value => + { + value.Should().Be(T.Value); + return Task.CompletedTask; + }); + + maybe.Value.Should().Be(T.Value); + returnedMaybe.Should().BeSameAs(maybe); + } + } +} diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.Left.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.Left.cs new file mode 100644 index 00000000..12ba1b74 --- /dev/null +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.Left.cs @@ -0,0 +1,32 @@ +using System.Threading.Tasks; +using CSharpFunctionalExtensions.ValueTasks; +using FluentAssertions; +using Xunit; + +namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions +{ + public class TapTests_ValueTask_Left : MaybeTestBase + { + [Fact] + public async Task Tap_ValueTask_Lef_does_not_execute_action_if_no_value() + { + Maybe maybe = null; + + var returnedMaybe = await maybe.AsValueTask().Tap(value => maybe = T.Value); + + maybe.HasNoValue.Should().BeTrue(); + returnedMaybe.Should().BeSameAs(maybe); + } + + [Fact] + public async Task Tap_ValueTask_Lef_executes_action_if_value() + { + Maybe maybe = T.Value; + + var returnedMaybe = await maybe.AsValueTask().Tap(value => value.Should().Be(T.Value)); + + maybe.Value.Should().Be(T.Value); + returnedMaybe.Should().BeSameAs(maybe); + } + } +} diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.Right.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.Right.cs new file mode 100644 index 00000000..6f072b5e --- /dev/null +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.Right.cs @@ -0,0 +1,40 @@ +using System.Threading.Tasks; +using CSharpFunctionalExtensions.ValueTasks; +using FluentAssertions; +using Xunit; + +namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions +{ + public class TapTests_ValueTask_Right : MaybeTestBase + { + [Fact] + public async Task Tap_ValueTask_Right_does_not_execute_action_if_no_value() + { + Maybe maybe = null; + + var returnedMaybe = await maybe.Tap(value => + { + maybe = T.Value; + return ValueTask.CompletedTask; + }); + + maybe.HasNoValue.Should().BeTrue(); + returnedMaybe.Should().BeSameAs(maybe); + } + + [Fact] + public async Task Tap_ValueTask_Right_executes_action_if_value() + { + Maybe maybe = T.Value; + + var returnedMaybe = await maybe.Tap(value => + { + value.Should().Be(T.Value); + return ValueTask.CompletedTask; + }); + + maybe.Value.Should().Be(T.Value); + returnedMaybe.Should().BeSameAs(maybe); + } + } +} diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.cs new file mode 100644 index 00000000..277ae99c --- /dev/null +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.cs @@ -0,0 +1,44 @@ +using System.Threading.Tasks; +using CSharpFunctionalExtensions.ValueTasks; +using FluentAssertions; +using Xunit; + +namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions +{ + public class TapTests_ValueTask : MaybeTestBase + { + [Fact] + public async Task Tap_ValueTask_does_not_execute_action_if_no_value() + { + Maybe maybe = null; + + var returnedMaybe = await maybe + .AsValueTask() + .Tap(value => + { + maybe = T.Value; + return ValueTask.CompletedTask; + }); + + maybe.HasNoValue.Should().BeTrue(); + returnedMaybe.Should().BeSameAs(maybe); + } + + [Fact] + public async Task Tap_ValueTask_executes_action_if_value() + { + Maybe maybe = T.Value; + + var returnedMaybe = await maybe + .AsValueTask() + .Tap(value => + { + value.Should().Be(T.Value); + return ValueTask.CompletedTask; + }); + + maybe.Value.Should().Be(T.Value); + returnedMaybe.Should().BeSameAs(maybe); + } + } +} diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.cs new file mode 100644 index 00000000..7b0daf4c --- /dev/null +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.cs @@ -0,0 +1,27 @@ +namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions +{ + public class TapTests : MaybeTestBase + { + [Fact] + public void Tap_does_not_execute_action_if_no_value() + { + Maybe maybe = null; + + var returnedMaybe = maybe.Tap(value => maybe = T.Value); + + maybe.HasNoValue.Should().BeTrue(); + returnedMaybe.Should().BeSameAs(maybe); + } + + [Fact] + public void Tap_executes_action_if_value() + { + Maybe maybe = T.Value; + + var returnedMaybe = maybe.Tap(value => value.Should().Be(T.Value)); + + maybe.Value.Should().Be(T.Value); + returnedMaybe.Should().BeSameAs(maybe); + } + } +} diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/Tap.Task.Left.cs b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.Task.Left.cs new file mode 100644 index 00000000..9fcdce87 --- /dev/null +++ b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.Task.Left.cs @@ -0,0 +1,28 @@ +using System; +using System.Threading.Tasks; + +namespace CSharpFunctionalExtensions +{ + public static partial class MaybeExtensions + { + /// + /// Executes the given if the produces a value + /// Returns the calling maybe. + /// + /// + /// + /// + /// The calling maybe + public static async Task> Tap(this Task> maybeTask, Action action) + { + var maybe = await maybeTask.DefaultAwait(); + + if (maybe.HasValue) + { + action(maybe.GetValueOrThrow()); + } + + return maybe; + } + } +} diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/Tap.Task.Right.cs b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.Task.Right.cs new file mode 100644 index 00000000..f7710b96 --- /dev/null +++ b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.Task.Right.cs @@ -0,0 +1,26 @@ +using System; +using System.Threading.Tasks; + +namespace CSharpFunctionalExtensions +{ + public static partial class MaybeExtensions + { + /// + /// Executes the given async if the has a value + /// Returns the calling maybe. + /// + /// + /// + /// + /// The calling maybe + public static async Task> Tap(this Maybe maybe, Func action) + { + if (maybe.HasValue) + { + await action(maybe.GetValueOrThrow()).DefaultAwait(); + } + + return maybe; + } + } +} diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/Tap.Task.cs b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.Task.cs new file mode 100644 index 00000000..33db528e --- /dev/null +++ b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.Task.cs @@ -0,0 +1,31 @@ +using System; +using System.Threading.Tasks; + +namespace CSharpFunctionalExtensions +{ + public static partial class MaybeExtensions + { + /// + /// Executes the given if the produces a value + /// Returns the calling maybe. + /// + /// + /// + /// + /// The calling maybe + public static async Task> Tap( + this Task> maybeTask, + Func asyncAction + ) + { + var maybe = await maybeTask.DefaultAwait(); + + if (maybe.HasValue) + { + await asyncAction(maybe.GetValueOrThrow()).DefaultAwait(); + } + + return maybe; + } + } +} diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/Tap.ValueTask.Left.cs b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.ValueTask.Left.cs new file mode 100644 index 00000000..a9eafdf0 --- /dev/null +++ b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.ValueTask.Left.cs @@ -0,0 +1,33 @@ +#if NET5_0_OR_GREATER +using System; +using System.Threading.Tasks; + +namespace CSharpFunctionalExtensions.ValueTasks +{ + public static partial class MaybeExtensions + { + /// + /// Executes the given if the produces a value + /// Returns the calling maybe. + /// + /// + /// + /// + /// The calling maybe + public static async ValueTask> Tap( + this ValueTask> maybeTask, + Action action + ) + { + var maybe = await maybeTask; + + if (maybe.HasValue) + { + action(maybe.GetValueOrThrow()); + } + + return maybe; + } + } +} +#endif diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/Tap.ValueTask.Right.cs b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.ValueTask.Right.cs new file mode 100644 index 00000000..874336a8 --- /dev/null +++ b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.ValueTask.Right.cs @@ -0,0 +1,30 @@ +#if NET5_0_OR_GREATER +using System; +using System.Threading.Tasks; + +namespace CSharpFunctionalExtensions.ValueTasks +{ + public static partial class MaybeExtensions + { + /// + /// Executes the given async if the has a value + /// Returns the calling maybe. + /// + /// + /// + /// + public static async ValueTask> Tap( + this Maybe maybe, + Func valueTask + ) + { + if (maybe.HasValue) + { + await valueTask(maybe.GetValueOrThrow()); + } + + return maybe; + } + } +} +#endif diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/Tap.ValueTask.cs b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.ValueTask.cs new file mode 100644 index 00000000..874d44d7 --- /dev/null +++ b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.ValueTask.cs @@ -0,0 +1,31 @@ +#if NET5_0_OR_GREATER +using System; +using System.Threading.Tasks; + +namespace CSharpFunctionalExtensions.ValueTasks +{ + public static partial class MaybeExtensions + { + /// + /// Executes the given if the produces a value + /// Returns the calling maybe. + /// + /// + /// + /// + /// The calling maybe + public static async ValueTask> Tap( + this ValueTask> maybeTask, + Func valueTask + ) + { + var maybe = await maybeTask; + + if (maybe.HasValue) + await valueTask(maybe.GetValueOrThrow()); + + return maybe; + } + } +} +#endif diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/Tap.cs b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.cs new file mode 100644 index 00000000..c8e2b4b7 --- /dev/null +++ b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.cs @@ -0,0 +1,25 @@ +using System; + +namespace CSharpFunctionalExtensions +{ + public static partial class MaybeExtensions + { + /// + /// Executes the given if the has a value + /// Returns the calling maybe. + /// + /// + /// + /// + /// The calling maybe + public static Maybe Tap(in this Maybe maybe, Action action) + { + if (maybe.HasValue) + { + action(maybe.GetValueOrThrow()); + } + + return maybe; + } + } +} diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.Task.Left.cs b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.Task.Left.cs new file mode 100644 index 00000000..fa3084cf --- /dev/null +++ b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.Task.Left.cs @@ -0,0 +1,30 @@ +using System; +using System.Threading.Tasks; + +namespace CSharpFunctionalExtensions +{ + public static partial class MaybeExtensions + { + /// + /// Executes the given if the produces no value + /// Returns the calling maybe. + /// + /// + /// + /// + /// The calling maybe + public static async Task> TapNoValue( + this Task> maybeTask, + Action action + ) + { + var maybe = await maybeTask.DefaultAwait(); + + if (maybe.HasNoValue) + { + action(); + } + return maybe; + } + } +} diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.Task.Right.cs b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.Task.Right.cs new file mode 100644 index 00000000..b6b82df7 --- /dev/null +++ b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.Task.Right.cs @@ -0,0 +1,26 @@ +using System; +using System.Threading.Tasks; + +namespace CSharpFunctionalExtensions +{ + public static partial class MaybeExtensions + { + /// + /// Executes the given async if the has no value + /// Returns the calling maybe. + /// + /// + /// + /// + /// The calling maybe + public static async Task> TapNoValue(this Maybe maybe, Func action) + { + if (maybe.HasNoValue) + { + await action().DefaultAwait(); + } + + return maybe; + } + } +} diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.Task.cs b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.Task.cs new file mode 100644 index 00000000..beecdd00 --- /dev/null +++ b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.Task.cs @@ -0,0 +1,30 @@ +using System; +using System.Threading.Tasks; + +namespace CSharpFunctionalExtensions +{ + public static partial class MaybeExtensions + { + /// + /// Executes the given if the produces no value + /// Returns the calling maybe. + /// + /// + /// + /// + public static async Task> TapNoValue( + this Task> maybeTask, + Func asyncAction + ) + { + var maybe = await maybeTask.DefaultAwait(); + + if (maybe.HasNoValue) + { + await asyncAction().DefaultAwait(); + } + + return maybe; + } + } +} diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.ValueTask.Left.cs b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.ValueTask.Left.cs new file mode 100644 index 00000000..bc741fbe --- /dev/null +++ b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.ValueTask.Left.cs @@ -0,0 +1,33 @@ +#if NET5_0_OR_GREATER +using System; +using System.Threading.Tasks; + +namespace CSharpFunctionalExtensions.ValueTasks +{ + public static partial class MaybeExtensions + { + /// + /// Executes the given if the produces no value + /// Returns the calling maybe. + /// + /// + /// + /// + /// The calling maybe + public static async ValueTask> TapNoValue( + this ValueTask> maybeTask, + Action action + ) + { + var maybe = await maybeTask; + + if (maybe.HasNoValue) + { + action(); + } + + return maybe; + } + } +} +#endif diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.ValueTask.Right.cs b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.ValueTask.Right.cs new file mode 100644 index 00000000..7d52a475 --- /dev/null +++ b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.ValueTask.Right.cs @@ -0,0 +1,31 @@ +#if NET5_0_OR_GREATER +using System; +using System.Threading.Tasks; + +namespace CSharpFunctionalExtensions.ValueTasks +{ + public static partial class MaybeExtensions + { + /// + /// Executes the given async if the has no value + /// Returns the calling maybe. + /// + /// + /// + /// + /// The calling maybe + public static async ValueTask> TapNoValue( + this Maybe maybe, + Func valueTask + ) + { + if (maybe.HasNoValue) + { + await valueTask(); + } + + return maybe; + } + } +} +#endif diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.ValueTask.cs b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.ValueTask.cs new file mode 100644 index 00000000..06ea5b49 --- /dev/null +++ b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.ValueTask.cs @@ -0,0 +1,33 @@ +#if NET5_0_OR_GREATER +using System; +using System.Threading.Tasks; + +namespace CSharpFunctionalExtensions.ValueTasks +{ + public static partial class MaybeExtensions + { + /// + /// Executes the given if the produces no value + /// Returns the calling maybe. + /// + /// + /// + /// + /// The calling maybe + public static async Task> TapNoValue( + this ValueTask> maybeTask, + Func valueTask + ) + { + var maybe = await maybeTask; + + if (maybe.HasNoValue) + { + await valueTask(); + } + + return maybe; + } + } +} +#endif diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.cs b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.cs new file mode 100644 index 00000000..4e6518bb --- /dev/null +++ b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.cs @@ -0,0 +1,25 @@ +using System; + +namespace CSharpFunctionalExtensions +{ + public static partial class MaybeExtensions + { + /// + /// Executes the given if the has no value + /// Returns the calling maybe. + /// + /// + /// + /// + /// The calling maybe + public static Maybe TapNoValue(in this Maybe maybe, Action action) + { + if (maybe.HasNoValue) + { + action(); + } + + return maybe; + } + } +} From 9bd83e756bb294deb76936b37de6646c3570770d Mon Sep 17 00:00:00 2001 From: Marcin Jahn <10273406+marcinjahn@users.noreply.github.com> Date: Sat, 12 Apr 2025 21:16:27 +0200 Subject: [PATCH 2/4] Deprecate Maybe.Execute and Maybe.ExecuteNoValue Maybe.Tap and Maybe.TapNoValue are able to take over the deprecated methods with added functionality. --- .../Maybe/Extensions/Execute.Task.Left.cs | 5 +++-- .../Maybe/Extensions/Execute.Task.Right.cs | 5 +++-- CSharpFunctionalExtensions/Maybe/Extensions/Execute.Task.cs | 5 +++-- .../Maybe/Extensions/Execute.ValueTask.Left.cs | 5 +++-- .../Maybe/Extensions/Execute.ValueTask.Right.cs | 5 +++-- .../Maybe/Extensions/Execute.ValueTask.cs | 5 +++-- CSharpFunctionalExtensions/Maybe/Extensions/Execute.cs | 5 +++-- .../Maybe/Extensions/ExecuteNoValue.Task.Left.cs | 5 +++-- .../Maybe/Extensions/ExecuteNoValue.Task.Right.cs | 5 +++-- .../Maybe/Extensions/ExecuteNoValue.Task.cs | 5 +++-- .../Maybe/Extensions/ExecuteNoValue.ValueTask.Left.cs | 5 +++-- .../Maybe/Extensions/ExecuteNoValue.ValueTask.Right.cs | 5 +++-- .../Maybe/Extensions/ExecuteNoValue.ValueTask.cs | 5 +++-- .../Maybe/Extensions/ExecuteNoValue.cs | 5 +++-- 14 files changed, 42 insertions(+), 28 deletions(-) diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/Execute.Task.Left.cs b/CSharpFunctionalExtensions/Maybe/Extensions/Execute.Task.Left.cs index b359cd52..3e6a72a2 100644 --- a/CSharpFunctionalExtensions/Maybe/Extensions/Execute.Task.Left.cs +++ b/CSharpFunctionalExtensions/Maybe/Extensions/Execute.Task.Left.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Threading.Tasks; namespace CSharpFunctionalExtensions @@ -12,6 +12,7 @@ public static partial class MaybeExtensions /// /// /// + [Obsolete("Use TapValue instead")] public static async Task Execute(this Task> maybeTask, Action action) { var maybe = await maybeTask.DefaultAwait(); @@ -22,4 +23,4 @@ public static async Task Execute(this Task> maybeTask, Action act action(maybe.GetValueOrThrow()); } } -} \ No newline at end of file +} diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/Execute.Task.Right.cs b/CSharpFunctionalExtensions/Maybe/Extensions/Execute.Task.Right.cs index 5b303c0f..afbf3d75 100644 --- a/CSharpFunctionalExtensions/Maybe/Extensions/Execute.Task.Right.cs +++ b/CSharpFunctionalExtensions/Maybe/Extensions/Execute.Task.Right.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Threading.Tasks; namespace CSharpFunctionalExtensions @@ -11,6 +11,7 @@ public static partial class MaybeExtensions /// /// /// + [Obsolete("Use TapValue instead")] public static async Task Execute(this Maybe maybe, Func action) { if (maybe.HasNoValue) @@ -19,4 +20,4 @@ public static async Task Execute(this Maybe maybe, Func action) await action(maybe.GetValueOrThrow()).DefaultAwait(); } } -} \ No newline at end of file +} diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/Execute.Task.cs b/CSharpFunctionalExtensions/Maybe/Extensions/Execute.Task.cs index 7129bde4..809aeabf 100644 --- a/CSharpFunctionalExtensions/Maybe/Extensions/Execute.Task.cs +++ b/CSharpFunctionalExtensions/Maybe/Extensions/Execute.Task.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Threading.Tasks; namespace CSharpFunctionalExtensions @@ -12,6 +12,7 @@ public static partial class MaybeExtensions /// /// /// + [Obsolete("Use TapValue instead")] public static async Task Execute(this Task> maybeTask, Func asyncAction) { var maybe = await maybeTask.DefaultAwait(); @@ -22,4 +23,4 @@ public static async Task Execute(this Task> maybeTask, Func await asyncAction(maybe.GetValueOrThrow()).DefaultAwait(); } } -} \ No newline at end of file +} diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/Execute.ValueTask.Left.cs b/CSharpFunctionalExtensions/Maybe/Extensions/Execute.ValueTask.Left.cs index 9a572430..193735e2 100644 --- a/CSharpFunctionalExtensions/Maybe/Extensions/Execute.ValueTask.Left.cs +++ b/CSharpFunctionalExtensions/Maybe/Extensions/Execute.ValueTask.Left.cs @@ -1,4 +1,4 @@ -#if NET5_0_OR_GREATER +#if NET5_0_OR_GREATER using System; using System.Threading.Tasks; @@ -13,6 +13,7 @@ public static partial class MaybeExtensions /// /// /// + [Obsolete("Use TapValue instead")] public static async Task Execute(this ValueTask> maybeTask, Action action) { var maybe = await maybeTask; @@ -24,4 +25,4 @@ public static async Task Execute(this ValueTask> maybeTask, Action /// /// + [Obsolete("Use TapValue instead")] public static async Task Execute(this Maybe maybe, Func valueTask) { if (maybe.HasNoValue) @@ -21,4 +22,4 @@ public static async Task Execute(this Maybe maybe, Func valu } } } -#endif \ No newline at end of file +#endif diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/Execute.ValueTask.cs b/CSharpFunctionalExtensions/Maybe/Extensions/Execute.ValueTask.cs index 9dc615c6..6ed7c1b8 100644 --- a/CSharpFunctionalExtensions/Maybe/Extensions/Execute.ValueTask.cs +++ b/CSharpFunctionalExtensions/Maybe/Extensions/Execute.ValueTask.cs @@ -1,4 +1,4 @@ -#if NET5_0_OR_GREATER +#if NET5_0_OR_GREATER using System; using System.Threading.Tasks; @@ -13,6 +13,7 @@ public static partial class MaybeExtensions /// /// /// + [Obsolete("Use TapValue instead")] public static async Task Execute(this ValueTask> maybeTask, Func valueTask) { var maybe = await maybeTask; @@ -24,4 +25,4 @@ public static async Task Execute(this ValueTask> maybeTask, Func /// /// + [Obsolete("Use TapValue instead")] public static void Execute(in this Maybe maybe, Action action) { if (maybe.HasNoValue) @@ -18,4 +19,4 @@ public static void Execute(in this Maybe maybe, Action action) action(maybe.GetValueOrThrow()); } } -} \ No newline at end of file +} diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.Task.Left.cs b/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.Task.Left.cs index f1090a8a..68b353df 100644 --- a/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.Task.Left.cs +++ b/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.Task.Left.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Threading.Tasks; namespace CSharpFunctionalExtensions @@ -11,6 +11,7 @@ public static partial class MaybeExtensions /// /// /// + [Obsolete("Use TapNoValue instead")] public static async Task ExecuteNoValue(this Task> maybeTask, Action action) { var maybe = await maybeTask.DefaultAwait(); @@ -21,4 +22,4 @@ public static async Task ExecuteNoValue(this Task> maybeTask, Action action(); } } -} \ No newline at end of file +} diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.Task.Right.cs b/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.Task.Right.cs index 90e53a66..a6e7781a 100644 --- a/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.Task.Right.cs +++ b/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.Task.Right.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Threading.Tasks; namespace CSharpFunctionalExtensions @@ -11,6 +11,7 @@ public static partial class MaybeExtensions /// /// /// + [Obsolete("Use TapNoValue instead")] public static async Task ExecuteNoValue(this Maybe maybe, Func action) { if (maybe.HasValue) @@ -19,4 +20,4 @@ public static async Task ExecuteNoValue(this Maybe maybe, Func actio await action().DefaultAwait(); } } -} \ No newline at end of file +} diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.Task.cs b/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.Task.cs index 32658d25..b7b851c9 100644 --- a/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.Task.cs +++ b/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.Task.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Threading.Tasks; namespace CSharpFunctionalExtensions @@ -11,6 +11,7 @@ public static partial class MaybeExtensions /// /// /// + [Obsolete("Use TapNoValue instead")] public static async Task ExecuteNoValue(this Task> maybeTask, Func asyncAction) { var maybe = await maybeTask.DefaultAwait(); @@ -21,4 +22,4 @@ public static async Task ExecuteNoValue(this Task> maybeTask, Func /// /// + [Obsolete("Use TapNoValue instead")] public static async Task ExecuteNoValue(this ValueTask> maybeTask, Action action) { var maybe = await maybeTask; @@ -23,4 +24,4 @@ public static async Task ExecuteNoValue(this ValueTask> maybeTask, A } } } -#endif \ No newline at end of file +#endif diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.ValueTask.Right.cs b/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.ValueTask.Right.cs index e1303380..082514df 100644 --- a/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.ValueTask.Right.cs +++ b/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.ValueTask.Right.cs @@ -1,4 +1,4 @@ -#if NET5_0_OR_GREATER +#if NET5_0_OR_GREATER using System; using System.Threading.Tasks; @@ -12,6 +12,7 @@ public static partial class MaybeExtensions /// /// /// + [Obsolete("Use TapNoValue instead")] public static async Task ExecuteNoValue(this Maybe maybe, Func valueTask) { if (maybe.HasValue) @@ -21,4 +22,4 @@ public static async Task ExecuteNoValue(this Maybe maybe, Func } } } -#endif \ No newline at end of file +#endif diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.ValueTask.cs b/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.ValueTask.cs index eb8ad8da..53242f9a 100644 --- a/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.ValueTask.cs +++ b/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.ValueTask.cs @@ -1,4 +1,4 @@ -#if NET5_0_OR_GREATER +#if NET5_0_OR_GREATER using System; using System.Threading.Tasks; @@ -12,6 +12,7 @@ public static partial class MaybeExtensions /// /// /// + [Obsolete("Use TapNoValue instead")] public static async Task ExecuteNoValue(this ValueTask> maybeTask, Func valueTask) { var maybe = await maybeTask; @@ -24,4 +25,4 @@ public static async Task ExecuteNoValue(this ValueTask> maybeTask, F } } -#endif \ No newline at end of file +#endif diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.cs b/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.cs index 0749cee3..a92ec865 100644 --- a/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.cs +++ b/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.cs @@ -1,4 +1,4 @@ -using System; +using System; namespace CSharpFunctionalExtensions { @@ -10,6 +10,7 @@ public static partial class MaybeExtensions /// /// /// + [Obsolete("Use TapNoValue instead")] public static void ExecuteNoValue(in this Maybe maybe, Action action) { if (maybe.HasValue) @@ -18,4 +19,4 @@ public static void ExecuteNoValue(in this Maybe maybe, Action action) action(); } } -} \ No newline at end of file +} From e1d2fae24009dc7c34de5144bc99a75a73598522 Mon Sep 17 00:00:00 2001 From: Marcin Jahn <10273406+marcinjahn@users.noreply.github.com> Date: Mon, 26 May 2025 15:28:23 +0200 Subject: [PATCH 3/4] fix tests --- .../MaybeTests/Extensions/TapTests.cs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.cs index 7b0daf4c..67d65384 100644 --- a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.cs +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.cs @@ -1,3 +1,6 @@ +using FluentAssertions; +using Xunit; + namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions { public class TapTests : MaybeTestBase From 08c3b4af4bae5a27d817b702fe11b1e9c070f9a8 Mon Sep 17 00:00:00 2001 From: Marcin Jahn <10273406+marcinjahn@users.noreply.github.com> Date: Mon, 26 May 2025 15:57:33 +0200 Subject: [PATCH 4/4] fix tests even better --- .../Extensions/TapNoValueTests.Task.Left.cs | 44 ++++----- .../Extensions/TapNoValueTests.Task.Right.cs | 2 +- .../Extensions/TapNoValueTests.Task.cs | 52 +++++------ .../TapNoValueTests.ValueTask.Left.cs | 46 +++++----- .../TapNoValueTests.ValueTask.Right.cs | 2 +- .../Extensions/TapNoValueTests.ValueTask.cs | 54 ++++++----- .../MaybeTests/Extensions/TapNoValueTests.cs | 2 +- .../Extensions/TapTests.Task.Left.cs | 63 ++++++------- .../Extensions/TapTests.Task.Right.cs | 4 +- .../MaybeTests/Extensions/TapTests.Task.cs | 9 +- .../Extensions/TapTests.ValueTask.Left.cs | 65 +++++++------- .../Extensions/TapTests.ValueTask.Right.cs | 81 ++++++++--------- .../Extensions/TapTests.ValueTask.cs | 89 ++++++++++--------- .../MaybeTests/Extensions/TapTests.cs | 9 +- 14 files changed, 260 insertions(+), 262 deletions(-) diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.Left.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.Left.cs index a7faa793..ad2ba1de 100644 --- a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.Left.cs +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.Left.cs @@ -1,22 +1,22 @@ -using System.Threading.Tasks; -using FluentAssertions; -using Xunit; - -namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions -{ - public class TapNoValueTests_Task_Left : MaybeTestBase - { - [Fact] - public async Task TapNoValue_Task_Left_executes_action_when_no_value() - { - string property = null; - - Maybe maybe = null; - - var returnedMaybe = await maybe.AsTask().TapNoValue(() => property = "Some value"); - - property.Should().Be("Some value"); - returnedMaybe.Should().BeSameAs(maybe); - } - } -} +using System.Threading.Tasks; +using FluentAssertions; +using Xunit; + +namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions +{ + public class TapNoValueTests_Task_Left : MaybeTestBase + { + [Fact] + public async Task TapNoValue_Task_Left_executes_action_when_no_value() + { + string property = null; + + Maybe maybe = null; + + var returnedMaybe = await maybe.AsTask().TapNoValue(() => property = "Some value"); + + property.Should().Be("Some value"); + returnedMaybe.HasNoValue.Should().BeTrue(); + } + } +} diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.Right.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.Right.cs index 5a3cec62..d1dd8cde 100644 --- a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.Right.cs +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.Right.cs @@ -20,7 +20,7 @@ public async Task TapNoValue_Task_Right_executes_action_when_no_value() }); property.Should().Be("Some value"); - returnedMaybe.Should().BeSameAs(maybe); + returnedMaybe.HasNoValue.Should().BeTrue(); } } } diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.cs index 49e5c95d..73faa1be 100644 --- a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.cs +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.cs @@ -1,28 +1,24 @@ -using System.Threading.Tasks; -using FluentAssertions; -using Xunit; - -namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions -{ - public class TapNoValueTests_Task : MaybeTestBase - { - [Fact] - public async Task TapNoValue_Task_executes_action_when_no_value() - { - string property = null; - - Maybe maybe = null; - - var returnedMaybe = await maybe - .AsTask() - .TapNoValue(() => - { - property = "Some value"; - return Task.CompletedTask; - }); - - property.Should().Be("Some value"); - returnedMaybe.Should().BeSameAs(maybe); - } - } -} +using System.Threading.Tasks; +using FluentAssertions; +using Xunit; + +namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions +{ + public class TapNoValueTests_Task : MaybeTestBase + { + [Fact] + public async Task TapNoValue_Task_executes_action_when_no_value() + { + string property = null; + + Maybe maybe = null; + + var returnedMaybe = await maybe + .AsTask() + .TapNoValue(() => property = "Some value"); + + property.Should().Be("Some value"); + returnedMaybe.HasNoValue.Should().BeTrue(); + } + } +} diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.Left.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.Left.cs index 451420fb..57ffc63a 100644 --- a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.Left.cs +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.Left.cs @@ -1,23 +1,23 @@ -using System.Threading.Tasks; -using CSharpFunctionalExtensions.ValueTasks; -using FluentAssertions; -using Xunit; - -namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions -{ - public class TapNoValueTests_ValueTask_Left : MaybeTestBase - { - [Fact] - public async Task TapNoValue_ValueTask_Left_executes_action_when_no_value() - { - string property = null; - - Maybe maybe = null; - - var returnedMaybe = await maybe.AsValueTask().TapNoValue(() => property = "Some value"); - - property.Should().Be("Some value"); - returnedMaybe.Should().BeSameAs(maybe); - } - } -} +using System.Threading.Tasks; +using CSharpFunctionalExtensions.ValueTasks; +using FluentAssertions; +using Xunit; + +namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions +{ + public class TapNoValueTests_ValueTask_Left : MaybeTestBase + { + [Fact] + public async Task TapNoValue_ValueTask_Left_executes_action_when_no_value() + { + string property = null; + + Maybe maybe = null; + + var returnedMaybe = await maybe.AsValueTask().TapNoValue(() => property = "Some value"); + + property.Should().Be("Some value"); + returnedMaybe.HasNoValue.Should().BeTrue(); + } + } +} diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.Right.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.Right.cs index b87da282..2a37de55 100644 --- a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.Right.cs +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.Right.cs @@ -21,7 +21,7 @@ public async Task TapNoValue_ValueTask_Right_executes_action_when_no_value() }); property.Should().Be("Some value"); - returnedMaybe.Should().BeSameAs(maybe); + returnedMaybe.HasNoValue.Should().BeTrue(); } } } diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.cs index a040dd65..beb35952 100644 --- a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.cs +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.cs @@ -1,29 +1,25 @@ -using System.Threading.Tasks; -using CSharpFunctionalExtensions.ValueTasks; -using FluentAssertions; -using Xunit; - -namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions -{ - public class TapNoValueTests_ValueTask : MaybeTestBase - { - [Fact] - public async Task TapNoValue_ValueTask_executes_action_when_no_value() - { - string property = null; - - Maybe maybe = null; - - var returnedMaybe = await maybe - .AsValueTask() - .TapNoValue(() => - { - property = "Some value"; - return ValueTask.CompletedTask; - }); - - property.Should().Be("Some value"); - returnedMaybe.Should().BeSameAs(maybe); - } - } -} +using System.Threading.Tasks; +using CSharpFunctionalExtensions.ValueTasks; +using FluentAssertions; +using Xunit; + +namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions +{ + public class TapNoValueTests_ValueTask : MaybeTestBase + { + [Fact] + public async Task TapNoValue_ValueTask_executes_action_when_no_value() + { + string property = null; + + Maybe maybe = null; + + var returnedMaybe = await maybe + .AsValueTask() + .TapNoValue(() => property = "Some value"); + + property.Should().Be("Some value"); + returnedMaybe.HasNoValue.Should().BeTrue(); + } + } +} diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.cs index 5bfbcd25..5c503430 100644 --- a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.cs +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.cs @@ -15,7 +15,7 @@ public void TapNoValue_executes_action_when_no_value() var returnedMaybe = maybe.TapNoValue(() => property = "Some value"); property.Should().Be("Some value"); - returnedMaybe.Should().BeSameAs(maybe); + returnedMaybe.HasNoValue.Should().BeTrue(); } } } diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.Left.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.Left.cs index a37d4e07..0e6bffc1 100644 --- a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.Left.cs +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.Left.cs @@ -1,31 +1,32 @@ -using System.Threading.Tasks; -using FluentAssertions; -using Xunit; - -namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions -{ - public class TapTests_Task_Left : MaybeTestBase - { - [Fact] - public async Task Tap_Task_Lef_does_not_execute_action_if_no_value() - { - Maybe maybe = null; - - var returnedMaybe = await maybe.AsTask().Tap(value => maybe = T.Value); - - maybe.HasNoValue.Should().BeTrue(); - returnedMaybe.Should().BeSameAs(maybe); - } - - [Fact] - public async Task Tap_Task_Lef_executes_action_if_value() - { - Maybe maybe = T.Value; - - var returnedMaybe = await maybe.AsTask().Tap(value => value.Should().Be(T.Value)); - - maybe.Value.Should().Be(T.Value); - returnedMaybe.Should().BeSameAs(maybe); - } - } -} +using System.Threading.Tasks; +using FluentAssertions; +using Xunit; + +namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions +{ + public class TapTests_Task_Left : MaybeTestBase + { + [Fact] + public async Task Tap_Task_Lef_does_not_execute_action_if_no_value() + { + Maybe maybe = null; + var executed = false; + + var returnedMaybe = await maybe.AsTask().Tap(value => executed = true); + + executed.Should().BeFalse(); + returnedMaybe.HasNoValue.Should().BeTrue(); + } + + [Fact] + public async Task Tap_Task_Lef_executes_action_if_value() + { + Maybe maybe = T.Value; + + var returnedMaybe = await maybe.AsTask().Tap(value => value.Should().Be(T.Value)); + + maybe.Value.Should().Be(T.Value); + returnedMaybe.Value.Should().BeSameAs(maybe.Value); + } + } +} diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.Right.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.Right.cs index 83f2957c..6632eb3e 100644 --- a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.Right.cs +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.Right.cs @@ -18,7 +18,7 @@ public async Task Tap_Task_Right_does_not_execute_action_if_no_value() }); maybe.HasNoValue.Should().BeTrue(); - returnedMaybe.Should().BeSameAs(maybe); + returnedMaybe.HasNoValue.Should().BeTrue(); } [Fact] @@ -34,7 +34,7 @@ public async Task Tap_Task_Right_executes_action_if_value() }); maybe.Value.Should().Be(T.Value); - returnedMaybe.Should().BeSameAs(maybe); + returnedMaybe.Value.Should().BeSameAs(maybe.Value); } } } diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.cs index cc458fe1..2272b217 100644 --- a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.cs +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.cs @@ -10,17 +10,18 @@ public class TapTests_Task : MaybeTestBase public async Task Tap_Task_does_not_execute_action_if_no_value() { Maybe maybe = null; + var executed = false; var returnedMaybe = await maybe .AsTask() .Tap(value => { - maybe = T.Value; + executed = true; return Task.CompletedTask; }); - maybe.HasNoValue.Should().BeTrue(); - returnedMaybe.Should().BeSameAs(maybe); + executed.Should().BeFalse(); + returnedMaybe.HasNoValue.Should().BeTrue(); } [Fact] @@ -37,7 +38,7 @@ public async Task Tap_Task_executes_action_if_value() }); maybe.Value.Should().Be(T.Value); - returnedMaybe.Should().BeSameAs(maybe); + returnedMaybe.Value.Should().BeSameAs(maybe.Value); } } } diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.Left.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.Left.cs index 12ba1b74..7b9c7e0f 100644 --- a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.Left.cs +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.Left.cs @@ -1,32 +1,33 @@ -using System.Threading.Tasks; -using CSharpFunctionalExtensions.ValueTasks; -using FluentAssertions; -using Xunit; - -namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions -{ - public class TapTests_ValueTask_Left : MaybeTestBase - { - [Fact] - public async Task Tap_ValueTask_Lef_does_not_execute_action_if_no_value() - { - Maybe maybe = null; - - var returnedMaybe = await maybe.AsValueTask().Tap(value => maybe = T.Value); - - maybe.HasNoValue.Should().BeTrue(); - returnedMaybe.Should().BeSameAs(maybe); - } - - [Fact] - public async Task Tap_ValueTask_Lef_executes_action_if_value() - { - Maybe maybe = T.Value; - - var returnedMaybe = await maybe.AsValueTask().Tap(value => value.Should().Be(T.Value)); - - maybe.Value.Should().Be(T.Value); - returnedMaybe.Should().BeSameAs(maybe); - } - } -} +using System.Threading.Tasks; +using CSharpFunctionalExtensions.ValueTasks; +using FluentAssertions; +using Xunit; + +namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions +{ + public class TapTests_ValueTask_Left : MaybeTestBase + { + [Fact] + public async Task Tap_ValueTask_Lef_does_not_execute_action_if_no_value() + { + Maybe maybe = null; + var executed = false; + + var returnedMaybe = await maybe.AsValueTask().Tap(value => executed = true); + + executed.Should().BeFalse(); + returnedMaybe.HasNoValue.Should().BeTrue(); + } + + [Fact] + public async Task Tap_ValueTask_Lef_executes_action_if_value() + { + Maybe maybe = T.Value; + + var returnedMaybe = await maybe.AsValueTask().Tap(value => value.Should().Be(T.Value)); + + maybe.Value.Should().Be(T.Value); + returnedMaybe.Value.Should().BeSameAs(maybe.Value); + } + } +} diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.Right.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.Right.cs index 6f072b5e..a42b77f8 100644 --- a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.Right.cs +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.Right.cs @@ -1,40 +1,41 @@ -using System.Threading.Tasks; -using CSharpFunctionalExtensions.ValueTasks; -using FluentAssertions; -using Xunit; - -namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions -{ - public class TapTests_ValueTask_Right : MaybeTestBase - { - [Fact] - public async Task Tap_ValueTask_Right_does_not_execute_action_if_no_value() - { - Maybe maybe = null; - - var returnedMaybe = await maybe.Tap(value => - { - maybe = T.Value; - return ValueTask.CompletedTask; - }); - - maybe.HasNoValue.Should().BeTrue(); - returnedMaybe.Should().BeSameAs(maybe); - } - - [Fact] - public async Task Tap_ValueTask_Right_executes_action_if_value() - { - Maybe maybe = T.Value; - - var returnedMaybe = await maybe.Tap(value => - { - value.Should().Be(T.Value); - return ValueTask.CompletedTask; - }); - - maybe.Value.Should().Be(T.Value); - returnedMaybe.Should().BeSameAs(maybe); - } - } -} +using System.Threading.Tasks; +using CSharpFunctionalExtensions.ValueTasks; +using FluentAssertions; +using Xunit; + +namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions +{ + public class TapTests_ValueTask_Right : MaybeTestBase + { + [Fact] + public async Task Tap_ValueTask_Right_does_not_execute_action_if_no_value() + { + Maybe maybe = null; + var executed = false; + + var returnedMaybe = await maybe.Tap(value => + { + executed = true; + return ValueTask.CompletedTask; + }); + + executed.Should().BeFalse(); + returnedMaybe.HasNoValue.Should().BeTrue(); + } + + [Fact] + public async Task Tap_ValueTask_Right_executes_action_if_value() + { + Maybe maybe = T.Value; + + var returnedMaybe = await maybe.Tap(value => + { + value.Should().Be(T.Value); + return ValueTask.CompletedTask; + }); + + maybe.Value.Should().Be(T.Value); + returnedMaybe.Value.Should().BeSameAs(maybe.Value); + } + } +} diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.cs index 277ae99c..05df5979 100644 --- a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.cs +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.cs @@ -1,44 +1,45 @@ -using System.Threading.Tasks; -using CSharpFunctionalExtensions.ValueTasks; -using FluentAssertions; -using Xunit; - -namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions -{ - public class TapTests_ValueTask : MaybeTestBase - { - [Fact] - public async Task Tap_ValueTask_does_not_execute_action_if_no_value() - { - Maybe maybe = null; - - var returnedMaybe = await maybe - .AsValueTask() - .Tap(value => - { - maybe = T.Value; - return ValueTask.CompletedTask; - }); - - maybe.HasNoValue.Should().BeTrue(); - returnedMaybe.Should().BeSameAs(maybe); - } - - [Fact] - public async Task Tap_ValueTask_executes_action_if_value() - { - Maybe maybe = T.Value; - - var returnedMaybe = await maybe - .AsValueTask() - .Tap(value => - { - value.Should().Be(T.Value); - return ValueTask.CompletedTask; - }); - - maybe.Value.Should().Be(T.Value); - returnedMaybe.Should().BeSameAs(maybe); - } - } -} +using System.Threading.Tasks; +using CSharpFunctionalExtensions.ValueTasks; +using FluentAssertions; +using Xunit; + +namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions +{ + public class TapTests_ValueTask : MaybeTestBase + { + [Fact] + public async Task Tap_ValueTask_does_not_execute_action_if_no_value() + { + Maybe maybe = null; + var executed = false; + + var returnedMaybe = await maybe + .AsValueTask() + .Tap(value => + { + executed = true; + return ValueTask.CompletedTask; + }); + + executed.Should().BeFalse(); + returnedMaybe.HasNoValue.Should().BeTrue(); + } + + [Fact] + public async Task Tap_ValueTask_executes_action_if_value() + { + Maybe maybe = T.Value; + + var returnedMaybe = await maybe + .AsValueTask() + .Tap(value => + { + value.Should().Be(T.Value); + return ValueTask.CompletedTask; + }); + + maybe.Value.Should().Be(T.Value); + returnedMaybe.Value.Should().BeSameAs(maybe.Value); + } + } +} diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.cs index 67d65384..9e707189 100644 --- a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.cs +++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.cs @@ -9,11 +9,12 @@ public class TapTests : MaybeTestBase public void Tap_does_not_execute_action_if_no_value() { Maybe maybe = null; + var executed = false; - var returnedMaybe = maybe.Tap(value => maybe = T.Value); + var returnedMaybe = maybe.Tap(value => executed = true); - maybe.HasNoValue.Should().BeTrue(); - returnedMaybe.Should().BeSameAs(maybe); + executed.Should().BeFalse(); + returnedMaybe.HasNoValue.Should().BeTrue(); } [Fact] @@ -24,7 +25,7 @@ public void Tap_executes_action_if_value() var returnedMaybe = maybe.Tap(value => value.Should().Be(T.Value)); maybe.Value.Should().Be(T.Value); - returnedMaybe.Should().BeSameAs(maybe); + returnedMaybe.Value.Should().BeSameAs(maybe.Value); } } }