diff --git a/src/DotNext/Optional.cs b/src/DotNext/Optional.cs
index c6dc79320..35d4b731b 100644
--- a/src/DotNext/Optional.cs
+++ b/src/DotNext/Optional.cs
@@ -48,6 +48,69 @@ public static class Optional
     public static async Task<Optional<TOutput>> Convert<TInput, TOutput>(this Task<Optional<TInput>> task, Converter<TInput, TOutput> converter)
         => (await task.ConfigureAwait(false)).Convert(converter);
 
+    /// <summary>
+    /// If a value is present, apply the provided mapping function to it, and if the result is
+    /// non-null, return an Optional describing the result. Otherwise returns <see cref="Optional{T}.None"/>.
+    /// </summary>
+    /// <typeparam name="TInput">The type of stored in the Optional container.</typeparam>
+    /// <typeparam name="TOutput">The type of the result of the mapping function.</typeparam>
+    /// <param name="task">The task containing Optional value.</param>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <returns>An Optional describing the result of applying a mapping function to the value of this Optional, if a value is present, otherwise <see cref="Optional{T}.None"/>.</returns>
+    public static async Task<Optional<TOutput>> Convert<TInput, TOutput>(this Task<Optional<TInput>> task, Converter<TInput, Optional<TOutput>> converter)
+        => (await task.ConfigureAwait(false)).Convert(converter);
+
+    /// <summary>
+    /// If a value is present, apply the provided mapping function to it, and if the result is
+    /// non-null, return an Optional describing the result. Otherwise returns <see cref="Optional{T}.None"/>.
+    /// </summary>
+    /// <typeparam name="TInput">The type of stored in the Optional container.</typeparam>
+    /// <typeparam name="TOutput">The type of the result of the mapping function.</typeparam>
+    /// <param name="task">The task containing Optional value.</param>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <returns>An Optional describing the result of applying a mapping function to the value of this Optional, if a value is present, otherwise <see cref="Optional{T}.None"/>.</returns>
+    public static async Task<Optional<TOutput>> Convert<TInput, TOutput>(this Task<Optional<TInput>> task, Converter<TInput, Task<Optional<TOutput>>> converter)
+        => await (await task.ConfigureAwait(false)).Convert(converter).ConfigureAwait(false);
+
+    /// <summary>
+    /// Creates <see cref="Result{T}"/> from <see cref="Optional{T}"/> instance.
+    /// </summary>
+    /// <param name="optional">The optional value.</param>
+    /// <returns>The converted optional value.</returns>
+    public static Result<T> ToResult<T>(this in Optional<T> optional)
+        => Result<T>.FromOptional(optional);
+
+    /// <summary>
+    /// Creates <see cref="Result{T}"/> from <see cref="Optional{T}"/> instance.
+    /// </summary>
+    /// <param name="task">The task containing Optional value.</param>
+    /// <returns>The converted optional value.</returns>
+    public static async Task<Result<T>> ToResult<T>(this Task<Optional<T>> task)
+        => Result<T>.FromOptional(await task.ConfigureAwait(false));
+
+    /// <summary>
+    /// Creates <see cref="Result{T, TError}"/> from <see cref="Optional{T}"/> instance.
+    /// </summary>
+    /// <param name="optional">The optional value.</param>
+    /// <param name="error">The error code to apply if the value is not present.</param>
+    /// <returns>The converted optional value.</returns>
+    public static Result<T, TError> ToResult<T, TError>(this in Optional<T> optional, TError error)
+        where TError : struct, Enum
+        => optional.HasValue ? new(optional.Value) : new(error);
+
+    /// <summary>
+    /// Creates <see cref="Result{T, TError}"/> from <see cref="Optional{T}"/> instance.
+    /// </summary>
+    /// <param name="task">The task containing Optional value.</param>
+    /// <param name="error">The error code to apply if the value is not present.</param>
+    /// <returns>The converted optional value.</returns>
+    public static async Task<Result<T, TError>> ToResult<T, TError>(this Task<Optional<T>> task, TError error)
+        where TError : struct, Enum
+    {
+        var optional = await task.ConfigureAwait(false);
+        return optional.HasValue ? new(optional.Value) : new(error);
+    }
+
     /// <summary>
     /// If a value is present, returns the value, otherwise throw exception.
     /// </summary>
@@ -553,6 +616,11 @@ private Optional<TResult> ConvertOptional<TResult, TConverter>(TConverter conver
         where TConverter : struct, ISupplier<T, Optional<TResult>>
         => HasValue ? converter.Invoke(value) : Optional<TResult>.None;
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private Task<Optional<TResult>> ConvertOptionalTask<TResult, TConverter>(TConverter converter)
+        where TConverter : struct, ISupplier<T, Task<Optional<TResult>>>
+        => HasValue ? converter.Invoke(value) : Task.FromResult(Optional<TResult>.None);
+
     /// <summary>
     /// If a value is present, apply the provided mapping function to it, and if the result is
     /// non-null, return an Optional describing the result. Otherwise, returns <see cref="None"/>.
@@ -570,10 +638,31 @@ public Optional<TResult> Convert<TResult>(Converter<T, Optional<TResult>> mapper
     /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
     /// <param name="mapper">A mapping function to be applied to the value, if present.</param>
     /// <returns>An Optional describing the result of applying a mapping function to the value of this Optional, if a value is present, otherwise <see cref="None"/>.</returns>
+    public Task<Optional<TResult>> Convert<TResult>(Converter<T, Task<Optional<TResult>>> mapper)
+        => ConvertOptionalTask<TResult, DelegatingConverter<T, Task<Optional<TResult>>>>(mapper);
+
+    /// <summary>
+    /// If a value is present, apply the provided mapping function to it, and if the result is
+    /// non-null, return an Optional describing the result. Otherwise returns <see cref="None"/>.
+    /// </summary>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <param name="mapper">A mapping function to be applied to the value, if present.</param>
+    /// <returns>An Optional describing the result of applying a mapping function to the value of this Optional, if a value is present, otherwise <see cref="None"/>.</returns>
     [CLSCompliant(false)]
     public unsafe Optional<TResult> Convert<TResult>(delegate*<T, Optional<TResult>> mapper)
         => ConvertOptional<TResult, Supplier<T, Optional<TResult>>>(mapper);
 
+    /// <summary>
+    /// If a value is present, apply the provided mapping function to it, and if the result is
+    /// non-null, return an Optional describing the result. Otherwise returns <see cref="None"/>.
+    /// </summary>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <param name="mapper">A mapping function to be applied to the value, if present.</param>
+    /// <returns>An Optional describing the result of applying a mapping function to the value of this Optional, if a value is present, otherwise <see cref="None"/>.</returns>
+    [CLSCompliant(false)]
+    public unsafe Task<Optional<TResult>> Convert<TResult>(delegate*<T, Task<Optional<TResult>>> mapper)
+        => ConvertOptionalTask<TResult, Supplier<T, Task<Optional<TResult>>>>(mapper);
+
     /// <inheritdoc cref="IFunctional{TDelegate}.ToDelegate()"/>
     Func<object?> IFunctional<Func<object?>>.ToDelegate() => Func.Constant<object?>(kind is NotEmptyValue ? value : null);
 
diff --git a/src/DotNext/Result.cs b/src/DotNext/Result.cs
index c9b2839eb..345d91284 100644
--- a/src/DotNext/Result.cs
+++ b/src/DotNext/Result.cs
@@ -7,6 +7,8 @@
 
 namespace DotNext;
 
+using System;
+using DotNext.Threading.Tasks;
 using Runtime.CompilerServices;
 using Intrinsics = Runtime.Intrinsics;
 
@@ -75,6 +77,87 @@ public static class Result
     /// <param name="e">The exception to be placed to the container.</param>
     /// <returns>The exception encapsulated by <see cref="Result{T}"/>.</returns>
     public static Result<T> FromException<T>(Exception e) => new(e);
+
+    /// <summary>
+    /// Creates a new instance of <see cref="Result{T, TError}"/> from the specified exception.
+    /// </summary>
+    /// <typeparam name="T">The type of the value.</typeparam>
+    /// <typeparam name="TError">The type of the error code. Default value must represent the successful result.</typeparam>
+    /// <param name="e">The error to be placed to the container.</param>
+    /// <returns>The exception encapsulated by <see cref="Result{T}"/>.</returns>
+    public static Result<T, TError> FromError<T, TError>(TError e)
+        where TError: struct, Enum
+        => new(e);
+
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function hiding any exception
+    /// caused by the converter.
+    /// </summary>
+    /// <param name="task">The task containing Result value.</param>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="T">The type of the value.</typeparam>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    public static AwaitableResult<TResult> Convert<T, TResult>(this AwaitableResult<T> task, Converter<T, TResult> converter)
+    {
+        async Task<TResult> ConvertInternal()
+        {
+            var result = await task.ConfigureAwait(false);
+            var conversionResult = result.Convert(converter);
+            return conversionResult.IsSuccessful ? conversionResult.Value : throw conversionResult.Error;
+        }
+
+        return ConvertInternal().SuspendException();
+    }
+
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function. If not,
+    /// forward the exception.
+    /// </summary>
+    /// <param name="task">The task containing Result value.</param>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="T">The type of the value.</typeparam>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    public static AwaitableResult<TResult> Convert<T, TResult>(this AwaitableResult<T> task, Converter<T, Result<TResult>> converter)
+    {
+        async Task<TResult> ConvertInternal()
+        {
+            var result = await task.ConfigureAwait(false);
+            var conversionResult = result.Convert(converter);
+            return conversionResult.IsSuccessful ? conversionResult.Value : throw conversionResult.Error;
+        }
+
+        return ConvertInternal().SuspendException();
+    }
+
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function. If not,
+    /// forward the exception.
+    /// </summary>
+    /// <param name="task">The task containing Result value.</param>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="T">The type of the value.</typeparam>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    public static AwaitableResult<TResult> Convert<T, TResult>(this AwaitableResult<T> task, Converter<T, Task<TResult>> converter)
+    {
+        async Task<TResult> ConvertInternal()
+        {
+            var result = await task.ConfigureAwait(false);
+            var conversionResult = await result.Convert(converter);
+            return conversionResult.IsSuccessful ? conversionResult.Value : throw conversionResult.Error;
+        }
+
+        return ConvertInternal().SuspendException();
+    }
+
+    /// <summary>
+    /// Converts the awaitable Result into a task holding <see cref="Optional{T}"/>.
+    /// </summary>
+    /// <returns>A task holding an Option monad representing value in this monad.</returns>
+    public static async Task<Optional<T>> TryGet<T>(this AwaitableResult<T> awaitableResult)
+        => (await awaitableResult.ConfigureAwait(false)).TryGet();
 }
 
 /// <summary>
@@ -201,6 +284,78 @@ private Result<TResult> Convert<TResult, TConverter>(TConverter converter)
         return result;
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private Result<TResult> ConvertResult<TResult, TConverter>(TConverter converter)
+        where TConverter : struct, ISupplier<T, Result<TResult>>
+    {
+        Result<TResult> result;
+        if (exception is null)
+        {
+            try
+            {
+                result = converter.Invoke(value);
+            }
+            catch (Exception e)
+            {
+                result = new(e);
+            }
+        }
+        else
+        {
+            result = new(exception);
+        }
+
+        return result;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private AwaitableResult<TResult> ConvertTask<TResult, TConverter>(TConverter converter)
+        where TConverter : struct, ISupplier<T, Task<TResult>>
+    {
+        AwaitableResult<TResult> result;
+        if (exception is null)
+        {
+            try
+            {
+                result = converter.Invoke(value).SuspendException();
+            }
+            catch (Exception e)
+            {
+                result = new(Task.FromException<TResult>(e));
+            }
+        }
+        else
+        {
+            result = new(Task.FromException<TResult>(exception.SourceException));
+        }
+
+        return result;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private AwaitableResult<TResult> ConvertAwaitableResult<TResult, TConverter>(TConverter converter)
+        where TConverter : struct, ISupplier<T, AwaitableResult<TResult>>
+    {
+        AwaitableResult<TResult> result;
+        if (exception is null)
+        {
+            var valueCopy = value;
+            async Task<TResult> GetConversionResult()
+            {
+                var conversionResult = await converter.Invoke(valueCopy).ConfigureAwait(false);
+                return conversionResult.IsSuccessful ? conversionResult.Value : throw conversionResult.Error;
+            }
+
+            result = new(GetConversionResult());
+        }
+        else
+        {
+            result = new(Task.FromException<TResult>(exception.SourceException));
+        }
+
+        return result;
+    }
+
     /// <summary>
     /// If successful result is present, apply the provided mapping function hiding any exception
     /// caused by the converter.
@@ -211,6 +366,36 @@ private Result<TResult> Convert<TResult, TConverter>(TConverter converter)
     public Result<TResult> Convert<TResult>(Converter<T, TResult> converter)
         => Convert<TResult, DelegatingConverter<T, TResult>>(converter);
 
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function. If not,
+    /// forward the exception.
+    /// </summary>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    public Result<TResult> Convert<TResult>(Converter<T, Result<TResult>> converter)
+        => ConvertResult<TResult, DelegatingConverter<T, Result<TResult>>>(converter);
+
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function. If not,
+    /// forward the exception.
+    /// </summary>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    public AwaitableResult<TResult> Convert<TResult>(Converter<T, Task<TResult>> converter)
+        => ConvertTask<TResult, DelegatingConverter<T, Task<TResult>>>(converter);
+
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function. If not,
+    /// forward the exception.
+    /// </summary>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    public AwaitableResult<TResult> Convert<TResult>(Converter<T, AwaitableResult<TResult>> converter)
+        => ConvertAwaitableResult<TResult, DelegatingConverter<T, AwaitableResult<TResult>>>(converter);
+
     /// <summary>
     /// If successful result is present, apply the provided mapping function hiding any exception
     /// caused by the converter.
@@ -222,6 +407,39 @@ public Result<TResult> Convert<TResult>(Converter<T, TResult> converter)
     public unsafe Result<TResult> Convert<TResult>(delegate*<T, TResult> converter)
         => Convert<TResult, Supplier<T, TResult>>(converter);
 
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function. If not,
+    /// forward the exception.
+    /// </summary>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    [CLSCompliant(false)]
+    public unsafe Result<TResult> Convert<TResult>(delegate*<T, Result<TResult>> converter)
+        => ConvertResult<TResult, Supplier<T, Result<TResult>>>(converter);
+
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function. If not,
+    /// forward the exception.
+    /// </summary>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    [CLSCompliant(false)]
+    public unsafe AwaitableResult<TResult> Convert<TResult>(delegate*<T, Task<TResult>> converter)
+        => ConvertTask<TResult, Supplier<T, Task<TResult>>>(converter);
+
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function. If not,
+    /// forward the exception.
+    /// </summary>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    [CLSCompliant(false)]
+    public unsafe AwaitableResult<TResult> Convert<TResult>(delegate*<T, AwaitableResult<TResult>> converter)
+        => ConvertAwaitableResult<TResult, Supplier<T, AwaitableResult<TResult>>>(converter);
+
     /// <summary>
     /// Attempts to extract value from container if it is present.
     /// </summary>
@@ -322,6 +540,13 @@ public ValueTask<T> AsTask()
             { } error => ValueTask.FromException<T>(error),
         };
 
+    /// <summary>
+    /// Converts this result to <see cref="AwaitableResult{TResult}"/>.
+    /// </summary>
+    /// <returns>The awaitable Result representing the result.</returns>
+    public AwaitableResult<T> ToAwaitable()
+        => IsSuccessful ? new(Task.FromResult(value)) : new(Task.FromException<T>(Error));
+
     /// <summary>
     /// Converts the result to <see cref="Task{TResult}"/>.
     /// </summary>
@@ -537,6 +762,11 @@ private Result<TResult, TError> Convert<TResult, TConverter>(TConverter converte
         where TConverter : struct, ISupplier<T, TResult>
         => IsSuccessful ? new(converter.Invoke(value)) : new(Error);
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private Result<TResult, TError> ConvertResult<TResult, TConverter>(TConverter converter)
+        where TConverter : struct, ISupplier<T, Result<TResult, TError>>
+        => IsSuccessful ? converter.Invoke(value) : new(Error);
+
     /// <summary>
     /// If successful result is present, apply the provided mapping function hiding any exception
     /// caused by the converter.
@@ -547,6 +777,16 @@ private Result<TResult, TError> Convert<TResult, TConverter>(TConverter converte
     public Result<TResult, TError> Convert<TResult>(Converter<T, TResult> converter)
         => Convert<TResult, DelegatingConverter<T, TResult>>(converter);
 
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function. If not,
+    /// forward the error.
+    /// </summary>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    public Result<TResult, TError> Convert<TResult>(Converter<T, Result<TResult, TError>> converter)
+        => ConvertResult<TResult, DelegatingConverter<T, Result<TResult,TError>>>(converter);
+
     /// <summary>
     /// If successful result is present, apply the provided mapping function hiding any exception
     /// caused by the converter.
@@ -558,6 +798,17 @@ public Result<TResult, TError> Convert<TResult>(Converter<T, TResult> converter)
     public unsafe Result<TResult, TError> Convert<TResult>(delegate*<T, TResult> converter)
         => Convert<TResult, Supplier<T, TResult>>(converter);
 
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function. If not,
+    /// forward the error.
+    /// </summary>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    [CLSCompliant(false)]
+    public unsafe Result<TResult, TError> Convert<TResult>(delegate*<T, Result<TResult, TError>> converter)
+        => ConvertResult<TResult, Supplier<T, Result<TResult, TError>>>(converter);
+
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private T OrInvoke<TSupplier>(TSupplier defaultFunc)
         where TSupplier : struct, ISupplier<T>
diff --git a/src/DotNext/Threading/Tasks/Conversion.cs b/src/DotNext/Threading/Tasks/Conversion.cs
index ac0535739..5d235be85 100644
--- a/src/DotNext/Threading/Tasks/Conversion.cs
+++ b/src/DotNext/Threading/Tasks/Conversion.cs
@@ -3,6 +3,7 @@
 
 namespace DotNext.Threading.Tasks;
 
+using System.Threading.Tasks;
 using Runtime.CompilerServices;
 
 /// <summary>
@@ -20,6 +21,16 @@ public static class Conversion
     public static Task<TOutput> Convert<TInput, TOutput>(this Task<TInput> task)
         where TInput : TOutput => task.Convert(Converter.Identity<TInput, TOutput>());
 
+    /// <summary>
+    /// Converts one type of <see cref="AwaitableResult{T}"/> into another.
+    /// </summary>
+    /// <typeparam name="TInput">The source Result type.</typeparam>
+    /// <typeparam name="TOutput">The target Result type.</typeparam>
+    /// <param name="awaitableResult">The awaitable Result to convert.</param>
+    /// <returns>The converted task.</returns>
+    public static AwaitableResult<TOutput> Convert<TInput, TOutput>(this AwaitableResult<TInput> awaitableResult)
+        where TInput : TOutput => awaitableResult.Convert(Converter.Identity<TInput, TOutput>());
+
     /// <summary>
     /// Converts one type of task into another.
     /// </summary>
@@ -31,6 +42,25 @@ public static Task<TOutput> Convert<TInput, TOutput>(this Task<TInput> task)
     public static async Task<TOutput> Convert<TInput, TOutput>(this Task<TInput> task, Converter<TInput, TOutput> converter)
         => converter(await task.ConfigureAwait(false));
 
+    /// <summary>
+    /// Converts one type of <see cref="AwaitableResult{T}"/> into another.
+    /// </summary>
+    /// <typeparam name="TInput">The source Result type.</typeparam>
+    /// <typeparam name="TOutput">The target Result type.</typeparam>
+    /// <param name="awaitableResult">The awaitable Result to convert.</param>
+    /// <param name="converter">Non-blocking conversion function.</param>
+    /// <returns>The converted task.</returns>
+    public static AwaitableResult<TOutput> Convert<TInput, TOutput>(this AwaitableResult<TInput> awaitableResult, Converter<TInput, TOutput> converter)
+    {
+        async Task<TOutput> ConvertInternal()
+        {
+            var result = await awaitableResult.ConfigureAwait(false);
+            return result.IsSuccessful ? converter(result.Value) : throw result.Error;
+        }
+
+        return ConvertInternal().SuspendException();
+    }
+
     /// <summary>
     /// Converts value type into nullable value type.
     /// </summary>
@@ -53,6 +83,26 @@ public static async Task<TOutput> Convert<TInput, TOutput>(this Task<TInput> tas
     public static async Task<TOutput> Convert<TInput, TOutput>(this Task<TInput> task, Converter<TInput, Task<TOutput>> converter)
         => await converter(await task.ConfigureAwait(false)).ConfigureAwait(false);
 
+    /// <summary>
+    /// Converts one type of <see cref="AwaitableResult{T}"/> into another.
+    /// </summary>
+    /// <typeparam name="TInput">The source Result type.</typeparam>
+    /// <typeparam name="TOutput">The target Result type.</typeparam>
+    /// <param name="awaitableResult">The awaitable Result to convert.</param>
+    /// <param name="converter">Asynchronous conversion function.</param>
+    /// <returns>The converted task.</returns>
+    public static AwaitableResult<TOutput> Convert<TInput, TOutput>(this AwaitableResult<TInput> awaitableResult, Converter<TInput, AwaitableResult<TOutput>> converter)
+    {
+        async Task<TOutput> ConvertInternal()
+        {
+            var result = await awaitableResult.ConfigureAwait(false);
+            var conversionResult = result.IsSuccessful ? await converter(result.Value).ConfigureAwait(false) : throw result.Error;
+            return conversionResult.IsSuccessful ? conversionResult.Value : throw conversionResult.Error;
+        }
+
+        return ConvertInternal().SuspendException();
+    }
+
     /// <summary>
     /// Allows to convert <see cref="Task{TResult}"/> of unknown result type into dynamically
     /// typed task which result can be obtained as <see cref="object"/>