From 567a22fb2c7b9b5a651a1829363cc8fbc2e140dc Mon Sep 17 00:00:00 2001
From: DrPepperBianco <11694093+DrPepperBianco@users.noreply.github.com>
Date: Tue, 22 Aug 2023 11:24:41 +0200
Subject: [PATCH 1/5] Added extension methods for IResultBase and
 IResult<TValue>

Theses changes allow to do fluent syntax when working
with the interface types instead of the explicit types.

The ceveat is, that because these methods always create
a new Result object, we might lose the covariance here.
---
 .../Extensions/ResultExtensions.cs            | 409 ++++++++++++++++++
 1 file changed, 409 insertions(+)

diff --git a/src/FluentResults/Extensions/ResultExtensions.cs b/src/FluentResults/Extensions/ResultExtensions.cs
index f11dfbe..0d4fcc4 100644
--- a/src/FluentResults/Extensions/ResultExtensions.cs
+++ b/src/FluentResults/Extensions/ResultExtensions.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using System.Threading.Tasks;
 
 namespace FluentResults.Extensions
@@ -148,5 +149,413 @@ public static async Task<Result<TValue>> ToResult<TValue>(this ValueTask<Result>
             var result = await resultTask;
             return result.ToResult(value);
         }
+
+        #region Interfaces
+
+        public static async Task<IResultBase> MapErrors(this Task<IResultBase> resultTask, Func<IError, IError> errorMapper)
+        {
+            var result = await resultTask;
+            return result.MapErrors(errorMapper);
+        }
+
+        public static async ValueTask<IResultBase> MapErrors(this ValueTask<IResultBase> resultTask, Func<IError, IError> errorMapper)
+        {
+            var result = await resultTask;
+            return result.MapErrors(errorMapper);
+        }
+
+        public static async Task<IResult<T>> MapErrors<T>(this Task<IResult<T>> resultTask, Func<IError, IError> errorMapper)
+        {
+            var result = await resultTask;
+            return result.MapErrors(errorMapper);
+        }
+
+        public static async ValueTask<IResult<T>> MapErrors<T>(this ValueTask<IResult<T>> resultTask, Func<IError, IError> errorMapper)
+        {
+            var result = await resultTask;
+            return result.MapErrors(errorMapper);
+        }
+
+        public static async Task<IResultBase> MapSuccesses(this Task<IResultBase> resultTask, Func<ISuccess, ISuccess> errorMapper)
+        {
+            var result = await resultTask;
+            return result.MapSuccesses(errorMapper);
+        }
+
+        public static async ValueTask<IResultBase> MapSuccesses(this ValueTask<IResultBase> resultTask, Func<ISuccess, ISuccess> errorMapper)
+        {
+            var result = await resultTask;
+            return result.MapSuccesses(errorMapper);
+        }
+
+        public static async Task<IResult<T>> MapSuccesses<T>(this Task<IResult<T>> resultTask, Func<ISuccess, ISuccess> errorMapper)
+        {
+            var result = await resultTask;
+            return result.MapSuccesses(errorMapper);
+        }
+
+        public static async ValueTask<IResult<T>> MapSuccesses<T>(this ValueTask<IResult<T>> resultTask, Func<ISuccess, ISuccess> errorMapper)
+        {
+            var result = await resultTask;
+            return result.MapSuccesses(errorMapper);
+        }
+
+        public static async Task<IResult<TNew>> Bind<TOld, TNew>(this Task<IResult<TOld>> resultTask, Func<TOld, Task<IResult<TNew>>> bind)
+        {
+            var result = await resultTask;
+            return await result.Bind(bind);
+        }
+
+        public static async ValueTask<IResult<TNew>> Bind<TOld, TNew>(this ValueTask<IResult<TOld>> resultTask, Func<TOld, ValueTask<IResult<TNew>>> bind)
+        {
+            var result = await resultTask;
+            return await result.Bind(bind);
+        }
+
+        public static async Task<IResult<TNew>> Bind<TOld, TNew>(this Task<IResult<TOld>> resultTask, Func<TOld, IResult<TNew>> bind)
+        {
+            var result = await resultTask;
+            return result.Bind(bind);
+        }
+
+        public static async ValueTask<IResult<TNew>> Bind<TOld, TNew>(this ValueTask<IResult<TOld>> resultTask, Func<TOld, IResult<TNew>> bind)
+        {
+            var result = await resultTask;
+            return result.Bind(bind);
+        }
+
+        public static async Task<IResultBase> Bind<TOld>(this Task<IResult<TOld>> resultTask, Func<TOld, Task<IResultBase>> bind)
+        {
+            var result = await resultTask;
+            return await result.Bind(bind);
+        }
+
+        public static async Task<IResultBase> Bind<TOld>(this Task<IResult<TOld>> resultTask, Func<TOld, IResultBase> bind)
+        {
+            var result = await resultTask;
+            return result.Bind(bind);
+        }
+
+        public static async ValueTask<IResultBase> Bind<TOld>(this ValueTask<IResult<TOld>> resultTask, Func<TOld, IResultBase> bind)
+        {
+            var result = await resultTask;
+            return result.Bind(bind);
+        }
+
+        public static async ValueTask<IResultBase> Bind<TOld>(this ValueTask<IResult<TOld>> resultTask, Func<TOld, ValueTask<IResultBase>> bind)
+        {
+            var result = await resultTask;
+            return await result.Bind(bind);
+        }
+
+        public static async Task<IResult<TNew>> Bind<TNew>(this Task<IResultBase> resultTask, Func<Task<IResult<TNew>>> bind)
+        {
+            var result = await resultTask;
+            return await result.Bind(bind);
+        }
+
+        public static async ValueTask<IResult<TNew>> Bind<TNew>(this ValueTask<IResultBase> resultTask, Func<ValueTask<IResult<TNew>>> bind)
+        {
+            var result = await resultTask;
+            return await result.Bind(bind);
+        }
+
+        public static async Task<IResultBase> Bind(this Task<IResultBase> resultTask, Func<Task<IResultBase>> bind)
+        {
+            var result = await resultTask;
+            return await result.Bind(bind);
+        }
+
+        public static async ValueTask<IResultBase> Bind(this ValueTask<IResultBase> resultTask, Func<ValueTask<IResultBase>> bind)
+        {
+            var result = await resultTask;
+            return await result.Bind(bind);
+        }
+
+        public static async Task<IResult<TNewValue>> Map<TOldValue, TNewValue>(this Task<IResult<TOldValue>> resultTask, Func<TOldValue, TNewValue> valueConverter)
+        {
+            var result = await resultTask;
+            return result.Map(valueConverter);
+        }
+
+        public static async Task<IResult<TNewValue>> Map<TOldValue, TNewValue>(this ValueTask<IResult<TOldValue>> resultTask, Func<TOldValue, TNewValue> valueConverter)
+        {
+            var result = await resultTask;
+            return result.Map(valueConverter);
+        }
+
+        public static async Task<IResult<TValue>> ToResult<TValue>(this Task<IResultBase> resultTask, TValue value)
+        {
+            var result = await resultTask;
+            return result.ToResult(value);
+        }
+
+        public static async Task<IResult<TValue>> ToResult<TValue>(this ValueTask<IResultBase> resultTask, TValue value)
+        {
+            var result = await resultTask;
+            return result.ToResult(value);
+        }
+
+        #endregion
+
+
+        #region Erweiterung: Member von Result für Interface IResultBase
+
+        /// <inheritdoc cref="Result.MapErrors(Func{IError, IError})"/>
+        public static IResultBase MapErrors(this IResultBase result, Func<IError, IError> errorMapper) =>
+            result.IsSuccess 
+                ? result
+                : new Result()
+                    .WithErrors(result.Errors.Select(errorMapper))
+                    .WithSuccesses(result.Successes);
+
+        /// <inheritdoc cref="Result.MapSuccesses(Func{ISuccess, ISuccess})"/>
+        public static IResultBase MapSuccesses(this IResultBase result, Func<ISuccess, ISuccess> successMapper) =>
+            new Result()
+                .WithErrors(result.Errors)
+                .WithSuccesses(result.Successes.Select(successMapper));
+
+        /// <inheritdoc cref="Result.ToResult{TNewValue}(TNewValue)"/>
+        public static IResult<TNewValue> ToResult<TNewValue>(this IResultBase result, TNewValue newValue = default) =>
+            new Result<TNewValue>()
+                .WithValue(result.IsFailed ? default : newValue)
+                .WithReasons(result.Reasons);
+
+        /// <inheritdoc cref="Result.Bind{TNewValue}(Func{Result{TNewValue}})"/>
+        public static IResult<TNewValue> Bind<TNewValue>(this IResultBase result, Func<IResult<TNewValue>> bind)
+        {
+            var out_result = new Result<TNewValue>();
+            out_result.WithReasons(result.Reasons);
+
+            if(result.IsSuccess)
+            {
+                var converted = bind();
+                out_result.WithValue(converted.ValueOrDefault);
+                out_result.WithReasons(converted.Reasons);
+            }
+
+            return out_result;
+        }
+
+        /// <inheritdoc cref="Result.Bind{TNewValue}(Func{Task{Result{TNewValue}}})"/>
+        public static async Task<IResult<TNewValue>> Bind<TNewValue>(this IResultBase result, Func<Task<IResult<TNewValue>>> bind)
+        {
+            var out_result = new Result<TNewValue>();
+            out_result.WithReasons(result.Reasons);
+
+            if(result.IsSuccess)
+            {
+                var converted = await bind();
+                out_result.WithValue(converted.ValueOrDefault);
+                out_result.WithReasons(converted.Reasons);
+            }
+
+            return out_result;
+        }
+
+        /// <inheritdoc cref="Result.Bind{TNewValue}(Func{ValueTask{Result{TNewValue}}})" />
+        public static async ValueTask<IResult<TNewValue>> Bind<TNewValue>(this IResultBase result, Func<ValueTask<IResult<TNewValue>>> bind)
+        {
+            var out_result = new Result<TNewValue>();
+            out_result.WithReasons(result.Reasons);
+
+            if(result.IsSuccess)
+            {
+                var converted = await bind();
+                out_result.WithValue(converted.ValueOrDefault);
+                out_result.WithReasons(converted.Reasons);
+            }
+
+            return out_result;
+        }
+
+        /// <inheritdoc cref="Result.Bind(Func{Result})"/>
+        public static IResultBase Bind(this IResultBase result, Func<IResultBase> action)
+        {
+            var out_result = new Result();
+            out_result.WithReasons(result.Reasons);
+
+            if(result.IsSuccess)
+            {
+                var converted = action();
+                out_result.WithReasons(converted.Reasons);
+            }
+
+            return result;
+        }
+
+        /// <inheritdoc cref="Result.Bind(Func{Task{Result}})"/>
+        public static async Task<IResultBase> Bind(this IResultBase result, Func<Task<IResultBase>> action)
+        {
+            var out_result = new Result();
+            out_result.WithReasons(result.Reasons);
+
+            if(result.IsSuccess)
+            {
+                var converted = await action();
+                out_result.WithReasons(converted.Reasons);
+            }
+
+            return out_result;
+        }
+
+        /// <inheritdoc cref="Result.Bind(Func{ValueTask{Result}})"/>
+        public static async ValueTask<IResultBase> Bind(this IResultBase result, Func<ValueTask<IResultBase>> action)
+        {
+            var out_result = new Result();
+            out_result.WithReasons(result.Reasons);
+
+            if(result.IsSuccess)
+            {
+                var converted = await action();
+                out_result.WithReasons(converted.Reasons);
+            }
+
+            return out_result;
+        }
+
+        #endregion
+
+
+        #region Erweiterung: Member von Result für Interface IResultBase
+
+        /// <inheritdoc cref="Result{TValue}.WithValue(TValue)"/>
+        public static IResult<TValue> WithValue<TValue>(this IResult<TValue> result, TValue value) =>
+            // ℹ️ You would assume immutability on results,
+            //     therefor we first create a copy!
+            new Result<TValue>()
+                .WithReasons(result.Reasons)
+                .WithValue(value);
+
+
+        /// <inheritdoc cref="Result{TValue}.MapErrors(Func{IError, IError})"/>
+        public static IResult<TValue> MapErrors<TValue>(this IResult<TValue> result, Func<IError, IError> errorMapper) =>
+            result.IsSuccess
+                ? result
+                : new Result<TValue>()
+                    .WithErrors(result.Errors.Select(errorMapper))
+                    .WithSuccesses(result.Successes);
+
+        /// <inheritdoc cref="Result{TValue}.MapSuccesses(Func{ISuccess, ISuccess})"/>
+        public static IResult<TValue> MapSuccesses<TValue>(this IResult<TValue> result, Func<ISuccess, ISuccess> successMapper) =>
+            new Result<TValue>()
+                .WithValue(result.ValueOrDefault)
+                .WithErrors(result.Errors)
+                .WithSuccesses(result.Successes.Select(successMapper));
+
+        /// <inheritdoc cref="Result{TValue}.ToResult()"/>
+        public static IResultBase ToResult<TValue>(this IResult<TValue> result) =>
+            new Result()
+                .WithReasons(result.Reasons);
+
+        /// <inheritdoc cref="Result{TValue}.ToResult{TNewValue}(Func{TValue, TNewValue})"/>
+        public static Result<TNewValue> ToResult<TValue, TNewValue>(this IResult<TValue> result, Func<TValue, TNewValue> valueConverter = null) =>
+            Map(result, valueConverter);
+
+        /// <inheritdoc cref="Result{TValue}.Map{TNewValue}(Func{TValue, TNewValue})"/>
+        public static Result<TNewValue> Map<TValue, TNewValue>(this IResult<TValue> result, Func<TValue, TNewValue> mapLogic)
+        {
+            if(result.IsSuccess && mapLogic == null)
+                throw new ArgumentException("If result is success then valueConverter should not be null");
+
+            return new Result<TNewValue>()
+                   .WithValue(result.IsFailed ? default : mapLogic(result.Value))
+                   .WithReasons(result.Reasons);
+        }
+
+        /// <inheritdoc cref="Result{TValue}.Bind{TNewValue}(Func{TValue, Result{TNewValue}})"/>
+        public static Result<TNewValue> Bind<TValue, TNewValue>(this IResult<TValue> result, Func<TValue, IResult<TNewValue>> bind)
+        {
+            var out_result = new Result<TNewValue>();
+            out_result.WithReasons(result.Reasons);
+
+            if(result.IsSuccess)
+            {
+                var converted = bind(result.Value);
+                out_result.WithValue(converted.ValueOrDefault);
+                out_result.WithReasons(converted.Reasons);
+            }
+
+            return out_result;
+        }
+
+        /// <inheritdoc cref="Result{TValue}.Bind{TNewValue}(Func{TValue, Task{Result{TNewValue}}})"/>
+        public static async Task<Result<TNewValue>> Bind<TValue, TNewValue>(this IResult<TValue> result, Func<TValue, Task<IResult<TNewValue>>> bind)
+        {
+            var out_result = new Result<TNewValue>();
+            out_result.WithReasons(result.Reasons);
+
+            if(result.IsSuccess)
+            {
+                var converted = await bind(result.Value);
+                out_result.WithValue(converted.ValueOrDefault);
+                out_result.WithReasons(converted.Reasons);
+            }
+
+            return out_result;
+        }
+
+        /// <inheritdoc cref="Result{TValue}.Bind{TNewValue}(Func{TValue, ValueTask{Result{TNewValue}}})"/>
+        public static async ValueTask<Result<TNewValue>> Bind<TValue, TNewValue>(this IResult<TValue> result, Func<TValue, ValueTask<IResult<TNewValue>>> bind)
+        {
+            var out_result = new Result<TNewValue>();
+            out_result.WithReasons(result.Reasons);
+
+            if(result.IsSuccess)
+            {
+                var converted = await bind(result.Value);
+                out_result.WithValue(converted.ValueOrDefault);
+                out_result.WithReasons(converted.Reasons);
+            }
+
+            return out_result;
+        }
+
+        /// <inheritdoc cref="Result{TValue}.Bind(Func{TValue, Result})"/>
+        public static IResultBase Bind<TValue>(this IResult<TValue> result, Func<TValue, IResultBase> action)
+        {
+            var out_result = new Result();
+            out_result.WithReasons(result.Reasons);
+
+            if(result.IsSuccess)
+            {
+                var converted = action(result.Value);
+                out_result.WithReasons(converted.Reasons);
+            }
+
+            return out_result;
+        }
+
+        /// <inheritdoc cref="Result{TValue}.Bind(Func{TValue, Task{Result}})"/>
+        public static async Task<IResultBase> Bind<TValue>(this IResult<TValue> result, Func<TValue, Task<IResultBase>> action)
+        {
+            var out_result = new Result();
+            out_result.WithReasons(result.Reasons);
+
+            if(result.IsSuccess)
+            {
+                var converted = await action(result.Value);
+                out_result.WithReasons(converted.Reasons);
+            }
+
+            return out_result;
+        }
+
+        /// <inheritdoc cref="Result{TValue}.Bind(Func{TValue, ValueTask{Result}})"/>
+        public static async ValueTask<IResultBase> Bind<TValue>(this IResult<TValue> result, Func<TValue, ValueTask<IResultBase>> action)
+        {
+            var out_result = new Result();
+            out_result.WithReasons(result.Reasons);
+
+            if(result.IsSuccess)
+            {
+                var converted = await action(result.Value);
+                out_result.WithReasons(converted.Reasons);
+            }
+
+            return out_result;
+        }
+
+        #endregion
     }
 }

From 5589605759e0b411f174fd31ec47c869479bca62 Mon Sep 17 00:00:00 2001
From: DrPepperBianco <11694093+DrPepperBianco@users.noreply.github.com>
Date: Wed, 23 Aug 2023 21:48:13 +0200
Subject: [PATCH 2/5] IResultTExtensions and refactor of ResultExtensions
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

ResultExtensions only contains extensions for
Task<…> and Value<…> objects.

All Extensions for IResult<TValue> are now in
IResultTExtensions.

IResultTExtensions is directly in Namespace
FluentResults.

New method "MapReasons()". Makes it easier
to implement MapErros and MapSuccesses.

The overloads of Bind implemented by one method
that is called from the other overloads. There
are two variants. Bind() that returns Result without
value and Bind() that returns Result with value.

Return value is always directly Result or
Result<TValue> except for "MapErrors", because
MapErrors can return the IResult<TValue> argument
directly. All other methods always create a new
object as return value.
---
 .../Extensions/IResultTExtensions.cs          | 142 +++++++++++++
 .../Extensions/ResultExtensions.cs            | 187 ++++--------------
 2 files changed, 182 insertions(+), 147 deletions(-)
 create mode 100644 src/FluentResults/Extensions/IResultTExtensions.cs

diff --git a/src/FluentResults/Extensions/IResultTExtensions.cs b/src/FluentResults/Extensions/IResultTExtensions.cs
new file mode 100644
index 0000000..b85501a
--- /dev/null
+++ b/src/FluentResults/Extensions/IResultTExtensions.cs
@@ -0,0 +1,142 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+// ReSharper disable once CheckNamespace
+namespace FluentResults
+{
+    /// <summary>
+    /// Extensions methods for <see cref="IResult{TValue}"/>
+    /// </summary>
+    public static class IResultTExtensions
+    {
+        /// <summary>
+        /// Map all reasons of the result via reasonMapper
+        /// </summary>
+        /// <remarks>
+        /// If TReason is different from IReason the mapper is only to applied to 
+        /// reasons of the appropriate type.
+        /// </remarks>
+        public static Result<TValue> MapReasons<TValue, TReason>(this IResult<TValue> result, Func<TReason, TReason> reasonMapper)
+            where TReason : IReason =>
+            // Create new Result object
+            new Result<TValue>()
+            // Set value, if any
+            .WithValue(result.ValueOrDefault)
+            // Set and map all reasons
+            .WithReasons(
+                result.Reasons.Select(reason =>
+                    reason is TReason tReason
+                    ? reasonMapper(tReason)
+                    : reason));
+
+
+        /// <inheritdoc cref="Result{TValue}.MapErrors(Func{IError, IError})"/>
+        public static IResult<TValue> MapErrors<TValue>(this IResult<TValue> result, Func<IError, IError> errorMapper) =>
+            result.IsSuccess
+                ? result
+                : result.MapReasons(errorMapper);
+
+        /// <inheritdoc cref="Result{TValue}.MapSuccesses(Func{ISuccess, ISuccess})"/>
+        public static Result<TValue> MapSuccesses<TValue>(this IResult<TValue> result, Func<ISuccess, ISuccess> successMapper) =>
+            result.MapReasons(successMapper);
+
+        /// <inheritdoc cref="Result{TValue}.ToResult()"/>
+        public static Result ToResult<TValue>(this IResult<TValue> result) =>
+            new Result()
+                .WithReasons(result.Reasons);
+
+        /// <inheritdoc cref="Result{TValue}.ToResult{TNewValue}(Func{TValue, TNewValue})"/>
+        public static Result<TNewValue> ToResult<TValue, TNewValue>(this IResult<TValue> result, Func<TValue, TNewValue> valueConverter = null) =>
+            Map(result, valueConverter);
+
+        /// <inheritdoc cref="Result{TValue}.Map{TNewValue}(Func{TValue, TNewValue})"/>
+        public static Result<TNewValue> Map<TValue, TNewValue>(this IResult<TValue> result, Func<TValue, TNewValue> mapLogic)
+        {
+            if(result.IsSuccess && mapLogic == null)
+                throw new ArgumentException("If result is success then valueConverter should not be null");
+
+            return new Result<TNewValue>()
+                   .WithValue(result.IsFailed ? default : mapLogic(result.Value))
+                   .WithReasons(result.Reasons);
+        }
+
+
+        #region Variants of Bind(), that return result with value
+
+        /// <inheritdoc cref="Result{TValue}.Bind{TNewValue}(Func{TValue, Result{TNewValue}})"/>
+        public static Result<TNewValue> Bind<TValue, TNewValue>(this IResult<TValue> result, Func<TValue, IResult<TNewValue>> bind) =>
+            Bind(result, new Func<TValue, ValueTask<IResult<TNewValue>>>(value => new ValueTask<IResult<TNewValue>>(bind(value))))
+            .GetAwaiter().GetResult();
+
+        /// <inheritdoc cref="Result{TValue}.Bind{TNewValue}(Func{TValue, Task{Result{TNewValue}}})"/>
+        public static Task<Result<TNewValue>> Bind<TValue, TNewValue>(this IResult<TValue> result, Func<TValue, Task<Result<TNewValue>>> bind) =>
+            Bind(result, new Func<TValue, Task<IResult<TNewValue>>>(async (value) => await bind(value)));
+
+        /// <inheritdoc cref="Result{TValue}.Bind{TNewValue}(Func{TValue, Task{Result{TNewValue}}})"/>
+        public static Task<Result<TNewValue>> Bind<TValue, TNewValue>(this IResult<TValue> result, Func<TValue, Task<IResult<TNewValue>>> bind) =>
+            Bind(result, new Func<TValue, ValueTask<IResult<TNewValue>>>(async (value) => await bind(value)))
+            .AsTask();
+        
+        /// <inheritdoc cref="Result{TValue}.Bind{TNewValue}(Func{TValue, ValueTask{Result{TNewValue}}})"/>
+        public static ValueTask<Result<TNewValue>> Bind<TValue, TNewValue>(this IResult<TValue> result, Func<TValue, ValueTask<Result<TNewValue>>> bind) =>
+            Bind(result, new Func<TValue, ValueTask<IResult<TNewValue>>>(async (value) => await bind(value)));
+
+        /// <inheritdoc cref="Result{TValue}.Bind{TNewValue}(Func{TValue, ValueTask{Result{TNewValue}}})"/>
+        public static async ValueTask<Result<TNewValue>> Bind<TValue, TNewValue>(this IResult<TValue> result, Func<TValue, ValueTask<IResult<TNewValue>>> bind)
+        {
+            var outResult = new Result<TNewValue>();
+            outResult.WithReasons(result.Reasons);
+
+            if(result.IsSuccess)
+            {
+                var converted = await bind(result.Value);
+                outResult.WithValue(converted.ValueOrDefault);
+                outResult.WithReasons(converted.Reasons);
+            }
+
+            return outResult;
+        }
+
+        #endregion
+
+
+        #region Variants of Bind(), that return result without value
+
+        /// <inheritdoc cref="Result{TValue}.Bind(Func{TValue, Result})"/>
+        public static Result Bind<TValue>(this IResult<TValue> result, Func<TValue, IResultBase> action) =>
+            Bind(result, new Func<TValue, ValueTask<IResultBase>>(value => new ValueTask<IResultBase>(action(value))))
+            .GetAwaiter().GetResult();
+
+        /// <inheritdoc cref="Result{TValue}.Bind(Func{TValue, Task{Result}})"/>
+        public static Task<Result> Bind<TValue>(this IResult<TValue> result, Func<TValue, Task<Result>> action) =>
+            Bind(result, new Func<TValue, Task<IResultBase>>(async (value) => await action(value)));
+
+        /// <inheritdoc cref="Result{TValue}.Bind(Func{TValue, Task{Result}})"/>
+        public static Task<Result> Bind<TValue>(this IResult<TValue> result, Func<TValue, Task<IResultBase>> action) =>
+            Bind(result, new Func<TValue, ValueTask<IResultBase>>(async (value) => await action(value)))
+            .AsTask();
+
+        /// <inheritdoc cref="Result{TValue}.Bind(Func{TValue, ValueTask{Result}})"/>
+        public static ValueTask<Result> Bind<TValue>(this IResult<TValue> result, Func<TValue, ValueTask<Result>> action) =>
+            Bind(result, new Func<TValue, ValueTask<IResultBase>>(async (value) => await action(value)));
+
+        /// <inheritdoc cref="Result{TValue}.Bind(Func{TValue, ValueTask{Result}})"/>
+        public static async ValueTask<Result> Bind<TValue>(this IResult<TValue> result, Func<TValue, ValueTask<IResultBase>> action)
+        {
+            var outResult = new Result();
+            outResult.WithReasons(result.Reasons);
+
+            if(result.IsSuccess)
+            {
+                var converted = await action(result.Value);
+                outResult.WithReasons(converted.Reasons);
+            }
+
+            return outResult;
+        }
+
+        #endregion
+    }
+}
\ No newline at end of file
diff --git a/src/FluentResults/Extensions/ResultExtensions.cs b/src/FluentResults/Extensions/ResultExtensions.cs
index 0d4fcc4..138a2bc 100644
--- a/src/FluentResults/Extensions/ResultExtensions.cs
+++ b/src/FluentResults/Extensions/ResultExtensions.cs
@@ -6,6 +6,8 @@ namespace FluentResults.Extensions
 {
     public static class ResultExtensions
     {
+        #region Extensions for Task<Result>, ValueTask<Result>, Task<Result<T>>, and ValueTask<Result<T>>
+
         public static async Task<Result> MapErrors(this Task<Result> resultTask, Func<IError, IError> errorMapper)
         {
             var result = await resultTask;
@@ -150,8 +152,12 @@ public static async Task<Result<TValue>> ToResult<TValue>(this ValueTask<Result>
             return result.ToResult(value);
         }
 
-        #region Interfaces
+        #endregion
+
+
+#region Extensions for Task<IResultBase>, ValueTask<IResultBase>, Task<IResult<T>>, and ValueTask<IResult<T>>
 
+#if false
         public static async Task<IResultBase> MapErrors(this Task<IResultBase> resultTask, Func<IError, IError> errorMapper)
         {
             var result = await resultTask;
@@ -163,6 +169,7 @@ public static async ValueTask<IResultBase> MapErrors(this ValueTask<IResultBase>
             var result = await resultTask;
             return result.MapErrors(errorMapper);
         }
+#endif
 
         public static async Task<IResult<T>> MapErrors<T>(this Task<IResult<T>> resultTask, Func<IError, IError> errorMapper)
         {
@@ -176,6 +183,7 @@ public static async ValueTask<IResult<T>> MapErrors<T>(this ValueTask<IResult<T>
             return result.MapErrors(errorMapper);
         }
 
+#if false
         public static async Task<IResultBase> MapSuccesses(this Task<IResultBase> resultTask, Func<ISuccess, ISuccess> errorMapper)
         {
             var result = await resultTask;
@@ -187,6 +195,7 @@ public static async ValueTask<IResultBase> MapSuccesses(this ValueTask<IResultBa
             var result = await resultTask;
             return result.MapSuccesses(errorMapper);
         }
+#endif
 
         public static async Task<IResult<T>> MapSuccesses<T>(this Task<IResult<T>> resultTask, Func<ISuccess, ISuccess> errorMapper)
         {
@@ -248,6 +257,7 @@ public static async ValueTask<IResultBase> Bind<TOld>(this ValueTask<IResult<TOl
             return await result.Bind(bind);
         }
 
+#if false
         public static async Task<IResult<TNew>> Bind<TNew>(this Task<IResultBase> resultTask, Func<Task<IResult<TNew>>> bind)
         {
             var result = await resultTask;
@@ -271,6 +281,7 @@ public static async ValueTask<IResultBase> Bind(this ValueTask<IResultBase> resu
             var result = await resultTask;
             return await result.Bind(bind);
         }
+#endif
 
         public static async Task<IResult<TNewValue>> Map<TOldValue, TNewValue>(this Task<IResult<TOldValue>> resultTask, Func<TOldValue, TNewValue> valueConverter)
         {
@@ -284,23 +295,45 @@ public static async Task<IResult<TNewValue>> Map<TOldValue, TNewValue>(this Valu
             return result.Map(valueConverter);
         }
 
-        public static async Task<IResult<TValue>> ToResult<TValue>(this Task<IResultBase> resultTask, TValue value)
+        #endregion
+
+        #region Convert (Value)Task of IResultBase into Task of Result
+
+        public static async Task<Result> ToResult(this Task<IResultBase> resultTask)
         {
             var result = await resultTask;
-            return result.ToResult(value);
+            return new Result()
+                .WithReasons(result.Reasons);
         }
 
-        public static async Task<IResult<TValue>> ToResult<TValue>(this ValueTask<IResultBase> resultTask, TValue value)
+        public static async ValueTask<Result> ToResult(this ValueTask<IResultBase> resultTask)
         {
             var result = await resultTask;
-            return result.ToResult(value);
+            return new Result()
+                .WithReasons(result.Reasons);
+        }
+
+        public static async Task<Result<TValue>> ToResult<TValue>(this Task<IResultBase> resultTask, TValue value)
+        {
+            var result = await resultTask;
+            return new Result<TValue>()
+                .WithValue(value)
+                .WithReasons(result.Reasons);
+        }
+
+        public static async ValueTask<Result<TValue>> ToResult<TValue>(this ValueTask<IResultBase> resultTask, TValue value)
+        {
+            var result = await resultTask;
+            return new Result<TValue>()
+                .WithValue(value)
+                .WithReasons(result.Reasons);
         }
 
         #endregion
 
 
         #region Erweiterung: Member von Result für Interface IResultBase
-
+#if false
         /// <inheritdoc cref="Result.MapErrors(Func{IError, IError})"/>
         public static IResultBase MapErrors(this IResultBase result, Func<IError, IError> errorMapper) =>
             result.IsSuccess 
@@ -413,149 +446,9 @@ public static async ValueTask<IResultBase> Bind(this IResultBase result, Func<Va
 
             return out_result;
         }
-
+#endif
         #endregion
 
 
-        #region Erweiterung: Member von Result für Interface IResultBase
-
-        /// <inheritdoc cref="Result{TValue}.WithValue(TValue)"/>
-        public static IResult<TValue> WithValue<TValue>(this IResult<TValue> result, TValue value) =>
-            // ℹ️ You would assume immutability on results,
-            //     therefor we first create a copy!
-            new Result<TValue>()
-                .WithReasons(result.Reasons)
-                .WithValue(value);
-
-
-        /// <inheritdoc cref="Result{TValue}.MapErrors(Func{IError, IError})"/>
-        public static IResult<TValue> MapErrors<TValue>(this IResult<TValue> result, Func<IError, IError> errorMapper) =>
-            result.IsSuccess
-                ? result
-                : new Result<TValue>()
-                    .WithErrors(result.Errors.Select(errorMapper))
-                    .WithSuccesses(result.Successes);
-
-        /// <inheritdoc cref="Result{TValue}.MapSuccesses(Func{ISuccess, ISuccess})"/>
-        public static IResult<TValue> MapSuccesses<TValue>(this IResult<TValue> result, Func<ISuccess, ISuccess> successMapper) =>
-            new Result<TValue>()
-                .WithValue(result.ValueOrDefault)
-                .WithErrors(result.Errors)
-                .WithSuccesses(result.Successes.Select(successMapper));
-
-        /// <inheritdoc cref="Result{TValue}.ToResult()"/>
-        public static IResultBase ToResult<TValue>(this IResult<TValue> result) =>
-            new Result()
-                .WithReasons(result.Reasons);
-
-        /// <inheritdoc cref="Result{TValue}.ToResult{TNewValue}(Func{TValue, TNewValue})"/>
-        public static Result<TNewValue> ToResult<TValue, TNewValue>(this IResult<TValue> result, Func<TValue, TNewValue> valueConverter = null) =>
-            Map(result, valueConverter);
-
-        /// <inheritdoc cref="Result{TValue}.Map{TNewValue}(Func{TValue, TNewValue})"/>
-        public static Result<TNewValue> Map<TValue, TNewValue>(this IResult<TValue> result, Func<TValue, TNewValue> mapLogic)
-        {
-            if(result.IsSuccess && mapLogic == null)
-                throw new ArgumentException("If result is success then valueConverter should not be null");
-
-            return new Result<TNewValue>()
-                   .WithValue(result.IsFailed ? default : mapLogic(result.Value))
-                   .WithReasons(result.Reasons);
-        }
-
-        /// <inheritdoc cref="Result{TValue}.Bind{TNewValue}(Func{TValue, Result{TNewValue}})"/>
-        public static Result<TNewValue> Bind<TValue, TNewValue>(this IResult<TValue> result, Func<TValue, IResult<TNewValue>> bind)
-        {
-            var out_result = new Result<TNewValue>();
-            out_result.WithReasons(result.Reasons);
-
-            if(result.IsSuccess)
-            {
-                var converted = bind(result.Value);
-                out_result.WithValue(converted.ValueOrDefault);
-                out_result.WithReasons(converted.Reasons);
-            }
-
-            return out_result;
-        }
-
-        /// <inheritdoc cref="Result{TValue}.Bind{TNewValue}(Func{TValue, Task{Result{TNewValue}}})"/>
-        public static async Task<Result<TNewValue>> Bind<TValue, TNewValue>(this IResult<TValue> result, Func<TValue, Task<IResult<TNewValue>>> bind)
-        {
-            var out_result = new Result<TNewValue>();
-            out_result.WithReasons(result.Reasons);
-
-            if(result.IsSuccess)
-            {
-                var converted = await bind(result.Value);
-                out_result.WithValue(converted.ValueOrDefault);
-                out_result.WithReasons(converted.Reasons);
-            }
-
-            return out_result;
-        }
-
-        /// <inheritdoc cref="Result{TValue}.Bind{TNewValue}(Func{TValue, ValueTask{Result{TNewValue}}})"/>
-        public static async ValueTask<Result<TNewValue>> Bind<TValue, TNewValue>(this IResult<TValue> result, Func<TValue, ValueTask<IResult<TNewValue>>> bind)
-        {
-            var out_result = new Result<TNewValue>();
-            out_result.WithReasons(result.Reasons);
-
-            if(result.IsSuccess)
-            {
-                var converted = await bind(result.Value);
-                out_result.WithValue(converted.ValueOrDefault);
-                out_result.WithReasons(converted.Reasons);
-            }
-
-            return out_result;
-        }
-
-        /// <inheritdoc cref="Result{TValue}.Bind(Func{TValue, Result})"/>
-        public static IResultBase Bind<TValue>(this IResult<TValue> result, Func<TValue, IResultBase> action)
-        {
-            var out_result = new Result();
-            out_result.WithReasons(result.Reasons);
-
-            if(result.IsSuccess)
-            {
-                var converted = action(result.Value);
-                out_result.WithReasons(converted.Reasons);
-            }
-
-            return out_result;
-        }
-
-        /// <inheritdoc cref="Result{TValue}.Bind(Func{TValue, Task{Result}})"/>
-        public static async Task<IResultBase> Bind<TValue>(this IResult<TValue> result, Func<TValue, Task<IResultBase>> action)
-        {
-            var out_result = new Result();
-            out_result.WithReasons(result.Reasons);
-
-            if(result.IsSuccess)
-            {
-                var converted = await action(result.Value);
-                out_result.WithReasons(converted.Reasons);
-            }
-
-            return out_result;
-        }
-
-        /// <inheritdoc cref="Result{TValue}.Bind(Func{TValue, ValueTask{Result}})"/>
-        public static async ValueTask<IResultBase> Bind<TValue>(this IResult<TValue> result, Func<TValue, ValueTask<IResultBase>> action)
-        {
-            var out_result = new Result();
-            out_result.WithReasons(result.Reasons);
-
-            if(result.IsSuccess)
-            {
-                var converted = await action(result.Value);
-                out_result.WithReasons(converted.Reasons);
-            }
-
-            return out_result;
-        }
-
-        #endregion
     }
 }

From 75b4a226aa304a55857970a739a5a98b970f9e45 Mon Sep 17 00:00:00 2001
From: DrPepperBianco <11694093+DrPepperBianco@users.noreply.github.com>
Date: Wed, 23 Aug 2023 22:26:49 +0200
Subject: [PATCH 3/5] Added Some Tests for IResultTExtensions

---
 .../IResultTExtensionsTests.cs                | 100 ++++++++++++++++++
 1 file changed, 100 insertions(+)
 create mode 100644 src/FluentResults.Test/IResultTExtensionsTests.cs

diff --git a/src/FluentResults.Test/IResultTExtensionsTests.cs b/src/FluentResults.Test/IResultTExtensionsTests.cs
new file mode 100644
index 0000000..5b1641a
--- /dev/null
+++ b/src/FluentResults.Test/IResultTExtensionsTests.cs
@@ -0,0 +1,100 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+using FluentAssertions;
+using FluentResults.Test.Mocks;
+using Microsoft.Extensions.Logging;
+using Xunit;
+
+namespace FluentResults.Test
+{
+    public class IResultTExtensionsTests
+    {
+        private void AssertEqual<TValue>(IResult<TValue> actual, IResult<TValue> expected)
+        {
+            // Assert
+            actual.IsFailed.Should().Be(expected.IsFailed);
+            actual.IsSuccess.Should().Be(expected.IsSuccess);
+            actual.ValueOrDefault.Should().Be(expected.ValueOrDefault);
+
+            actual.Reasons.Should().BeEquivalentTo(expected.Reasons);
+            actual.Errors.Should().BeEquivalentTo(expected.Errors);
+            actual.Successes.Should().BeEquivalentTo(expected.Successes);
+        }
+
+        [Fact]
+        public void Ok_MapReason_with_IError_NoChange()
+        {
+            // Act
+            IResult<string> result = Result.Ok("FooBar");
+            IResult<string> actual = result.MapReasons((IError error) => new Error("\"" + error.Message + "\""));
+
+            // Assert
+            AssertEqual(actual, result);
+        }
+
+        [Fact]
+        public void Fail_MapReason_with_IError_ShouldChange()
+        {
+            // Act
+            IResult<string> result = Result.Fail<string>("FooBar");
+            IResult<string> actual = result.MapReasons((IError error) => new Error("\"" + error.Message + "\""));
+
+            // Assert
+            var expected = result;
+            actual.IsFailed.Should().Be(expected.IsFailed);
+            actual.IsSuccess.Should().Be(expected.IsSuccess);
+            actual.ValueOrDefault.Should().Be(expected.ValueOrDefault);
+
+            actual.Successes.Should().BeEquivalentTo(expected.Successes);
+            actual.Reasons.Should().NotBeEquivalentTo(expected.Reasons);
+            actual.Errors.Should().NotBeEquivalentTo(expected.Errors);
+
+            actual.Errors.Count.Should().Be(1);
+            actual.Errors[0].Message.Should().Be("\"FooBar\"");
+        }
+
+        [Fact]
+        public void Ok_Bind_Success()
+        {
+            // Act
+            IResult<string> result = Result.Ok("4815162342");
+            IResult<long> actual = result.Bind(s => Result.Try(() => long.Parse(s)));
+
+            // Assert
+            actual.IsSuccess.Should().Be(true);
+            actual.IsFailed.Should().Be(false);
+            actual.Errors.Should().BeEmpty();
+            actual.Reasons.Should().BeEmpty();
+            actual.Successes.Should().BeEmpty();
+            actual.ValueOrDefault.Should().Be(4815162342L);
+        }
+
+        [Fact]
+        public void Ok_Bind_Failure()
+        {
+            // Act
+            bool delegateHasBeenCalled = false;
+            IResult<string> result = Result.Ok("4815162342").WithError("FooBar");
+            IResult<long> actual = result.Bind(s =>
+            {
+                delegateHasBeenCalled = true;
+                return Result.Try(() => long.Parse(s));
+            });
+
+            // Assert
+            delegateHasBeenCalled.Should().Be(false, "Bind of failed result should be called");
+            actual.IsSuccess.Should().Be(false);
+            actual.IsFailed.Should().Be(true);
+            actual.Errors.Should().NotBeEmpty();
+            actual.Errors.Count.Should().Be(1);
+            actual.Reasons.Should().NotBeEmpty();
+            actual.Reasons.Count.Should().Be(1);
+            actual.Successes.Should().BeEmpty();
+            actual.ValueOrDefault.Should().Be(default);
+        }
+    }
+}

From 4bc152a2afcf11c38f4463483097e6810a87fd4a Mon Sep 17 00:00:00 2001
From: DrPepperBianco <11694093+DrPepperBianco@users.noreply.github.com>
Date: Thu, 24 Aug 2023 10:53:08 +0200
Subject: [PATCH 4/5] rename IResultTExtensions to ResulTValueExtensions

seems a better name, also avoids letting a class
start with an I.
---
 ...tTExtensionsTests.cs => ResultTValueExtensionsTests.cs} | 2 +-
 .../{IResultTExtensions.cs => ResultTValueExtensions.cs}   | 7 ++++++-
 2 files changed, 7 insertions(+), 2 deletions(-)
 rename src/FluentResults.Test/{IResultTExtensionsTests.cs => ResultTValueExtensionsTests.cs} (98%)
 rename src/FluentResults/Extensions/{IResultTExtensions.cs => ResultTValueExtensions.cs} (96%)

diff --git a/src/FluentResults.Test/IResultTExtensionsTests.cs b/src/FluentResults.Test/ResultTValueExtensionsTests.cs
similarity index 98%
rename from src/FluentResults.Test/IResultTExtensionsTests.cs
rename to src/FluentResults.Test/ResultTValueExtensionsTests.cs
index 5b1641a..a45fe6d 100644
--- a/src/FluentResults.Test/IResultTExtensionsTests.cs
+++ b/src/FluentResults.Test/ResultTValueExtensionsTests.cs
@@ -11,7 +11,7 @@
 
 namespace FluentResults.Test
 {
-    public class IResultTExtensionsTests
+    public class ResultTValueExtensionsTests
     {
         private void AssertEqual<TValue>(IResult<TValue> actual, IResult<TValue> expected)
         {
diff --git a/src/FluentResults/Extensions/IResultTExtensions.cs b/src/FluentResults/Extensions/ResultTValueExtensions.cs
similarity index 96%
rename from src/FluentResults/Extensions/IResultTExtensions.cs
rename to src/FluentResults/Extensions/ResultTValueExtensions.cs
index b85501a..d394abb 100644
--- a/src/FluentResults/Extensions/IResultTExtensions.cs
+++ b/src/FluentResults/Extensions/ResultTValueExtensions.cs
@@ -9,7 +9,12 @@ namespace FluentResults
     /// <summary>
     /// Extensions methods for <see cref="IResult{TValue}"/>
     /// </summary>
-    public static class IResultTExtensions
+    /// <remarks>
+    /// Adds methods that are defined in 
+    /// <see cref="Result{TValue}"/> so that they are also
+    /// available in <see cref="IResult{TValue}"/>.
+    /// </remarks>
+    public static class ResultTValueExtensions
     {
         /// <summary>
         /// Map all reasons of the result via reasonMapper

From fed8be5be5c76aa7dd7f906cb717701bfe8054d5 Mon Sep 17 00:00:00 2001
From: DrPepperBianco <11694093+DrPepperBianco@users.noreply.github.com>
Date: Thu, 24 Aug 2023 10:53:32 +0200
Subject: [PATCH 5/5] ResultBaseExtensions

Adds methods, that are else defined in ResultBase, so that
they are also available for IResultBase.
---
 .../Extensions/ResultBaseExtensions.cs        | 219 ++++++++++++++++++
 1 file changed, 219 insertions(+)
 create mode 100644 src/FluentResults/Extensions/ResultBaseExtensions.cs

diff --git a/src/FluentResults/Extensions/ResultBaseExtensions.cs b/src/FluentResults/Extensions/ResultBaseExtensions.cs
new file mode 100644
index 0000000..5693da1
--- /dev/null
+++ b/src/FluentResults/Extensions/ResultBaseExtensions.cs
@@ -0,0 +1,219 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace FluentResults
+{
+    /// <summary>
+    /// Extensions methods for IResultBase
+    /// </summary>
+    /// <remarks>
+    /// Adds methods, that are else defined in ResultBase, so that 
+    /// they are also available for IResultBase.
+    /// </remarks>
+    public static class ResultBaseExtensions
+    {
+        #region Methods from ResultBase
+
+        /// <inheritdoc cref="ResultBase.HasError{TError}()"/>
+        public static bool HasError<TError>(this IResultBase resultBase) where TError : IError
+        {
+            return HasError<TError>(resultBase, out _);
+        }
+
+        /// <inheritdoc cref="ResultBase.HasError{TError}(out IEnumerable{TError})"/>
+        public static bool HasError<TError>(this IResultBase resultBase, out IEnumerable<TError> result) where TError : IError
+        {
+            return HasError<TError>(resultBase, e => true, out result);
+        }
+
+        /// <inheritdoc cref="ResultBase.HasError{TError}(Func{TError, bool})"/>
+        public static bool HasError<TError>(this IResultBase resultBase, Func<TError, bool> predicate) where TError : IError
+        {
+            return HasError<TError>(resultBase, predicate, out _);
+        }
+
+        /// <inheritdoc cref="ResultBase.HasError{TError}(Func{TError, bool}, out IEnumerable{TError})"/>
+        public static bool HasError<TError>(this IResultBase resultBase, Func<TError, bool> predicate, out IEnumerable<TError> result) where TError : IError
+        {
+            if(predicate == null)
+                throw new ArgumentNullException(nameof(predicate));
+
+            return ResultHelper.HasError(resultBase.Errors, predicate, out result);
+        }
+
+        /// <inheritdoc cref="ResultBase.HasError(Func{IError, bool})"/>
+        public static bool HasError(this IResultBase resultBase, Func<IError, bool> predicate)
+        {
+            return HasError(resultBase, predicate, out _);
+        }
+
+        /// <inheritdoc cref="ResultBase.HasError(Func{IError, bool}, out IEnumerable{IError})"/>
+        public static bool HasError(this IResultBase resultBase, Func<IError, bool> predicate, out IEnumerable<IError> result)
+        {
+            if(predicate == null)
+                throw new ArgumentNullException(nameof(predicate));
+
+            return ResultHelper.HasError(resultBase.Errors, predicate, out result);
+        }
+
+        /// <inheritdoc cref="ResultBase.HasException{TException}()"/>
+        public static bool HasException<TException>(this IResultBase resultBase) where TException : Exception
+        {
+            return HasException<TException>(resultBase, out _);
+        }
+
+        /// <inheritdoc cref="ResultBase.HasException{TException}(out IEnumerable{IError})"/>
+        public static bool HasException<TException>(this IResultBase resultBase, out IEnumerable<IError> result) where TException : Exception
+        {
+            return HasException<TException>(resultBase, error => true, out result);
+        }
+
+        /// <inheritdoc cref="ResultBase.HasException{TException}(Func{TException, bool})"/>
+        public static bool HasException<TException>(this IResultBase resultBase, Func<TException, bool> predicate) where TException : Exception
+        {
+            return HasException(resultBase, predicate, out _);
+        }
+
+        /// <inheritdoc cref="ResultBase.HasException{TException}(Func{TException, bool}, out IEnumerable{IError})"/>
+        public static bool HasException<TException>(this IResultBase resultBase, Func<TException, bool> predicate, out IEnumerable<IError> result) where TException : Exception
+        {
+            if(predicate == null)
+                throw new ArgumentNullException(nameof(predicate));
+
+            return ResultHelper.HasException(resultBase.Errors, predicate, out result);
+        }
+
+        /// <inheritdoc cref="ResultBase.HasSuccess{TSuccess}()" />
+        public static bool HasSuccess<TSuccess>(this IResultBase resultBase) where TSuccess : ISuccess
+        {
+            return HasSuccess<TSuccess>(resultBase, success => true, out _);
+        }
+
+        /// <inheritdoc cref="ResultBase.HasSuccess{TSuccess}(out IEnumerable{TSuccess})"/>
+        public static bool HasSuccess<TSuccess>(this IResultBase resultBase, out IEnumerable<TSuccess> result) where TSuccess : ISuccess
+        {
+            return HasSuccess<TSuccess>(resultBase, success => true, out result);
+        }
+
+        /// <inheritdoc cref="ResultBase.HasSuccess{TSuccess}(Func{TSuccess, bool})"/>
+        public static bool HasSuccess<TSuccess>(this IResultBase resultBase, Func<TSuccess, bool> predicate) where TSuccess : ISuccess
+        {
+            return HasSuccess(resultBase, predicate, out _);
+        }
+
+        /// <inheritdoc cref="ResultBase.HasSuccess{TSuccess}(Func{TSuccess, bool}, out IEnumerable{TSuccess})"/>
+        public static bool HasSuccess<TSuccess>(this IResultBase resultBase, Func<TSuccess, bool> predicate, out IEnumerable<TSuccess> result) where TSuccess : ISuccess
+        {
+            return ResultHelper.HasSuccess(resultBase.Successes, predicate, out result);
+        }
+
+        /// <inheritdoc cref="ResultBase.HasSuccess(Func{ISuccess, bool}, out IEnumerable{ISuccess})"/>
+        public static bool HasSuccess(this IResultBase resultBase, Func<ISuccess, bool> predicate, out IEnumerable<ISuccess> result)
+        {
+            return ResultHelper.HasSuccess(resultBase.Successes, predicate, out result);
+        }
+
+        /// <inheritdoc cref="ResultBase.HasSuccess{TSuccess}()"/>
+        public static bool HasSuccess(this IResultBase resultBase, Func<ISuccess, bool> predicate)
+        {
+            return ResultHelper.HasSuccess(resultBase.Successes, predicate, out _);
+        }
+
+        /// <inheritdoc cref="ResultBase.Deconstruct(out bool, out bool)"/>
+        public static void Deconstruct(this IResultBase resultBase, out bool isSuccess, out bool isFailed)
+        {
+            isSuccess = resultBase.IsSuccess;
+            isFailed = resultBase.IsFailed;
+        }
+
+        /// <inheritdoc cref="ResultBase.Deconstruct(out bool, out bool, out List{IError})"/>
+        public static void Deconstruct(this IResultBase resultBase, out bool isSuccess, out bool isFailed, out IReadOnlyList<IError> errors)
+        {
+            isSuccess = resultBase.IsSuccess;
+            isFailed = resultBase.IsFailed;
+            errors = isFailed ? resultBase.Errors : (IReadOnlyList<IError>)Array.Empty<IError>();
+        }
+
+        #endregion
+
+
+        #region Methods from ResultBase<TResult> (return the same type, for fluent syntax)
+
+        /// <inheritdoc cref="ResultBase{TResult}.WithReason(IReason)"/>
+        public static TResult WithReason<TResult>(this TResult result, IReason reason)
+            where TResult : IResultBase
+        {
+            result.Reasons.Add(reason);
+            return result;
+        }
+
+        /// <inheritdoc cref="ResultBase{TResult}.WithReasons(IEnumerable{IReason})"/>
+        public static TResult WithReasons<TResult>(this TResult result, IEnumerable<IReason> reasons)
+            where TResult : IResultBase
+        {
+            result.Reasons.AddRange(reasons);
+            return result;
+        }
+
+        /// <inheritdoc cref="ResultBase{TResult}.WithError(string)"/>
+        public static TResult WithError<TResult>(this TResult result, string errorMessage)
+            where TResult : IResultBase
+        {
+            return result.WithError(Result.Settings.ErrorFactory(errorMessage));
+        }
+
+        /// <inheritdoc cref="ResultBase{TResult}.WithError(IError)"/>
+        public static TResult WithError<TResult>(this TResult result, IError error)
+            where TResult : IResultBase
+        {
+            return result.WithReason(error);
+        }
+
+        /// <inheritdoc cref="ResultBase{TResult}.WithErrors(IEnumerable{IError})"/>
+        public static TResult WithErrors<TResult>(this TResult result, IEnumerable<IError> errors)
+            where TResult : IResultBase
+        {
+            return result.WithReasons(errors);
+        }
+
+        /// <inheritdoc cref="ResultBase{TResult}.WithErrors(IEnumerable{string})"/>
+        public static TResult WithErrors<TResult>(this TResult result, IEnumerable<string> errors)
+            where TResult : IResultBase
+        {
+            return result.WithReasons(errors.Select(errorMessage => Result.Settings.ErrorFactory(errorMessage)));
+        }
+
+        /// <inheritdoc cref="ResultBase{TResult}.WithSuccess(string)"/>
+        public static TResult WithSuccess<TResult>(this TResult result, string successMessage)
+            where TResult : IResultBase
+        {
+            return result.WithSuccess(Result.Settings.SuccessFactory(successMessage));
+        }
+
+        /// <inheritdoc cref="ResultBase{TResult}.WithSuccess(ISuccess)"/>
+        public static TResult WithSuccess<TResult>(this TResult result, ISuccess success)
+            where TResult : IResultBase
+        {
+            return result.WithReason(success);
+        }
+
+        /// <inheritdoc cref="ResultBase{TResult}.WithSuccesses(IEnumerable{ISuccess})"/>
+        public static TResult WithSuccesses<TResult>(this TResult result, IEnumerable<ISuccess> successes)
+            where TResult : IResultBase
+        {
+            foreach(var success in successes)
+            {
+                result.WithSuccess(success);
+            }
+
+            return result;
+        }
+
+
+        #endregion
+
+    }
+
+}
\ No newline at end of file