diff --git a/Sagitta.sln b/Sagitta.sln
index 8ec1eb9..5d4207b 100644
--- a/Sagitta.sln
+++ b/Sagitta.sln
@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 17
-VisualStudioVersion = 17.8.34322.80
+VisualStudioVersion = 17.8.34330.188
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Core", "Core", "{D4223882-8D25-49B3-9299-A680AFD6D275}"
 EndProject
diff --git a/source/Monads/Result.cs b/source/Monads/Result.cs
index 997af58..ee615b0 100644
--- a/source/Monads/Result.cs
+++ b/source/Monads/Result.cs
@@ -20,6 +20,23 @@ public static Result<TSuccess, TFailure> Ensure<TSuccess, TFailure>(TSuccess? su
 			? Fail<TSuccess, TFailure>(failure)
 			: Succeed<TSuccess, TFailure>(success);
 
+	/// <summary>Creates a new failed result if <paramref name="success"/> is <see langword="null"/>; otherwise, creates a new successful result.</summary>
+	/// <typeparam name="TSuccess">Type of expected success.</typeparam>
+	/// <typeparam name="TFailure">Type of possible failure.</typeparam>
+	/// <param name="success">The expected success.</param>
+	/// <param name="createFailure">
+	///     <para>Creates the possible failure.</para>
+	///     <para>If <paramref name="createFailure"/> is <see langword="null"/> or its value is <see langword="null"/>, <seealso cref="ArgumentNullException"/> will be thrown.</para>
+	/// </param>
+	/// <returns>A new failed result if <paramref name="success"/> is <see langword="null"/>; otherwise, a new successful result.</returns>
+	///	<exception cref="ArgumentNullException"/>
+	public static Result<TSuccess, TFailure> Ensure<TSuccess, TFailure>(TSuccess? success, Func<TFailure> createFailure)
+		where TSuccess : notnull
+		where TFailure : notnull
+		=> success is null
+			? Fail<TSuccess, TFailure>(createFailure)
+			: Succeed<TSuccess, TFailure>(success);
+
 	/// <summary>Creates a new failed result if the value of <paramref name="createSuccess"/> throws <typeparamref name="TException"/>; otherwise, creates a new successful result.</summary>
 	/// <typeparam name="TException">Type of possible exception.</typeparam>
 	/// <typeparam name="TSuccess">Type of expected success.</typeparam>
diff --git a/test/unit/Monads/ResultTest.cs b/test/unit/Monads/ResultTest.cs
index 8d0168e..9fbf426 100644
--- a/test/unit/Monads/ResultTest.cs
+++ b/test/unit/Monads/ResultTest.cs
@@ -14,6 +14,8 @@ public sealed class ResultTest
 
 	#region Ensure
 
+	#region Overload No. 01
+
 	[Fact]
 	[Trait(root, ensure)]
 	public void Ensure_NullSuccessPlusNullFailure_ArgumentNullException()
@@ -61,6 +63,73 @@ public void Ensure_SuccessPlusFailure_SuccessfulResult()
 
 	#endregion
 
+	#region Overload No. 02
+
+	[Fact]
+	[Trait(root, ensure)]
+	public void Ensure_NullSuccessPlusNullCreateFailure_ArgumentNullException()
+	{
+		//Arrange
+		const string success = null!;
+		const Func<string> createFailure = null!;
+
+		//Act
+		ArgumentNullException? actualException = ExceptionHandler.Catch<ArgumentNullException>(static () => _ = Result.Ensure(success, createFailure));
+
+		//Assert
+		ArgumentNullExceptionAsserter.AreEqualParameterNames(nameof(createFailure), actualException);
+	}
+
+	[Fact]
+	[Trait(root, ensure)]
+	public void Ensure_NullSuccessPlusCreateFailureWithNullValue_ArgumentNullException()
+	{
+		//Arrange
+		const string success = null!;
+		Func<string> createFailure = static () => null!;
+
+		//Act
+		ArgumentNullException? actualException = ExceptionHandler.Catch<ArgumentNullException>(() => _ = Result.Ensure(success, createFailure));
+
+		//Assert
+		ArgumentNullExceptionAsserter.AreEqualParameterNames(nameof(createFailure), actualException);
+	}
+
+	[Fact]
+	[Trait(root, ensure)]
+	public void Ensure_NullSuccessPlusCreateFailure_FailedResult()
+	{
+		//Arrange
+		const string? success = null;
+		const string expectedFailure = ResultFixture.Failure;
+		Func<string> createFailure = static () => expectedFailure;
+
+		//Act
+		Result<string, string> actualResult = Result.Ensure(success, createFailure);
+
+		//Assert
+		ResultAsserter.AreFailed(expectedFailure, actualResult);
+	}
+
+	[Fact]
+	[Trait(root, ensure)]
+	public void Ensure_SuccessPlusCreateFailure_SuccessfulResult()
+	{
+		//Arrange
+		const string expectedSuccess = ResultFixture.Success;
+		Func<string> createFailure = static () => ResultFixture.Failure;
+
+		//Act
+		Result<string, string> actualResult = Result.Ensure(expectedSuccess, createFailure);
+
+		//Assert
+		ResultAsserter.AreSuccessful(expectedSuccess, actualResult);
+	}
+
+	#endregion
+
+	#endregion
+
 	#region Catch
 
 	[Fact]