Merge pull request #2 from mrxrsd/feature/implicit-conversions

feat: implicit conversions

Author: mrxrsd

README.md

@@ -344,7 +344,27 @@ Bespoke errors provide several benefits:
 
 ## Implicit Conversions
 
-ARPL supports implicit conversions between `Either<Error,R>` and `SResult<R>`, making it seamless to work with both types:
+ARPL supports several implicit conversions to make your code more concise and readable.
+
+### Either from Base Types
+
+You can create an `Either<L, R>` instance directly from values of type `L` or `R`:
+
+```csharp
+// Implicitly create a Right-sided Either
+Either<string, int> success = 42;
+
+// Implicitly create a Left-sided Either
+Either<string, int> error = "Something went wrong";
+
+// This is equivalent to:
+var successExplicit = Either<string, int>.Right(42);
+var errorExplicit = Either<string, int>.Left("Something went wrong");
+```
+
+### Between `Either<Error,R>` and `SResult<R>`
+
+ARPL also supports seamless conversion between `Either<Error,R>` and `SResult<R>`:
 
 ```csharp
 // Convert from Either to SResult
@@ -356,7 +376,7 @@ SResult<int> sresult = SResult<int>.Success(42);
 Either<Error, int> converted = sresult; // Implicit conversion
 ```
 
-> **Note:** The implicit conversion only works for `Either<Error, R>` and `SResult<R>`. Attempting to convert other types will throw an exception.
+> **Note:** The implicit conversion between `Either` and `SResult` only works for `Either<Error, R>`. Attempting to convert other `Either` types will result in a compile-time error or throw an exception.
 
 ## StaticFactory Helpers
 

arpl.tests/Core/EitherTests.cs

@@ -66,5 +66,34 @@ public void ImplicitConversion_ToSResult_PreservesLeft()
             Assert.True(result.IsFail);
             Assert.Equal(error, result.ErrorValue);
         }
+
+
+        [Fact(DisplayName = "Implicit Conversion - To Either preserves Left value")]
+        public void ImplicitConversion_ToEither_PreservesLeft()
+        {
+            // Arrange
+            var error = Errors.New("Test error");
+            
+            // Act
+            Either<Error,string> result = error;
+
+            // Assert
+            Assert.True(result.IsLeft);
+            Assert.Equal(error, result.LeftValue);
+        }
+
+        [Fact(DisplayName = "Implicit Conversion - To Either preserves Right value")]
+        public void ImplicitConversion_ToEither_PreservesRight()
+        {
+            // Arrange
+            var value = "abc";
+
+            // Act
+            Either<Error, string> result = value;
+
+            // Assert
+            Assert.True(result.IsRight);
+            Assert.Equal(value, result.RightValue);
+        }
     }
 }

arpl/core/Either.cs

@@ -85,6 +85,19 @@ public EitherRight(R value)
         /// <returns>A new Either instance representing a right value.</returns>
         public static Either<L, R> Right(R value) => new EitherRight<L, R>(value);
 
+        /// <summary>
+        /// Implicitly converts a Left value to an Either
+        /// </summary>
+        /// <param name="left"></param>
+        public static implicit operator Either<L,R>(L left) => Either<L, R>.Left(left);
+
+        /// <summary>
+        /// Implicitly converts a Left value to an Either
+        /// </summary>
+        /// <param name="left"></param>
+        public static implicit operator Either<L, R>(R right) => Either<L, R>.Right(right);
+
+
         /// <summary>
         /// Implicitly converts an Either type to an SResult when the left type is Error.
         /// </summary>