diff --git a/CMakeLists.txt b/CMakeLists.txt
index ce42978..b2bc655 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,65 +1,67 @@
 cmake_minimum_required(VERSION 3.0)
 
 project(KAsync VERSION 0.3.0)
 
 # ECM setup
 find_package(ECM 5.10.0 CONFIG REQUIRED)
 set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH})
 set(CMAKE_CXX_STANDARD 14)
 
 include(KDEInstallDirs)
 include(KDECMakeSettings)
 include(KDEFrameworkCompilerSettings NO_POLICY_SCOPE)
 include(GenerateExportHeader)
 include(ECMGenerateHeaders)
 include(ECMGeneratePriFile)
 include(CMakePackageConfigHelpers)
 include(ECMSetupVersion)
 include(FeatureSummary)
 
+kde_enable_exceptions()
+
 set(QT_REQUIRED_VERSION "5.2.0")
 
 ecm_setup_version(${KAsync_VERSION}
     VARIABLE_PREFIX KASYNC
     VERSION_HEADER "${CMAKE_CURRENT_BINARY_DIR}/kasync_version.h"
     PACKAGE_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/KAsyncConfigVersion.cmake"
     SOVERSION 0
 )
 
 
 ########### Find packages ###########
 find_package(Qt5 ${QT_REQUIRED_VERSION} REQUIRED COMPONENTS Core Test)
 
 ########### Targets ###########
 add_subdirectory(src)
 add_subdirectory(autotests)
 
 
 ########### CMake Config Files ###########
 set(CMAKECONFIG_INSTALL_DIR "${KDE_INSTALL_CMAKEPACKAGEDIR}/KAsync")
 
 configure_package_config_file(
     "${CMAKE_CURRENT_SOURCE_DIR}/KAsyncConfig.cmake.in"
     "${CMAKE_CURRENT_BINARY_DIR}/KAsyncConfig.cmake"
     INSTALL_DESTINATION ${CMAKECONFIG_INSTALL_DIR}
 )
 
 install(FILES
     "${CMAKE_CURRENT_BINARY_DIR}/KAsyncConfig.cmake"
     "${CMAKE_CURRENT_BINARY_DIR}/KAsyncConfigVersion.cmake"
     DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
     COMPONENT Devel
 )
 
 install(EXPORT
     KAsyncTargets
     DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
     FILE KAsyncTargets.cmake
     )
 
 install(FILES
     ${CMAKE_CURRENT_BINARY_DIR}/kasync_version.h
     DESTINATION ${KDE_INSTALL_INCLUDEDIR} COMPONENT Devel
 )
 
 feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
diff --git a/autotests/CMakeLists.txt b/autotests/CMakeLists.txt
index c04c025..0c1cdb2 100644
--- a/autotests/CMakeLists.txt
+++ b/autotests/CMakeLists.txt
@@ -1,6 +1,11 @@
 include(ECMAddTests)
 
 ecm_add_test(asynctest.cpp
              TEST_NAME asynctest
              LINK_LIBRARIES KAsync Qt5::Test
 )
+ecm_add_test(continuationstest.cpp
+             TEST_NAME continuationstest
+             LINK_LIBRARIES KAsync Qt5::Test
+)
+
diff --git a/autotests/continuationstest.cpp b/autotests/continuationstest.cpp
new file mode 100644
index 0000000..ac055f3
--- /dev/null
+++ b/autotests/continuationstest.cpp
@@ -0,0 +1,116 @@
+/*
+ * Copyright 2019  Daniel Vrátil <dvratil@kde.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License or (at your option) version 3 or any later version
+ * accepted by the membership of KDE e.V. (or its successor approved
+ * by the membership of KDE e.V.), which shall act as a proxy
+ * defined in Section 14 of version 3 of the license.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <QObject>
+#include <QTest>
+
+#define KASYNC_TEST
+
+#include "../src/continuations_p.h"
+
+namespace KAsync
+{
+// Simplified definition of KAsync::Job so we can return it from
+// the test continuations
+template<typename T, typename ... U>
+class Job {};
+}
+
+Q_DECLARE_METATYPE(std::function<bool()>)
+
+#define STATIC_COMPARE(actual, expected) \
+    static_assert((actual) == (expected), "Check failed: " #actual " == " #expected)
+
+class ContinuationHolderTest : public QObject
+{
+    Q_OBJECT
+
+    using TestedHolder = KAsync::Private::ContinuationHolder<void>;
+    template<typename Continuation, typename T>
+    void testContinuation(T &&func, int index)
+    {
+
+        #define CHECK(Cont) \
+            QCOMPARE(KAsync::Private::continuationIs<KAsync::Cont<void>>(holder), (std::is_same<Continuation, KAsync::Cont<void>>::value))
+
+        TestedHolder holder(Continuation(std::move(func)));
+        QCOMPARE(holder.mIndex, index);
+        CHECK(SyncContinuation);
+        CHECK(SyncErrorContinuation);
+        CHECK(AsyncContinuation);
+        CHECK(AsyncErrorContinuation);
+        CHECK(JobContinuation);
+        CHECK(JobErrorContinuation);
+
+        //KAsync::Private::continuation_get<Continuation>(holder)();
+    }
+
+private Q_SLOTS:
+    void testTupleMax()
+    {
+        using TestHolder = KAsync::Private::ContinuationHolder<int>;
+        using Tuple = std::tuple<uint8_t, uint32_t, uint16_t>;
+
+        STATIC_COMPARE(TestHolder::tuple_max<Tuple>::size, sizeof(uint32_t));
+        STATIC_COMPARE(TestHolder::tuple_max<Tuple>::alignment, alignof(uint32_t));
+    }
+
+    void testTupleIndex()
+    {
+        using TestHolder = KAsync::Private::ContinuationHolder<int>;
+        using Tuple = std::tuple<uint8_t, uint32_t, uint16_t>;
+
+        STATIC_COMPARE((TestHolder::tuple_index<uint8_t, Tuple>::value), 0);
+        STATIC_COMPARE((TestHolder::tuple_index<uint32_t, Tuple>::value), 1);
+        STATIC_COMPARE((TestHolder::tuple_index<uint16_t, Tuple>::value), 2);
+    }
+
+    void testContinuationHolder_data()
+    {
+        QTest::addColumn<std::function<bool()>>("func");
+
+#define ADD_ROW(name, lambda, index) \
+        QTest::newRow(#name) << std::function<bool()>([this]() { \
+            bool called = true; \
+            testContinuation<KAsync::name<void>>(lambda, index); \
+            return called; \
+        });
+
+        ADD_ROW(AsyncContinuation, [&called](KAsync::Future<void> &) mutable { called = true; }, 0);
+        ADD_ROW(AsyncErrorContinuation, [&called](const KAsync::Error &, KAsync::Future<void> &) mutable { called = true; }, 1);
+ADD_ROW(SyncContinuation, [&called]() mutable { called = true; }, 2)
+        ADD_ROW(SyncErrorContinuation, [&called](const KAsync::Error &) mutable { called = true; }, 3);
+        ADD_ROW(JobContinuation, [&called]() mutable { called = true; return KAsync::Job<void>(); }, 4);
+        ADD_ROW(JobErrorContinuation, [&called](const KAsync::Error &) mutable { called = true; return KAsync::Job<void>(); }, 5);
+    }
+
+    void testContinuationHolder()
+    {
+        QFETCH(std::function<bool()>, func);
+
+        QVERIFY(func());
+    }
+};
+
+QTEST_GUILESS_MAIN(ContinuationHolderTest)
+
+#include "continuationstest.moc"
+
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 0157167..2492982 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,61 +1,62 @@
 set(kasync_SRCS
     async.cpp
     future.cpp
     debug.cpp
 )
 
 set(kasync_priv_HEADERS
+    continuations_p.h
     async_impl.h
     job_impl.h
     debug.h
 )
 
 ecm_generate_headers(kasync_HEADERS
     HEADER_NAMES
     Async
     Future
     REQUIRED_HEADERS kasync_HEADERS
 )
 
 
 add_library(KAsync ${kasync_SRCS})
 
 generate_export_header(KAsync BASE_NAME kasync)
 
 target_include_directories(KAsync INTERFACE "$<INSTALL_INTERFACE:${KDE_INSTALL_INCLUDEDIR}/KAsync>")
 target_include_directories(KAsync PUBLIC "$<BUILD_INTERFACE:${KAsync_SOURCE_DIR}/src>")
 
 target_link_libraries(KAsync
     PUBLIC
         Qt5::Core
 )
 
 
 set_target_properties(KAsync PROPERTIES
     VERSION ${KASYNC_VERSION_STRING}
     SOVERSION ${KASYNC_SOVERSION}
     EXPORT_NAME KAsync
 )
 
 ecm_generate_pri_file(BASE_NAME KAsync
     LIB_NAME KAsync
     FILENAME_VAR PRI_FILENAME
 )
 
 install(TARGETS
     KAsync
     EXPORT KAsyncTargets ${KDE_INSTALL_TARGETS_DEFAULT_ARGS}
 )
 
 install(FILES
     ${CMAKE_CURRENT_BINARY_DIR}/kasync_export.h
     ${kasync_HEADERS}
     ${kasync_priv_HEADERS}
     DESTINATION ${KDE_INSTALL_INCLUDEDIR}/KAsync
     COMPONENT Devel
 )
 
 install(FILES
     ${PRI_FILENAME}
     DESTINATION ${ECM_MKSPECS_INSTALL_DIR}
 )
diff --git a/src/async.h b/src/async.h
index a7bb76d..252ffc4 100644
--- a/src/async.h
+++ b/src/async.h
@@ -1,755 +1,708 @@
 /*
  * Copyright 2014 - 2015 Daniel Vrátil <dvratil@redhat.com>
  * Copyright 2016  Daniel Vrátil <dvratil@kde.org>
  * Copyright 2016  Christian Mollekopf <mollekopf@kolabsystems.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library. If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef KASYNC_H
 #define KASYNC_H
 
 #include "kasync_export.h"
 
 #include <functional>
 #include <list>
 #include <type_traits>
 #include <cassert>
 #include <iterator>
 #include <memory>
 
 #include "future.h"
 #include "debug.h"
 #include "async_impl.h"
+#include "continuations_p.h"
 
 #include <QVector>
 #include <QObject>
 #include <QSharedPointer>
 #include <QPointer>
 
 #include <QDebug>
 
 
 /**
  * @mainpage KAsync
  *
  * @brief API to help write async code.
  *
  * This API is based around jobs that take lambdas to execute asynchronous tasks.
  * Each async operation can take a continuation that can then be used to execute
  * further async operations. That way it is possible to build async chains of
  * operations that can be stored and executed later on. Jobs can be composed,
  * similarly to functions.
  *
  * Relations between the components:
  * * Job: API wrapper around Executors chain. Can be destroyed while still running,
  *        because the actual execution happens in the background
  * * Executor: Describes task to execute. Executors form a linked list matching the
  *        order in which they will be executed. The Executor chain is destroyed when
  *        the parent Job is destroyed. However if the Job is still running it is
  *        guaranteed that the Executor chain will not be destroyed until the execution
  *        is finished.
  * * Execution: The running execution of the task stored in Executor. Each call to
  *        Job::exec() instantiates new Execution chain, which makes it possible for
  *        the Job to be executed multiple times (even in parallel).
  * * Future: Representation of the result that is being calculated
  *
  *
  * TODO: Possibility to abort a job through future (perhaps optional?)
  * TODO: Support for timeout, specified during exec call, after which the error
  *       handler gets called with a defined errorCode.
  */
 
 
 namespace KAsync {
 
 template<typename PrevOut, typename Out, typename ... In>
 class Executor;
 
 class JobBase;
 
 template<typename Out, typename ... In>
 class Job;
 
-template<typename Out, typename ... In>
-using AsyncContinuation = typename detail::identity<std::function<void(In ..., KAsync::Future<Out>&)>>::type;
-
-template<typename Out, typename ... In>
-using AsyncErrorContinuation = typename detail::identity<std::function<void(const KAsync::Error &, In ..., KAsync::Future<Out>&)>>::type;
-
-template<typename Out, typename ... In>
-using SyncContinuation = typename detail::identity<std::function<Out(In ...)>>::type;
-
-template<typename Out, typename ... In>
-using SyncErrorContinuation = typename detail::identity<std::function<Out(const KAsync::Error &, In ...)>>::type;
-
-template<typename Out, typename ... In>
-using JobContinuation = typename detail::identity<std::function<KAsync::Job<Out>(In ...)>>::type;
-
-template<typename Out, typename ... In>
-using JobErrorContinuation = typename detail::identity<std::function<KAsync::Job<Out>(const KAsync::Error &, In ...)>>::type;
-
 
 //@cond PRIVATE
 namespace Private
 {
 
 class ExecutorBase;
 typedef QSharedPointer<ExecutorBase> ExecutorBasePtr;
 
 class ExecutionContext;
 
 struct KASYNC_EXPORT Execution {
     explicit Execution(const ExecutorBasePtr &executor);
     virtual ~Execution();
     void setFinished();
 
     template<typename T>
     KAsync::Future<T>* result() const
     {
         return static_cast<KAsync::Future<T>*>(resultBase);
     }
 
     void releaseFuture();
 
     ExecutorBasePtr executor;
     ExecutionPtr prevExecution;
     std::unique_ptr<Tracer> tracer;
     FutureBase *resultBase = nullptr;
 };
 
-
-template<typename Out, typename ... In>
-struct ContinuationHolder {
-    ContinuationHolder(AsyncContinuation<Out, In...> &&func)
-        : asyncContinuation(std::move(func))
-    {};
-    ContinuationHolder(AsyncErrorContinuation<Out, In...> &&func)
-        : asyncErrorContinuation(std::move(func))
-    {};
-    ContinuationHolder(SyncContinuation<Out, In...> &&func)
-        : syncContinuation(std::move(func))
-    {}
-    ContinuationHolder(SyncErrorContinuation<Out, In...> &&func)
-        : syncErrorContinuation(std::move(func))
-    {}
-    ContinuationHolder(JobContinuation<Out, In...> &&func)
-        : jobContinuation(std::move(func))
-    {};
-    ContinuationHolder(JobErrorContinuation<Out, In...> &&func)
-        : jobErrorContinuation(std::move(func))
-    {};
-
-    AsyncContinuation<Out, In...> asyncContinuation;
-    AsyncErrorContinuation<Out, In...> asyncErrorContinuation;
-    SyncContinuation<Out, In...> syncContinuation;
-    SyncErrorContinuation<Out, In...> syncErrorContinuation;
-    JobContinuation<Out, In...> jobContinuation;
-    JobErrorContinuation<Out, In...> jobErrorContinuation;
-};
-
 typedef QSharedPointer<Execution> ExecutionPtr;
 
 class KASYNC_EXPORT ExecutorBase
 {
     template<typename PrevOut, typename Out, typename ... In>
     friend class Executor;
 
     template<typename Out, typename ... In>
     friend class KAsync::Job;
 
     friend struct Execution;
     friend class KAsync::Tracer;
 
 public:
     virtual ~ExecutorBase() = default;
     virtual ExecutionPtr exec(const ExecutorBasePtr &self, QSharedPointer<Private::ExecutionContext> context) = 0;
 
 protected:
     ExecutorBase(const ExecutorBasePtr &parent)
         : mPrev(parent)
     {}
 
     template<typename T>
     KAsync::Future<T>* createFuture(const ExecutionPtr &execution) const;
 
     ExecutorBasePtr mPrev;
 
     void prepend(const ExecutorBasePtr &e)
     {
         if (mPrev) {
             mPrev->prepend(e);
         } else {
             mPrev = e;
         }
     }
 
     void addToContext(const QVariant &entry)
     {
         mContext << entry;
     }
 
     void guard(const QObject *o)
     {
         mGuards.append(QPointer<const QObject>{o});
     }
 
     QString mExecutorName;
     QVector<QVariant> mContext;
     QVector<QPointer<const QObject>> mGuards;
 };
 
 enum ExecutionFlag {
     Always,
     ErrorCase,
     GoodCase
 };
 
 template<typename PrevOut, typename Out, typename ... In>
 class Executor : public ExecutorBase
 {
 protected:
 
     Executor(const Private::ExecutorBasePtr &parent, ExecutionFlag executionFlag)
         : ExecutorBase(parent)
         , executionFlag(executionFlag)
     {}
 
     virtual ~Executor() {}
     virtual void run(const ExecutionPtr &execution) = 0;
 
     ExecutionPtr exec(const ExecutorBasePtr &self, QSharedPointer<Private::ExecutionContext> context) override;
 
     const ExecutionFlag executionFlag;
 
 private:
     void runExecution(const KAsync::Future<PrevOut> *prevFuture, const ExecutionPtr &execution, bool guardIsBroken);
 };
 
 } // namespace Private
 //@endcond
 
 
 template<typename Out, typename ... In>
 Job<Out, In ...> startImpl(Private::ContinuationHolder<Out, In ...> &&);
 
 template<typename Out, typename ... In>
 Job<Out, In ...> syncStartImpl(SyncContinuation<Out, In ...> &&);
 
 
 
 /**
  * @relates Job
  *
  * Start an asynchronous job sequence.
  *
  * start() is your starting point to build a chain of jobs to be executed
  * asynchronously.
  *
  * @param func A continuation to be executed.
  */
 
 ///Sync continuation without job: [] () -> T { ... }
 template<typename Out = void, typename ... In, typename F>
 auto start(F &&func) -> std::enable_if_t<!std::is_base_of<JobBase, decltype(func(std::declval<In>() ...))>::value,
                                          Job<decltype(func(std::declval<In>() ...)), In...>>
 {
     static_assert(sizeof...(In) <= 1, "Only one or zero input parameters are allowed.");
     return syncStartImpl<Out, In...>(std::forward<F>(func));
 }
 
 ///continuation with job: [] () -> KAsync::Job<...> { ... }
 template<typename Out = void, typename ... In, typename F>
 auto start(F &&func) -> std::enable_if_t<std::is_base_of<JobBase, decltype(func(std::declval<In>() ...))>::value,
                                          Job<typename decltype(func(std::declval<In>() ...))::OutType, In...>>
 {
     static_assert(sizeof...(In) <= 1, "Only one or zero input parameters are allowed.");
     return startImpl<Out, In...>(Private::ContinuationHolder<Out, In ...>(JobContinuation<Out, In...>(std::forward<F>(func))));
 }
 
 ///Handle continuation: [] (KAsync::Future<T>, ...) { ... }
 template<typename Out = void, typename ... In>
 auto start(AsyncContinuation<Out, In ...> &&func) -> Job<Out, In ...>
 {
     static_assert(sizeof...(In) <= 1, "Only one or zero input parameters are allowed.");
     return startImpl<Out, In...>(Private::ContinuationHolder<Out, In ...>(std::forward<AsyncContinuation<Out, In ...>>(func)));
 }
 
 enum ControlFlowFlag {
     Break,
     Continue
 };
 
 /**
  * @relates Job
  *
  * Async while loop.
  *
  * Loop continues while body returns ControlFlowFlag::Continue.
  */
 KASYNC_EXPORT Job<void> doWhile(const Job<ControlFlowFlag> &body);
 
 /**
  * @relates Job
  *
  * Async while loop.
  *
  * Shorthand that takes a continuation.
  *
  * @see doWhile
  */
 KASYNC_EXPORT Job<void> doWhile(const JobContinuation<ControlFlowFlag> &body);
 
 
 
 /**
  * @relates Job
  *
  * Async delay.
  */
 KASYNC_EXPORT Job<void> wait(int delay);
 
 /**
  * @relates Job
  *
  * A null job.
  *
  * An async noop.
  *
  */
 template<typename Out = void>
 Job<Out> null();
 
 /**
  * @relates Job
  *
  * Async value.
  */
 template<typename Out>
 Job<Out> value(Out);
 
 /**
  * @relates Job
  *
  * Async foreach loop.
  *
  * This will execute a job for every value in the list.
  * Errors while not stop processing of other jobs but set an error on the wrapper job.
  */
 template<typename List, typename ValueType = typename List::value_type>
 Job<void, List> forEach(KAsync::Job<void, ValueType> job);
 
 /**
  * @relates Job
  *
  * Async foreach loop.
  *
  * Shorthand that takes a continuation.
  *
  * @see serialForEach
  */
 template<typename List, typename ValueType = typename List::value_type>
  Job<void, List> forEach(JobContinuation<void, ValueType> &&);
 
 
 /**
  * @relates Job
  *
  * Serial Async foreach loop.
  *
  * This will execute a job for every value in the list sequentially.
  * Errors while not stop processing of other jobs but set an error on the wrapper job.
  */
 template<typename List, typename ValueType = typename List::value_type>
 Job<void, List> serialForEach(KAsync::Job<void, ValueType> job);
 
 /**
  * @relates Job
  *
  * Serial Async foreach loop.
  *
  * Shorthand that takes a continuation.
  *
  * @see serialForEach
  */
 template<typename List, typename ValueType = typename List::value_type>
 Job<void, List> serialForEach(JobContinuation<void, ValueType> &&);
 
 
 /**
  * @relates Job
  *
  * An error job.
  *
  * An async error.
  *
  */
 template<typename Out = void>
 Job<Out> error(int errorCode = 1, const QString &errorMessage = QString());
 
 /**
  * @relates Job
  *
  * An error job.
  *
  * An async error.
  *
  */
 template<typename Out = void>
 Job<Out> error(const char *);
 
 /**
  * @relates Job
  *
  * An error job.
  *
  * An async error.
  *
  */
 template<typename Out = void>
 Job<Out> error(const Error &);
 
 //@cond PRIVATE
 class KASYNC_EXPORT JobBase
 {
     template<typename Out, typename ... In>
     friend class Job;
 
 public:
     explicit JobBase(const Private::ExecutorBasePtr &executor)
         : mExecutor(executor)
     {}
 
     virtual ~JobBase() = default;
 
 protected:
     Private::ExecutorBasePtr mExecutor;
 };
 //@endcond
 
 /**
  * @brief An Asynchronous job
  *
  * A single instance of Job represents a single method that will be executed
  * asynchronously. The Job is started by exec(), which returns Future
  * immediatelly. The Future will be set to finished state once the asynchronous
  * task has finished. You can use Future::waitForFinished() to wait for
  * for the Future in blocking manner.
  *
  * It is possible to chain multiple Jobs one after another in different fashion
  * (sequential, parallel, etc.). Calling exec() will then return a pending
  * Future, and will execute the entire chain of jobs.
  *
  * @code
  * auto job = Job::start<QList<int>>(
  *     [](KAsync::Future<QList<int>> &future) {
  *         MyREST::PendingUsers *pu = MyREST::requestListOfUsers();
  *         QObject::connect(pu, &PendingOperation::finished,
  *                          [&](PendingOperation *pu) {
  *                              future->setValue(dynamic_cast<MyREST::PendingUsers*>(pu)->userIds());
  *                              future->setFinished();
  *                          });
  *      })
  * .each<QList<MyREST::User>, int>(
  *      [](const int &userId, KAsync::Future<QList<MyREST::User>> &future) {
  *          MyREST::PendingUser *pu = MyREST::requestUserDetails(userId);
  *          QObject::connect(pu, &PendingOperation::finished,
  *                           [&](PendingOperation *pu) {
  *                              future->setValue(Qlist<MyREST::User>() << dynamic_cast<MyREST::PendingUser*>(pu)->user());
  *                              future->setFinished();
  *                           });
  *      });
  *
  * KAsync::Future<QList<MyREST::User>> usersFuture = job.exec();
  * usersFuture.waitForFinished();
  * QList<MyRest::User> users = usersFuture.value();
  * @endcode
  *
  * In the example above, calling @p job.exec() will first invoke the first job,
  * which will retrieve a list of IDs and then will invoke the second function
  * for each single entry in the list returned by the first function.
  */
 template<typename Out, typename ... In>
 class Job : public JobBase
 {
     //@cond PRIVATE
     template<typename OutOther, typename ... InOther>
     friend class Job;
 
     template<typename OutOther, typename ... InOther>
     friend Job<OutOther, InOther ...> startImpl(Private::ContinuationHolder<OutOther, InOther ...> &&);
 
     template<typename OutOther, typename ... InOther>
     friend Job<OutOther, InOther ...> syncStartImpl(SyncContinuation<OutOther, InOther ...> &&);
 
     template<typename List, typename ValueType>
     friend  Job<void, List> forEach(KAsync::Job<void, ValueType> job);
 
     template<typename List, typename ValueType>
     friend Job<void, List> serialForEach(KAsync::Job<void, ValueType> job);
 
     // Used to disable implicit conversion of Job<void to Job<void> which triggers
     // comiler warning.
     struct IncompleteType;
     //@endcond
 
 public:
     typedef Out OutType;
 
     ///A continuation
     template<typename OutOther, typename ... InOther>
     Job<OutOther, In ...> then(const Job<OutOther, InOther ...> &job) const;
 
     ///Shorthands for a job that returns another job from it's continuation
     //
     //OutOther and InOther are only there fore backwards compatibility, but are otherwise ignored.
     //It should never be neccessary to specify any template arguments, as they are automatically deduced from the provided argument.
     //
     //We currently have to write a then overload for:
     //* One argument in the continuation
     //* No argument in the continuation
     //* One argument + error in the continuation
     //* No argument + error in the continuation
     //This is due to how we extract the return type with "decltype(func(std::declval<Out>()))".
     //Ideally we could conflate this into at least fewer overloads, but I didn't manage so far and this at least works as expected.
 
     ///Continuation returning job: [] (Arg) -> KAsync::Job<...> { ... }
     template<typename OutOther = void, typename ... InOther, typename F>
     auto then(F &&func) const -> std::enable_if_t<std::is_base_of<JobBase, decltype(func(std::declval<Out>()))>::value,
                                                   Job<typename decltype(func(std::declval<Out>()))::OutType, In...>>
     {
         using ResultJob = decltype(func(std::declval<Out>())); //Job<QString, int>
         return thenImpl<typename ResultJob::OutType, Out>(
                 {JobContinuation<typename ResultJob::OutType, Out>(std::forward<F>(func))}, Private::ExecutionFlag::GoodCase);
     }
 
     ///Void continuation with job: [] () -> KAsync::Job<...> { ... }
     template<typename OutOther = void, typename ... InOther, typename F>
     auto then(F &&func) const -> std::enable_if_t<std::is_base_of<JobBase, decltype(func())>::value,
                                                   Job<typename decltype(func())::OutType, In...>>
     {
         using ResultJob = decltype(func()); //Job<QString, void>
         return thenImpl<typename ResultJob::OutType>(
                 {JobContinuation<typename ResultJob::OutType>(std::forward<F>(func))}, Private::ExecutionFlag::GoodCase);
     }
 
     ///Error continuation returning job: [] (KAsync::Error, Arg) -> KAsync::Job<...> { ... }
     template<typename OutOther = void, typename ... InOther, typename F>
     auto then(F &&func) const -> std::enable_if_t<std::is_base_of<JobBase, decltype(func(KAsync::Error{}, std::declval<Out>()))>::value,
                                                   Job<typename decltype(func(KAsync::Error{}, std::declval<Out>()))::OutType, In...>>
     {
         using ResultJob = decltype(func(KAsync::Error{}, std::declval<Out>())); //Job<QString, int>
         return thenImpl<typename ResultJob::OutType, Out>(
                 {JobErrorContinuation<typename ResultJob::OutType, Out>(std::forward<F>(func))}, Private::ExecutionFlag::Always);
     }
 
     ///Error void continuation returning job: [] (KAsync::Error) -> KAsync::Job<...> { ... }
     template<typename OutOther = void, typename ... InOther, typename F>
     auto then(F &&func) const -> std::enable_if_t<std::is_base_of<JobBase, decltype(func(KAsync::Error{}))>::value,
                                                   Job<typename decltype(func(KAsync::Error{}))::OutType, In...>>
     {
         using ResultJob = decltype(func(KAsync::Error{}));
         return thenImpl<typename ResultJob::OutType>(
                 {JobErrorContinuation<typename ResultJob::OutType>(std::forward<F>(func))}, Private::ExecutionFlag::Always);
     }
 
     ///Sync continuation: [] (Arg) -> void { ... }
     template<typename OutOther = void, typename ... InOther, typename F>
     auto then(F &&func) const -> std::enable_if_t<!std::is_base_of<JobBase, decltype(func(std::declval<Out>()))>::value,
                                                   Job<decltype(func(std::declval<Out>())), In...>>
     {
         using ResultType = decltype(func(std::declval<Out>())); //QString
         return syncThenImpl<ResultType, Out>(
                 {SyncContinuation<ResultType, Out>(std::forward<F>(func))}, Private::ExecutionFlag::GoodCase);
     }
 
     ///Sync void continuation: [] () -> void { ... }
     template<typename OutOther = void, typename ... InOther, typename F>
     auto then(F &&func) const -> std::enable_if_t<!std::is_base_of<JobBase, decltype(func())>::value,
                                                   Job<decltype(func()), In...>>
     {
         using ResultType = decltype(func()); //QString
         return syncThenImpl<ResultType>(
                 {SyncContinuation<ResultType>(std::forward<F>(func))}, Private::ExecutionFlag::GoodCase);
     }
 
     ///Sync error continuation: [] (KAsync::Error, Arg) -> void { ... }
     template<typename OutOther = void, typename ... InOther, typename F>
     auto then(F &&func) const -> std::enable_if_t<!std::is_base_of<JobBase, decltype(func(KAsync::Error{}, std::declval<Out>()))>::value,
                                                   Job<decltype(func(KAsync::Error{}, std::declval<Out>())),In...>>
     {
         using ResultType = decltype(func(KAsync::Error{}, std::declval<Out>())); //QString
         return syncThenImpl<ResultType, Out>(
                 {SyncErrorContinuation<ResultType, Out>(std::forward<F>(func))}, Private::ExecutionFlag::Always);
     }
 
     ///Sync void error continuation: [] (KAsync::Error) -> void { ... }
     template<typename OutOther = void, typename ... InOther, typename F>
     auto then(F &&func) const -> std::enable_if_t<!std::is_base_of<JobBase, decltype(func(KAsync::Error{}))>::value,
                                                   Job<decltype(func(KAsync::Error{})), In...>>
     {
         using ResultType = decltype(func(KAsync::Error{}));
         return syncThenImpl<ResultType>(
                 {SyncErrorContinuation<ResultType>(std::forward<F>(func))}, Private::ExecutionFlag::Always);
     }
 
     ///Shorthand for a job that receives the error and a handle
     template<typename OutOther, typename ... InOther>
     Job<OutOther, In ...> then(AsyncContinuation<OutOther, InOther ...> &&func) const
     {
         return thenImpl<OutOther, InOther ...>({std::forward<AsyncContinuation<OutOther, InOther ...>>(func)},
                                                Private::ExecutionFlag::GoodCase);
     }
 
     ///Shorthand for a job that receives the error and a handle
     template<typename OutOther, typename ... InOther>
     Job<OutOther, In ...> then(AsyncErrorContinuation<OutOther, InOther ...> &&func) const
     {
         return thenImpl<OutOther, InOther ...>({std::forward<AsyncErrorContinuation<OutOther, InOther ...>>(func)}, Private::ExecutionFlag::Always);
     }
 
     ///Shorthand for a job that receives the error only
     Job<Out, In ...> onError(SyncErrorContinuation<void> &&errorFunc) const;
 
     /**
      * Shorthand for a forEach loop that automatically uses the return type of
      * this job to deduce the type exepected.
      */
     template<typename OutOther = void, typename ListType = Out, typename ValueType = typename ListType::value_type, std::enable_if_t<!std::is_void<ListType>::value, int> = 0>
     Job<void, In ...> each(JobContinuation<void, ValueType> &&func) const
     {
         eachInvariants<OutOther>();
         return then<void, In ...>(forEach<Out, ValueType>(std::forward<JobContinuation<void, ValueType>>(func)));
     }
 
     /**
      * Shorthand for a serialForEach loop that automatically uses the return type
      * of this job to deduce the type exepected.
      */
     template<typename OutOther = void, typename ListType = Out, typename ValueType = typename ListType::value_type, std::enable_if_t<!std::is_void<ListType>::value, int> = 0>
     Job<void, In ...> serialEach(JobContinuation<void, ValueType> &&func) const
     {
         eachInvariants<OutOther>();
         return then<void, In ...>(serialForEach<Out, ValueType>(std::forward<JobContinuation<void, ValueType>>(func)));
     }
 
     /**
      * Enable implicit conversion to Job<void>.
      *
      * This is necessary in assignments that only use the return value (which is the normal case).
      * This avoids constructs like:
      * auto job = KAsync::start<int>( ... )
      *  .then<void, int>( ... )
      *  .then<void>([](){}); //Necessary for the assignment without the implicit conversion
      */
     template<typename ... InOther>
     operator std::conditional_t<std::is_void<OutType>::value, IncompleteType, Job<void>>();
 
     /**
      * Adds an unnamed value to the context.
      * The context is guaranteed to persist until the jobs execution has finished.
      *
      * Useful for setting smart pointer to manage lifetime of objects required
      * during the execution of the job.
      */
     template<typename T>
     Job<Out, In ...> &addToContext(const T &value)
     {
         assert(mExecutor);
         mExecutor->addToContext(QVariant::fromValue<T>(value));
         return *this;
     }
 
     /**
      * Adds a guard.
      * It is guaranteed that no callback is executed after the guard vanishes.
      *
      * Use this i.e. ensure you don't call-back into an already destroyed object.
      */
     Job<Out, In ...> &guard(const QObject *o)
     {
         assert(mExecutor);
         mExecutor->guard(o);
         return *this;
     }
 
     /**
      * @brief Starts execution of the job chain.
      *
      * This will start the execution of the task chain, starting from the
      * first one. It is possible to call this function multiple times, each
      * invocation will start a new processing and provide a new Future to
      * watch its status.
      *
      * @param in Argument to be passed to the very first task
      * @return Future&lt;Out&gt; object which will contain result of the last
      * task once if finishes executing. See Future documentation for more details.
      *
      * @see exec(), Future
      */
     template<typename FirstIn>
     KAsync::Future<Out> exec(FirstIn in);
 
     /**
      * @brief Starts execution of the job chain.
      *
      * This will start the execution of the task chain, starting from the
      * first one. It is possible to call this function multiple times, each
      * invocation will start a new processing and provide a new Future to
      * watch its status.
      *
      * @return Future&lt;Out&gt; object which will contain result of the last
      * task once if finishes executing. See Future documentation for more details.
      *
      * @see exec(FirstIn in), Future
      */
     KAsync::Future<Out> exec();
 
     explicit Job(JobContinuation<Out, In ...> &&func);
     explicit Job(AsyncContinuation<Out, In ...> &&func);
 
 private:
     //@cond PRIVATE
     explicit Job(Private::ExecutorBasePtr executor);
 
     template<typename OutOther, typename ... InOther>
     Job<OutOther, In ...> thenImpl(Private::ContinuationHolder<OutOther, InOther ...> helper,
                                    Private::ExecutionFlag execFlag = Private::ExecutionFlag::GoodCase) const;
 
     template<typename OutOther, typename ... InOther>
     Job<OutOther, In ...> syncThenImpl(SyncContinuation<OutOther, InOther ...> &&func,
                                        Private::ExecutionFlag execFlag = Private::ExecutionFlag::GoodCase) const;
     template<typename OutOther, typename ... InOther>
     Job<OutOther, In ...> syncThenImpl(SyncErrorContinuation<OutOther, InOther ...> &&func,
                                        Private::ExecutionFlag execFlag = Private::ExecutionFlag::Always) const;
 
     template<typename InOther, typename ... InOtherTail>
     void thenInvariants() const;
 
     //Base case for an empty parameter pack
     template<typename ... InOther>
     auto thenInvariants() const -> std::enable_if_t<(sizeof...(InOther) == 0)>;
 
     template<typename OutOther>
     void eachInvariants() const;
     //@endcond
 };
 
 } // namespace KAsync
 
 
 // out-of-line definitions of Job methods
 #include "job_impl.h"
 
 #endif // KASYNC_H
diff --git a/src/async_impl.h b/src/async_impl.h
index 9abfd85..545ee66 100644
--- a/src/async_impl.h
+++ b/src/async_impl.h
@@ -1,97 +1,94 @@
 /*
  * Copyright 2014 - 2015 Daniel Vrátil <dvratil@redhat.com>
  * Copyright 2016        Daniel Vrátil <dvratil@kde.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library. If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef KASYNC_IMPL_H
 #define KASYNC_IMPL_H
 
-#include "async.h"
 #include <type_traits>
+#include <tuple>
 
 //@cond PRIVATE
 
 namespace KAsync {
 
-namespace detail {
-
 template<typename T>
-struct identity
-{
-    typedef T type;
-};
+class Future;
+
+namespace detail {
 
 template<typename T, typename Enable = void>
 struct isIterable {
     enum { value = 0 };
 };
 
 template<typename T>
 struct isIterable<T, std::conditional_t<false, typename T::iterator, void>> {
     enum { value = 1 };
 };
 
 template<typename ... T>
 struct prevOut {
     using type = std::tuple_element_t<0, std::tuple<T ..., void>>;
 };
 
 template<typename T, typename Out, typename ... In>
 struct funcHelper {
     using type = void(T::*)(In ..., KAsync::Future<Out> &);
 };
 
 template<typename T, typename Out, typename ... In>
 struct syncFuncHelper {
     using type =  Out(T::*)(In ...);
 };
 
 template<typename T>
 inline std::enable_if_t<!std::is_void<T>::value, void>
 copyFutureValue(const KAsync::Future<T> &in, KAsync::Future<T> &out)
 {
     out.setValue(in.value());
 }
 
 template<typename T>
 inline std::enable_if_t<std::is_void<T>::value, void>
 copyFutureValue(const KAsync::Future<T> &/* in */, KAsync::Future<T> &/* out */)
 {
     // noop
 }
 
 template<typename T>
 inline std::enable_if_t<!std::is_void<T>::value, void>
 aggregateFutureValue(const KAsync::Future<T> &in, KAsync::Future<T> &out)
 {
     out.setValue(out.value() + in.value());
 }
 
 template<typename T>
 inline std::enable_if_t<std::is_void<T>::value, void>
 aggregateFutureValue(const KAsync::Future<T> & /*in */, KAsync::Future<T> & /*out */)
 {
     // noop
 }
 
 } // namespace Detail
 
 
 } // namespace KAsync
 
 //@endcond
 
 #endif // KASYNC_IMPL_H
diff --git a/src/continuations_p.h b/src/continuations_p.h
new file mode 100644
index 0000000..89eaa9c
--- /dev/null
+++ b/src/continuations_p.h
@@ -0,0 +1,242 @@
+/*
+ * Copyright 2014 - 2015 Daniel Vrátil <dvratil@redhat.com>
+ * Copyright 2016 - 2019 Daniel Vrátil <dvratil@kde.org>
+ * Copyright 2016  Christian Mollekopf <mollekopf@kolabsystems.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef KASYNC_CONTINUATIONS_P_H_
+#define KASYNC_CONTINUATIONS_P_H_
+
+#include <limits>
+#include <functional>
+#include <type_traits>
+
+namespace KAsync
+{
+
+template<typename Out, typename ... In>
+class Job;
+
+template<typename T>
+class Future;
+
+struct Error;
+
+//@cond PRIVATE
+namespace detail {
+template<typename T>
+struct identity {
+    using type = T;
+};
+template<typename T>
+using identity_t = typename identity<T>::type;
+}
+//@endcond
+
+template<typename Out, typename ... In>
+using AsyncContinuation = detail::identity_t<std::function<void(In ..., KAsync::Future<Out>&)>>;
+
+template<typename Out, typename ... In>
+using AsyncErrorContinuation = detail::identity_t<std::function<void(const KAsync::Error &, In ..., KAsync::Future<Out>&)>>;
+
+template<typename Out, typename ... In>
+using SyncContinuation = detail::identity_t<std::function<Out(In ...)>>;
+
+template<typename Out, typename ... In>
+using SyncErrorContinuation = detail::identity_t<std::function<Out(const KAsync::Error &, In ...)>>;
+
+template<typename Out, typename ... In>
+using JobContinuation = detail::identity_t<std::function<KAsync::Job<Out>(In ...)>>;
+
+template<typename Out, typename ... In>
+using JobErrorContinuation = detail::identity_t<std::function<KAsync::Job<Out>(const KAsync::Error &, In ...)>>;
+
+//@cond PRIVATE
+namespace Private
+{
+/**
+ * FIXME: This should be a simple alias to std::variant once we can depend on C++17.
+ */
+template<typename Out, typename ... In>
+struct ContinuationHolder
+{
+#ifndef KASYNC_TEST
+private:
+#endif
+    using Tuple = std::tuple<
+        AsyncContinuation<Out, In ...>,
+        AsyncErrorContinuation<Out, In ...>,
+        SyncContinuation<Out, In ...>,
+        SyncErrorContinuation<Out, In ...>,
+        JobContinuation<Out, In ...>,
+        JobErrorContinuation<Out, In ...>
+    >;
+
+    template<typename T>
+    struct tuple_max;
+
+    template<typename T>
+    struct tuple_max<std::tuple<T>> {
+        static constexpr std::size_t size = sizeof(T);
+        static constexpr std::size_t alignment = alignof(T);
+    };
+    template<typename T, typename ... Types>
+    struct tuple_max<std::tuple<T, Types ...>> {
+        static constexpr std::size_t size = std::max(sizeof(T), tuple_max<std::tuple<Types ...>>::size);
+        static constexpr std::size_t alignment = std::max(alignof(T), tuple_max<std::tuple<Types ...>>::alignment);
+    };
+
+    template<typename T, typename Tuple>
+    struct tuple_index;
+
+    template<typename T, typename ... Types>
+    struct tuple_index<T, std::tuple<T, Types ...>> {
+        static constexpr std::size_t value = 0;
+    };
+    template<typename T, typename U, typename ... Types>
+    struct tuple_index<T, std::tuple<U, Types ...>> {
+        static constexpr std::size_t value = tuple_index<T, std::tuple<Types ...>>::value + 1;
+    };
+
+    template<typename T>
+    inline static void move_helper(void *storage, void *data) {
+        new (storage) T(std::move(*reinterpret_cast<T*>(data)));
+    }
+
+    template<typename T>
+    inline static void destroy_helper(void *storage) {
+        reinterpret_cast<T*>(storage)->~T();
+    }
+
+    template<typename Tuple,
+             std::size_t I = std::tuple_size<Tuple>::value - 1>
+    struct storage_helper {
+        using T = std::tuple_element_t<I, Tuple>;
+        inline static void move(std::size_t index, void *storage, void *data) {
+            if (I == index) {
+                move_helper<T>(storage, data);
+            } else {
+                storage_helper<Tuple, I - 1>::move(index, storage, data);
+            }
+        }
+        inline static void destroy(std::size_t index, void *storage) {
+            if (I == index) {
+                destroy_helper<T>(storage);
+            } else {
+                storage_helper<Tuple, I - 1>::destroy(index, storage);
+            }
+        }
+    };
+
+    template<typename Tuple>
+    struct storage_helper<Tuple, 0> {
+        using T = std::tuple_element_t<0, Tuple>;
+        inline static void move(std::size_t, void *storage, void *data) {
+            move_helper<T>(storage, data);
+        }
+        inline static void destroy(std::size_t, void *storage) {
+            destroy_helper<T>(storage);
+        }
+    };
+
+    enum {
+        Invalid = std::numeric_limits<std::size_t>::max() - 1
+    };
+
+    std::size_t mIndex = Invalid;
+    std::aligned_storage_t<tuple_max<Tuple>::size, tuple_max<Tuple>::alignment> mStorage = {};
+
+public:
+    #define KASYNC_P_DEFINE_CONSTRUCTOR(type) \
+        ContinuationHolder(type<Out, In ...> &&cont) \
+            : mIndex(tuple_index<type<Out, In ...>, Tuple>::value) \
+        { \
+            move_helper<type<Out, In ...>>(&mStorage, &cont); \
+        }
+    KASYNC_P_DEFINE_CONSTRUCTOR(AsyncContinuation)
+    KASYNC_P_DEFINE_CONSTRUCTOR(AsyncErrorContinuation)
+    KASYNC_P_DEFINE_CONSTRUCTOR(SyncContinuation)
+    KASYNC_P_DEFINE_CONSTRUCTOR(SyncErrorContinuation)
+    KASYNC_P_DEFINE_CONSTRUCTOR(JobContinuation)
+    KASYNC_P_DEFINE_CONSTRUCTOR(JobErrorContinuation)
+    #undef KASYNC_P_DEFINE_CONSTRUCTOR
+
+    ContinuationHolder(ContinuationHolder &&other) noexcept {
+        std::swap(mIndex, other.mIndex);
+        storage_helper<Tuple>::move(mIndex, &mStorage, &other.mStorage);
+    }
+
+    ContinuationHolder &operator=(ContinuationHolder &&other) noexcept {
+        std::swap(mIndex, other.mIndex);
+        storage_helper<Tuple>::move(mIndex, &mStorage, &other.mStorage);
+        return *this;
+    }
+
+    ContinuationHolder(const ContinuationHolder &) = delete;
+    ContinuationHolder &operator=(const ContinuationHolder &) = delete;
+
+    ~ContinuationHolder() {
+        if (mIndex != Invalid) {
+            storage_helper<Tuple>::destroy(mIndex, &mStorage);
+            mIndex = Invalid;
+        }
+    }
+
+    template<typename T>
+    inline bool is() const {
+        return mIndex == tuple_index<T, Tuple>::value;
+    }
+
+    template<typename T>
+    inline const T &get() const {
+        if (!is<T>()) {
+            throw std::bad_cast();
+        }
+        return *reinterpret_cast<const T *>(&mStorage);
+    }
+
+    template<typename T>
+    inline T &&get() {
+        if (!is<T>()) {
+            throw std::bad_cast();
+        }
+        return std::move(*reinterpret_cast<T *>(&mStorage));
+    }
+};
+
+template<typename T, typename Holder>
+inline bool continuationIs(const Holder &holder) {
+    return holder.template is<T>();
+}
+
+template<typename T, typename Holder>
+inline const T &continuationGet(const Holder &holder) {
+    return holder.template get<T>();
+}
+
+template<typename T, typename Holder>
+inline T &&continuationGet(Holder &holder) {
+    return holder.template get<T>();
+}
+
+} // namespace Private
+//@endcond
+
+
+}
+
+
+#endif
diff --git a/src/job_impl.h b/src/job_impl.h
index afaca2e..ae66983 100644
--- a/src/job_impl.h
+++ b/src/job_impl.h
@@ -1,579 +1,580 @@
 /*
  * Copyright 2014 - 2015 Daniel Vrátil <dvratil@redhat.com>
  * Copyright 2015 - 2016 Daniel Vrátil <dvratil@kde.org>
  * Copyright 2016  Christian Mollekopf <mollekopf@kolabsystems.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library. If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef KASYNC_JOB_IMPL_H
 #define KASYNC_JOB_IMPL_H
 
 #include "async.h"
 
 //@cond PRIVATE
 
 namespace KAsync
 {
 
 namespace Private {
 
 template<typename Out, typename ... In>
 class ThenExecutor: public Executor<typename detail::prevOut<In ...>::type, Out, In ...>
 {
 public:
     ThenExecutor(ContinuationHolder<Out, In ...> &&workerHelper, const ExecutorBasePtr &parent = {},
                  ExecutionFlag executionFlag = ExecutionFlag::GoodCase)
         : Executor<typename detail::prevOut<In ...>::type, Out, In ...>(parent, executionFlag)
         , mContinuationHolder(std::move(workerHelper))
     {
         STORE_EXECUTOR_NAME("ThenExecutor", Out, In ...);
     }
 
     void run(const ExecutionPtr &execution) Q_DECL_OVERRIDE
     {
         KAsync::Future<typename detail::prevOut<In ...>::type> *prevFuture = nullptr;
         if (execution->prevExecution) {
             prevFuture = execution->prevExecution->result<typename detail::prevOut<In ...>::type>();
             assert(prevFuture->isFinished());
         }
 
         //Execute one of the available workers
         KAsync::Future<Out> *future = execution->result<Out>();
 
-        const auto &helper = ThenExecutor<Out, In ...>::mContinuationHolder;
-        if (helper.asyncContinuation) {
-            helper.asyncContinuation(prevFuture ? prevFuture->value() : In() ..., *future);
-        } else if (helper.asyncErrorContinuation) {
-            helper.asyncErrorContinuation(prevFuture->hasError() ? prevFuture->errors().first() : Error(),
-                                           prevFuture ? prevFuture->value() : In() ..., *future);
-        } else if (helper.syncContinuation) {
+        const auto &continuation = ThenExecutor<Out, In ...>::mContinuationHolder;
+        if (continuationIs<AsyncContinuation<Out, In ...>>(continuation)) {
+            continuationGet<AsyncContinuation<Out, In ...>>(continuation)(prevFuture ? prevFuture->value() : In() ..., *future);
+        } else if (continuationIs<AsyncErrorContinuation<Out, In ...>>(continuation)) {
+            continuationGet<AsyncErrorContinuation<Out, In ...>>(continuation)(
+                    prevFuture->hasError() ? prevFuture->errors().first() : Error(),
+                    prevFuture ? prevFuture->value() : In() ..., *future);
+        } else if (continuationIs<SyncContinuation<Out, In ...>>(continuation)) {
             callAndApply(prevFuture ? prevFuture->value() : In() ...,
-                         helper.syncContinuation, *future, std::is_void<Out>());
+                         continuationGet<SyncContinuation<Out, In ...>>(continuation), *future, std::is_void<Out>());
             future->setFinished();
-        } else if (helper.syncErrorContinuation) {
+        } else if (continuationIs<SyncErrorContinuation<Out, In ...>>(continuation)) {
             assert(prevFuture);
             callAndApply(prevFuture->hasError() ? prevFuture->errors().first() : Error(),
                          prevFuture ? prevFuture->value() : In() ...,
-                         helper.syncErrorContinuation, *future, std::is_void<Out>());
+                         continuationGet<SyncErrorContinuation<Out, In ...>>(continuation), *future, std::is_void<Out>());
             future->setFinished();
-        } else if (helper.jobContinuation) {
+        } else if (continuationIs<JobContinuation<Out, In ...>>(continuation)) {
             executeJobAndApply(prevFuture ? prevFuture->value() : In() ...,
-                               helper.jobContinuation, *future, std::is_void<Out>());
-        } else if (helper.jobErrorContinuation) {
+                               continuationGet<JobContinuation<Out, In ...>>(continuation), *future, std::is_void<Out>());
+        } else if (continuationIs<JobErrorContinuation<Out, In ...>>(continuation)) {
             executeJobAndApply(prevFuture->hasError() ? prevFuture->errors().first() : Error(),
                                prevFuture ? prevFuture->value() : In() ...,
-                               helper.jobErrorContinuation, *future, std::is_void<Out>());
+                               continuationGet<JobErrorContinuation<Out, In ...>>(continuation), *future, std::is_void<Out>());
         }
     }
 
 private:
 
     void executeJobAndApply(In && ... input, const JobContinuation<Out, In ...> &func,
                             Future<Out> &future, std::false_type)
     {
         func(std::forward<In>(input) ...)
             .template then<void, Out>([&future](const KAsync::Error &error, const Out &v,
                                                 KAsync::Future<void> &f) {
                 if (error) {
                     future.setError(error);
                 } else {
                     future.setResult(v);
                 }
                 f.setFinished();
             }).exec();
     }
 
     void executeJobAndApply(In && ... input, const JobContinuation<Out, In ...> &func,
                             Future<Out> &future, std::true_type)
     {
         func(std::forward<In>(input) ...)
             .template then<void>([&future](const KAsync::Error &error, KAsync::Future<void> &f) {
                 if (error) {
                     future.setError(error);
                 } else {
                     future.setFinished();
                 }
                 f.setFinished();
             }).exec();
     }
 
     void executeJobAndApply(const Error &error, In && ... input, const JobErrorContinuation<Out, In ...> &func,
                             Future<Out> &future, std::false_type)
     {
         func(error, std::forward<In>(input) ...)
             .template then<void, Out>([&future](const KAsync::Error &error, const Out &v,
                                                 KAsync::Future<void> &f) {
                 if (error) {
                     future.setError(error);
                 } else {
                     future.setResult(v);
                 }
                 f.setFinished();
             }).exec();
     }
 
     void executeJobAndApply(const Error &error, In && ... input, const JobErrorContinuation<Out, In ...> &func,
                             Future<Out> &future, std::true_type)
     {
         func(error, std::forward<In>(input) ...)
             .template then<void>([&future](const KAsync::Error &error, KAsync::Future<void> &f) {
                 if (error) {
                     future.setError(error);
                 } else {
                     future.setFinished();
                 }
                 f.setFinished();
             }).exec();
     }
 
     void callAndApply(In && ... input, const SyncContinuation<Out, In ...> &func, Future<Out> &future, std::false_type)
     {
         future.setValue(func(std::forward<In>(input) ...));
     }
 
     void callAndApply(In && ... input, const SyncContinuation<Out, In ...> &func, Future<Out> &, std::true_type)
     {
         func(std::forward<In>(input) ...);
     }
 
     void callAndApply(const Error &error, In && ... input, const SyncErrorContinuation<Out, In ...> &func, Future<Out> &future, std::false_type)
     {
         future.setValue(func(error, std::forward<In>(input) ...));
     }
 
     void callAndApply(const Error &error, In && ... input, const SyncErrorContinuation<Out, In ...> &func, Future<Out> &, std::true_type)
     {
         func(error, std::forward<In>(input) ...);
     }
 
     ContinuationHolder<Out, In ...> mContinuationHolder;
 };
 
 template<typename T>
 KAsync::Future<T>* ExecutorBase::createFuture(const ExecutionPtr &execution) const
 {
     return new KAsync::Future<T>(execution);
 }
 
 template<typename PrevOut, typename Out, typename ... In>
 void Executor<PrevOut, Out, In ...>::runExecution(const KAsync::Future<PrevOut> *prevFuture,
                                                   const ExecutionPtr &execution, bool guardIsBroken)
 {
     if (guardIsBroken) {
         execution->resultBase->setFinished();
         return;
     }
     if (prevFuture) {
         if (prevFuture->hasError() && executionFlag == ExecutionFlag::GoodCase) {
             //Propagate the error to the outer Future
             Q_ASSERT(prevFuture->errors().size() == 1);
             execution->resultBase->setError(prevFuture->errors().first());
             return;
         }
         if (!prevFuture->hasError() && executionFlag == ExecutionFlag::ErrorCase) {
             //Propagate the value to the outer Future
             KAsync::detail::copyFutureValue<PrevOut>(*prevFuture, *execution->result<PrevOut>());
             execution->resultBase->setFinished();
             return;
         }
     }
     run(execution);
 }
 
 class ExecutionContext {
 public:
     typedef QSharedPointer<ExecutionContext> Ptr;
 
     QVector<QPointer<const QObject>> guards;
     bool guardIsBroken() const
     {
         for (const auto &g : guards) {
             if (!g) {
                 return true;
             }
         }
         return false;
     }
 };
 
 template<typename PrevOut, typename Out, typename ... In>
 ExecutionPtr Executor<PrevOut, Out, In ...>::exec(const ExecutorBasePtr &self, ExecutionContext::Ptr context)
 {
     /*
      * One executor per job, created with the construction of the Job object.
      * One execution per job per exec(), created only once exec() is called.
      *
      * The executors make up the linked list that makes up the complete execution chain.
      *
      * The execution then tracks the execution of each executor.
      */
 
     // Passing 'self' to execution ensures that the Executor chain remains
     // valid until the entire execution is finished
     ExecutionPtr execution = ExecutionPtr::create(self);
 #ifndef QT_NO_DEBUG
     execution->tracer = std::make_unique<Tracer>(execution.data()); // owned by execution
 #endif
 
     context->guards += mGuards;
 
     // chainup
     execution->prevExecution = mPrev ? mPrev->exec(mPrev, context) : ExecutionPtr();
 
     execution->resultBase = ExecutorBase::createFuture<Out>(execution);
     //We watch our own future to finish the execution once we're done
     auto fw = new KAsync::FutureWatcher<Out>();
     QObject::connect(fw, &KAsync::FutureWatcher<Out>::futureReady,
                      [fw, execution]() {
                          execution->setFinished();
                          delete fw;
                      });
     fw->setFuture(*execution->result<Out>());
 
     KAsync::Future<PrevOut> *prevFuture = execution->prevExecution ? execution->prevExecution->result<PrevOut>()
                                                                    : nullptr;
     if (!prevFuture || prevFuture->isFinished()) { //The previous job is already done
         runExecution(prevFuture, execution, context->guardIsBroken());
     } else { //The previous job is still running and we have to wait for it's completion
         auto prevFutureWatcher = new KAsync::FutureWatcher<PrevOut>();
         QObject::connect(prevFutureWatcher, &KAsync::FutureWatcher<PrevOut>::futureReady,
                          [prevFutureWatcher, execution, this, context]() {
                              auto prevFuture = prevFutureWatcher->future();
                              assert(prevFuture.isFinished());
                              delete prevFutureWatcher;
                              runExecution(&prevFuture, execution, context->guardIsBroken());
                          });
 
         prevFutureWatcher->setFuture(*static_cast<KAsync::Future<PrevOut>*>(prevFuture));
     }
 
     return execution;
 }
 
 } // namespace Private
 
 
 template<typename Out, typename ... In>
 template<typename ... InOther>
 Job<Out, In ...>::operator std::conditional_t<std::is_void<OutType>::value, IncompleteType, Job<void>> ()
 {
     return thenImpl<void, InOther ...>({JobContinuation<void, InOther ...>([](InOther ...){ return KAsync::null<void>(); })}, {});
 }
 
 template<typename Out, typename ... In>
 template<typename OutOther, typename ... InOther>
 Job<OutOther, In ...> Job<Out, In ...>::thenImpl(Private::ContinuationHolder<OutOther, InOther ...> workHelper,
                                                  Private::ExecutionFlag execFlag) const
 {
     thenInvariants<InOther ...>();
     return Job<OutOther, In ...>(QSharedPointer<Private::ThenExecutor<OutOther, InOther ...>>::create(
                 std::forward<Private::ContinuationHolder<OutOther, InOther ...>>(workHelper), mExecutor, execFlag));
 }
 
 template<typename Out, typename ... In>
 template<typename OutOther, typename ... InOther>
 Job<OutOther, In ...> Job<Out, In ...>::then(const Job<OutOther, InOther ...> &job) const
 {
     thenInvariants<InOther ...>();
     auto executor = job.mExecutor;
     executor->prepend(mExecutor);
     return Job<OutOther, In ...>(executor);
 }
 
 template<typename Out, typename ... In>
 template<typename OutOther, typename ... InOther>
 Job<OutOther, In ...> Job<Out, In ...>::syncThenImpl(SyncContinuation<OutOther, InOther ...> &&func,
                                                      Private::ExecutionFlag execFlag) const
 {
     static_assert(sizeof...(In) <= 1, "Only one or zero input parameters are allowed.");
     thenInvariants<InOther ...>();
     return Job<OutOther, In...>(QSharedPointer<Private::ThenExecutor<OutOther, InOther ...>>::create(
                 Private::ContinuationHolder<OutOther, InOther ...>(std::forward<SyncContinuation<OutOther, InOther ...>>(func)),
                 mExecutor, execFlag));
 }
 
 template<typename Out, typename ... In>
 template<typename OutOther, typename ... InOther>
 Job<OutOther, In ...> Job<Out, In ...>::syncThenImpl(SyncErrorContinuation<OutOther, InOther ...> &&func,
                                                      Private::ExecutionFlag execFlag) const
 {
     static_assert(sizeof...(In) <= 1, "Only one or zero input parameters are allowed.");
     thenInvariants<InOther ...>();
     return Job<OutOther, In...>(QSharedPointer<Private::ThenExecutor<OutOther, InOther ...>>::create(
                 Private::ContinuationHolder<OutOther, InOther ...>(std::forward<SyncErrorContinuation<OutOther, InOther ...>>(func)),
                 mExecutor, execFlag));
 }
 
 template<typename Out, typename ... In>
 Job<Out, In ...> Job<Out, In ...>::onError(SyncErrorContinuation<void> &&errorFunc) const
 {
     return Job<Out, In...>(QSharedPointer<Private::ThenExecutor<Out, Out>>::create(
                 // Extra indirection to allow propagating the result of a previous future when no
                 // error occurs
                 Private::ContinuationHolder<Out, Out>([errorFunc = std::move(errorFunc)](const Error &error, const Out &val) {
                     errorFunc(error);
                     return val;
                 }), mExecutor, Private::ExecutionFlag::ErrorCase));
 }
 
 template<> // Specialize for void jobs
 inline Job<void> Job<void>::onError(SyncErrorContinuation<void> &&errorFunc) const
 {
     return Job<void>(QSharedPointer<Private::ThenExecutor<void>>::create(
                 Private::ContinuationHolder<void>(std::forward<SyncErrorContinuation<void>>(errorFunc)),
                 mExecutor, Private::ExecutionFlag::ErrorCase));
 }
 
 
 template<typename Out, typename ... In>
 template<typename FirstIn>
 KAsync::Future<Out> Job<Out, In ...>::exec(FirstIn in)
 {
     // Inject a fake sync executor that will return the initial value
     Private::ExecutorBasePtr first = mExecutor;
     while (first->mPrev) {
         first = first->mPrev;
     }
 
     first->mPrev = QSharedPointer<Private::ThenExecutor<FirstIn>>::create(
             Private::ContinuationHolder<FirstIn>([val = std::move(in)](Future<FirstIn> &future) {
                  future.setResult(val);
             }));
 
     auto result = exec();
     // Remove the injected executor
     first->mPrev.reset();
     return result;
 }
 
 template<typename Out, typename ... In>
 KAsync::Future<Out> Job<Out, In ...>::exec()
 {
     Private::ExecutionPtr execution = mExecutor->exec(mExecutor, Private::ExecutionContext::Ptr::create());
     KAsync::Future<Out> result = *execution->result<Out>();
 
     return result;
 }
 
 template<typename Out, typename ... In>
 Job<Out, In ...>::Job(Private::ExecutorBasePtr executor)
     : JobBase(executor)
 {}
 
 template<typename Out, typename ... In>
 Job<Out, In ...>::Job(JobContinuation<Out, In ...> &&func)
     : JobBase(new Private::ThenExecutor<Out, In ...>(std::forward<JobContinuation<Out, In ...>>(func), {}))
 {
     qWarning() << "Creating job job";
     static_assert(sizeof...(In) <= 1, "Only one or zero input parameters are allowed.");
 }
 
 template<typename Out, typename ... In>
 template<typename OutOther>
 void Job<Out, In ...>::eachInvariants() const
 {
     static_assert(detail::isIterable<Out>::value,
                     "The 'Each' task can only be connected to a job that returns a list or an array.");
     static_assert(std::is_void<OutOther>::value || detail::isIterable<OutOther>::value,
                     "The result type of 'Each' task must be void, a list or an array.");
 }
 
 template<typename Out, typename ... In>
 template<typename InOtherFirst, typename ... InOtherTail>
 void Job<Out, In ...>::thenInvariants() const
 {
     static_assert(!std::is_void<Out>::value && (std::is_convertible<Out, InOtherFirst>::value || std::is_base_of<Out, InOtherFirst>::value),
                     "The return type of previous task must be compatible with input type of this task");
 }
 
 template<typename Out, typename ... In>
 template<typename ... InOther>
 auto Job<Out, In ...>::thenInvariants() const -> std::enable_if_t<(sizeof...(InOther) == 0)>
 {
 
 }
 
 
 template<typename Out, typename ... In>
 Job<Out, In ...> startImpl(Private::ContinuationHolder<Out, In ...> &&helper)
 {
     static_assert(sizeof...(In) <= 1, "Only one or zero input parameters are allowed.");
     return Job<Out, In...>(QSharedPointer<Private::ThenExecutor<Out, In ...>>::create(
                 std::forward<Private::ContinuationHolder<Out, In...>>(helper), nullptr, Private::ExecutionFlag::GoodCase));
 }
 
 template<typename Out, typename ... In>
 Job<Out, In ...> syncStartImpl(SyncContinuation<Out, In ...> &&func)
 {
     static_assert(sizeof...(In) <= 1, "Only one or zero input parameters are allowed.");
     return Job<Out, In...>(QSharedPointer<Private::ThenExecutor<Out, In ...>>::create(
                 Private::ContinuationHolder<Out, In ...>(std::forward<SyncContinuation<Out, In ...>>(func)),
                 nullptr, Private::ExecutionFlag::GoodCase));
 }
 
 static inline KAsync::Job<void> waitForCompletion(QList<KAsync::Future<void>> &futures)
 {
     auto context = new QObject;
     return start<void>([futures, context](KAsync::Future<void> &future) {
             const auto total = futures.size();
             auto count = QSharedPointer<int>::create();
             int i = 0;
             for (KAsync::Future<void> subFuture : futures) {
                 i++;
                 if (subFuture.isFinished()) {
                     *count += 1;
                     continue;
                 }
                 // FIXME bind lifetime all watcher to future (repectively the main job
                 auto watcher = QSharedPointer<KAsync::FutureWatcher<void>>::create();
                 QObject::connect(watcher.data(), &KAsync::FutureWatcher<void>::futureReady,
                                  [count, total, &future, context]() {
                                     *count += 1;
                                     if (*count == total) {
                                         delete context;
                                         future.setFinished();
                                     }
                                 });
                 watcher->setFuture(subFuture);
                 context->setProperty(QString::fromLatin1("future%1").arg(i).toLatin1().data(),
                                      QVariant::fromValue(watcher));
             }
             if (*count == total) {
                 delete context;
                 future.setFinished();
             }
         });
         // .finally<void>([context]() { delete context; });
 }
 
 template<typename List, typename ValueType>
 Job<void, List> forEach(KAsync::Job<void, ValueType> job)
 {
     auto cont = [job] (const List &values) mutable {
             auto error = QSharedPointer<KAsync::Error>::create();
             QList<KAsync::Future<void>> list;
             for (const auto &v : values) {
                 auto future = job
                     .template then<void>([error] (const KAsync::Error &e) {
                         if (e && !*error) {
                             //TODO ideally we would aggregate the errors instead of just using the first one
                             *error = e;
                         }
                     })
                     .exec(v);
                 list << future;
             }
             return waitForCompletion(list)
                 .then<void>([error](KAsync::Future<void> &future) {
                     if (*error) {
                         future.setError(*error);
                     } else {
                         future.setFinished();
                     }
                 });
         };
     return Job<void, List>(QSharedPointer<Private::ThenExecutor<void, List>>::create(
                 Private::ContinuationHolder<void, List>(JobContinuation<void, List>(std::move(cont))), nullptr, Private::ExecutionFlag::GoodCase));
 }
 
 
 template<typename List, typename ValueType>
 Job<void, List> serialForEach(KAsync::Job<void, ValueType> job)
 {
     auto cont = [job] (const List &values) mutable {
             auto error = QSharedPointer<KAsync::Error>::create();
             auto serialJob = KAsync::null<void>();
             for (const auto &value : values) {
                 serialJob = serialJob.then<void>([value, job, error](KAsync::Future<void> &future) {
                     job.template then<void>([&future, error] (const KAsync::Error &e) {
                         if (e && !*error) {
                             //TODO ideally we would aggregate the errors instead of just using the first one
                             *error = e;
                         }
                         future.setFinished();
                     })
                     .exec(value);
                 });
             }
             return serialJob
                 .then<void>([error](KAsync::Future<void> &future) {
                     if (*error) {
                         future.setError(*error);
                     } else {
                         future.setFinished();
                     }
                 });
         };
     return Job<void, List>(QSharedPointer<Private::ThenExecutor<void, List>>::create(
             Private::ContinuationHolder<void, List>(JobContinuation<void, List>(std::move(cont))), nullptr, Private::ExecutionFlag::GoodCase));
 }
 
 template<typename List, typename ValueType>
 Job<void, List> forEach(JobContinuation<void, ValueType> &&func)
 {
     return forEach<List, ValueType>(KAsync::start<void, ValueType>(std::forward<JobContinuation<void, ValueType>>(func)));
 }
 
 template<typename List, typename ValueType>
 Job<void, List> serialForEach(JobContinuation<void, ValueType> &&func)
 {
     return serialForEach<List, ValueType>(KAsync::start<void, ValueType>(std::forward<JobContinuation<void, ValueType>>(func)));
 }
 
 template<typename Out>
 Job<Out> null()
 {
     return KAsync::start<Out>(
         [](KAsync::Future<Out> &future) {
             future.setFinished();
         });
 }
 
 template<typename Out>
 Job<Out> value(Out v)
 {
     return KAsync::start<Out>(
         [val = std::move(v)](KAsync::Future<Out> &future) {
             future.setResult(val);
         });
 }
 
 template<typename Out>
 Job<Out> error(int errorCode, const QString &errorMessage)
 {
     return error<Out>({errorCode, errorMessage});
 }
 
 template<typename Out>
 Job<Out> error(const char *message)
 {
     return error<Out>(Error(message));
 }
 
 template<typename Out>
 Job<Out> error(const Error &error)
 {
     return KAsync::start<Out>(
         [error](KAsync::Future<Out> &future) {
             future.setError(error);
         });
 }
 
 
 } // namespace KAsync
 
 //@endconf
 
 #endif // KASYNC_JOB_IMPL_H