diff --git a/src/FluentResults.Test/ResultTValueExtensionsTests.cs b/src/FluentResults.Test/ResultTValueExtensionsTests.cs
new file mode 100644
index 0000000..a45fe6d
--- /dev/null
+++ b/src/FluentResults.Test/ResultTValueExtensionsTests.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 ResultTValueExtensionsTests
+    {
+        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);
+        }
+    }
+}
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
diff --git a/src/FluentResults/Extensions/ResultExtensions.cs b/src/FluentResults/Extensions/ResultExtensions.cs
index f11dfbe..138a2bc 100644
--- a/src/FluentResults/Extensions/ResultExtensions.cs
+++ b/src/FluentResults/Extensions/ResultExtensions.cs
@@ -1,10 +1,13 @@
 using System;
+using System.Linq;
 using System.Threading.Tasks;
 
 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;
@@ -148,5 +151,304 @@ public static async Task<Result<TValue>> ToResult<TValue>(this ValueTask<Result>
             var result = await resultTask;
             return result.ToResult(value);
         }
+
+        #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;
+            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);
+        }
+#endif
+
+        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);
+        }
+
+#if false
+        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);
+        }
+#endif
+
+        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);
+        }
+
+#if false
+        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);
+        }
+#endif
+
+        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);
+        }
+
+        #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 new Result()
+                .WithReasons(result.Reasons);
+        }
+
+        public static async ValueTask<Result> ToResult(this ValueTask<IResultBase> resultTask)
+        {
+            var result = await resultTask;
+            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 
+                ? 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;
+        }
+#endif
+        #endregion
+
+
     }
 }
diff --git a/src/FluentResults/Extensions/ResultTValueExtensions.cs b/src/FluentResults/Extensions/ResultTValueExtensions.cs
new file mode 100644
index 0000000..d394abb
--- /dev/null
+++ b/src/FluentResults/Extensions/ResultTValueExtensions.cs
@@ -0,0 +1,147 @@
+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>
+    /// <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
+        /// </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