bool.Then() (#27)

* BoolExtensions

* Async

* Adding justfile

* Test coverage

Author: jtmueller

justfile

@@ -0,0 +1,27 @@
+# Just: https://github.com/casey/just
+
+# Select a target to run
+default:
+  @just --choose
+
+# Build the project
+build *FLAGS:
+  dotnet build {{FLAGS}} src/
+
+# Generate a NuGet package
+pack:
+  dotnet pack -c Release src/
+
+# Run tests in .NET 8.0
+test:
+  dotnet test -f net8.0 src/
+
+# Clean build artifacts
+clean:
+  dotnet clean src/
+
+# Build documentation
+doc:
+  dotnet build -c Release src/
+  docfx metadata docs/docfx.json
+  docfx build docs/docfx.json

src/RustyOptions.FSharp/RustyOptions.FSharp.fsproj

@@ -4,8 +4,8 @@
     <TargetFrameworks>net8.0;net7.0;net6.0</TargetFrameworks>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <AssemblyName>RustyOptions.FSharp</AssemblyName>
-    <Version>0.10.0</Version>
-    <ReleaseVersion>0.10.0</ReleaseVersion>
+    <Version>0.10.1</Version>
+    <ReleaseVersion>0.10.1</ReleaseVersion>
     <PackageId>RustyOptions.FSharp</PackageId>
     <Authors>Joel Mueller</Authors>
     <Company></Company>

src/RustyOptions.Tests/BoolExtensionsTests.cs

@@ -0,0 +1,170 @@
+using RustyOptions.Async;
+
+namespace RustyOptions.Tests;
+
+#pragma warning disable CA1707 // Identifiers should not contain underscores
+
+public class BoolExtensionsTests
+{
+    [Fact]
+    public void Then_ReturnsOptionWithValue_WhenBooleanIsTrue()
+    {
+        // Arrange
+        bool condition = true;
+
+        // Act
+        var result = condition.Then(() => 42);
+
+        // Assert
+        Assert.True(result.IsSome(out int resultVal));
+        Assert.Equal(42, resultVal);
+    }
+
+    [Fact]
+    public void Then_ReturnsDefaultOption_WhenBooleanIsFalse()
+    {
+        // Arrange
+        bool condition = false;
+
+        // Act
+        var result = condition.Then(() => 42);
+
+        // Assert
+        Assert.True(result.IsNone);
+    }
+
+    [Fact]
+    public void ThenSome_ReturnsOptionWithValue_WhenBooleanIsTrue()
+    {
+        // Arrange
+        bool condition = true;
+        int value = 42;
+
+        // Act
+        var result = condition.ThenSome(value);
+
+        // Assert
+        Assert.True(result.IsSome(out int resultVal));
+        Assert.Equal(42, resultVal);
+    }
+
+    [Fact]
+    public void ThenSome_ReturnsDefaultOption_WhenBooleanIsFalse()
+    {
+        // Arrange
+        bool condition = false;
+        int value = 42;
+
+        // Act
+        var result = condition.ThenSome(value);
+
+        // Assert
+        Assert.True(result.IsNone);
+    }
+
+    [Fact]
+    public async Task ThenAsync_Task_ReturnsDefaultWhenFalse()
+    {
+        bool condition = false;
+        var result = await condition.ThenAsync(() => Task.FromResult("Test"));
+        Assert.True(result.IsNone);
+    }
+
+    [Fact]
+    public async Task ThenAsync_Task_ReturnsResultWhenTrue()
+    {
+        bool condition = true;
+        var result = await condition.ThenAsync(() => Task.FromResult("Test"));
+        Assert.True(result.IsSome(out var resultVal));
+        Assert.Equal("Test", resultVal);
+    }
+
+    [Fact]
+    public async Task ThenAsync_ValueTask_ReturnsDefaultWhenFalse()
+    {
+        bool condition = false;
+        var result = await condition.ThenAsync(() => new ValueTask<string>("Test"));
+        Assert.True(result.IsNone);
+    }
+
+    [Fact]
+    public async Task ThenAsync_ValueTask_ReturnsResultWhenTrue()
+    {
+        bool condition = true;
+        var result = await condition.ThenAsync(() => new ValueTask<int>(42));
+        Assert.True(result.IsSome(out var resultVal));
+        Assert.Equal(42, resultVal);
+    }
+
+    [Fact]
+    public async Task ThenSomeAsync_Task_WhenTrue_ShouldReturnOptionWithValue()
+    {
+        bool condition = true;
+        var result = await condition.ThenSomeAsync(Task.FromResult("Hello"));
+
+        Assert.True(result.IsSome(out var value));
+        Assert.Equal("Hello", value);
+    }
+
+    [Fact]
+    public async Task ThenSomeAsync_Task_NotCompleted_WhenTrue_ShouldReturnOptionWithValue()
+    {
+        bool condition = true;
+        var result = await condition.ThenSomeAsync(GetTask("Hello"));
+
+        Assert.True(result.IsSome(out var value));
+        Assert.Equal("Hello", value);
+    }
+
+    [Fact]
+    public async Task ThenSomeAsync_Task_WhenFalse_ShouldReturnDefaultOption()
+    {
+        bool condition = false;
+        var result = await condition.ThenSomeAsync(Task.FromResult("Hello"));
+
+        Assert.True(result.IsNone);
+    }
+
+    [Fact]
+    public async Task ThenSomeAsync_ValueTask_WhenTrue_ShouldReturnOptionWithValue()
+    {
+        bool condition = true;
+        var result = await condition.ThenSomeAsync(new ValueTask<string>("Hello"));
+
+        Assert.True(result.IsSome(out var value));
+        Assert.Equal("Hello", value);
+    }
+
+    [Fact]
+    public async Task ThenSomeAsync_ValueTask_NotCompleted_WhenTrue_ShouldReturnOptionWithValue()
+    {
+        bool condition = true;
+        var result = await condition.ThenSomeAsync(GetValueTask("Hello"));
+
+        Assert.True(result.IsSome(out var value));
+        Assert.Equal("Hello", value);
+    }
+
+    [Fact]
+    public async Task ThenSomeAsync_ValueTask_WhenFalse_ShouldReturnDefaultOption()
+    {
+        bool condition = false;
+        var result = await condition.ThenSomeAsync(new ValueTask<string>("Hello"));
+
+        Assert.True(result.IsNone);
+    }
+
+    private static async Task<T> GetTask<T>(T value)
+    {
+        await Task.Delay(1);
+        return value;
+    }
+
+    private static async ValueTask<T> GetValueTask<T>(T value)
+    {
+        await Task.Delay(1);
+        return value;
+    }
+}
+
+#pragma warning restore CA1707 // Identifiers should not contain underscores

src/RustyOptions.Tests/OptionAsyncTests.cs

@@ -1,4 +1,5 @@
 using System.Runtime.CompilerServices;
+using System.Diagnostics.CodeAnalysis;
 using RustyOptions.Async;
 using static RustyOptions.Option;
 
@@ -68,6 +69,7 @@ public async Task CanGetFirstOrNoneWithCancelAsync()
 
     [Theory]
     [MemberData(nameof(GetMapAsyncValues))]
+    [SuppressMessage("Usage", "xUnit1031:Do not use blocking task operations in test method", Justification = "Will not block")]
     public async Task CanMapAsync(object source, object mapper, Option<long> expected)
     {
         switch ((source, mapper))
@@ -80,21 +82,27 @@ public async Task CanMapAsync(object source, object mapper, Option<long> expecte
                 break;
             case (ValueTask<Option<int>> src, Func<int, long> mpr):
                 Assert.Equal(expected, await src.MapAsync(mpr));
+                Assert.Equal(expected, await GetValueTask(src.Result).MapAsync(mpr));
                 break;
             case (Task<Option<int>> src, Func<int, long> mpr):
                 Assert.Equal(expected, await src.MapAsync(mpr));
+                Assert.Equal(expected, await GetTask(src.Result).MapAsync(mpr));
                 break;
             case (ValueTask<Option<int>> src, Func<int, ValueTask<long>> mpr):
                 Assert.Equal(expected, await src.MapAsync(mpr));
+                Assert.Equal(expected, await GetValueTask(src.Result).MapAsync(mpr));
                 break;
             case (Task<Option<int>> src, Func<int, ValueTask<long>> mpr):
                 Assert.Equal(expected, await src.MapAsync(mpr));
+                Assert.Equal(expected, await GetTask(src.Result).MapAsync(mpr));
                 break;
             case (ValueTask<Option<int>> src, Func<int, Task<long>> mpr):
                 Assert.Equal(expected, await src.MapAsync(mpr));
+                Assert.Equal(expected, await GetValueTask(src.Result).MapAsync(mpr));
                 break;
             case (Task<Option<int>> src, Func<int, Task<long>> mpr):
                 Assert.Equal(expected, await src.MapAsync(mpr));
+                Assert.Equal(expected, await GetTask(src.Result).MapAsync(mpr));
                 break;
 
             default:
@@ -139,6 +147,7 @@ public static IEnumerable<object[]> GetMapAsyncValues()
 
     [Theory]
     [MemberData(nameof(GetMapOrElseAsyncValues))]
+    [SuppressMessage("Usage", "xUnit1031:Do not use blocking task operations in test method", Justification = "Will not block")]
     public async Task CanMapOrElseAsync(object source, object mapper, object defaultFactory, long expected)
     {
         switch ((source, mapper, defaultFactory))
@@ -151,21 +160,27 @@ public async Task CanMapOrElseAsync(object source, object mapper, object default
                 break;
             case (ValueTask<Option<int>> src, Func<int, long> mpr, Func<long> dff):
                 Assert.Equal(expected, await src.MapOrElseAsync(mpr, dff));
+                Assert.Equal(expected, await GetValueTask(src.Result).MapOrElseAsync(mpr, dff));
                 break;
             case (Task<Option<int>> src, Func<int, long> mpr, Func<long> dff):
                 Assert.Equal(expected, await src.MapOrElseAsync(mpr, dff));
+                Assert.Equal(expected, await GetTask(src.Result).MapOrElseAsync(mpr, dff));
                 break;
             case (ValueTask<Option<int>> src, Func<int, ValueTask<long>> mpr, Func<ValueTask<long>> dff):
                 Assert.Equal(expected, await src.MapOrElseAsync(mpr, dff));
+                Assert.Equal(expected, await GetValueTask(src.Result).MapOrElseAsync(mpr, dff));
                 break;
             case (Task<Option<int>> src, Func<int, ValueTask<long>> mpr, Func<ValueTask<long>> dff):
                 Assert.Equal(expected, await src.MapOrElseAsync(mpr, dff));
+                Assert.Equal(expected, await GetTask(src.Result).MapOrElseAsync(mpr, dff));
                 break;
             case (ValueTask<Option<int>> src, Func<int, Task<long>> mpr, Func<Task<long>> dff):
                 Assert.Equal(expected, await src.MapOrElseAsync(mpr, dff));
+                Assert.Equal(expected, await GetValueTask(src.Result).MapOrElseAsync(mpr, dff));
                 break;
             case (Task<Option<int>> src, Func<int, Task<long>> mpr, Func<Task<long>> dff):
                 Assert.Equal(expected, await src.MapOrElseAsync(mpr, dff));
+                Assert.Equal(expected, await GetTask(src.Result).MapOrElseAsync(mpr, dff));
                 break;
 
             default:
@@ -215,6 +230,7 @@ public static IEnumerable<object[]> GetMapOrElseAsyncValues()
 
     [Theory]
     [MemberData(nameof(GetAndThenAsyncValues))]
+    [SuppressMessage("Usage", "xUnit1031:Do not use blocking task operations in test method", Justification = "Will not block")]
     public async Task CanAndThenAsync(object source, object mapper, Option<long> expected)
     {
         switch ((source, mapper))
@@ -227,21 +243,27 @@ public async Task CanAndThenAsync(object source, object mapper, Option<long> exp
                 break;
             case (ValueTask<Option<int>> src, Func<int, Option<long>> mpr):
                 Assert.Equal(expected, await src.AndThenAsync(mpr));
+                Assert.Equal(expected, await GetValueTask(src.Result).AndThenAsync(mpr));
                 break;
             case (Task<Option<int>> src, Func<int, Option<long>> mpr):
                 Assert.Equal(expected, await src.AndThenAsync(mpr));
+                Assert.Equal(expected, await GetTask(src.Result).AndThenAsync(mpr));
                 break;
             case (ValueTask<Option<int>> src, Func<int, ValueTask<Option<long>>> mpr):
                 Assert.Equal(expected, await src.AndThenAsync(mpr));
+                Assert.Equal(expected, await GetValueTask(src.Result).AndThenAsync(mpr));
                 break;
             case (Task<Option<int>> src, Func<int, ValueTask<Option<long>>> mpr):
                 Assert.Equal(expected, await src.AndThenAsync(mpr));
+                Assert.Equal(expected, await GetTask(src.Result).AndThenAsync(mpr));
                 break;
             case (ValueTask<Option<int>> src, Func<int, Task<Option<long>>> mpr):
                 Assert.Equal(expected, await src.AndThenAsync(mpr));
+                Assert.Equal(expected, await GetValueTask(src.Result).AndThenAsync(mpr));
                 break;
             case (Task<Option<int>> src, Func<int, Task<Option<long>>> mpr):
                 Assert.Equal(expected, await src.AndThenAsync(mpr));
+                Assert.Equal(expected, await GetTask(src.Result).AndThenAsync(mpr));
                 break;
 
             default:
@@ -286,6 +308,7 @@ public static IEnumerable<object[]> GetAndThenAsyncValues()
 
     [Theory]
     [MemberData(nameof(GetOrElseAsyncValues))]
+    [SuppressMessage("Usage", "xUnit1031:Do not use blocking task operations in test method", Justification = "Will not block")]
     public async Task CanOrElseAsync(object source, object mapper, Option<int> expected)
     {
         switch ((source, mapper))
@@ -298,21 +321,27 @@ public async Task CanOrElseAsync(object source, object mapper, Option<int> expec
                 break;
             case (ValueTask<Option<int>> src, Func<Option<int>> mpr):
                 Assert.Equal(expected, await src.OrElseAsync(mpr));
+                Assert.Equal(expected, await GetValueTask(src.Result).OrElseAsync(mpr));
                 break;
             case (Task<Option<int>> src, Func<Option<int>> mpr):
                 Assert.Equal(expected, await src.OrElseAsync(mpr));
+                Assert.Equal(expected, await GetTask(src.Result).OrElseAsync(mpr));
                 break;
             case (ValueTask<Option<int>> src, Func<ValueTask<Option<int>>> mpr):
                 Assert.Equal(expected, await src.OrElseAsync(mpr));
+                Assert.Equal(expected, await GetValueTask(src.Result).OrElseAsync(mpr));
                 break;
             case (Task<Option<int>> src, Func<ValueTask<Option<int>>> mpr):
                 Assert.Equal(expected, await src.OrElseAsync(mpr));
+                Assert.Equal(expected, await GetTask(src.Result).OrElseAsync(mpr));
                 break;
             case (ValueTask<Option<int>> src, Func<Task<Option<int>>> mpr):
                 Assert.Equal(expected, await src.OrElseAsync(mpr));
+                Assert.Equal(expected, await GetValueTask(src.Result).OrElseAsync(mpr));
                 break;
             case (Task<Option<int>> src, Func<Task<Option<int>>> mpr):
                 Assert.Equal(expected, await src.OrElseAsync(mpr));
+                Assert.Equal(expected, await GetTask(src.Result).OrElseAsync(mpr));
                 break;
 
             default:
@@ -382,4 +411,16 @@ private static async IAsyncEnumerable<Option<int>> EnumerateFilteredAsync(int ex
             yield return predicate(i) ? Some(i) : None<int>();
         }
     }
+
+    private static async Task<T> GetTask<T>(T value)
+    {
+        await Task.Delay(1);
+        return value;
+    }
+
+    private static async ValueTask<T> GetValueTask<T>(T value)
+    {
+        await Task.Delay(1);
+        return value;
+    }
 }

src/RustyOptions.Tests/OptionTests.cs

@@ -403,7 +403,7 @@ public void CanAndThen()
         Assert.Equal(None<int>(), someOtherStr.AndThen(ParseInt));
 
         static Option<int> ParseInt(string s)
-            => int.TryParse(s, out int parsed) ? Some(parsed) : None<int>();
+            => int.TryParse(s, out int parsed).ThenSome(parsed);
     }
 
     [Fact]