diff --git a/src/Tranquire/ActionExtensions.cs b/src/Tranquire/ActionExtensions.cs
index 5fea74fd..72de099b 100644
--- a/src/Tranquire/ActionExtensions.cs
+++ b/src/Tranquire/ActionExtensions.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Threading.Tasks;
 using Tranquire.Extensions;
+using SM = Tranquire.Extensions.SelectMany;
 
 namespace Tranquire
 {
@@ -111,12 +112,13 @@ public DiscardActionResult(IAction<TResult> action)
         /// </summary>
         /// <typeparam name="TSource"></typeparam>
         /// <typeparam name="TResult"></typeparam>
-        /// <param name="action">The action which result is transformed</param>
+        /// <param name="source">The action which result is transformed</param>
         /// <param name="selector">A transform function that returns a new action.</param>
         /// <returns></returns>
-        public static IAction<TResult> SelectMany<TSource, TResult>(this IAction<TSource> action, Func<TSource, IAction<TResult>> selector)
+        public static IAction<TResult> SelectMany<TSource, TResult>(this IAction<TSource> source, Func<TSource, IAction<TResult>> selector)
         {
-            return new SelectManyAction<TSource, TResult>(action, selector);
+            var selectMany = SM.Create(source, SM.Execute<TSource>(), selector, SM.Execute<TResult>());
+            return selectMany.ToAction();
         }
 
         /// <summary>
@@ -124,12 +126,13 @@ public static IAction<TResult> SelectMany<TSource, TResult>(this IAction<TSource
         /// </summary>
         /// <typeparam name="TSource"></typeparam>
         /// <typeparam name="TResult"></typeparam>
-        /// <param name="action">The action which result is transformed</param>
+        /// <param name="source">The action which result is transformed</param>
         /// <param name="selector">A transform function that returns a new action.</param>
         /// <returns></returns>
-        public static IQuestion<TResult> SelectMany<TSource, TResult>(this IAction<TSource> action, Func<TSource, IQuestion<TResult>> selector)
+        public static IQuestion<TResult> SelectMany<TSource, TResult>(this IAction<TSource> source, Func<TSource, IQuestion<TResult>> selector)
         {
-            return new SelectManyActionToQuestion<TSource, TResult>(action, selector);
+            var selectMany = SM.Create(source, SM.Execute<TSource>(), selector, SM.AsksFor<TResult>());
+            return selectMany.ToQuestion();
         }
 
         /// <summary>
@@ -137,12 +140,13 @@ public static IQuestion<TResult> SelectMany<TSource, TResult>(this IAction<TSour
         /// </summary>
         /// <typeparam name="TSource"></typeparam>
         /// <typeparam name="TResult"></typeparam>
-        /// <param name="action">The action which result is transformed</param>
+        /// <param name="source">The action which result is transformed</param>
         /// <param name="selector">A transform function that returns a new action.</param>
         /// <returns></returns>
-        public static IAction<Task<TResult>> SelectMany<TSource, TResult>(this IAction<Task<TSource>> action, Func<TSource, IAction<TResult>> selector)
+        public static IAction<Task<TResult>> SelectMany<TSource, TResult>(this IAction<Task<TSource>> source, Func<TSource, IAction<TResult>> selector)
         {
-            return new SelectManyActionAsync<TSource, TResult>(action, selector);
+            var selectMany = SM.Create(source, SM.Execute<Task<TSource>>(), selector, SM.ExecuteAsync<TResult>());
+            return selectMany.ToAction();
         }
 
         /// <summary>
@@ -150,12 +154,26 @@ public static IAction<Task<TResult>> SelectMany<TSource, TResult>(this IAction<T
         /// </summary>
         /// <typeparam name="TSource"></typeparam>
         /// <typeparam name="TResult"></typeparam>
-        /// <param name="action">The action which result is transformed</param>
+        /// <param name="source">The action which result is transformed</param>
         /// <param name="selector">A transform function that returns a new action.</param>
         /// <returns></returns>
-        public static IAction<Task<TResult>> SelectMany<TSource, TResult>(this IAction<Task<TSource>> action, Func<TSource, IAction<Task<TResult>>> selector)
+        public static IAction<Task<TResult>> SelectMany<TSource, TResult>(this IAction<Task<TSource>> source, Func<TSource, IAction<Task<TResult>>> selector)
         {
-            return new SelectManyActionAsyncReturningAsync<TSource, TResult>(action, selector);
+            var selectMany = SM.Create(source, SM.Execute<Task<TSource>>(), selector, SM.ExecuteAsync<Task<TResult>>());
+            return selectMany.ToAction();
+        }
+
+        /// <summary>
+        /// Projects the result of an asynchronous action into a new action.
+        /// </summary>
+        /// <typeparam name="TSource"></typeparam>
+        /// <param name="source">The action which result is transformed</param>
+        /// <param name="selector">A transform function that returns a new action.</param>
+        /// <returns></returns>
+        public static IAction<Task> SelectMany<TSource>(this IAction<Task<TSource>> source, Func<TSource, IAction<Task>> selector)
+        {
+            var selectMany = SM.Create(source, SM.Execute<Task<TSource>>(), selector, SM.ExecuteAsync<Task>());
+            return selectMany.ToAction();
         }
 
         /// <summary>
@@ -163,12 +181,13 @@ public static IAction<Task<TResult>> SelectMany<TSource, TResult>(this IAction<T
         /// </summary>
         /// <typeparam name="TSource"></typeparam>
         /// <typeparam name="TResult"></typeparam>
-        /// <param name="action">The action which result is transformed</param>
+        /// <param name="source">The action which result is transformed</param>
         /// <param name="selector">A transform function that returns a new action.</param>
         /// <returns></returns>
-        public static IQuestion<Task<TResult>> SelectMany<TSource, TResult>(this IAction<Task<TSource>> action, Func<TSource, IQuestion<TResult>> selector)
+        public static IQuestion<Task<TResult>> SelectMany<TSource, TResult>(this IAction<Task<TSource>> source, Func<TSource, IQuestion<TResult>> selector)
         {
-            return new SelectManyActionAsyncToQuestion<TSource, TResult>(action, selector);
+            var selectMany = SM.Create(source, SM.Execute<Task<TSource>>(), selector, SM.AsksForAsync<TResult>());
+            return selectMany.ToQuestion();
         }
 
         /// <summary>
@@ -176,12 +195,77 @@ public static IQuestion<Task<TResult>> SelectMany<TSource, TResult>(this IAction
         /// </summary>
         /// <typeparam name="TSource"></typeparam>
         /// <typeparam name="TResult"></typeparam>
-        /// <param name="action">The action which result is transformed</param>
+        /// <param name="source">The action which result is transformed</param>
+        /// <param name="selector">A transform function that returns a new action.</param>
+        /// <returns></returns>
+        public static IQuestion<Task<TResult>> SelectMany<TSource, TResult>(this IAction<Task<TSource>> source, Func<TSource, IQuestion<Task<TResult>>> selector)
+        {
+            var selectMany = SM.Create(source, SM.Execute<Task<TSource>>(), selector, SM.AsksForAsync<Task<TResult>>());
+            return selectMany.ToQuestion();
+        }
+
+        /// <summary>
+        /// Projects the result of an asynchronous action into a new action.
+        /// </summary>
+        /// <typeparam name="TResult"></typeparam>
+        /// <param name="source">The action which result is transformed</param>
+        /// <param name="selector">A transform function that returns a new action.</param>
+        /// <returns></returns>
+        public static IAction<Task<TResult>> SelectMany<TResult>(this IAction<Task> source, Func<IAction<TResult>> selector)
+        {
+            var selectMany = SM.Create(source, SM.Execute<Task>(), selector, SM.ExecuteAsync<TResult>());
+            return selectMany.ToAction();
+        }
+
+        /// <summary>
+        /// Projects the result of an asynchronous action into a new action.
+        /// </summary>
+        /// <param name="source">The action which result is transformed</param>
+        /// <param name="selector">A transform function that returns a new action.</param>
+        /// <returns></returns>
+        public static IAction<Task> SelectMany(this IAction<Task> source, Func<IAction<Task>> selector)
+        {
+            var selectMany = SM.Create(source, SM.Execute<Task>(), selector, SM.ExecuteAsync<Task>());
+            return selectMany.ToAction();
+        }
+
+        /// <summary>
+        /// Projects the result of an asynchronous action into a new action.
+        /// </summary>
+        /// <typeparam name="TResult"></typeparam>
+        /// <param name="source">The action which result is transformed</param>
+        /// <param name="selector">A transform function that returns a new action.</param>
+        /// <returns></returns>
+        public static IAction<Task<TResult>> SelectMany<TResult>(this IAction<Task> source, Func<IAction<Task<TResult>>> selector)
+        {
+            var selectMany = SM.Create(source, SM.Execute<Task>(), selector, SM.ExecuteAsync<Task<TResult>>());
+            return selectMany.ToAction();
+        }
+
+        /// <summary>
+        /// Projects the result of an asynchronous action into a new question.
+        /// </summary>
+        /// <typeparam name="TResult"></typeparam>
+        /// <param name="source">The action which result is transformed</param>
+        /// <param name="selector">A transform function that returns a new action.</param>
+        /// <returns></returns>
+        public static IQuestion<Task<TResult>> SelectMany<TResult>(this IAction<Task> source, Func<IQuestion<TResult>> selector)
+        {
+            var selectMany = SM.Create(source, SM.Execute<Task>(), selector, SM.AsksForAsync<TResult>());
+            return selectMany.ToQuestion();
+        }
+
+        /// <summary>
+        /// Projects the result of an asynchronous action into a new question.
+        /// </summary>
+        /// <typeparam name="TResult"></typeparam>
+        /// <param name="source">The action which result is transformed</param>
         /// <param name="selector">A transform function that returns a new action.</param>
         /// <returns></returns>
-        public static IQuestion<Task<TResult>> SelectMany<TSource, TResult>(this IAction<Task<TSource>> action, Func<TSource, IQuestion<Task<TResult>>> selector)
+        public static IQuestion<Task<TResult>> SelectMany<TResult>(this IAction<Task> source, Func<IQuestion<Task<TResult>>> selector)
         {
-            return new SelectManyActionAsyncToQuestionAsync<TSource, TResult>(action, selector);
+            var selectMany = SM.Create(source, SM.Execute<Task>(), selector, SM.AsksForAsync<Task<TResult>>());
+            return selectMany.ToQuestion();
         }
         #endregion
 
diff --git a/src/Tranquire/Extensions/SelectMany.cs b/src/Tranquire/Extensions/SelectMany.cs
index ac83015c..9cf8c8e2 100644
--- a/src/Tranquire/Extensions/SelectMany.cs
+++ b/src/Tranquire/Extensions/SelectMany.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 
 namespace Tranquire.Extensions
@@ -38,6 +39,7 @@ public TResult Apply(IActor actor)
 
     internal static class SelectMany
     {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static ISelectMany<TResult> Create<TActionSource, TSource, TActionResult, TResult>(
             TActionSource source,
             Func<IActor, TActionSource, TSource> applySource,
@@ -47,9 +49,19 @@ Func<IActor, TActionResult, TResult> applyResult
             where TActionSource : class, INamed
             where TActionResult : class
         {
+            if (source is null)
+            {
+                throw new ArgumentNullException(nameof(source));
+            }
+            if (selector is null)
+            {
+                throw new ArgumentNullException(nameof(selector));
+            }
+
             return new SelectMany<TActionSource, TSource, TActionResult, TResult>(source, applySource, selector, applyResult);
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static ISelectMany<Task<TResult>> Create<TActionSource, TSource, TActionResult, TResult>(
             TActionSource source,
             Func<IActor, TActionSource, Task<TSource>> applySource,
@@ -59,6 +71,15 @@ Func<IActor, Task<TActionResult>, Task<TResult>> applyResult
             where TActionSource : class, INamed
             where TActionResult : class
         {
+            if (source is null)
+            {
+                throw new ArgumentNullException(nameof(source));
+            }
+            if (selector is null)
+            {
+                throw new ArgumentNullException(nameof(selector));
+            }
+
             Func<Task<TSource>, Task<TActionResult>> selectorAsync = async sourceTask =>
             {
                 var s = await sourceTask;
@@ -67,18 +88,101 @@ Func<IActor, Task<TActionResult>, Task<TResult>> applyResult
             return Create(source, applySource, selectorAsync, applyResult);
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ISelectMany<Task<TResult>> Create<TActionSource, TActionResult, TResult>(
+            TActionSource source,
+            Func<IActor, TActionSource, Task> applySource,
+            Func<TActionResult> selector,
+            Func<IActor, Task<TActionResult>, Task<TResult>> applyResult
+            )
+            where TActionSource : class, INamed
+            where TActionResult : class
+        {
+            if (source is null)
+            {
+                throw new ArgumentNullException(nameof(source));
+            }
+            if (selector is null)
+            {
+                throw new ArgumentNullException(nameof(selector));
+            }
+
+            Func<Task, Task<TActionResult>> selectorAsync = async sourceTask =>
+            {
+                await sourceTask;
+                return selector();
+            };
+            return Create(source, applySource, selectorAsync, applyResult);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Func<IActor, IQuestion<T>, T> AsksFor<T>() => (actor, q) => actor.AsksFor(q);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Func<IActor, Task<IQuestion<T>>, Task<T>> AsksForAsync<T>() => async (actor, questionTask) =>
         {
             var question = await questionTask;
             return actor.AsksFor(question);
         };
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Func<IActor, IAction<T>, T> Execute<T>() => (actor, q) => actor.Execute(q);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Func<IActor, Task<IAction<T>>, Task<T>> ExecuteAsync<T>() => async (actor, actionTask) =>
         {
             var action = await actionTask;
             return actor.Execute(action);
         };
     }
+
+    internal static class SelectManyExtensions
+    {
+        public static IAction<TResult> ToAction<TResult>(this ISelectMany<TResult> selectMany)
+        {
+            return Actions.Create(
+                selectMany.Name,
+                actor => selectMany.Apply(actor));
+        }
+
+        public static IAction<Task<TResult>> ToAction<TResult>(this ISelectMany<Task<Task<TResult>>> selectMany)
+        {
+            return Actions.Create(
+                selectMany.Name,
+                async actor =>
+                {
+                    var task = await selectMany.Apply(actor);
+                    return await task;
+                });
+        }
+
+        public static IAction<Task> ToAction(this ISelectMany<Task<Task>> selectMany)
+        {
+            return Actions.Create(
+                selectMany.Name,
+                async actor =>
+                {
+                    var task = await selectMany.Apply(actor);
+                    await task;
+                });
+        }
+
+        public static IQuestion<TResult> ToQuestion<TResult>(this ISelectMany<TResult> selectMany)
+        {
+            return Questions.Create(
+                selectMany.Name,
+                actor => selectMany.Apply(actor));
+        }
+
+        public static IQuestion<Task<TResult>> ToQuestion<TResult>(this ISelectMany<Task<Task<TResult>>> selectMany)
+        {
+            return Questions.Create(
+                selectMany.Name,
+                async actor =>
+                {
+                    var task = await selectMany.Apply(actor);
+                    return await task;
+                });
+        }
+    }
 }
diff --git a/src/Tranquire/Extensions/SelectManyAction.cs b/src/Tranquire/Extensions/SelectManyAction.cs
deleted file mode 100644
index 54d512c5..00000000
--- a/src/Tranquire/Extensions/SelectManyAction.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-using System;
-
-namespace Tranquire.Extensions
-{
-    /// <summary>
-    /// Represents an action which result is transform by the given selector function
-    /// </summary>
-    /// <typeparam name="TSource">The result type of the source question</typeparam>
-    /// <typeparam name="TResult">The result type of the selector function</typeparam>
-    internal sealed class SelectManyAction<TSource, TResult> : ActionBase<TResult>
-    {
-        private readonly ISelectMany<TResult> _selectMany;
-
-        /// <summary>Record Constructor</summary>
-        /// <param name="action">The question to get the result from</param>
-        /// <param name="selector">The function to apply of the question result.</param>
-        public SelectManyAction(IAction<TSource> action, Func<TSource, IAction<TResult>> selector)
-        {
-            if (action == null)
-            {
-                throw new ArgumentNullException(nameof(action));
-            }
-
-            _selectMany = SelectMany.Create(action, SelectMany.Execute<TSource>(), selector, SelectMany.Execute<TResult>());
-        }
-
-        /// <inheritsdoc />
-        public override string Name => _selectMany.Name;
-
-        /// <inheritsdoc />
-        protected override TResult ExecuteWhen(IActor actor) => _selectMany.Apply(actor);
-    }
-}
diff --git a/src/Tranquire/Extensions/SelectManyActionAsync.cs b/src/Tranquire/Extensions/SelectManyActionAsync.cs
deleted file mode 100644
index c82bcedb..00000000
--- a/src/Tranquire/Extensions/SelectManyActionAsync.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-using System;
-using System.Threading.Tasks;
-
-namespace Tranquire.Extensions
-{
-    /// <summary>
-    /// Represents an asynchronous action which result is transform by the given selector function
-    /// </summary>
-    /// <typeparam name="TSource">The result type of the source question</typeparam>
-    /// <typeparam name="TResult">The result type of the selector function</typeparam>
-    internal sealed class SelectManyActionAsync<TSource, TResult> : ActionBase<Task<TResult>>
-    {
-        private readonly ISelectMany<Task<TResult>> _selectMany;
-
-        /// <summary>Record Constructor</summary>
-        /// <param name="action">The question to get the result from</param>
-        /// <param name="selector">The function to apply of the question result.</param>
-        public SelectManyActionAsync(IAction<Task<TSource>> action, Func<TSource, IAction<TResult>> selector)
-        {
-            if (action == null)
-            {
-                throw new ArgumentNullException(nameof(action));
-            }
-            if (selector == null)
-            {
-                throw new ArgumentNullException(nameof(selector));
-            }
-
-            _selectMany = SelectMany.Create(action, SelectMany.Execute<Task<TSource>>(), selector, SelectMany.ExecuteAsync<TResult>());
-        }
-
-        /// <inheritsdoc />
-        public override string Name => _selectMany.Name;
-
-        /// <inheritsdoc />
-        protected override Task<TResult> ExecuteWhen(IActor actor) => _selectMany.Apply(actor);
-    }
-}
diff --git a/src/Tranquire/Extensions/SelectManyActionAsyncReturningAsync.cs b/src/Tranquire/Extensions/SelectManyActionAsyncReturningAsync.cs
deleted file mode 100644
index f50babcd..00000000
--- a/src/Tranquire/Extensions/SelectManyActionAsyncReturningAsync.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-using System;
-using System.Threading.Tasks;
-
-namespace Tranquire.Extensions
-{
-    /// <summary>
-    /// Represents an asynchronous action which result is transform by the given selector function
-    /// </summary>
-    /// <typeparam name="TSource">The result type of the source question</typeparam>
-    /// <typeparam name="TResult">The result type of the selector function</typeparam>
-    internal sealed class SelectManyActionAsyncReturningAsync<TSource, TResult> : ActionBase<Task<TResult>>
-    {
-        private readonly ISelectMany<Task<Task<TResult>>> _selectMany;
-
-        /// <summary>Record Constructor</summary>
-        /// <param name="action">The question to get the result from</param>
-        /// <param name="selector">The function to apply of the question result.</param>
-        public SelectManyActionAsyncReturningAsync(IAction<Task<TSource>> action, Func<TSource, IAction<Task<TResult>>> selector)
-        {
-            if (action == null)
-            {
-                throw new ArgumentNullException(nameof(action));
-            }
-            if (selector == null)
-            {
-                throw new ArgumentNullException(nameof(selector));
-            }
-
-            _selectMany = SelectMany.Create(action, SelectMany.Execute<Task<TSource>>(), selector, SelectMany.ExecuteAsync<Task<TResult>>());
-        }
-
-        /// <inheritsdoc />
-        public override string Name => _selectMany.Name;
-
-        /// <inheritsdoc />
-        protected override async Task<TResult> ExecuteWhen(IActor actor)
-        {
-            var resultTask = await _selectMany.Apply(actor);
-            return await resultTask;
-        }
-    }
-}
diff --git a/src/Tranquire/Extensions/SelectManyActionAsyncToQuestion.cs b/src/Tranquire/Extensions/SelectManyActionAsyncToQuestion.cs
deleted file mode 100644
index cc49c41b..00000000
--- a/src/Tranquire/Extensions/SelectManyActionAsyncToQuestion.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-using System;
-using System.Threading.Tasks;
-
-namespace Tranquire.Extensions
-{
-    /// <summary>
-    /// Represents an action which result is transform by the given selector function
-    /// </summary>
-    /// <typeparam name="TSource">The result type of the source action</typeparam>
-    /// <typeparam name="TResult">The result type of the selector function</typeparam>
-    internal sealed class SelectManyActionAsyncToQuestion<TSource, TResult> : QuestionBase<Task<TResult>>
-    {
-        private readonly ISelectMany<Task<TResult>> _selectMany;
-
-        /// <summary>Creates a new instance of <see cref="SelectManyActionToQuestion{TSource, TResult}"/></summary>
-        /// <param name="action">The action to get the result from</param>
-        /// <param name="selector">The function to apply of the action result.</param>
-        public SelectManyActionAsyncToQuestion(IAction<Task<TSource>> action, Func<TSource, IQuestion<TResult>> selector)
-        {
-            if (action == null)
-            {
-                throw new ArgumentNullException(nameof(action));
-            }
-            if (selector is null)
-            {
-                throw new ArgumentNullException(nameof(selector));
-            }
-
-            _selectMany = SelectMany.Create(action, SelectMany.Execute<Task<TSource>>(), selector, SelectMany.AsksForAsync<TResult>());
-        }
-
-        /// <inheritdoc />
-        public override string Name => _selectMany.Name;
-
-        /// <inheritdoc />
-        protected override Task<TResult> Answer(IActor actor) => _selectMany.Apply(actor);
-    }
-}
diff --git a/src/Tranquire/Extensions/SelectManyActionAsyncToQuestionAsync.cs b/src/Tranquire/Extensions/SelectManyActionAsyncToQuestionAsync.cs
deleted file mode 100644
index 2ffd2677..00000000
--- a/src/Tranquire/Extensions/SelectManyActionAsyncToQuestionAsync.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-using System;
-using System.Threading.Tasks;
-
-namespace Tranquire.Extensions
-{
-    /// <summary>
-    /// Represents an action which result is transform by the given selector function
-    /// </summary>
-    /// <typeparam name="TSource">The result type of the source action</typeparam>
-    /// <typeparam name="TResult">The result type of the selector function</typeparam>
-    internal sealed class SelectManyActionAsyncToQuestionAsync<TSource, TResult> : QuestionBase<Task<TResult>>
-    {
-        private readonly ISelectMany<Task<Task<TResult>>> _selectMany;
-
-        /// <summary>Creates a new instance of <see cref="SelectManyActionToQuestion{TSource, TResult}"/></summary>
-        /// <param name="action">The action to get the result from</param>
-        /// <param name="selector">The function to apply of the action result.</param>
-        public SelectManyActionAsyncToQuestionAsync(IAction<Task<TSource>> action, Func<TSource, IQuestion<Task<TResult>>> selector)
-        {
-            if (action == null)
-            {
-                throw new ArgumentNullException(nameof(action));
-            }
-            if (selector is null)
-            {
-                throw new ArgumentNullException(nameof(selector));
-            }
-
-            _selectMany = SelectMany.Create(action, SelectMany.Execute<Task<TSource>>(), selector, SelectMany.AsksForAsync<Task<TResult>>());
-        }
-
-        /// <inheritdoc />
-        public override string Name => _selectMany.Name;
-
-        /// <inheritdoc />
-        protected override async Task<TResult> Answer(IActor actor)
-        {
-            var questionTask = await _selectMany.Apply(actor);
-            return await questionTask;
-        }
-    }
-}
diff --git a/src/Tranquire/Extensions/SelectManyActionToQuestion.cs b/src/Tranquire/Extensions/SelectManyActionToQuestion.cs
deleted file mode 100644
index 252f9acb..00000000
--- a/src/Tranquire/Extensions/SelectManyActionToQuestion.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-using System;
-
-namespace Tranquire.Extensions
-{
-    /// <summary>
-    /// Represents an action which result is transform by the given selector function
-    /// </summary>
-    /// <typeparam name="TSource">The result type of the source action</typeparam>
-    /// <typeparam name="TResult">The result type of the selector function</typeparam>
-    internal sealed class SelectManyActionToQuestion<TSource, TResult> : QuestionBase<TResult>
-    {
-        private readonly ISelectMany<TResult> _selectMany;        
-
-        /// <summary>Creates a new instance of <see cref="SelectManyActionToQuestion{TSource, TResult}"/></summary>
-        /// <param name="action">The action to get the result from</param>
-        /// <param name="selector">The function to apply of the action result.</param>
-        public SelectManyActionToQuestion(IAction<TSource> action, Func<TSource, IQuestion<TResult>> selector)
-        {
-            if (action == null)
-            {
-                throw new ArgumentNullException(nameof(action));
-            }
-
-            _selectMany = SelectMany.Create(action, SelectMany.Execute<TSource>(), selector, SelectMany.AsksFor<TResult>());
-        }
-
-        /// <inheritdoc />
-        public override string Name => _selectMany.Name;
-
-        /// <inheritdoc />
-        protected override TResult Answer(IActor actor) => _selectMany.Apply(actor);
-    }
-}
diff --git a/src/Tranquire/Extensions/SelectManyQuestion.cs b/src/Tranquire/Extensions/SelectManyQuestion.cs
deleted file mode 100644
index d696a48d..00000000
--- a/src/Tranquire/Extensions/SelectManyQuestion.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-using System;
-
-namespace Tranquire.Extensions
-{
-    /// <summary>
-    /// Represents a question which result is transform by the given selector function
-    /// </summary>
-    /// <typeparam name="TSource">The result type of the source question</typeparam>
-    /// <typeparam name="TResult">The result type of the selector function</typeparam>
-    internal sealed class SelectManyQuestion<TSource, TResult> : QuestionBase<TResult>
-    {
-        private readonly ISelectMany<TResult> _selectMany;
-
-        /// <summary>Record Constructor</summary>
-        /// <param name="question">The question to get the result from</param>
-        /// <param name="selector">The function to apply of the question result.</param>
-        public SelectManyQuestion(IQuestion<TSource> question, Func<TSource, IQuestion<TResult>> selector)
-        {
-            if (question == null)
-            {
-                throw new ArgumentNullException(nameof(question));
-            }
-
-            _selectMany = SelectMany.Create(question, SelectMany.AsksFor<TSource>(), selector, SelectMany.AsksFor<TResult>());
-        }
-
-        /// <inheritsdoc />
-        public override string Name => _selectMany.Name;
-
-        /// <inheritsdoc />
-        protected override TResult Answer(IActor actor) => _selectMany.Apply(actor);
-    }
-}
diff --git a/src/Tranquire/Extensions/SelectManyQuestionAsync.cs b/src/Tranquire/Extensions/SelectManyQuestionAsync.cs
deleted file mode 100644
index 757491f6..00000000
--- a/src/Tranquire/Extensions/SelectManyQuestionAsync.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-using System;
-using System.Threading.Tasks;
-
-namespace Tranquire.Extensions
-{
-    /// <summary>
-    /// Represents a question which result is transform by the given selector function
-    /// </summary>
-    /// <typeparam name="TSource">The result type of the source question</typeparam>
-    /// <typeparam name="TResult">The result type of the selector function</typeparam>
-    internal sealed class SelectManyQuestionAsync<TSource, TResult> : QuestionBase<Task<TResult>>
-    {
-        private readonly ISelectMany<Task<TResult>> _selectMany;
-
-        /// <summary>Record Constructor</summary>
-        /// <param name="question">The question to get the result from</param>
-        /// <param name="selector">The function to apply of the question result.</param>
-        public SelectManyQuestionAsync(IQuestion<Task<TSource>> question, Func<TSource, IQuestion<TResult>> selector)
-        {
-            if (question == null)
-            {
-                throw new ArgumentNullException(nameof(question));
-            }
-            if (selector is null)
-            {
-                throw new ArgumentNullException(nameof(selector));
-            }
-
-            _selectMany = SelectMany.Create(question, SelectMany.AsksFor<Task<TSource>>(), selector, SelectMany.AsksForAsync<TResult>());
-        }
-
-        /// <inheritsdoc />
-        public override string Name => _selectMany.Name;
-
-        /// <inheritsdoc />
-        protected override Task<TResult> Answer(IActor actor) => _selectMany.Apply(actor);
-    }
-}
diff --git a/src/Tranquire/Extensions/SelectManyQuestionAsyncReturningAsync.cs b/src/Tranquire/Extensions/SelectManyQuestionAsyncReturningAsync.cs
deleted file mode 100644
index aa54c3cf..00000000
--- a/src/Tranquire/Extensions/SelectManyQuestionAsyncReturningAsync.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-using System;
-using System.Threading.Tasks;
-
-namespace Tranquire.Extensions
-{
-    /// <summary>
-    /// Represents a question which result is transform by the given selector function
-    /// </summary>
-    /// <typeparam name="TSource">The result type of the source question</typeparam>
-    /// <typeparam name="TResult">The result type of the selector function</typeparam>
-    internal sealed class SelectManyQuestionAsyncReturningAsync<TSource, TResult> : QuestionBase<Task<TResult>>
-    {
-        private readonly ISelectMany<Task<Task<TResult>>> _selectMany;
-
-        /// <summary>Record Constructor</summary>
-        /// <param name="question">The question to get the result from</param>
-        /// <param name="selector">The function to apply of the question result.</param>
-        public SelectManyQuestionAsyncReturningAsync(IQuestion<Task<TSource>> question, Func<TSource, IQuestion<Task<TResult>>> selector)
-        {
-            if (question == null)
-            {
-                throw new ArgumentNullException(nameof(question));
-            }
-            if (selector is null)
-            {
-                throw new ArgumentNullException(nameof(selector));
-            }
-
-            _selectMany = SelectMany.Create(question, SelectMany.AsksFor<Task<TSource>>(), selector, SelectMany.AsksForAsync<Task<TResult>>());
-        }
-
-        /// <inheritsdoc />
-        public override string Name => _selectMany.Name;
-
-        /// <inheritsdoc />
-        protected override async Task<TResult> Answer(IActor actor)
-        {
-            var resultTask = await _selectMany.Apply(actor);
-            return await resultTask;
-        }
-    }
-}
diff --git a/src/Tranquire/Extensions/SelectManyQuestionAsyncToAction.cs b/src/Tranquire/Extensions/SelectManyQuestionAsyncToAction.cs
deleted file mode 100644
index d051cff8..00000000
--- a/src/Tranquire/Extensions/SelectManyQuestionAsyncToAction.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-using System;
-using System.Threading.Tasks;
-
-namespace Tranquire.Extensions
-{
-    /// <summary>
-    /// Represents a question which result is transform by the given selector function
-    /// </summary>
-    /// <typeparam name="TSource">The result type of the source question</typeparam>
-    /// <typeparam name="TResult">The result type of the selector function</typeparam>
-    internal sealed class SelectManyQuestionAsyncToAction<TSource, TResult> : Tranquire.ActionBase<Task<TResult>>
-    {
-        private readonly ISelectMany<Task<TResult>> _selectMany;
-
-        /// <summary>Record Constructor</summary>
-        /// <param name="question">The question to get the result from</param>
-        /// <param name="selector">The function to apply of the question result.</param>
-        public SelectManyQuestionAsyncToAction(IQuestion<Task<TSource>> question, Func<TSource, IAction<TResult>> selector)
-        {
-            if (question == null)
-            {
-                throw new ArgumentNullException(nameof(question));
-            }
-            if (selector is null)
-            {
-                throw new ArgumentNullException(nameof(selector));
-            }
-
-            _selectMany = SelectMany.Create(question, SelectMany.AsksFor<Task<TSource>>(), selector, SelectMany.ExecuteAsync<TResult>());
-        }
-
-        /// <inheritsdoc />
-        public override string Name => _selectMany.Name;
-
-        /// <inheritsdoc />
-        protected override Task<TResult>ExecuteWhen(IActor actor) => _selectMany.Apply(actor);
-    }
-}
diff --git a/src/Tranquire/Extensions/SelectManyQuestionAsyncToActionAsync.cs b/src/Tranquire/Extensions/SelectManyQuestionAsyncToActionAsync.cs
deleted file mode 100644
index 1eda315b..00000000
--- a/src/Tranquire/Extensions/SelectManyQuestionAsyncToActionAsync.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-using System;
-using System.Threading.Tasks;
-
-namespace Tranquire.Extensions
-{
-    /// <summary>
-    /// Represents a question which result is transform by the given selector function
-    /// </summary>
-    /// <typeparam name="TSource">The result type of the source question</typeparam>
-    /// <typeparam name="TResult">The result type of the selector function</typeparam>
-    internal sealed class SelectManyQuestionAsyncToActionAsync<TSource, TResult> : Tranquire.ActionBase<Task<TResult>>
-    {
-        private readonly ISelectMany<Task<Task<TResult>>> _selectMany;
-
-        /// <summary>Record Constructor</summary>
-        /// <param name="question">The question to get the result from</param>
-        /// <param name="selector">The function to apply of the question result.</param>
-        public SelectManyQuestionAsyncToActionAsync(IQuestion<Task<TSource>> question, Func<TSource, IAction<Task<TResult>>> selector)
-        {
-            if (question == null)
-            {
-                throw new ArgumentNullException(nameof(question));
-            }
-            if (selector is null)
-            {
-                throw new ArgumentNullException(nameof(selector));
-            }
-
-            _selectMany = SelectMany.Create(question, SelectMany.AsksFor<Task<TSource>>(), selector, SelectMany.ExecuteAsync<Task<TResult>>());
-        }
-
-        /// <inheritsdoc />
-        public override string Name => _selectMany.Name;
-
-        /// <inheritsdoc />
-        protected override async Task<TResult> ExecuteWhen(IActor actor)
-        {
-            var resultTask = await _selectMany.Apply(actor);
-            return await resultTask;
-        }
-    }
-}
diff --git a/src/Tranquire/Extensions/SelectManyQuestionToAction.cs b/src/Tranquire/Extensions/SelectManyQuestionToAction.cs
deleted file mode 100644
index 6e491227..00000000
--- a/src/Tranquire/Extensions/SelectManyQuestionToAction.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-using System;
-
-namespace Tranquire.Extensions
-{
-    /// <summary>
-    /// Represents a question which result is transform by the given selector function
-    /// </summary>
-    /// <typeparam name="TSource">The result type of the source question</typeparam>
-    /// <typeparam name="TResult">The result type of the selector function</typeparam>
-    internal sealed class SelectManyQuestionToAction<TSource, TResult> : Tranquire.ActionBase<TResult>
-    {
-        private readonly ISelectMany<TResult> _selectMany;
-
-        /// <summary>Record Constructor</summary>
-        /// <param name="question">The question to get the result from</param>
-        /// <param name="selector">The function to apply of the question result.</param>
-        public SelectManyQuestionToAction(IQuestion<TSource> question, Func<TSource, IAction<TResult>> selector)
-        {
-            if (question == null)
-            {
-                throw new ArgumentNullException(nameof(question));
-            }
-
-            _selectMany = SelectMany.Create(question, SelectMany.AsksFor<TSource>(), selector, SelectMany.Execute<TResult>());
-        }
-
-        /// <inheritsdoc />
-        public override string Name => _selectMany.Name;
-
-        /// <inheritsdoc />
-        protected override TResult ExecuteWhen(IActor actor) => _selectMany.Apply(actor);
-    }
-}
diff --git a/src/Tranquire/QuestionExtensions.cs b/src/Tranquire/QuestionExtensions.cs
index 27a8f1dc..d14c19d6 100644
--- a/src/Tranquire/QuestionExtensions.cs
+++ b/src/Tranquire/QuestionExtensions.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Threading.Tasks;
 using Tranquire.Extensions;
+using SM = Tranquire.Extensions.SelectMany;
 
 namespace Tranquire
 {
@@ -61,12 +62,13 @@ public static IQuestion<Task<TResult>> Select<TSource, TResult>(this IQuestion<T
         /// </summary>
         /// <typeparam name="TSource"></typeparam>
         /// <typeparam name="TResult"></typeparam>
-        /// <param name="question">The question which result is transformed</param>
+        /// <param name="source">The question which result is transformed</param>
         /// <param name="selector">A transform function that returns a new question.</param>
         /// <returns></returns>
-        public static IQuestion<TResult> SelectMany<TSource, TResult>(this IQuestion<TSource> question, Func<TSource, IQuestion<TResult>> selector)
+        public static IQuestion<TResult> SelectMany<TSource, TResult>(this IQuestion<TSource> source, Func<TSource, IQuestion<TResult>> selector)
         {
-            return new SelectManyQuestion<TSource, TResult>(question, selector);
+            var selectMany = SM.Create(source, SM.AsksFor<TSource>(), selector, SM.AsksFor<TResult>());
+            return selectMany.ToQuestion();
         }
 
         /// <summary>
@@ -74,12 +76,13 @@ public static IQuestion<TResult> SelectMany<TSource, TResult>(this IQuestion<TSo
         /// </summary>
         /// <typeparam name="TSource"></typeparam>
         /// <typeparam name="TResult"></typeparam>
-        /// <param name="question">The question which result is transformed</param>
+        /// <param name="source">The question which result is transformed</param>
         /// <param name="selector">A transform function that returns a new action.</param>
         /// <returns></returns>
-        public static IAction<TResult> SelectMany<TSource, TResult>(this IQuestion<TSource> question, Func<TSource, IAction<TResult>> selector)
+        public static IAction<TResult> SelectMany<TSource, TResult>(this IQuestion<TSource> source, Func<TSource, IAction<TResult>> selector)
         {
-            return new SelectManyQuestionToAction<TSource, TResult>(question, selector);
+            var selectMany = SM.Create(source, SM.AsksFor<TSource>(), selector, SM.Execute<TResult>());
+            return selectMany.ToAction();
         }
 
         /// <summary>
@@ -87,12 +90,13 @@ public static IAction<TResult> SelectMany<TSource, TResult>(this IQuestion<TSour
         /// </summary>
         /// <typeparam name="TSource"></typeparam>
         /// <typeparam name="TResult"></typeparam>
-        /// <param name="question">The question which result is transformed</param>
+        /// <param name="source">The question which result is transformed</param>
         /// <param name="selector">A transform function that returns a new question.</param>
         /// <returns></returns>
-        public static IQuestion<Task<TResult>> SelectMany<TSource, TResult>(this IQuestion<Task<TSource>> question, Func<TSource, IQuestion<TResult>> selector)
+        public static IQuestion<Task<TResult>> SelectMany<TSource, TResult>(this IQuestion<Task<TSource>> source, Func<TSource, IQuestion<TResult>> selector)
         {
-            return new SelectManyQuestionAsync<TSource, TResult>(question, selector);
+            var selectMany = SM.Create(source, SM.AsksFor<Task<TSource>>(), selector, SM.AsksForAsync<TResult>());
+            return selectMany.ToQuestion();
         }
 
         /// <summary>
@@ -100,12 +104,13 @@ public static IQuestion<Task<TResult>> SelectMany<TSource, TResult>(this IQuesti
         /// </summary>
         /// <typeparam name="TSource"></typeparam>
         /// <typeparam name="TResult"></typeparam>
-        /// <param name="question">The question which result is transformed</param>
+        /// <param name="source">The question which result is transformed</param>
         /// <param name="selector">A transform function that returns a new question.</param>
         /// <returns></returns>
-        public static IQuestion<Task<TResult>> SelectMany<TSource, TResult>(this IQuestion<Task<TSource>> question, Func<TSource, IQuestion<Task<TResult>>> selector)
+        public static IQuestion<Task<TResult>> SelectMany<TSource, TResult>(this IQuestion<Task<TSource>> source, Func<TSource, IQuestion<Task<TResult>>> selector)
         {
-            return new SelectManyQuestionAsyncReturningAsync<TSource, TResult>(question, selector);
+            var selectMany = SM.Create(source, SM.AsksFor<Task<TSource>>(), selector, SM.AsksForAsync<Task<TResult>>());
+            return selectMany.ToQuestion();
         }
 
         /// <summary>
@@ -113,12 +118,13 @@ public static IQuestion<Task<TResult>> SelectMany<TSource, TResult>(this IQuesti
         /// </summary>
         /// <typeparam name="TSource"></typeparam>
         /// <typeparam name="TResult"></typeparam>
-        /// <param name="question">The question which result is transformed</param>
+        /// <param name="source">The question which result is transformed</param>
         /// <param name="selector">A transform function that returns a new action.</param>
         /// <returns></returns>
-        public static IAction<Task<TResult>> SelectMany<TSource, TResult>(this IQuestion<Task<TSource>> question, Func<TSource, IAction<TResult>> selector)
+        public static IAction<Task<TResult>> SelectMany<TSource, TResult>(this IQuestion<Task<TSource>> source, Func<TSource, IAction<TResult>> selector)
         {
-            return new SelectManyQuestionAsyncToAction<TSource, TResult>(question, selector);
+            var selectMany = SM.Create(source, SM.AsksFor<Task<TSource>>(), selector, SM.ExecuteAsync<TResult>());
+            return selectMany.ToAction();
         }
 
         /// <summary>
@@ -126,12 +132,26 @@ public static IAction<Task<TResult>> SelectMany<TSource, TResult>(this IQuestion
         /// </summary>
         /// <typeparam name="TSource"></typeparam>
         /// <typeparam name="TResult"></typeparam>
-        /// <param name="question">The question which result is transformed</param>
+        /// <param name="source">The question which result is transformed</param>
+        /// <param name="selector">A transform function that returns a new action.</param>
+        /// <returns></returns>
+        public static IAction<Task<TResult>> SelectMany<TSource, TResult>(this IQuestion<Task<TSource>> source, Func<TSource, IAction<Task<TResult>>> selector)
+        {
+            var selectMany = SM.Create(source, SM.AsksFor<Task<TSource>>(), selector, SM.ExecuteAsync<Task<TResult>>());
+            return selectMany.ToAction();
+        }
+
+        /// <summary>
+        /// Projects the result of an asynchronous question into a new asynchronous action.
+        /// </summary>
+        /// <typeparam name="TSource"></typeparam>
+        /// <param name="source">The question which result is transformed</param>
         /// <param name="selector">A transform function that returns a new action.</param>
         /// <returns></returns>
-        public static IAction<Task<TResult>> SelectMany<TSource, TResult>(this IQuestion<Task<TSource>> question, Func<TSource, IAction<Task<TResult>>> selector)
+        public static IAction<Task> SelectMany<TSource>(this IQuestion<Task<TSource>> source, Func<TSource, IAction<Task>> selector)
         {
-            return new SelectManyQuestionAsyncToActionAsync<TSource, TResult>(question, selector);
+            var selectMany = SM.Create(source, SM.AsksFor<Task<TSource>>(), selector, SM.ExecuteAsync<Task>());
+            return selectMany.ToAction();
         }
         #endregion
 
diff --git a/tests/ToDoList.Specifications/Setup.cs b/tests/ToDoList.Specifications/Setup.cs
index 3f584d35..aea26324 100644
--- a/tests/ToDoList.Specifications/Setup.cs
+++ b/tests/ToDoList.Specifications/Setup.cs
@@ -3,7 +3,6 @@
 using Microsoft.AspNetCore.TestHost;
 using OpenQA.Selenium.Chrome;
 using System;
-using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.IO;
@@ -19,7 +18,6 @@
 using Tranquire.Reporting;
 using Tranquire.Selenium;
 using Tranquire.Selenium.Extensions;
-using static Microsoft.AspNetCore.Hosting.Internal.HostingApplication;
 
 namespace ToDoList.Specifications
 {
diff --git a/tests/Tranquire.Tests/Extensions/ActionExtensionsTests.cs b/tests/Tranquire.Tests/Extensions/ActionExtensionsTests.cs
index 501b8d2b..7457dc8a 100644
--- a/tests/Tranquire.Tests/Extensions/ActionExtensionsTests.cs
+++ b/tests/Tranquire.Tests/Extensions/ActionExtensionsTests.cs
@@ -1,11 +1,11 @@
-using FluentAssertions;
-using Moq;
-using AutoFixture;
+using AutoFixture;
 using AutoFixture.Idioms;
+using FluentAssertions;
+using Moq;
 using System;
+using System.Threading.Tasks;
 using Tranquire.Extensions;
 using Xunit;
-using System.Threading.Tasks;
 
 namespace Tranquire.Tests.Extensions
 {
@@ -86,7 +86,7 @@ public void Using_ShouldReturnCorrectValue(IAction<IDisposable> disposableAction
         }
         #endregion
 
-        #region SelectMany - action
+        #region SelectMany: IAction<T> -> IAction<U>
         [Theory, DomainAutoData]
         public void SelectMany_ShouldReturnCorrectResult(
             int value1,
@@ -136,7 +136,7 @@ public void SelectMany_Name_ShouldReturnCorrectResult(
         }
         #endregion
 
-        #region SelectMany - action to question
+        #region SelectMany: IAction<T> -> IQuestion<U>
         [Theory, DomainAutoData]
         public void SelectMany_ReturningQuestion_ShouldReturnCorrectResult(
             int value1,
@@ -168,7 +168,7 @@ public void SelectMany_ReturningQuestion_Name_ShouldReturnCorrectResult(
         }
         #endregion
 
-        #region SelectMany - action async
+        #region SelectMany: IAction<Task<T>> -> IAction<U>
         [Theory, DomainAutoData]
         public async Task SelectMany_Async_ShouldReturnCorrectResult(
             int value1,
@@ -218,7 +218,7 @@ public void SelectMany_Async_Name_ShouldReturnCorrectResult(
         }
         #endregion
 
-        #region SelectMany - action async returning async action
+        #region SelectMany: IAction<Task<T>> -> IAction<Task<U>>
         [Theory, DomainAutoData]
         public async Task SelectMany_Async_ReturningAsyncAction_ShouldReturnCorrectResult(
             int value1,
@@ -268,7 +268,41 @@ public void SelectMany_Async_Name_ReturningAsyncAction_ShouldReturnCorrectResult
         }
         #endregion
 
-        #region SelectMany - action to question async
+        #region SelectMany: IAction<Task<T>> -> IAction<Task>
+        [Theory, DomainAutoData]
+        public async Task SelectMany_Async_ReturningAsyncTaskAction_ShouldReturnCorrectResult(
+            int value1,
+            int value2)
+        {
+            // arrange
+            var actor = new Actor("John");
+            var actual = 0;
+            var action = Actions.FromResult(Task.FromResult(value1))
+                                .SelectMany(v => Actions.Create("set result", _ => Delay(() => { actual = v + value2; })));
+            // act
+            var task = actor.When(action);
+            await task;
+            // assert            
+            var expected = value1 + value2;
+            Assert.Equal(expected, actual);
+        }
+
+        [Theory, DomainAutoData]
+        public void SelectMany_Async_Name_ReturningAsyncTaskAction_ShouldReturnCorrectResult(
+            IAction<Task<int>> action1,
+            IAction<Task> action2)
+        {
+            // arrange
+            var action = action1.SelectMany<int>(_ => action2);
+            // act
+            var actual = action.Name;
+            // assert
+            var expected = "[SelectMany] " + action1.Name;
+            Assert.Equal(expected, actual);
+        }
+        #endregion
+
+        #region SelectMany: IAction<Task<T>> -> IQuestion<T>
         [Theory, DomainAutoData]
         public async Task SelectMany_Async_ReturningQuestion_ShouldReturnCorrectResult(
             int value1,
@@ -300,7 +334,7 @@ public void SelectMany_Async_Name_ReturningQuestion_ShouldReturnCorrectResult(
         }
         #endregion
 
-        #region SelectMany - action async returning async question
+        #region SelectMany: IAction<Task<T>> -> IQuestion<Task<T>>
         [Theory, DomainAutoData]
         public async Task SelectMany_Async_ReturningAsyncQuestion_ShouldReturnCorrectResult(
             int value1,
@@ -332,6 +366,185 @@ public void SelectMany_Async_Name_ReturningAsyncQuestion_ShouldReturnCorrectResu
         }
         #endregion
 
+        #region SelectMany: IAction<Task> -> IAction<U>
+        [Theory, DomainAutoData]
+        public async Task SelectMany_AsyncTask_ShouldReturnCorrectResult(
+            int value1,
+            int value2)
+        {
+            // arrange
+            var actor = new Actor("John");
+            var currentValue = 0;
+            var action = Actions.Create("set value", _ => Delay(() => currentValue = value1))
+                                .SelectMany(() => Actions.FromResult(currentValue + value2));
+            // act
+            var actual = await actor.When(action);
+            // assert
+            var expected = value1 + value2;
+            Assert.Equal(expected, actual);
+        }
+
+        [Theory, DomainAutoData]
+        public void SelectMany_AsyncTask_Name_ShouldReturnCorrectResult(
+            IAction<Task> action1,
+            IAction<int> action2)
+        {
+            // arrange
+            var action = action1.SelectMany(() => action2);
+            // act
+            var actual = action.Name;
+            // assert
+            var expected = "[SelectMany] " + action1.Name;
+            Assert.Equal(expected, actual);
+        }
+        #endregion
+
+        #region SelectMany: IAction<Task> -> IAction<Task<T>>
+        [Theory, DomainAutoData]
+        public async Task SelectMany_Async_Task_ReturningAsyncAction_ShouldReturnCorrectResult(
+            int value1,
+            int value2)
+        {
+            // arrange
+            var actor = new Actor("John");
+            var currentResult = 0;
+            var action = Actions.FromResult(Delay(() => { currentResult = value1; }))
+                                .SelectMany(() => Actions.FromResult(Task.FromResult(currentResult + value2)));
+            // act
+            var actual = await actor.When(action);
+            // assert
+            var expected = value1 + value2;
+            Assert.Equal(expected, actual);
+        }
+
+        [Theory, DomainAutoData]
+        public void SelectMany_Async_Task_Name_ReturningAsyncAction_ShouldReturnCorrectResult(
+            IAction<Task> action1,
+            IAction<Task<int>> action2)
+        {
+            // arrange
+            var action = action1.SelectMany(() => action2);
+            // act
+            var actual = action.Name;
+            // assert
+            var expected = "[SelectMany] " + action1.Name;
+            Assert.Equal(expected, actual);
+        }
+        #endregion
+
+        #region SelectMany: IAction<Task> -> IAction<Task>
+        [Theory, DomainAutoData]
+        public async Task SelectMany_Async_Task_ReturningAsyncTaskAction_ShouldReturnCorrectResult(
+            int value1,
+            int value2)
+        {
+            // arrange
+            var actor = new Actor("John");
+            var result = 0;
+            var action = Actions.FromResult(Delay(() => { result = value1; }))
+                                .SelectMany(() => Actions.FromResult(Delay(() => { result += value2; })));
+            // act
+            var task = actor.When(action);
+            await task;
+            var actual = result;
+            // assert
+            var expected = value1 + value2;
+            Assert.Equal(expected, actual);
+        }
+
+        [Theory, DomainAutoData]
+        public void SelectMany_Async_Task_Name_ReturningAsyncTaskAction_ShouldReturnCorrectResult(
+            IAction<Task> action1,
+            IAction<Task> action2)
+        {
+            // arrange
+            var action = action1.SelectMany(() => action2);
+            // act
+            var actual = action.Name;
+            // assert
+            var expected = "[SelectMany] " + action1.Name;
+            Assert.Equal(expected, actual);
+        }
+        #endregion
+
+        #region SelectMany: IAction<Task> -> IQuestion<T>
+        [Theory, DomainAutoData]
+        public async Task SelectMany_Async_Task_ReturningQuestion_ShouldReturnCorrectResult(
+            int value1,
+            int value2)
+        {
+            // arrange
+            var actor = new Actor("John");
+            var currentResult = 0;
+            var question = Actions.FromResult(Delay(() => { currentResult = value1; }))
+                                  .SelectMany(() => Questions.FromResult(currentResult + value2));
+            // act
+            var actual = await actor.AsksFor(question);
+            // assert
+            var expected = value1 + value2;
+            Assert.Equal(expected, actual);
+        }
+
+        [Theory, DomainAutoData]
+        public void SelectMany_Async_Task_Name_ReturningQuestion_ShouldReturnCorrectResult(
+            IAction<Task> action1,
+            IQuestion<int> question2)
+        {
+            // arrange
+            var question = action1.SelectMany(() => question2);
+            // act
+            var actual = question.Name;
+            // assert
+            var expected = "[SelectMany] " + action1.Name;
+            Assert.Equal(expected, actual);
+        }
+        #endregion
+
+        #region SelectMany: IAction<Task> -> IQuestion<Task<T>>
+        [Theory, DomainAutoData]
+        public async Task SelectMany_Async_Task_ReturningQuestionAsync_ShouldReturnCorrectResult(
+            int value1,
+            int value2)
+        {
+            // arrange
+            var actor = new Actor("John");
+            var currentResult = 0;
+            var question = Actions.FromResult(Delay(() => { currentResult = value1; }))
+                                  .SelectMany(() => Questions.FromResult(Delay(() => currentResult + value2)));
+            // act
+            var actual = await actor.AsksFor(question);
+            // assert
+            var expected = value1 + value2;
+            Assert.Equal(expected, actual);
+        }
+
+        [Theory, DomainAutoData]
+        public void SelectMany_Async_Task_Name_ReturningQuestionAsync_ShouldReturnCorrectResult(
+            IAction<Task> action1,
+            IQuestion<Task<int>> question2)
+        {
+            // arrange
+            var question = action1.SelectMany(() => question2);
+            // act
+            var actual = question.Name;
+            // assert
+            var expected = "[SelectMany] " + action1.Name;
+            Assert.Equal(expected, actual);
+        }
+        #endregion
+
+        private static async Task Delay(Action action)
+        {
+            await Task.Delay(1);
+            action();
+        }
+
+        private static async Task<T> Delay<T>(Func<T> action)
+        {
+            await Task.Delay(1);
+            return action();
+        }
+
         #region Select
         [Theory, DomainAutoData]
         public void Select_ShouldReturnCorrectResult(IAction<string> action, Func<string, object> selector)
diff --git a/tests/Tranquire.Tests/QuestionExtensionsTests.cs b/tests/Tranquire.Tests/Extensions/QuestionExtensionsTests.cs
similarity index 71%
rename from tests/Tranquire.Tests/QuestionExtensionsTests.cs
rename to tests/Tranquire.Tests/Extensions/QuestionExtensionsTests.cs
index 14ff3168..59f26184 100644
--- a/tests/Tranquire.Tests/QuestionExtensionsTests.cs
+++ b/tests/Tranquire.Tests/Extensions/QuestionExtensionsTests.cs
@@ -1,12 +1,12 @@
-using FluentAssertions;
-using AutoFixture.Idioms;
+using AutoFixture.Idioms;
+using FluentAssertions;
+using Moq;
 using System;
+using System.Threading.Tasks;
 using Tranquire.Extensions;
 using Xunit;
-using Moq;
-using System.Threading.Tasks;
 
-namespace Tranquire.Tests
+namespace Tranquire.Tests.Extensions
 {
     public class QuestionExtensionsTests
     {
@@ -52,7 +52,7 @@ public void Select_Async_WithAsyncFunc_ShouldReturnCorrectResult(IQuestion<Task<
         }
         #endregion
 
-        #region SelectMany - question
+        #region SelectMany: IQuestion<T> -> IQuestion<U>
         [Theory, DomainAutoData]
         public void SelectMany_ShouldReturnCorrectResult(
             int value1,
@@ -101,8 +101,40 @@ public void SelectMany_Name_ShouldReturnCorrectResult(
             Assert.Equal(expected, actual);
         }
         #endregion
+        
+        #region SelectMany: IQuestion<T> -> IQuestion<Task<U>>
+        [Theory, DomainAutoData]
+        public async Task SelectMany_ReturningAsyncQuestion_ShouldReturnCorrectResult(
+            int value1,
+            int value2)
+        {
+            // arrange
+            var question = Questions.FromResult(value1)
+                                    .SelectMany(v => Questions.FromResult(Delay(() => v + value2)));
+            var actor = new Actor("john");
+            // act
+            var actual = await actor.AsksFor(question);
+            // assert
+            var expected = value1 + value2;
+            Assert.Equal(expected, actual);
+        }
 
-        #region SelectMany - question to action
+        [Theory, DomainAutoData]
+        public void SelectMany_Name_ReturningAsyncQuestion_ShouldReturnCorrectResult(
+            IQuestion<int> question1,
+            IQuestion<Task<int>> question2)
+        {
+            // arrange
+            var question = question1.SelectMany(_ => question2);
+            // act
+            var actual = question.Name;
+            // assert
+            var expected = "[SelectMany] " + question1.Name;
+            Assert.Equal(expected, actual);
+        }
+        #endregion
+
+        #region SelectMany: IQuestion<T> -> IAction<U>
         [Theory, DomainAutoData]
         public void SelectMany_ReturningAction_ShouldReturnCorrectResult(
             int value1,
@@ -120,7 +152,7 @@ public void SelectMany_ReturningAction_ShouldReturnCorrectResult(
         }
 
         [Theory, DomainAutoData]
-        public void SelectMany_ReturningQuestion_Name_ShouldReturnCorrectResult(
+        public void SelectMany_ReturningAction_Name_ShouldReturnCorrectResult(
             IQuestion<int> question1,
             IAction<int> action2)
         {
@@ -134,7 +166,42 @@ public void SelectMany_ReturningQuestion_Name_ShouldReturnCorrectResult(
         }
         #endregion
 
-        #region SelectMany - question async
+        #region SelectMany: IQuestion<T> -> IAction<Task>
+        [Theory, DomainAutoData]
+        public async Task SelectMany_ReturningActionAsyncTask_ShouldReturnCorrectResult(
+            int value1,
+            int value2)
+        {
+            // arrange
+            var result = 0;
+            var action = Questions.FromResult(value1)
+                                  .SelectMany(v => Actions.FromResult(Delay(() => { result = v + value2; })));
+            var actor = new Actor("john");
+            // act
+            var task = actor.When(action);
+            await task;
+            var actual = result;
+            // assert
+            var expected = value1 + value2;
+            Assert.Equal(expected, actual);
+        }
+
+        [Theory, DomainAutoData]
+        public void SelectMany_ReturningActionAsyncTask_Name_ShouldReturnCorrectResult(
+            IQuestion<int> question1,
+            IAction<Task> action2)
+        {
+            // arrange
+            var action = question1.SelectMany(_ => action2);
+            // act
+            var actual = action.Name;
+            // assert
+            var expected = "[SelectMany] " + question1.Name;
+            Assert.Equal(expected, actual);
+        }
+        #endregion
+
+        #region SelectMany: IQuestion<Task<T>> -> IQuestion<U>
         [Theory, DomainAutoData]
         public async Task SelectMany_Async_ShouldReturnCorrectResult(
             int value1,
@@ -184,7 +251,7 @@ public void SelectMany_Async_Name_ShouldReturnCorrectResult(
         }
         #endregion
 
-        #region SelectMany - question async returning async question
+        #region SelectMany: IQuestion<Task<T>> -> IQuestion<Task<U>>
         [Theory, DomainAutoData]
         public async Task SelectMany_Async_ReturningAsyncQuestion_ShouldReturnCorrectResult(
            int value1,
@@ -234,7 +301,7 @@ public void SelectMany_Async_Name_ReturningAsyncQuestion_ShouldReturnCorrectResu
         }
         #endregion
 
-        #region SelectMany - question to action async
+        #region SelectMany: IQuestion<Task<T>> -> IAction<U>
         [Theory, DomainAutoData]
         public async Task SelectMany_Async_ReturningAction_ShouldReturnCorrectResult(
             int value1,
@@ -266,7 +333,7 @@ public void SelectMany_Async_Name_ReturningAction_ShouldReturnCorrectResult(
         }
         #endregion
 
-        #region SelectMany - question async returning async action 
+        #region SelectMany: IQuestion<Task<T>> -> IAction<Task<U>>
         [Theory, DomainAutoData]
         public async Task SelectMany_Async_ReturningAsyncAction_ShouldReturnCorrectResult(
             int value1,
@@ -298,6 +365,53 @@ public void SelectMany_Async_Name_ReturningAsyncAction_ShouldReturnCorrectResult
         }
         #endregion
 
+        #region SelectMany: IQuestion<Task<T>> -> IAction<Task>
+        [Theory, DomainAutoData]
+        public async Task SelectMany_Async_ReturningAsyncActionTask_ShouldReturnCorrectResult(
+            int value1,
+            int value2)
+        {
+            // arrange
+            var result = 0;
+            var action = Questions.FromResult(Task.FromResult(value1))
+                                  .SelectMany(v => Actions.Create("set result", _ => Delay(() => { result = v + value2; })));
+            var actor = new Actor("john");
+            // act
+            var task = actor.When(action);
+            await task;
+            var actual = result;
+            // assert
+            var expected = value1 + value2;
+            Assert.Equal(expected, actual);
+        }
+
+        [Theory, DomainAutoData]
+        public void SelectMany_Async_Name_ReturningAsyncActionTask_ShouldReturnCorrectResult(
+            IQuestion<Task<int>> question1,
+            IAction<Task> action2)
+        {
+            // arrange
+            var action = question1.SelectMany((int _) => action2);
+            // act
+            var actual = action.Name;
+            // assert
+            var expected = "[SelectMany] " + question1.Name;
+            Assert.Equal(expected, actual);
+        }
+        #endregion
+
+        private static async Task Delay(Action action)
+        {
+            await Task.Delay(1);
+            action();
+        }
+
+        private static async Task<T> Delay<T>(Func<T> action)
+        {
+            await Task.Delay(1);
+            return action();
+        }
+
         #region Tagged
         [Theory, DomainAutoData]
         public void Tagged_ShouldReturnCorrectValue(IQuestion<object> question, string tag)