feat: Add implicit conversion from value to Result<T> (#47)

src/Core/ResultOfT.cs

@@ -1,4 +1,6 @@
-namespace SimpleResults;
+using SimpleResults.Resources;
+
+namespace SimpleResults;
 
 /// <summary>
 /// Represents the result of an operation that returns a value.
@@ -26,4 +28,18 @@ public sealed class Result<T> : ResultBase
     /// <param name="result">An instance of type <see cref="Result"/>.</param>
     public static implicit operator Result<T>(Result result) 
         => result.ToResult(default(T));
+
+    /// <summary>
+    /// Converts the value of type <typeparamref name="T"/> to an instance of type <see cref="Result{T}"/>.
+    /// </summary>
+    /// <param name="value">
+    /// An instance of type <typeparamref name="T"/> that represents the value.
+    /// </param>
+    public static implicit operator Result<T>(T value) => new() 
+    { 
+        IsSuccess = true,
+        Data = value,
+        Message = ResponseMessages.Success,
+        Status = ResultStatus.Ok
+    };
 }

tests/Core/ResultOfT.Tests.cs

@@ -37,4 +37,27 @@ public void ImplicitOperator_WhenConvertedFromResultType_ShouldReturnsResultOfT(
         actual.Errors.Should().BeEmpty();
         actual.Status.Should().Be(ResultStatus.NotFound);
     }
+
+    [Test]
+    public void ImplicitOperator_WhenConvertedFromValueOfT_ShouldReturnsResultOfT()
+    {
+        // Arrange
+        var expectedValue = new List<Person>
+        {
+            new() { Name = "Bob" },
+            new() { Name = "Alice" }
+        };
+        var expectedMessage = ResponseMessages.Success;
+
+        // Act
+        Result<List<Person>> actual = expectedValue;
+
+        // Asserts
+        actual.Data.Should().BeEquivalentTo(expectedValue);
+        actual.IsSuccess.Should().BeTrue();
+        actual.IsFailed.Should().BeFalse();
+        actual.Message.Should().Be(expectedMessage);
+        actual.Errors.Should().BeEmpty();
+        actual.Status.Should().Be(ResultStatus.Ok);
+    }
 }