From 043228dddfa9f30b46b6b74f6d3b915857b53beb Mon Sep 17 00:00:00 2001
From: Gregory Nickonov <gregory@digillect.ru>
Date: Sun, 7 Dec 2025 22:40:01 +0300
Subject: [PATCH] feat: Add `MapError` method for transforming errors in
 `Result<T>`

- Introduce `MapError` to `Result<T>` for converting errors using a mapping function.
- Add async `MapError` extension in `TaskResultExtensions` for handling errors in asynchronous contexts.
---
 src/Digillect.FP.Types/Result.cs               | 17 +++++++++++++++++
 src/Digillect.FP.Types/TaskResultExtensions.cs | 15 +++++++++++++++
 2 files changed, 32 insertions(+)

diff --git a/src/Digillect.FP.Types/Result.cs b/src/Digillect.FP.Types/Result.cs
index d0bb284..4e2b4d9 100644
--- a/src/Digillect.FP.Types/Result.cs
+++ b/src/Digillect.FP.Types/Result.cs
@@ -120,6 +120,23 @@ public async Task<Result<TResult>> MapAsync<TResult>(Func<T, Task<TResult>> map)
 		return Result.Success(result);
 	}
 
+	/// <summary>
+	/// Converts the error of the current result into a new error using the specified mapping function.
+	/// </summary>
+	/// <param name="mapError">A function to transform the current error into a new error.</param>
+	/// <returns>A result with the current value and the transformed error.</returns>
+	public Result<T> MapError(Func<Error, Error> mapError)
+	{
+		if (_error is null)
+		{
+			return this;
+		}
+
+		var error = mapError(_error);
+
+		return Result.Error<T>(error);
+	}
+
 	/// <summary>
 	/// Chains the successful result to another operation that returns a <see cref="Result{TResult}"/> using the provided binding function.
 	/// </summary>
diff --git a/src/Digillect.FP.Types/TaskResultExtensions.cs b/src/Digillect.FP.Types/TaskResultExtensions.cs
index cc74fdb..ca97593 100644
--- a/src/Digillect.FP.Types/TaskResultExtensions.cs
+++ b/src/Digillect.FP.Types/TaskResultExtensions.cs
@@ -53,6 +53,21 @@ public static async Task<Result<TResult>> Map<T, TResult>(this Task<Result<T>> r
 		return awaitedResult.Map(map);
 	}
 
+	/// <summary>
+	/// Maps an error from a failed <see cref="Result{T}"/> into a new <see cref="Result{T}"/> with the transformed error value.
+	/// </summary>
+	/// <typeparam name="T">The type of the value contained in the original result.</typeparam>
+	/// <param name="result">The original result to map the error from.</param>
+	/// <param name="mapError">A function to transform the error from the original result to the new error type.</param>
+	/// <returns>
+	/// A new <see cref="Result{T}"/> that contains either the original success value or the transformed error.
+	/// </returns>
+	public static async Task<Result<T>> MapError<T>(this Task<Result<T>> result, Func<Error, Error> mapError)
+	{
+		var awaitedResult = await result.ConfigureAwait(false);
+		return awaitedResult.MapError(mapError);
+	}
+
 	/// <summary>
 	/// Transforms the success value of the current asynchronous <see cref="Result{T}"/> instance using the specified
 	/// asynchronous mapping function <paramref name="map"/>.