From 03bad94d7da999c2b91c8fc4b9baf6ab564d7184 Mon Sep 17 00:00:00 2001
From: trippwill <5862883+trippwill@users.noreply.github.com>
Date: Fri, 3 Jan 2025 13:04:58 +0000
Subject: [PATCH 1/2] Fix nullable bugs in Select and From

Updated the `Opt` class in `Opt.cs` to include XML documentation for the `From` method, which now supports both nullable value types and non-nullable reference types. Converted `Zip` and `Flatten` methods to extension methods. Changed the constructor of `Opt<T>` to internal and modified the `Select` method to accept functions returning nullable types. Added a new `Where` method for filtering options based on predicates.

In `OptTests.cs`, added unit tests for the `Select` and `Where` methods, covering value transformations, null handling, and behavior when the option is `None`. Included additional tests for casting options to validate correct and incorrect casts.
---
 src/libanvl.Opt/Opt.cs            | 37 +++++++++++++---
 test/libanvl.Opt.Test/OptTests.cs | 74 +++++++++++++++++++++++++++++++
 2 files changed, 106 insertions(+), 5 deletions(-)

diff --git a/src/libanvl.Opt/Opt.cs b/src/libanvl.Opt/Opt.cs
index a906566..d94099a 100644
--- a/src/libanvl.Opt/Opt.cs
+++ b/src/libanvl.Opt/Opt.cs
@@ -33,6 +33,14 @@ public static class Opt
     /// <returns>An <see cref="Opt{T}"/> containing the value if not null, otherwise <see cref="Opt{T}.None"/>.</returns>
     public static Opt<T> From<T>(T? value) where T : notnull => value is null ? Opt<T>.None : Some(value);
 
+    /// <summary>
+    /// Creates an <see cref="Opt{T}"/> from a nullable value.
+    /// </summary>
+    /// <typeparam name="T">The type of the value.</typeparam>
+    /// <param name="value">The nullable value to wrap.</param>
+    /// <returns>An <see cref="Opt{T}"/> containing the value if not null, otherwise <see cref="Opt{T}.None"/>.</returns>
+    public static Opt<T> From<T>(T? value) where T : struct => value.HasValue ? Some(value.Value) : Opt<T>.None;
+
     /// <summary>
     /// Combines two options into an option containing a tuple of their values if both are present.
     /// </summary>
@@ -41,7 +49,7 @@ public static class Opt
     /// <param name="opt1">The first option.</param>
     /// <param name="opt2">The second option.</param>
     /// <returns>An option containing a tuple of the values if both are present, otherwise none.</returns>
-    public static Opt<(T, U)> Zip<T, U>(Opt<T> opt1, Opt<U> opt2)
+    public static Opt<(T, U)> Zip<T, U>(this Opt<T> opt1, Opt<U> opt2)
         where T : notnull
         where U : notnull
     {
@@ -55,7 +63,7 @@ public static class Opt
     /// </summary>
     /// <param name="opt">The option to flatten.</param>
     /// <returns>The flattened option.</returns>
-    public static Opt<T> Flatten<T>(Opt<Opt<T>> opt)
+    public static Opt<T> Flatten<T>(this Opt<Opt<T>> opt)
         where T : notnull => opt.IsSome ? opt.Unwrap() : Opt<T>.None;
 
     /// <summary>
@@ -102,7 +110,7 @@ public static Opt<U> AndThen<T, U>(this Opt<T> opt, Func<T, Opt<U>> fn) where T
     /// </summary>
     /// <param name="value">The value to wrap.</param>
     /// <exception cref="OptException">Thrown if the value is null.</exception>
-    public Opt(T value)
+    internal Opt(T value)
     {
         OptException.ThrowIfNull(value);
         _value = value;
@@ -248,10 +256,29 @@ public TResult Match<TResult>(Func<T, TResult> some, Func<TResult> none) => IsSo
     /// <typeparam name="U">The type of the result.</typeparam>
     /// <param name="fn">The function to transform the value.</param>
     /// <returns>An <see cref="Opt{U}"/> containing the transformed value or none.</returns>
-    public Opt<U> Select<U>(Func<T, U> fn) where U : notnull => IsSome
-        ? new(fn(OptException.ThrowInternalErrorIfNull(_value)))
+    public Opt<U> Select<U>(Func<T, U?> fn) where U : notnull => IsSome
+        ? Opt.From(fn(OptException.ThrowInternalErrorIfNull(_value)))
         : Opt<U>.None;
 
+    /// <summary>
+    /// Transforms the value if present using the specified function.
+    /// </summary>
+    /// <typeparam name="U">The type of the result.</typeparam>
+    /// <param name="fn">The function to transform the value.</param>
+    /// <returns>An <see cref="Opt{U}"/> containing the transformed value or none.</returns>
+    public Opt<U> Select<U>(Func<T, U?> fn) where U: struct => IsSome
+        ? Opt.From(fn(OptException.ThrowInternalErrorIfNull(_value)))
+        : Opt<U>.None;
+
+    /// <summary>
+    /// Filters the option based on a predicate.
+    /// </summary>
+    /// <param name="predicate">The predicate to apply.</param>
+    /// <returns>The option if the predicate is true, otherwise none.</returns>
+    public Opt<T> Where(Func<T, bool> predicate) => IsSome && predicate(OptException.ThrowInternalErrorIfNull(_value))
+        ? this
+        : None;
+
     /// <summary>
     /// Casts the value to the specified type if present.
     /// </summary>
diff --git a/test/libanvl.Opt.Test/OptTests.cs b/test/libanvl.Opt.Test/OptTests.cs
index 8a18b21..bf141e7 100644
--- a/test/libanvl.Opt.Test/OptTests.cs
+++ b/test/libanvl.Opt.Test/OptTests.cs
@@ -268,4 +268,78 @@ public void GetHashCode_ReturnsSameHashCode_ForNone()
         var opt2 = Opt<int>.None;
         Assert.Equal(opt1.GetHashCode(), opt2.GetHashCode());
     }
+
+    [Fact]
+    public void Select_ReturnsTransformedOption_WhenSome()
+    {
+        var opt = Opt.Some(5);
+        var result = opt.Select(x => x * 2);
+        Assert.True(result.IsSome);
+        Assert.Equal(10, result.Unwrap());
+    }
+
+    [Fact]
+    public void Select_ReturnsNone_WhenTransformedValueIsNull()
+    {
+        var opt = Opt.Some("Hello");
+        var result = opt.Select<string>(x => null);
+        Assert.True(result.IsNone);
+    }
+
+    [Fact]
+    public void Select_ReturnsNone_WhenTransformedValueIsNullValueType()
+    {
+        Opt<int> opt = 5;
+        var result = opt.Select<int>(_ => null);
+        Assert.True(result.IsNone);
+    }
+
+    [Fact]
+    public void Select_ReturnsNone_WhenNone()
+    {
+        var opt = Opt<int>.None;
+        var result = opt.Select(x => x * 2);
+        Assert.True(result.IsNone);
+    }
+
+    [Fact]
+    public void Where_ReturnsSome_WhenPredicateIsTrue()
+    {
+        var opt = Opt.Some(5);
+        var result = opt.Where(x => x > 3);
+        Assert.True(result.IsSome);
+    }
+
+    [Fact]
+    public void Where_ReturnsNone_WhenPredicateIsFalse()
+    {
+        var opt = Opt.Some(5);
+        var result = opt.Where(x => x < 3);
+        Assert.True(result.IsNone);
+    }
+
+    [Fact]
+    public void Where_ReturnsNone_WhenOptionIsNone()
+    {
+        var opt = Opt<int>.None;
+        var result = opt.Where(x => x > 3);
+        Assert.True(result.IsNone);
+    }
+
+    [Fact]
+    public void Cast_ReturnsSome_WhenCastIsValid()
+    {
+        var opt = Opt.Some((object)5);
+        var result = opt.Cast<int>();
+        Assert.True(result.IsSome);
+        Assert.Equal(5, result.Unwrap());
+    }
+
+    [Fact]
+    public void Cast_ReturnsNone_WhenCastIsInvalid()
+    {
+        var opt = Opt.Some((object)"string");
+        var result = opt.Cast<int>();
+        Assert.True(result.IsNone);
+    }
 }

From 74bcfc9bf05f2c5c320256fd53b3d9f77139fac1 Mon Sep 17 00:00:00 2001
From: Charles Willis <5862883+trippwill@users.noreply.github.com>
Date: Fri, 3 Jan 2025 15:59:17 +0000
Subject: [PATCH 2/2] Enhance Opt class with new transformation methods (#24)

Updated `Opt.cs` to add overloaded `AndThen` methods supporting nullable return types and introduced new `OrThen` methods for option handling. Added unit tests in `OptTests.cs` to validate the new functionality for both some and none cases.
---
 src/libanvl.Opt/Opt.cs            | 83 +++++++++++++++++++++++++++++--
 test/libanvl.Opt.Test/OptTests.cs | 52 ++++++++++++++++++-
 2 files changed, 128 insertions(+), 7 deletions(-)

diff --git a/src/libanvl.Opt/Opt.cs b/src/libanvl.Opt/Opt.cs
index d94099a..cfaba73 100644
--- a/src/libanvl.Opt/Opt.cs
+++ b/src/libanvl.Opt/Opt.cs
@@ -1,7 +1,5 @@
-using libanvl.Exceptions;
-using System.Collections;
-using System;
-using System.Runtime.Serialization;
+using System.Collections;
+using libanvl.Exceptions;
 
 namespace libanvl;
 
@@ -86,10 +84,85 @@ public static Opt<T> Filter<T>(this Opt<T> opt, Func<T, bool> predicate) where T
     /// <param name="opt">The option to transform.</param>
     /// <param name="fn">The function to transform the value.</param>
     /// <returns>The transformed option.</returns>
-    public static Opt<U> AndThen<T, U>(this Opt<T> opt, Func<T, Opt<U>> fn) where T : notnull where U : notnull
+    public static Opt<U> AndThen<T, U>(this Opt<T> opt, Func<T, Opt<U>> fn)
+        where T : notnull
+        where U : notnull
     {
         return opt.IsSome ? fn(opt.Unwrap()) : Opt<U>.None;
     }
+
+    /// <summary>
+    /// Transforms the option using a function that returns another option.
+    /// </summary>
+    /// <typeparam name="T">The type of the value.</typeparam>
+    /// <typeparam name="U">The type of the result.</typeparam>
+    /// <param name="opt">The option to transform.</param>
+    /// <param name="fn">The function to transform the value.</param>
+    /// <returns>The transformed option.</returns>
+    public static Opt<U> AndThen<T, U>(this Opt<T> opt, Func<T, U?> fn)
+        where T : notnull
+        where U : notnull
+    {
+        return opt.IsSome ? From(fn(opt.Unwrap())) : Opt<U>.None;
+    }
+
+    /// <summary>
+    /// Transforms the option using a function that returns another option.
+    /// </summary>
+    /// <typeparam name="T">The type of the value.</typeparam>
+    /// <typeparam name="U">The type of the result.</typeparam>
+    /// <param name="opt">The option to transform.</param>
+    /// <param name="fn">The function to transform the value.</param>
+    /// <returns>The transformed option.</returns>
+    public static Opt<U> AndThen<T, U>(this Opt<T> opt, Func<T, U?> fn)
+        where T : notnull
+        where U : struct
+    {
+        return opt.IsSome ? From(fn(opt.Unwrap())) : Opt<U>.None;
+    }
+
+    /// <summary>
+    /// Returns the first option if it has a value, otherwise returns the result of the specified function.
+    /// </summary>
+    /// <typeparam name="T">The type of the value.</typeparam>
+    /// <typeparam name="U">The type of the state.</typeparam>
+    /// <param name="opt">The option to check.</param>
+    /// <param name="state">The state to pass to the function if the option does not have a value.</param>
+    /// <param name="fn">The function to invoke if the option does not have a value.</param>
+    /// <returns>The first option if it has a value, otherwise the result of the function.</returns>
+    public static Opt<T> OrThen<T, U>(this Opt<T> opt, U state, Func<U, T?> fn)
+        where T : notnull
+    {
+        return opt.IsSome ? opt : From(fn(state));
+    }
+
+    /// <summary>
+    /// Returns the first option if it has a value, otherwise returns the result of the specified function.
+    /// </summary>
+    /// <typeparam name="T">The type of the value.</typeparam>
+    /// <typeparam name="U">The type of the state.</typeparam>
+    /// <param name="opt">The option to check.</param>
+    /// <param name="state">The state to pass to the function if the option does not have a value.</param>
+    /// <param name="fn">The function to invoke if the option does not have a value.</param>
+    /// <returns>The first option if it has a value, otherwise the result of the function.</returns>
+    public static Opt<T> OrThen<T, U>(this Opt<T> opt, U state, Func<U, T?> fn)
+        where T : struct
+    {
+        return opt.IsSome ? opt : From(fn(state));
+    }
+
+    /// <summary>
+    /// Returns the first option if it has a value, otherwise returns the second option.
+    /// </summary>
+    /// <typeparam name="T">The type of the value.</typeparam>
+    /// <param name="left">The first option.</param>
+    /// <param name="right">The second option.</param>
+    /// <returns>The first option if it has a value, otherwise the second option.</returns>
+    public static Opt<T> OrThen<T>(this Opt<T> left, Opt<T> right)
+        where T : notnull
+    {
+        return left.IsSome ? left : right;
+    }
 }
 
 /// <summary>
diff --git a/test/libanvl.Opt.Test/OptTests.cs b/test/libanvl.Opt.Test/OptTests.cs
index bf141e7..f5e365f 100644
--- a/test/libanvl.Opt.Test/OptTests.cs
+++ b/test/libanvl.Opt.Test/OptTests.cs
@@ -82,6 +82,7 @@ public void AndThen_ReturnsNone_WhenNone()
         var result = opt.AndThen(x => Opt.Some(x * 2));
         Assert.True(result.IsNone);
     }
+
     [Fact]
     public void CompareTo_ReturnsNegative_WhenThisIsSomeAndOtherIsNone()
     {
@@ -311,13 +312,60 @@ public void Where_ReturnsSome_WhenPredicateIsTrue()
     }
 
     [Fact]
-    public void Where_ReturnsNone_WhenPredicateIsFalse()
+    public void AndThen_WithNullableFunc_ReturnsTransformedOption_WhenSome()
     {
         var opt = Opt.Some(5);
-        var result = opt.Where(x => x < 3);
+        var result = opt.AndThen(x => (int?)(x * 2));
+        Assert.True(result.IsSome);
+        Assert.Equal(10, result.Unwrap());
+    }
+
+    [Fact]
+    public void AndThen_WithNullableFunc_ReturnsNone_WhenNone()
+    {
+        var opt = Opt<int>.None;
+        var result = opt.AndThen(x => (int?)(x * 2));
         Assert.True(result.IsNone);
     }
 
+    [Fact]
+    public void OrThen_WithFunc_ReturnsFirstOption_WhenSome()
+    {
+        var opt = Opt.Some(5);
+        var result = opt.OrThen("state", state => (int?)10);
+        Assert.True(result.IsSome);
+        Assert.Equal(5, result.Unwrap());
+    }
+
+    [Fact]
+    public void OrThen_WithFunc_ReturnsTransformedOption_WhenNone()
+    {
+        var opt = Opt<int>.None;
+        var result = opt.OrThen("state", state => (int?)10);
+        Assert.True(result.IsSome);
+        Assert.Equal(10, result.Unwrap());
+    }
+
+    [Fact]
+    public void OrThen_WithOption_ReturnsFirstOption_WhenSome()
+    {
+        var opt1 = Opt.Some(5);
+        var opt2 = Opt.Some(10);
+        var result = opt1.OrThen(opt2);
+        Assert.True(result.IsSome);
+        Assert.Equal(5, result.Unwrap());
+    }
+
+    [Fact]
+    public void OrThen_WithOption_ReturnsSecondOption_WhenNone()
+    {
+        var opt1 = Opt<int>.None;
+        var opt2 = Opt.Some(10);
+        var result = opt1.OrThen(opt2);
+        Assert.True(result.IsSome);
+        Assert.Equal(10, result.Unwrap());
+    }
+
     [Fact]
     public void Where_ReturnsNone_WhenOptionIsNone()
     {