(GH-123) Implicit operators added for Maybe and MaybeStruct.

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]

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]

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>

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>