diff --git a/src/Optional.Async.Tests/AsyncEitherTests.cs b/src/Optional.Async.Tests/AsyncEitherTests.cs
index 11ceaa6..de7565c 100644
--- a/src/Optional.Async.Tests/AsyncEitherTests.cs
+++ b/src/Optional.Async.Tests/AsyncEitherTests.cs
@@ -1,10 +1,80 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Threading.Tasks;
 
 namespace Optional.Async.Tests
 {
     [TestClass]
     public class AsyncEitherTests
     {
+        [TestMethod]
+        public async Task AsyncEither_SomeNotNullAsync()
+        {
+            // Arrange
+            var task = Task.FromResult<object>(null);
+            var exception = "A truly exceptional string :)";
+
+            // Act
+            var result = await task.SomeNotNullAsync(exception);
+
+            // Assert
+            var expectedResult = (await task).SomeNotNull(exception);
+
+            result.Should().Be(expectedResult);
+        }
+
+        [TestMethod]
+        public async Task AsyncEither_SomeWhenAsync()
+        {
+            // Arrange
+            var value = ValueGenerator.RandomString();
+            var task = Task.FromResult(value);
+
+            Func<string, bool> predicate = s => s == "This should definitely return false";
+            var error = "Error";
+
+            // Act
+            var result = await task.SomeWhenAsync(predicate, error);
+
+            // Assert
+            var expectedResult = (await task).SomeWhen(predicate, error);
+
+            result.Should().Be(expectedResult);
+        }
+
+        [TestMethod]
+        public async Task AsyncEither_SomeWhenAsync_With_ExceptionFactory()
+        {
+            // Arrange
+            var value = ValueGenerator.RandomString();
+            var task = Task.FromResult(value);
+
+            Func<string, bool> predicate = s => s == "This should definitely return false";
+            Func<string, int> exceptionFactory = _ => 10;
+
+            // Act
+            var result = await task.SomeWhenAsync(predicate, exceptionFactory);
+
+            // Assert
+            var expectedResult = (await task).SomeWhen(predicate, exceptionFactory);
+
+            result.Should().Be(expectedResult);
+        }
+
+        [TestMethod]
+        public async Task AsyncEither_ToAsync()
+        {
+            // Arrange
+            var option = 10.Some<int, string>();
+
+            // Act
+            var result = option.ToAsync();
+
+            // Assert
+            (await result).Should().Be(option);
+        }
+
         [TestMethod]
         public void AsyncEither_MapAsync()
         {
diff --git a/src/Optional.Async.Tests/AsyncMaybeTests.cs b/src/Optional.Async.Tests/AsyncMaybeTests.cs
index 38223a6..fcb0474 100644
--- a/src/Optional.Async.Tests/AsyncMaybeTests.cs
+++ b/src/Optional.Async.Tests/AsyncMaybeTests.cs
@@ -1,6 +1,7 @@
 using FluentAssertions;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Optional.Unsafe;
+using System;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -9,6 +10,89 @@ namespace Optional.Async.Tests
     [TestClass]
     public class AsyncMaybeTests
     {
+        [TestMethod]
+        public async Task AsyncMaybe_ToAsync()
+        {
+            // Arrange
+            var option = 10.Some();
+
+            // Act
+            var result = option.ToAsync();
+
+            // Assert
+            (await result).Should().Be(option);
+        }
+
+        [TestMethod]
+        public async Task AsyncMaybe_FlatMapAsync_To_Exceptional()
+        {
+            // Arrange
+            var option = Option.None<int>();
+            var exceptionalOption = Option.None<int, string>(ValueGenerator.RandomString());
+            var error = "Error";
+
+            // Act
+            var result = await option.FlatMapAsync(_ => Task.FromResult(exceptionalOption), error);
+
+            // Assert
+            var expected = Option.None<int, string>(error);
+
+            result.Should().Be(expected);
+        }
+
+        [TestMethod]
+        public async Task AsyncMaybe_FilterAsync_Should_Return_Exception()
+        {
+            // Arrange
+            var optionTask = ValueGenerator.DelayedSome(10);
+
+            Func<int, Task<bool>> predicate = _ => Task.FromResult(false);
+            var exception = "Error";
+
+            // Act
+            var result = await optionTask.FilterAsync(predicate, exception);
+
+            // Assert
+            var expected = Option.None<int, string>(exception);
+
+            result.Should().Be(expected);
+        }
+
+        [TestMethod]
+        public async Task AsyncMaybe_FilterAsync_Should_Return_Value()
+        {
+            // Arrange
+            var value = 10;
+            var optionTask = ValueGenerator.DelayedSome(value);
+
+            Func<int, Task<bool>> predicate = _ => Task.FromResult(true);
+            var exception = "Error";
+
+            // Act
+            var result = await optionTask.FilterAsync(predicate, exception);
+
+            // Assert
+            var expected = Option.Some<int, string>(value);
+
+            result.Should().Be(expected);
+        }
+
+        [TestMethod]
+        public async Task AsyncMaybe_SomeNotNull()
+        {
+            // Arrange
+            object nullObject = null;
+            var nullTask = Task.FromResult(nullObject);
+
+            // Act
+            var result = await nullTask.SomeNotNullAsync();
+
+            // Assert
+            var expected = nullObject.SomeNotNull();
+
+            result.Should().Be(expected);
+        }
+
         [TestMethod]
         public async Task AsyncMaybe_CanMapAsync()
         {
diff --git a/src/Optional.Async.Tests/ValueGenerator.cs b/src/Optional.Async.Tests/ValueGenerator.cs
index d90c244..9ca29e6 100644
--- a/src/Optional.Async.Tests/ValueGenerator.cs
+++ b/src/Optional.Async.Tests/ValueGenerator.cs
@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System;
+using System.Threading.Tasks;
 
 namespace Optional.Async.Tests
 {
@@ -10,6 +11,10 @@ public static async Task<T> DelayedValue<T>(T value)
             return value;
         }
 
+        public static string RandomString() => Guid.NewGuid().ToString();
+        public static Func<T, Task<TResult>> AsyncOperation<T, TResult>(TResult result) => _ => Task.FromResult(result);
+        public static Func<T, TResult> SynchronousOperation<T, TResult>(TResult result) => _ => result;
+
         public static Task<Option<T>> DelayedSome<T>(T value) => DelayedValue(value.Some());
         public static Task<Option<T, TException>> DelayedSome<T, TException>(T value) => DelayedValue(value.Some<T, TException>());
 
diff --git a/src/Optional.Async/OptionTaskExtensions_Either.cs b/src/Optional.Async/OptionTaskExtensions_Either.cs
index ff90197..e94a62d 100644
--- a/src/Optional.Async/OptionTaskExtensions_Either.cs
+++ b/src/Optional.Async/OptionTaskExtensions_Either.cs
@@ -5,68 +5,81 @@ namespace Optional.Async
 {
     public static partial class OptionTaskExtensions
     {
-        public static Task<Option<TResult, TException>> MapAsync<T, TException, TResult>(this Option<T, TException> option, Func<T, Task<TResult>> mapping)
+        public static async Task<Option<T, TException>> ElseAsync<T, TException>(this Option<T, TException> option, Func<Task<Option<T, TException>>> alternativeOptionFactory)
         {
-            if (mapping == null) throw new ArgumentNullException(nameof(mapping));
+            if (alternativeOptionFactory == null) throw new ArgumentNullException(nameof(alternativeOptionFactory));
 
-            return option.Map(mapping).Match(
-                some: async valueTask =>
-                {
-                    if (valueTask == null) throw new InvalidOperationException($"{nameof(mapping)} must not return a null task.");
-                    var value = await valueTask.ConfigureAwait(continueOnCapturedContext: false);
-                    return value.Some<TResult, TException>();
-                },
-                none: exception => Task.FromResult(Option.None<TResult, TException>(exception))
-            );
+            if (option.HasValue) return option;
+
+            var alternativeOptionTask = alternativeOptionFactory();
+            if (alternativeOptionTask == null) throw new InvalidOperationException($"{nameof(alternativeOptionFactory)} must not return a null task.");
+
+            return await alternativeOptionTask.ConfigureAwait(continueOnCapturedContext: false);
         }
 
-        public static async Task<Option<TResult, TException>> MapAsync<T, TException, TResult>(this Task<Option<T, TException>> optionTask, Func<T, TResult> mapping, bool executeOnCapturedContext = false)
+        public static async Task<Option<T, TException>> ElseAsync<T, TException>(this Task<Option<T, TException>> optionTask, Func<Option<T, TException>> alternativeOptionFactory, bool executeOnCapturedContext = false)
         {
             if (optionTask == null) throw new ArgumentNullException(nameof(optionTask));
-            if (mapping == null) throw new ArgumentNullException(nameof(mapping));
+            if (alternativeOptionFactory == null) throw new ArgumentNullException(nameof(alternativeOptionFactory));
 
             var option = await optionTask.ConfigureAwait(executeOnCapturedContext);
-            return option.Map(mapping);
+            return option.Else(alternativeOptionFactory);
         }
 
-        public static async Task<Option<TResult, TException>> MapAsync<T, TException, TResult>(this Task<Option<T, TException>> optionTask, Func<T, Task<TResult>> mapping, bool executeOnCapturedContext = false)
+        public static async Task<Option<T, TException>> ElseAsync<T, TException>(this Task<Option<T, TException>> optionTask, Func<Task<Option<T, TException>>> alternativeOptionFactory, bool executeOnCapturedContext = false)
         {
             if (optionTask == null) throw new ArgumentNullException(nameof(optionTask));
-            if (mapping == null) throw new ArgumentNullException(nameof(mapping));
+            if (alternativeOptionFactory == null) throw new ArgumentNullException(nameof(alternativeOptionFactory));
 
             var option = await optionTask.ConfigureAwait(executeOnCapturedContext);
-            return await option.MapAsync(mapping).ConfigureAwait(continueOnCapturedContext: false);
+            return await option.ElseAsync(alternativeOptionFactory).ConfigureAwait(continueOnCapturedContext: false);
         }
 
-        public static Task<Option<T, TExceptionResult>> MapExceptionAsync<T, TException, TExceptionResult>(this Option<T, TException> option, Func<TException, Task<TExceptionResult>> mapping)
+        public static Task<Option<T, TException>> FilterAsync<T, TException>(this Option<T, TException> option, Func<T, Task<bool>> predicate, TException exception) =>
+            option.FilterAsync(predicate, () => exception);
+
+        public static Task<Option<T, TException>> FilterAsync<T, TException>(this Option<T, TException> option, Func<T, Task<bool>> predicate, Func<TException> exceptionFactory)
         {
-            return option.MapException(mapping).Match(
-                some: value => Task.FromResult(Option.Some<T, TExceptionResult>(value)),
-                none: async exceptionTask =>
+            if (predicate == null) throw new ArgumentNullException(nameof(predicate));
+            if (exceptionFactory == null) throw new ArgumentNullException(nameof(exceptionFactory));
+
+            return option.Match(
+                some: async value =>
                 {
-                    if (exceptionTask == null) throw new InvalidOperationException($"{nameof(mapping)} must not return a null task.");
-                    var exception = await exceptionTask.ConfigureAwait(continueOnCapturedContext: false);
-                    return Option.None<T, TExceptionResult>(exception);
-                }
+                    var predicateTask = predicate(value);
+                    if (predicateTask == null) throw new InvalidOperationException($"{nameof(predicate)} must not return a null task.");
+
+                    var condition = await predicateTask.ConfigureAwait(continueOnCapturedContext: false);
+                    return option.Filter(condition, exceptionFactory);
+                },
+                none: _ => Task.FromResult(option)
             );
         }
 
-        public static async Task<Option<T, TExceptionResult>> MapExceptionAsync<T, TException, TExceptionResult>(this Task<Option<T, TException>> optionTask, Func<TException, TExceptionResult> mapping, bool executeOnCapturedContext = false)
+        public static Task<Option<T, TException>> FilterAsync<T, TException>(this Task<Option<T, TException>> optionTask, Func<T, bool> predicate, TException exception, bool executeOnCapturedContext = false) =>
+            optionTask.FilterAsync(predicate, () => exception, executeOnCapturedContext);
+
+        public static async Task<Option<T, TException>> FilterAsync<T, TException>(this Task<Option<T, TException>> optionTask, Func<T, bool> predicate, Func<TException> exceptionFactory, bool executeOnCapturedContext = false)
         {
             if (optionTask == null) throw new ArgumentNullException(nameof(optionTask));
-            if (mapping == null) throw new ArgumentNullException(nameof(mapping));
+            if (predicate == null) throw new ArgumentNullException(nameof(predicate));
+            if (exceptionFactory == null) throw new ArgumentNullException(nameof(exceptionFactory));
 
             var option = await optionTask.ConfigureAwait(executeOnCapturedContext);
-            return option.MapException(mapping);
+            return option.Filter(predicate, exceptionFactory);
         }
 
-        public static async Task<Option<T, TExceptionResult>> MapExceptionAsync<T, TException, TExceptionResult>(this Task<Option<T, TException>> optionTask, Func<TException, Task<TExceptionResult>> mapping, bool executeOnCapturedContext = false)
+        public static Task<Option<T, TException>> FilterAsync<T, TException>(this Task<Option<T, TException>> optionTask, Func<T, Task<bool>> predicate, TException exception, bool executeOnCapturedContext = false) =>
+            optionTask.FilterAsync(predicate, () => exception, executeOnCapturedContext);
+
+        public static async Task<Option<T, TException>> FilterAsync<T, TException>(this Task<Option<T, TException>> optionTask, Func<T, Task<bool>> predicate, Func<TException> exceptionFactory, bool executeOnCapturedContext = false)
         {
             if (optionTask == null) throw new ArgumentNullException(nameof(optionTask));
-            if (mapping == null) throw new ArgumentNullException(nameof(mapping));
+            if (predicate == null) throw new ArgumentNullException(nameof(predicate));
+            if (exceptionFactory == null) throw new ArgumentNullException(nameof(exceptionFactory));
 
             var option = await optionTask.ConfigureAwait(executeOnCapturedContext);
-            return await option.MapExceptionAsync(mapping).ConfigureAwait(false);
+            return await option.FilterAsync(predicate, exceptionFactory).ConfigureAwait(continueOnCapturedContext: false);
         }
 
         public static Task<Option<TResult, TException>> FlatMapAsync<T, TException, TResult>(this Option<T, TException> option, Func<T, Task<Option<TResult, TException>>> mapping)
@@ -143,51 +156,76 @@ public static async Task<Option<TResult, TException>> FlatMapAsync<T, TException
             return await option.FlatMapAsync(mapping, exceptionFactory).ConfigureAwait(continueOnCapturedContext: false);
         }
 
-        public static Task<Option<T, TException>> FilterAsync<T, TException>(this Option<T, TException> option, Func<T, Task<bool>> predicate, TException exception) =>
-            option.FilterAsync(predicate, () => exception);
+        public static async Task<Option<T, TException>> FlattenAsync<T, TException>(this Task<Option<Option<T, TException>, TException>> optionTask)
+        {
+            if (optionTask == null) throw new ArgumentNullException(nameof(optionTask));
 
-        public static Task<Option<T, TException>> FilterAsync<T, TException>(this Option<T, TException> option, Func<T, Task<bool>> predicate, Func<TException> exceptionFactory)
+            var option = await optionTask.ConfigureAwait(continueOnCapturedContext: false);
+            return option.Flatten();
+        }
+
+        public static Task<Option<TResult, TException>> MapAsync<T, TException, TResult>(this Option<T, TException> option, Func<T, Task<TResult>> mapping)
         {
-            if (predicate == null) throw new ArgumentNullException(nameof(predicate));
-            if (exceptionFactory == null) throw new ArgumentNullException(nameof(exceptionFactory));
+            if (mapping == null) throw new ArgumentNullException(nameof(mapping));
 
-            return option.Match(
-                some: async value =>
+            return option.Map(mapping).Match(
+                some: async valueTask =>
                 {
-                    var predicateTask = predicate(value);
-                    if (predicateTask == null) throw new InvalidOperationException($"{nameof(predicate)} must not return a null task.");
-
-                    var condition = await predicateTask.ConfigureAwait(continueOnCapturedContext: false);
-                    return option.Filter(condition, exceptionFactory);
+                    if (valueTask == null) throw new InvalidOperationException($"{nameof(mapping)} must not return a null task.");
+                    var value = await valueTask.ConfigureAwait(continueOnCapturedContext: false);
+                    return value.Some<TResult, TException>();
                 },
-                none: _ => Task.FromResult(option)
+                none: exception => Task.FromResult(Option.None<TResult, TException>(exception))
             );
         }
 
-        public static Task<Option<T, TException>> FilterAsync<T, TException>(this Task<Option<T, TException>> optionTask, Func<T, bool> predicate, TException exception, bool executeOnCapturedContext = false) =>
-            optionTask.FilterAsync(predicate, () => exception, executeOnCapturedContext);
+        public static async Task<Option<TResult, TException>> MapAsync<T, TException, TResult>(this Task<Option<T, TException>> optionTask, Func<T, TResult> mapping, bool executeOnCapturedContext = false)
+        {
+            if (optionTask == null) throw new ArgumentNullException(nameof(optionTask));
+            if (mapping == null) throw new ArgumentNullException(nameof(mapping));
 
-        public static async Task<Option<T, TException>> FilterAsync<T, TException>(this Task<Option<T, TException>> optionTask, Func<T, bool> predicate, Func<TException> exceptionFactory, bool executeOnCapturedContext = false)
+            var option = await optionTask.ConfigureAwait(executeOnCapturedContext);
+            return option.Map(mapping);
+        }
+
+        public static async Task<Option<TResult, TException>> MapAsync<T, TException, TResult>(this Task<Option<T, TException>> optionTask, Func<T, Task<TResult>> mapping, bool executeOnCapturedContext = false)
         {
             if (optionTask == null) throw new ArgumentNullException(nameof(optionTask));
-            if (predicate == null) throw new ArgumentNullException(nameof(predicate));
-            if (exceptionFactory == null) throw new ArgumentNullException(nameof(exceptionFactory));
+            if (mapping == null) throw new ArgumentNullException(nameof(mapping));
 
             var option = await optionTask.ConfigureAwait(executeOnCapturedContext);
-            return option.Filter(predicate, exceptionFactory);
+            return await option.MapAsync(mapping).ConfigureAwait(continueOnCapturedContext: false);
         }
 
-        public static Task<Option<T, TException>> FilterAsync<T, TException>(this Task<Option<T, TException>> optionTask, Func<T, Task<bool>> predicate, TException exception, bool executeOnCapturedContext = false) =>
-            optionTask.FilterAsync(predicate, () => exception, executeOnCapturedContext);
+        public static Task<Option<T, TExceptionResult>> MapExceptionAsync<T, TException, TExceptionResult>(this Option<T, TException> option, Func<TException, Task<TExceptionResult>> mapping)
+        {
+            return option.MapException(mapping).Match(
+                some: value => Task.FromResult(Option.Some<T, TExceptionResult>(value)),
+                none: async exceptionTask =>
+                {
+                    if (exceptionTask == null) throw new InvalidOperationException($"{nameof(mapping)} must not return a null task.");
+                    var exception = await exceptionTask.ConfigureAwait(continueOnCapturedContext: false);
+                    return Option.None<T, TExceptionResult>(exception);
+                }
+            );
+        }
 
-        public static async Task<Option<T, TException>> FilterAsync<T, TException>(this Task<Option<T, TException>> optionTask, Func<T, Task<bool>> predicate, Func<TException> exceptionFactory, bool executeOnCapturedContext = false)
+        public static async Task<Option<T, TExceptionResult>> MapExceptionAsync<T, TException, TExceptionResult>(this Task<Option<T, TException>> optionTask, Func<TException, TExceptionResult> mapping, bool executeOnCapturedContext = false)
         {
             if (optionTask == null) throw new ArgumentNullException(nameof(optionTask));
-            if (predicate == null) throw new ArgumentNullException(nameof(predicate));
-            if (exceptionFactory == null) throw new ArgumentNullException(nameof(exceptionFactory));
+            if (mapping == null) throw new ArgumentNullException(nameof(mapping));
 
             var option = await optionTask.ConfigureAwait(executeOnCapturedContext);
-            return await option.FilterAsync(predicate, exceptionFactory).ConfigureAwait(continueOnCapturedContext: false);
+            return option.MapException(mapping);
+        }
+
+        public static async Task<Option<T, TExceptionResult>> MapExceptionAsync<T, TException, TExceptionResult>(this Task<Option<T, TException>> optionTask, Func<TException, Task<TExceptionResult>> mapping, bool executeOnCapturedContext = false)
+        {
+            if (optionTask == null) throw new ArgumentNullException(nameof(optionTask));
+            if (mapping == null) throw new ArgumentNullException(nameof(mapping));
+
+            var option = await optionTask.ConfigureAwait(executeOnCapturedContext);
+            return await option.MapExceptionAsync(mapping).ConfigureAwait(false);
         }
 
         public static Task<Option<T, TException>> NotNullAsync<T, TException>(this Task<Option<T, TException>> optionTask, TException exception) =>
@@ -231,35 +269,23 @@ public static async Task<Option<T, TException>> OrAsync<T, TException>(this Task
             return await option.OrAsync(alternativeFactory).ConfigureAwait(continueOnCapturedContext: false);
         }
 
-        public static async Task<Option<T, TException>> ElseAsync<T, TException>(this Option<T, TException> option, Func<Task<Option<T, TException>>> alternativeOptionFactory)
-        {
-            if (alternativeOptionFactory == null) throw new ArgumentNullException(nameof(alternativeOptionFactory));
+        public static async Task<Option<T, TException>> SomeNotNullAsync<T, TException>(this Task<T> task, TException exception) =>
+                                                                                                                                                                                                                                                            (await task).SomeNotNull(exception);
 
-            if (option.HasValue) return option;
-
-            var alternativeOptionTask = alternativeOptionFactory();
-            if (alternativeOptionTask == null) throw new InvalidOperationException($"{nameof(alternativeOptionFactory)} must not return a null task.");
-
-            return await alternativeOptionTask.ConfigureAwait(continueOnCapturedContext: false);
-        }
-
-        public static async Task<Option<T, TException>> ElseAsync<T, TException>(this Task<Option<T, TException>> optionTask, Func<Option<T, TException>> alternativeOptionFactory, bool executeOnCapturedContext = false)
+        public static async Task<Option<T, TException>> SomeWhenAsync<T, TException>(this Task<T> valueTask, Func<T, bool> predicate, Func<T, TException> exceptionFactory)
         {
-            if (optionTask == null) throw new ArgumentNullException(nameof(optionTask));
-            if (alternativeOptionFactory == null) throw new ArgumentNullException(nameof(alternativeOptionFactory));
+            var value = await valueTask;
+            var result = predicate(value);
 
-            var option = await optionTask.ConfigureAwait(executeOnCapturedContext);
-            return option.Else(alternativeOptionFactory);
+            return result ?
+                value.Some<T, TException>() :
+                Option.None<T, TException>(exceptionFactory(value));
         }
 
-        public static async Task<Option<T, TException>> ElseAsync<T, TException>(this Task<Option<T, TException>> optionTask, Func<Task<Option<T, TException>>> alternativeOptionFactory, bool executeOnCapturedContext = false)
-        {
-            if (optionTask == null) throw new ArgumentNullException(nameof(optionTask));
-            if (alternativeOptionFactory == null) throw new ArgumentNullException(nameof(alternativeOptionFactory));
+        public static async Task<Option<T, TException>> SomeWhenAsync<T, TException>(this Task<T> task, Func<T, bool> predicate, TException exception) =>
+            (await task).SomeWhen(predicate, exception);
 
-            var option = await optionTask.ConfigureAwait(executeOnCapturedContext);
-            return await option.ElseAsync(alternativeOptionFactory).ConfigureAwait(continueOnCapturedContext: false);
-        }
+        public static Task<Option<T, TException>> ToAsync<T, TException>(this Option<T, TException> option) => Task.FromResult(option);
 
         public static async Task<Option<T>> WithoutExceptionAsync<T, TException>(this Task<Option<T, TException>> optionTask)
         {
@@ -268,13 +294,5 @@ public static async Task<Option<T>> WithoutExceptionAsync<T, TException>(this Ta
             var option = await optionTask.ConfigureAwait(false);
             return option.WithoutException();
         }
-
-        public static async Task<Option<T, TException>> FlattenAsync<T, TException>(this Task<Option<Option<T, TException>, TException>> optionTask)
-        {
-            if (optionTask == null) throw new ArgumentNullException(nameof(optionTask));
-
-            var option = await optionTask.ConfigureAwait(continueOnCapturedContext: false);
-            return option.Flatten();
-        }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Optional.Async/OptionTaskExtensions_Maybe.cs b/src/Optional.Async/OptionTaskExtensions_Maybe.cs
index ae70a15..b4d9a43 100644
--- a/src/Optional.Async/OptionTaskExtensions_Maybe.cs
+++ b/src/Optional.Async/OptionTaskExtensions_Maybe.cs
@@ -5,37 +5,86 @@ namespace Optional.Async
 {
     public static partial class OptionTaskExtensions
     {
-        public static Task<Option<TResult>> MapAsync<T, TResult>(this Option<T> option, Func<T, Task<TResult>> mapping)
+        public static async Task<Option<T>> ElseAsync<T>(this Option<T> option, Func<Task<Option<T>>> alternativeOptionFactory)
         {
-            if (mapping == null) throw new ArgumentNullException(nameof(mapping));
+            if (alternativeOptionFactory == null) throw new ArgumentNullException(nameof(alternativeOptionFactory));
 
-            return option.Map(mapping).Match(
-                some: async valueTask =>
+            if (option.HasValue) return option;
+
+            var alternativeOptionTask = alternativeOptionFactory();
+            if (alternativeOptionTask == null) throw new InvalidOperationException($"{nameof(alternativeOptionFactory)} must not return a null task.");
+
+            return await alternativeOptionTask.ConfigureAwait(continueOnCapturedContext: false);
+        }
+
+        public static async Task<Option<T>> ElseAsync<T>(this Task<Option<T>> optionTask, Func<Option<T>> alternativeOptionFactory, bool executeOnCapturedContext = false)
+        {
+            if (optionTask == null) throw new ArgumentNullException(nameof(optionTask));
+            if (alternativeOptionFactory == null) throw new ArgumentNullException(nameof(alternativeOptionFactory));
+
+            var option = await optionTask.ConfigureAwait(executeOnCapturedContext);
+            return option.Else(alternativeOptionFactory);
+        }
+
+        public static async Task<Option<T>> ElseAsync<T>(this Task<Option<T>> optionTask, Func<Task<Option<T>>> alternativeOptionFactory, bool executeOnCapturedContext = false)
+        {
+            if (optionTask == null) throw new ArgumentNullException(nameof(optionTask));
+            if (alternativeOptionFactory == null) throw new ArgumentNullException(nameof(alternativeOptionFactory));
+
+            var option = await optionTask.ConfigureAwait(executeOnCapturedContext);
+            return await option.ElseAsync(alternativeOptionFactory).ConfigureAwait(continueOnCapturedContext: false);
+        }
+
+        public static async Task<Option<T, TException>> FilterAsync<T, TException>(this Task<Option<T>> optionTask, Func<T, Task<bool>> predicate, TException exception) =>
+            await (await optionTask).FilterAsync(predicate).WithExceptionAsync(exception);
+
+        public static Task<Option<T>> FilterAsync<T>(this Option<T> option, Func<T, Task<bool>> predicate)
+        {
+            if (predicate == null) throw new ArgumentNullException(nameof(predicate));
+
+            return option.Match(
+                some: async value =>
                 {
-                    if (valueTask == null) throw new InvalidOperationException($"{nameof(mapping)} must not return a null task.");
-                    var value = await valueTask.ConfigureAwait(continueOnCapturedContext: false);
-                    return value.Some();
+                    var predicateTask = predicate(value);
+                    if (predicateTask == null) throw new InvalidOperationException($"{nameof(predicate)} must not return a null task.");
+
+                    var condition = await predicateTask.ConfigureAwait(continueOnCapturedContext: false);
+                    return option.Filter(condition);
                 },
-                none: () => Task.FromResult(Option.None<TResult>())
+                none: () => Task.FromResult(option)
             );
         }
 
-        public static async Task<Option<TResult>> MapAsync<T, TResult>(this Task<Option<T>> optionTask, Func<T, TResult> mapping, bool executeOnCapturedContext = false)
+        public static async Task<Option<T>> FilterAsync<T>(this Task<Option<T>> optionTask, Func<T, bool> predicate, bool executeOnCapturedContext = false)
         {
             if (optionTask == null) throw new ArgumentNullException(nameof(optionTask));
-            if (mapping == null) throw new ArgumentNullException(nameof(mapping));
+            if (predicate == null) throw new ArgumentNullException(nameof(predicate));
 
             var option = await optionTask.ConfigureAwait(executeOnCapturedContext);
-            return option.Map(mapping);
+            return option.Filter(predicate);
         }
 
-        public static async Task<Option<TResult>> MapAsync<T, TResult>(this Task<Option<T>> optionTask, Func<T, Task<TResult>> mapping, bool executeOnCapturedContext = false)
+        public static async Task<Option<T>> FilterAsync<T>(this Task<Option<T>> optionTask, Func<T, Task<bool>> predicate, bool executeOnCapturedContext = false)
         {
             if (optionTask == null) throw new ArgumentNullException(nameof(optionTask));
-            if (mapping == null) throw new ArgumentNullException(nameof(mapping));
+            if (predicate == null) throw new ArgumentNullException(nameof(predicate));
 
             var option = await optionTask.ConfigureAwait(executeOnCapturedContext);
-            return await option.MapAsync(mapping).ConfigureAwait(continueOnCapturedContext: false);
+            return await option.FilterAsync(predicate).ConfigureAwait(continueOnCapturedContext: false);
+        }
+
+        public static Task<Option<TResult, TException>> FlatMapAsync<T, TException, TResult>(this Option<T> option, Func<T, Task<Option<TResult, TException>>> mapping, TException exception)
+        {
+            if (mapping == null) throw new ArgumentNullException(nameof(mapping));
+
+            return option.Map(mapping).Match(
+                some: resultOptionTask =>
+                {
+                    if (resultOptionTask == null) throw new InvalidOperationException($"{nameof(mapping)} must not return a null task.");
+                    return resultOptionTask;
+                },
+                none: () => Task.FromResult(Option.None<TResult, TException>(exception))
+            );
         }
 
         public static Task<Option<TResult>> FlatMapAsync<T, TResult>(this Option<T> option, Func<T, Task<Option<TResult>>> mapping)
@@ -100,39 +149,45 @@ public static async Task<Option<TResult>> FlatMapAsync<T, TResult, TException>(t
             return await option.FlatMapAsync(mapping).ConfigureAwait(continueOnCapturedContext: false);
         }
 
-        public static Task<Option<T>> FilterAsync<T>(this Option<T> option, Func<T, Task<bool>> predicate)
+        public static async Task<Option<T>> FlattenAsync<T>(this Task<Option<Option<T>>> optionTask)
         {
-            if (predicate == null) throw new ArgumentNullException(nameof(predicate));
+            if (optionTask == null) throw new ArgumentNullException(nameof(optionTask));
 
-            return option.Match(
-                some: async value =>
-                {
-                    var predicateTask = predicate(value);
-                    if (predicateTask == null) throw new InvalidOperationException($"{nameof(predicate)} must not return a null task.");
+            var option = await optionTask.ConfigureAwait(continueOnCapturedContext: false);
+            return option.Flatten();
+        }
 
-                    var condition = await predicateTask.ConfigureAwait(continueOnCapturedContext: false);
-                    return option.Filter(condition);
+        public static Task<Option<TResult>> MapAsync<T, TResult>(this Option<T> option, Func<T, Task<TResult>> mapping)
+        {
+            if (mapping == null) throw new ArgumentNullException(nameof(mapping));
+
+            return option.Map(mapping).Match(
+                some: async valueTask =>
+                {
+                    if (valueTask == null) throw new InvalidOperationException($"{nameof(mapping)} must not return a null task.");
+                    var value = await valueTask.ConfigureAwait(continueOnCapturedContext: false);
+                    return value.Some();
                 },
-                none: () => Task.FromResult(option)
+                none: () => Task.FromResult(Option.None<TResult>())
             );
         }
 
-        public static async Task<Option<T>> FilterAsync<T>(this Task<Option<T>> optionTask, Func<T, bool> predicate, bool executeOnCapturedContext = false)
+        public static async Task<Option<TResult>> MapAsync<T, TResult>(this Task<Option<T>> optionTask, Func<T, TResult> mapping, bool executeOnCapturedContext = false)
         {
             if (optionTask == null) throw new ArgumentNullException(nameof(optionTask));
-            if (predicate == null) throw new ArgumentNullException(nameof(predicate));
+            if (mapping == null) throw new ArgumentNullException(nameof(mapping));
 
             var option = await optionTask.ConfigureAwait(executeOnCapturedContext);
-            return option.Filter(predicate);
+            return option.Map(mapping);
         }
 
-        public static async Task<Option<T>> FilterAsync<T>(this Task<Option<T>> optionTask, Func<T, Task<bool>> predicate, bool executeOnCapturedContext = false)
+        public static async Task<Option<TResult>> MapAsync<T, TResult>(this Task<Option<T>> optionTask, Func<T, Task<TResult>> mapping, bool executeOnCapturedContext = false)
         {
             if (optionTask == null) throw new ArgumentNullException(nameof(optionTask));
-            if (predicate == null) throw new ArgumentNullException(nameof(predicate));
+            if (mapping == null) throw new ArgumentNullException(nameof(mapping));
 
             var option = await optionTask.ConfigureAwait(executeOnCapturedContext);
-            return await option.FilterAsync(predicate).ConfigureAwait(continueOnCapturedContext: false);
+            return await option.MapAsync(mapping).ConfigureAwait(continueOnCapturedContext: false);
         }
 
         public static Task<Option<T>> NotNullAsync<T>(this Task<Option<T>> optionTask)
@@ -172,35 +227,9 @@ public static async Task<Option<T>> OrAsync<T>(this Task<Option<T>> optionTask,
             return await option.OrAsync(alternativeFactory).ConfigureAwait(continueOnCapturedContext: false);
         }
 
-        public static async Task<Option<T>> ElseAsync<T>(this Option<T> option, Func<Task<Option<T>>> alternativeOptionFactory)
-        {
-            if (alternativeOptionFactory == null) throw new ArgumentNullException(nameof(alternativeOptionFactory));
-
-            if (option.HasValue) return option;
-
-            var alternativeOptionTask = alternativeOptionFactory();
-            if (alternativeOptionTask == null) throw new InvalidOperationException($"{nameof(alternativeOptionFactory)} must not return a null task.");
-
-            return await alternativeOptionTask.ConfigureAwait(continueOnCapturedContext: false);
-        }
-
-        public static async Task<Option<T>> ElseAsync<T>(this Task<Option<T>> optionTask, Func<Option<T>> alternativeOptionFactory, bool executeOnCapturedContext = false)
-        {
-            if (optionTask == null) throw new ArgumentNullException(nameof(optionTask));
-            if (alternativeOptionFactory == null) throw new ArgumentNullException(nameof(alternativeOptionFactory));
-
-            var option = await optionTask.ConfigureAwait(executeOnCapturedContext);
-            return option.Else(alternativeOptionFactory);
-        }
+        public static async Task<Option<T>> SomeNotNullAsync<T>(this Task<T> task) => (await task).SomeNotNull();
 
-        public static async Task<Option<T>> ElseAsync<T>(this Task<Option<T>> optionTask, Func<Task<Option<T>>> alternativeOptionFactory, bool executeOnCapturedContext = false)
-        {
-            if (optionTask == null) throw new ArgumentNullException(nameof(optionTask));
-            if (alternativeOptionFactory == null) throw new ArgumentNullException(nameof(alternativeOptionFactory));
-
-            var option = await optionTask.ConfigureAwait(executeOnCapturedContext);
-            return await option.ElseAsync(alternativeOptionFactory).ConfigureAwait(continueOnCapturedContext: false);
-        }
+        public static Task<Option<T>> ToAsync<T>(this Option<T> option) => Task.FromResult(option);
 
         public static Task<Option<T, TException>> WithExceptionAsync<T, TException>(this Task<Option<T>> optionTask, TException exception) =>
             optionTask.WithExceptionAsync(() => exception);
@@ -213,13 +242,5 @@ public static async Task<Option<T, TException>> WithExceptionAsync<T, TException
             var option = await optionTask.ConfigureAwait(executeOnCapturedContext);
             return option.WithException(exceptionFactory);
         }
-
-        public static async Task<Option<T>> FlattenAsync<T>(this Task<Option<Option<T>>> optionTask)
-        {
-            if (optionTask == null) throw new ArgumentNullException(nameof(optionTask));
-
-            var option = await optionTask.ConfigureAwait(continueOnCapturedContext: false);
-            return option.Flatten();
-        }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Optional.sln b/src/Optional.sln
index 12eb394..ecbcc98 100644
--- a/src/Optional.sln
+++ b/src/Optional.sln
@@ -17,7 +17,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Optional.Sandbox", "Optiona
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Optional.Samples", "Optional.Samples\Optional.Samples.csproj", "{02A7D729-3C90-45E2-8183-FC10BA760A80}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Optional.Async.Tests", "Optional.Async.Tests\Optional.Async.Tests.csproj", "{89D005BD-46B2-4E79-8267-AAB77C818998}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Optional.Async.Tests", "Optional.Async.Tests\Optional.Async.Tests.csproj", "{89D005BD-46B2-4E79-8267-AAB77C818998}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -34,7 +34,6 @@ Global
 		{A61CE069-370F-474A-B925-C17B74F9198C}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{A61CE069-370F-474A-B925-C17B74F9198C}.Release|Any CPU.Build.0 = Release|Any CPU
 		{F00BED6E-4808-48EE-B14E-092182080EB3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{F00BED6E-4808-48EE-B14E-092182080EB3}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{F00BED6E-4808-48EE-B14E-092182080EB3}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{F00BED6E-4808-48EE-B14E-092182080EB3}.Release|Any CPU.Build.0 = Release|Any CPU
 		{12606143-9C9B-4A92-81D5-CEA814AC64AC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
@@ -46,7 +45,6 @@ Global
 		{9ADFB283-560D-4FD1-981C-3348BF1DDAF4}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{9ADFB283-560D-4FD1-981C-3348BF1DDAF4}.Release|Any CPU.Build.0 = Release|Any CPU
 		{02A7D729-3C90-45E2-8183-FC10BA760A80}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{02A7D729-3C90-45E2-8183-FC10BA760A80}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{02A7D729-3C90-45E2-8183-FC10BA760A80}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{02A7D729-3C90-45E2-8183-FC10BA760A80}.Release|Any CPU.Build.0 = Release|Any CPU
 		{89D005BD-46B2-4E79-8267-AAB77C818998}.Debug|Any CPU.ActiveCfg = Debug|Any CPU