From 33dece6af302c007d88d5920da8e1f0b12edaca2 Mon Sep 17 00:00:00 2001
From: Stefan Lindegger <stefan.lindegger@bbtsoftware.ch>
Date: Sat, 31 Dec 2022 16:30:13 +0100
Subject: [PATCH] implicit operators added for Maybe and MaybeStruct.

---
 .../MaybeStructTests.cs                       | 32 ++++++++++++++++++-
 src/BBT.MaybePattern.Tests/MaybeTests.cs      | 30 +++++++++++++++++
 src/BBT.MaybePattern/Maybe.cs                 |  6 ++++
 src/BBT.MaybePattern/MaybeStruct.cs           |  6 ++++
 4 files changed, 73 insertions(+), 1 deletion(-)

diff --git a/src/BBT.MaybePattern.Tests/MaybeStructTests.cs b/src/BBT.MaybePattern.Tests/MaybeStructTests.cs
index 1a2648f..96990f2 100644
--- a/src/BBT.MaybePattern.Tests/MaybeStructTests.cs
+++ b/src/BBT.MaybePattern.Tests/MaybeStructTests.cs
@@ -297,7 +297,7 @@ public void Should_Return_False_If_Input_Is_Not_Of_Same_Type()
             {
                 // Arrange
                 var maybe = Maybe.NoneStruct<BaseStruct>();
-                var otherType = new BaseStruct();
+                var otherType = new ReferencedStruct();
 
                 // Act
                 var isEqual = maybe.Equals(otherType);
@@ -446,6 +446,36 @@ public void Should_Return_True_If_One_Is_Some_And_Other_Is_None_Maybe()
             }
         }
 
+        public sealed class TheImplicitOperator
+        {
+            [Fact]
+            public void Should_Return_Some_MaybeStruct_If_Assigned_With_Some_Struct()
+            {
+                // Arrange
+                var someStruct = new BaseStruct();
+
+                // Act
+                MaybeStruct<BaseStruct> maybeSomeStruct = someStruct;
+
+                // Assert
+                maybeSomeStruct.ShouldBeOfType<MaybeStruct<BaseStruct>>();
+                maybeSomeStruct.HasValue.ShouldBeTrue();
+                maybeSomeStruct.ValueOrException().ShouldBe(someStruct);
+            }
+
+            [Fact]
+            public void Should_Return_None_Maybe_If_Assigned_With_Null()
+            {
+                // Act
+                MaybeStruct<BaseStruct> maybeNone = null;
+
+                // Assert
+                maybeNone.ShouldBeOfType<MaybeStruct<BaseStruct>>();
+                maybeNone.HasValue.ShouldBeFalse();
+                maybeNone.ShouldBe(Maybe.NoneStruct<BaseStruct>());
+            }
+        }
+
         public sealed class TheGetHashCodeMethod
         {
             [Fact]
diff --git a/src/BBT.MaybePattern.Tests/MaybeTests.cs b/src/BBT.MaybePattern.Tests/MaybeTests.cs
index 6ab508c..74b5f3c 100644
--- a/src/BBT.MaybePattern.Tests/MaybeTests.cs
+++ b/src/BBT.MaybePattern.Tests/MaybeTests.cs
@@ -485,6 +485,36 @@ public void Should_Return_True_If_One_Is_Some_And_Other_Is_None_Maybe()
             }
         }
 
+        public sealed class TheImplicitOperator
+        {
+            [Fact]
+            public void Should_Return_Some_Maybe_If_Assigned_With_Some()
+            {
+                // Arrange
+                var some = new BaseClass();
+
+                // Act
+                Maybe<BaseClass> maybeSome = some;
+
+                // Assert
+                maybeSome.ShouldBeOfType<Maybe<BaseClass>>();
+                maybeSome.HasValue.ShouldBeTrue();
+                maybeSome.ValueOrException().ShouldBe(some);
+            }
+
+            [Fact]
+            public void Should_Return_None_Maybe_If_Assigned_With_Null()
+            {
+                // Act
+                Maybe<BaseClass> maybeNone = null;
+
+                // Assert
+                maybeNone.ShouldBeOfType<Maybe<BaseClass>>();
+                maybeNone.HasValue.ShouldBeFalse();
+                maybeNone.ShouldBe(Maybe.None<BaseClass>());
+            }
+        }
+
         public sealed class TheGetHashCodeMethod
         {
             [Fact]
diff --git a/src/BBT.MaybePattern/Maybe.cs b/src/BBT.MaybePattern/Maybe.cs
index cb02d0e..dd74124 100644
--- a/src/BBT.MaybePattern/Maybe.cs
+++ b/src/BBT.MaybePattern/Maybe.cs
@@ -43,6 +43,12 @@ internal Maybe(SerializationInfo info, StreamingContext context)
         /// </summary>
         public bool HasValue => this.value != null;
 
+        /// <summary>
+        /// Implicit conversion from reference type to maybe.
+        /// </summary>
+        /// <param name="value">the reference type object or null.</param>
+        public static implicit operator Maybe<T>(T value) => new Maybe<T>(value);
+
         /// <summary>
         /// Checks whether the operands are equal.
         /// </summary>
diff --git a/src/BBT.MaybePattern/MaybeStruct.cs b/src/BBT.MaybePattern/MaybeStruct.cs
index f37f31d..52777d6 100644
--- a/src/BBT.MaybePattern/MaybeStruct.cs
+++ b/src/BBT.MaybePattern/MaybeStruct.cs
@@ -43,6 +43,12 @@ internal MaybeStruct(SerializationInfo info, StreamingContext context)
         /// </summary>
         public bool HasValue => this.value.HasValue;
 
+        /// <summary>
+        /// Implicit conversion from struct to maybe.
+        /// </summary>
+        /// <param name="value">the struct or null.</param>
+        public static implicit operator MaybeStruct<T>(T? value) => new MaybeStruct<T>(value);
+
         /// <summary>
         /// Checks whether the operands are equal.
         /// </summary>