feature: reverse from Result<TFailure, TSuccess> to Result<TSuccess, TFailure>

source/Monads/Result.cs

@@ -1,29 +1,29 @@
 namespace Daht.Sagitta.Core.Monads;
 
-/// <summary>Reference point to initialize <see cref="Result{TFailure, TSuccess}"/>.</summary>
+/// <summary>Reference point to initialize <see cref="Result{TSuccess, TFailure}"/>.</summary>
 public static class Result
 {
 	/// <summary>Creates a new failed result if <paramref name="success"/> is <see langword="null"/>; otherwise, creates a new successful result.</summary>
-	/// <typeparam name="TFailure">Type of possible failure.</typeparam>
 	/// <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="failure">
 	///		<para>The possible failure.</para>
 	///     <para>If <paramref name="failure"/> 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<TFailure, TSuccess> Ensure<TFailure, TSuccess>(TSuccess? success, TFailure failure)
-		where TFailure : notnull
+	public static Result<TSuccess, TFailure> Ensure<TSuccess, TFailure>(TSuccess? success, TFailure failure)
 		where TSuccess : notnull
+		where TFailure : notnull
 		=> success is null
-			? Fail<TFailure, TSuccess>(failure)
-			: Succeed<TFailure, TSuccess>(success);
+			? Fail<TSuccess, TFailure>(failure)
+			: 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="TFailure">Type of possible failure.</typeparam>
 	/// <typeparam name="TSuccess">Type of expected success.</typeparam>
+	/// <typeparam name="TFailure">Type of possible failure.</typeparam>
 	/// <param name="createSuccess">
 	///		<para>Creates the expected success.</para>
 	///     <para>If <paramref name="createSuccess"/> is <see langword="null"/> or its value is <see langword="null"/>, <seealso cref="ArgumentNullException"/> will be thrown.</para>
@@ -34,129 +34,129 @@ public static Result<TFailure, TSuccess> Ensure<TFailure, TSuccess>(TSuccess? su
 	/// </param>
 	/// <returns>A new failed result if the value of <paramref name="createSuccess"/> throws <typeparamref name="TException"/>; otherwise, a new successful result.</returns>
 	/// <exception cref="ArgumentNullException"/>
-	public static Result<TFailure, TSuccess> Catch<TException, TFailure, TSuccess>(Func<TSuccess> createSuccess, Func<TException, TFailure> createFailure)
+	public static Result<TSuccess, TFailure> Catch<TException, TSuccess, TFailure>(Func<TSuccess> createSuccess, Func<TException, TFailure> createFailure)
 		where TException : Exception
-		where TFailure : notnull
 		where TSuccess : notnull
+		where TFailure : notnull
 	{
 		try
 		{
-			return Succeed<TFailure, TSuccess>(createSuccess);
+			return Succeed<TSuccess, TFailure>(createSuccess);
 		}
 		catch (TException exception)
 		{
 			ArgumentNullException.ThrowIfNull(createFailure);
 			TFailure failure = createFailure(exception) ?? throw new ArgumentNullException(nameof(createFailure));
-			return Fail<TFailure, TSuccess>(failure);
+			return Fail<TSuccess, TFailure>(failure);
 		}
 	}
 
-	/// <summary>Creates a new failed result.</summary>
-	/// <typeparam name="TFailure">Type of possible failure.</typeparam>
-	/// <typeparam name="TSuccess">Type of expected success.</typeparam>
-	/// <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.</returns>
-	/// <exception cref="ArgumentNullException"/>
-	public static Result<TFailure, TSuccess> Fail<TFailure, TSuccess>(Func<TFailure> createFailure)
-		where TFailure : notnull
-		where TSuccess : notnull
-	{
-		ArgumentNullException.ThrowIfNull(createFailure);
-		TFailure failure = createFailure() ?? throw new ArgumentNullException(nameof(createFailure));
-		return Fail<TFailure, TSuccess>(failure);
-	}
-
-	/// <summary>Creates a new failed result.</summary>
-	/// <typeparam name="TFailure">Type of possible failure.</typeparam>
-	/// <typeparam name="TSuccess">Type of expected success.</typeparam>
-	/// <param name="failure">
-	///     <para>The possible failure.</para>
-	///     <para>If <paramref name="failure"/> is <see langword="null"/>, <seealso cref="ArgumentNullException"/> will be thrown.</para>
-	/// </param>
-	/// <returns>A new failed result.</returns>
-	/// <exception cref="ArgumentNullException"/>
-	public static Result<TFailure, TSuccess> Fail<TFailure, TSuccess>(TFailure failure)
-		where TFailure : notnull
-		where TSuccess : notnull
-		=> failure is null
-			? throw new ArgumentNullException(nameof(failure))
-			: new Result<TFailure, TSuccess>()
-			{
-				IsFailed = true,
-				Failure = failure
-			};
-
 	/// <summary>Creates a new successful result.</summary>
-	/// <typeparam name="TFailure">Type of possible failure.</typeparam>
 	/// <typeparam name="TSuccess">Type of expected success.</typeparam>
+	/// <typeparam name="TFailure">Type of possible failure.</typeparam>
 	/// <param name="createSuccess">
 	///     <para>Creates the expected success.</para>
 	///     <para>If <paramref name="createSuccess"/> is <see langword="null"/> or its value is <see langword="null"/>, <seealso cref="ArgumentNullException"/> will be thrown.</para>
 	/// </param>
 	/// <returns>A new successful result.</returns>
 	/// <exception cref="ArgumentNullException"/>
-	public static Result<TFailure, TSuccess> Succeed<TFailure, TSuccess>(Func<TSuccess> createSuccess)
-		where TFailure : notnull
+	public static Result<TSuccess, TFailure> Succeed<TSuccess, TFailure>(Func<TSuccess> createSuccess)
 		where TSuccess : notnull
+		where TFailure : notnull
 	{
 		ArgumentNullException.ThrowIfNull(createSuccess);
 		TSuccess success = createSuccess() ?? throw new ArgumentNullException(nameof(createSuccess));
-		return Succeed<TFailure, TSuccess>(success);
+		return Succeed<TSuccess, TFailure>(success);
 	}
 
 	/// <summary>Creates a new successful result.</summary>
-	/// <typeparam name="TFailure">Type of possible failure.</typeparam>
 	/// <typeparam name="TSuccess">Type of expected success.</typeparam>
+	/// <typeparam name="TFailure">Type of possible failure.</typeparam>
 	/// <param name="success">
 	///		<para>The expected success.</para>
 	///     <para>If <paramref name="success"/> is <see langword="null"/>, <seealso cref="ArgumentNullException"/> will be thrown.</para>
 	/// </param>
 	/// <returns>A new successful result.</returns>
 	/// <exception cref="ArgumentNullException"/>
-	public static Result<TFailure, TSuccess> Succeed<TFailure, TSuccess>(TSuccess success)
-		where TFailure : notnull
+	public static Result<TSuccess, TFailure> Succeed<TSuccess, TFailure>(TSuccess success)
 		where TSuccess : notnull
+		where TFailure : notnull
 		=> success is null
 			? throw new ArgumentNullException(nameof(success))
-			: new Result<TFailure, TSuccess>()
+			: new Result<TSuccess, TFailure>()
 			{
 				IsSuccessful = true,
 				Success = success
 			};
+
+	/// <summary>Creates a new failed result.</summary>
+	/// <typeparam name="TSuccess">Type of expected success.</typeparam>
+	/// <typeparam name="TFailure">Type of possible failure.</typeparam>
+	/// <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.</returns>
+	/// <exception cref="ArgumentNullException"/>
+	public static Result<TSuccess, TFailure> Fail<TSuccess, TFailure>(Func<TFailure> createFailure)
+		where TSuccess : notnull
+		where TFailure : notnull
+	{
+		ArgumentNullException.ThrowIfNull(createFailure);
+		TFailure failure = createFailure() ?? throw new ArgumentNullException(nameof(createFailure));
+		return Fail<TSuccess, TFailure>(failure);
+	}
+
+	/// <summary>Creates a new failed result.</summary>
+	/// <typeparam name="TSuccess">Type of expected success.</typeparam>
+	/// <typeparam name="TFailure">Type of possible failure.</typeparam>
+	/// <param name="failure">
+	///     <para>The possible failure.</para>
+	///     <para>If <paramref name="failure"/> is <see langword="null"/>, <seealso cref="ArgumentNullException"/> will be thrown.</para>
+	/// </param>
+	/// <returns>A new failed result.</returns>
+	/// <exception cref="ArgumentNullException"/>
+	public static Result<TSuccess, TFailure> Fail<TSuccess, TFailure>(TFailure failure)
+		where TSuccess : notnull
+		where TFailure : notnull
+		=> failure is null
+			? throw new ArgumentNullException(nameof(failure))
+			: new Result<TSuccess, TFailure>()
+			{
+				IsFailed = true,
+				Failure = failure
+			};
 }
 
-/// <summary>Type that encapsulates both the possible failure and the expected success of a given action</summary>
-///	<typeparam name="TFailure">Type of possible failure.</typeparam>
+/// <summary>Type that encapsulates both the expected success and the possible failure of a given action.</summary>
 /// <typeparam name="TSuccess">Type of expected success.</typeparam>
-public readonly record struct Result<TFailure, TSuccess>
-	where TFailure : notnull
+///	<typeparam name="TFailure">Type of possible failure.</typeparam>
+public readonly record struct Result<TSuccess, TFailure>
 	where TSuccess : notnull
+	where TFailure : notnull
 {
-	/// <summary>Indicates whether the status is failed or <see langword="default"/>.</summary>
-	public bool IsFailedOrDefault => IsFailed || IsDefault;
-
 	/// <summary>Indicates whether the status is successful or <see langword="default"/>.</summary>
 	public bool IsSuccessfulOrDefault => IsSuccessful || IsDefault;
 
+	/// <summary>Indicates whether the status is failed or <see langword="default"/>.</summary>
+	public bool IsFailedOrDefault => IsFailed || IsDefault;
+
 	/// <summary>Indicates whether the status is <see langword="default"/>.</summary>
 	public bool IsDefault => this is
 	{
-		IsFailed: false,
-		IsSuccessful: false
+		IsSuccessful: false,
+		IsFailed: false
 	};
 
-	/// <summary>Indicates whether the status is failed.</summary>
-	public bool IsFailed { get; internal init; }
-
-	/// <summary>The possible failure.</summary>
-	public TFailure Failure { get; internal init; }
-
 	/// <summary>Indicates whether the status is successful.</summary>
 	public bool IsSuccessful { get; internal init; }
 
 	/// <summary>The expected success.</summary>
 	public TSuccess Success { get; internal init; }
+
+	/// <summary>Indicates whether the status is failed.</summary>
+	public bool IsFailed { get; internal init; }
+
+	/// <summary>The possible failure.</summary>
+	public TFailure Failure { get; internal init; }
 }

test/unit/Monads/Asserters/ResultAsserter.cs

@@ -2,29 +2,29 @@ namespace Daht.Sagitta.Core.UnitTest.Monads.Asserters;
 
 internal static class ResultAsserter
 {
-	internal static void AreFailed<TFailure, TSuccess>(TFailure expectedFailure, Result<TFailure, TSuccess> actualResult)
-		where TFailure : notnull
+	internal static void AreSuccessful<TSuccess, TFailure>(TSuccess expectedSuccess, Result<TSuccess, TFailure> actualResult)
 		where TSuccess : notnull
+		where TFailure : notnull
 	{
-		Assert.True(actualResult.IsFailedOrDefault);
-		Assert.False(actualResult.IsSuccessfulOrDefault);
+		Assert.True(actualResult.IsSuccessfulOrDefault);
+		Assert.False(actualResult.IsFailedOrDefault);
 		Assert.False(actualResult.IsDefault);
-		Assert.True(actualResult.IsFailed);
-		Assert.Equal(expectedFailure, actualResult.Failure);
-		Assert.False(actualResult.IsSuccessful);
-		Assert.Equal(default, actualResult.Success);
+		Assert.True(actualResult.IsSuccessful);
+		Assert.Equal(expectedSuccess, actualResult.Success);
+		Assert.False(actualResult.IsFailed);
+		Assert.Equal(default, actualResult.Failure);
 	}
 
-	internal static void AreSuccessful<TFailure, TSuccess>(TSuccess expectedSuccess, Result<TFailure, TSuccess> actualResult)
-		where TFailure : notnull
+	internal static void AreFailed<TSuccess, TFailure>(TFailure expectedFailure, Result<TSuccess, TFailure> actualResult)
 		where TSuccess : notnull
+		where TFailure : notnull
 	{
-		Assert.False(actualResult.IsFailedOrDefault);
-		Assert.True(actualResult.IsSuccessfulOrDefault);
+		Assert.False(actualResult.IsSuccessfulOrDefault);
+		Assert.True(actualResult.IsFailedOrDefault);
 		Assert.False(actualResult.IsDefault);
-		Assert.False(actualResult.IsFailed);
-		Assert.Equal(default, actualResult.Failure);
-		Assert.True(actualResult.IsSuccessful);
-		Assert.Equal(expectedSuccess, actualResult.Success);
+		Assert.False(actualResult.IsSuccessful);
+		Assert.Equal(default, actualResult.Success);
+		Assert.True(actualResult.IsFailed);
+		Assert.Equal(expectedFailure, actualResult.Failure);
 	}
 }

test/unit/Monads/Fixtures/ResultFixture.cs

@@ -2,7 +2,7 @@ namespace Daht.Sagitta.Core.UnitTest.Monads.Fixtures;
 
 internal static class ResultFixture
 {
-	internal const string Failure = nameof(Failure);
-
 	internal const string Success = nameof(Success);
+
+	internal const string Failure = nameof(Failure);
 }