Feature Additional Extension Methods for Optional (#733)

* Added additional extension methods for Optional * Improve parameter names and associated comments * Added more test coverage
reactivemarbles · Oct 5, 2023 · 0e28e70 · 0e28e70
1 parent b3180bc
commit 0e28e70
Show file tree

Hide file tree

Showing 2 changed files with 236 additions and 1 deletion.
diff --git a/src/DynamicData.Tests/Kernal/OptionFixture.cs b/src/DynamicData.Tests/Kernal/OptionFixture.cs
@@ -1,4 +1,6 @@
-using DynamicData.Kernel;
+using System;
+using System.Globalization;
+using DynamicData.Kernel;
 using DynamicData.Tests.Domain;
 
 using FluentAssertions;
@@ -78,4 +80,193 @@ public void OptionSomeHasValue()
         option.HasValue.Should().BeTrue();
         ReferenceEquals(person, option.Value).Should().BeTrue();
     }
+
+    [Fact]
+    public void OptionConvertThrowsIfConverterIsNull()
+    {
+        var caught = false;
+
+        Func<string, string>? converter = null;
+
+        try
+        {
+            Optional.None<string>().Convert(converter!);
+        }
+        catch (ArgumentNullException)
+        {
+            caught = true;
+        }
+
+        caught.Should().BeTrue();
+    }
+
+    [Fact]
+    public void OptionConvertToOptionalInvokesConverterWithValue()
+    {
+        var option = Optional.Some(string.Empty);
+        var invoked = false;
+
+        Optional<string> Converter(string input)
+        {
+            invoked = true;
+            return Optional.Some(input);
+        }
+
+        var result = option.Convert(Converter);
+
+        invoked.Should().BeTrue();
+        result.HasValue.Should().BeTrue();
+    }
+
+    [Fact]
+    public void OptionConvertToOptionalInvokesConverterOnlyWithValue()
+    {
+        var option = Optional.None<string>();
+        var invoked = false;
+
+        Optional<string> Converter(string input)
+        {
+            invoked = true;
+            return Optional.Some(input);
+        }
+
+        var result = option.Convert(Converter);
+
+        invoked.Should().BeFalse();
+        result.HasValue.Should().BeFalse();
+    }
+
+    [Fact]
+    public void OptionConvertToOptionalCanReturnValue()
+    {
+        const int TestData = 37;
+
+        var option = Optional.Some(TestData.ToString());
+
+        var result = option.Convert(ParseInt);
+
+        result.HasValue.Should().BeTrue();
+        result.Value.Should().Be(TestData);
+    }
+
+    [Fact]
+    public void OptionConvertToOptionalCanReturnNone()
+    {
+        var option = Optional.Some("Not An Int");
+
+        var result = option.Convert(ParseInt);
+
+        result.HasValue.Should().BeFalse();
+    }
+
+    [Fact]
+    public void OptionConvertToOptionalThrowsIfConverterIsNull()
+    {
+        var caught = false;
+
+        Func<string, Optional<string>>? converter = null;
+
+        try
+        {
+            Optional.None<string>().Convert(converter!);
+        }
+        catch (ArgumentNullException)
+        {
+            caught = true;
+        }
+
+        caught.Should().BeTrue();
+    }
+
+    [Fact]
+    public void OptionOrElseInvokesWithoutValue()
+    {
+        var option = Optional.None<string>();
+        var invoked = false;
+
+        Optional<string> Fallback()
+        {
+            invoked = true;
+            return Optional.None<string>();
+        }
+
+        var result = option.OrElse(Fallback);
+
+        invoked.Should().BeTrue();
+    }
+
+    [Fact]
+    public void OptionOrElseInvokesOnlyWithoutValue()
+    {
+        var option = Optional.Some(string.Empty);
+        var invoked = false;
+
+        Optional<string> Fallback()
+        {
+            invoked = true;
+            return Optional.None<string>();
+        }
+
+        var result = option.OrElse(Fallback);
+
+        invoked.Should().BeFalse();
+    }
+
+    [Fact]
+    public void OptionOrElseCanReturnValue()
+    {
+        const string TestString = nameof(TestString);
+
+        var option = Optional.None<string>();
+        var result = option.OrElse(() => TestString);
+
+        result.HasValue.Should().BeTrue();
+        result.Value.Should().Be(TestString);
+    }
+
+    [Fact]
+    public void OptionOrElseCanReturnNone()
+    {
+        var option = Optional.None<string>();
+        var result = option.OrElse(Optional.None<string>);
+
+        result.HasValue.Should().BeFalse();
+    }
+
+    [Fact]
+    public void OptionOrElseCanBeChained()
+    {
+        const int Expected = unchecked((int)0xc001d00d);
+
+        var option = Optional.None<string>();
+        var result = option.OrElse(Optional.None<string>)
+                                      .OrElse(() => Optional.Some(Expected.ToString("x")))
+                                      .Convert(s => ParseInt(s).OrElse(() => ParseHex(s)));
+
+        result.HasValue.Should().BeTrue();
+        result.Value.Should().Be(Expected);
+    }
+
+    [Fact]
+    public void OptionOrElseThrowsIfFallbackIsNull()
+    {
+        var caught = false;
+
+        try
+        {
+            Optional.None<string>().OrElse(null!);
+        }
+        catch(ArgumentNullException)
+        {
+            caught = true;
+        }
+
+        caught.Should().BeTrue();
+    }
+
+    private static Optional<int> ParseInt(string input) =>
+        int.TryParse(input, out var result) ? Optional.Some(result) : Optional.None<int>();
+
+    private static Optional<int> ParseHex(string input) =>
+        int.TryParse(input, NumberStyles.HexNumber, null, out var result) ? Optional.Some(result) : Optional.None<int>();
 }
diff --git a/src/DynamicData/Kernel/OptionExtensions.cs b/src/DynamicData/Kernel/OptionExtensions.cs
@@ -34,6 +34,27 @@ public static Optional<TDestination> Convert<TSource, TDestination>(this Optiona
         return source.HasValue ? converter(source.Value) : Optional.None<TDestination>();
     }
 
+    /// <summary>
+    /// Attempts to converts the specified source, but the conversion might result in a None value.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the source.</typeparam>
+    /// <typeparam name="TDestination">The type of the destination.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="converter">The converter that returns an optional value.</param>
+    /// <returns>The converted value.</returns>
+    /// <exception cref="System.ArgumentNullException">converter.</exception>
+    public static Optional<TDestination> Convert<TSource, TDestination>(this Optional<TSource> source, Func<TSource, Optional<TDestination>> converter)
+        where TSource : notnull
+        where TDestination : notnull
+    {
+        if (converter is null)
+        {
+            throw new ArgumentNullException(nameof(converter));
+        }
+
+        return source.HasValue ? converter(source.Value) : Optional.None<TDestination>();
+    }
+
     /// <summary>
     /// Converts the option value if it has a value, otherwise returns the result of the fallback converter.
     /// </summary>
@@ -64,6 +85,29 @@ public static Optional<TDestination> Convert<TSource, TDestination>(this Optiona
         return source.HasValue ? converter(source.Value) : fallbackConverter();
     }
 
+    /// <summary>
+    /// Returns the original optional if it has a value, otherwise returns the result of the fallback operation.
+    /// </summary>
+    /// <typeparam name="T">The type of the source.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="fallbackOperation">The fallback operation.</param>
+    /// <returns>The original value or the result of the fallback operation.</returns>
+    /// <exception cref="System.ArgumentNullException">
+    /// converter
+    /// or
+    /// fallbackOperation.
+    /// </exception>
+    public static Optional<T> OrElse<T>(this Optional<T> source, Func<Optional<T>> fallbackOperation)
+        where T : notnull
+    {
+        if (fallbackOperation is null)
+        {
+            throw new ArgumentNullException(nameof(fallbackOperation));
+        }
+
+        return source.HasValue ? source : fallbackOperation();
+    }
+
     /// <summary>
     /// Overloads Enumerable.FirstOrDefault() and wraps the result in a Optional<typeparam>
     ///         <name>&amp;gt;T</name>