diff --git a/fluent++/Callback.h b/fluent++/Callback.h
index c469d63..3d7525c 100644
--- a/fluent++/Callback.h
+++ b/fluent++/Callback.h
@@ -40,7 +40,7 @@ namespace detail
     struct do_unwrap_callback;
 
     template<typename... Args>
-    struct do_unwrap_callback<std::tuple<Args...>>
+    struct do_unwrap_callback<::fu::identity<Args...>>
     {
         typedef Callback<Args...> CallbackType;
 
diff --git a/fluent++/Continuable.h b/fluent++/Continuable.h
index 86fad4a..76e8bf9 100644
--- a/fluent++/Continuable.h
+++ b/fluent++/Continuable.h
@@ -21,36 +21,32 @@
 
 #include "Callback.h"
 
+template <typename _CTy>
+struct Continuable;
 
-
-template <typename _MTy>
-class ContinuableBase
-{
-
-};
-
-template <typename _CTy, typename _WTy = void>
-class Continuable;
-
-template <typename... _ATy, typename _WTy>
-class Continuable<Callback<_ATy...>, typename _WTy>
+template <typename... _ATy>
+struct Continuable<Callback<_ATy...>>
 {
 public:
-    
+    template <typename _CTy>
+    Continuable<Callback<_ATy...>>& then(_CTy&& callback)
+    {
+        return *this;
+    }
 };
 
 namespace detail
 {
-    template <typename _FTy, typename _RTy, typename... _ATy>
+    template <typename _FTy, typename _RTy, typename _ATy>
     struct ContinuableFactory;
 
-    template <typename _FTy, typename _RTy, typename... _ATy>
-    struct ContinuableFactory<_FTy, _RTy, std::tuple<_ATy...>>
+    template <typename _FTy, typename _RTy, typename _ATy>
+    struct ContinuableFactory<_FTy, _RTy, ::fu::identity<_ATy>>
     {
         static auto CreateFrom(_FTy&& functional)
-            -> int
+            -> _FTy// Continuable<_ATy>
         {
-            return 1;
+            return _FTy; //  Continuable<_ATy>();
         }
     };
 
@@ -62,9 +58,9 @@ namespace detail
 
 template <typename _FTy>
 inline auto make_continuable(_FTy&& functional)
-    -> decltype(typename detail::continuable_factory_t<_FTy>::CreateFrom(std::declval<_FTy>()))
+    -> int// decltype(typename detail::continuable_factory_t<_FTy>::CreateFrom(std::declval<_FTy>()))
 {
-    return detail::continuable_factory_t<_FTy>::CreateFrom(std::forward<_FTy>(functional));
+    return 1; //  detail::continuable_factory_t<_FTy>::CreateFrom(std::forward<_FTy>(functional));
 }
 
 #endif /// _CONTINUABLE_H_
diff --git a/fluent++/WeakCallbackContainer.h b/fluent++/WeakCallbackContainer.h
index ee66731..1066dfb 100644
--- a/fluent++/WeakCallbackContainer.h
+++ b/fluent++/WeakCallbackContainer.h
@@ -39,7 +39,7 @@ class WeakCallbackContainer
     struct ProxyFactory;
 
     template<typename _CTy, typename... Args>
-    struct ProxyFactory<_CTy, std::tuple<Args...>>
+    struct ProxyFactory<_CTy, ::fu::identity<Args...>>
     {
         // Creates a weak proxy callback which prevents invoking to an invalid context.
         // Removes itself from the owner with the given handler.
diff --git a/fluent++/functional_unwrap.hpp b/fluent++/functional_unwrap.hpp
index 5af50c0..481f587 100644
--- a/fluent++/functional_unwrap.hpp
+++ b/fluent++/functional_unwrap.hpp
@@ -25,10 +25,14 @@
 #define _FUNCTIONAL_UNWRAP_HPP_
 
 #include <functional>
-#include <tuple>
 
 namespace fu
 {
+    template<typename... Args>
+    struct identity
+    {
+    };
+
     namespace detail
     {
         template<typename Function>
@@ -40,8 +44,8 @@ namespace fu
             /// The return type of the function.
             typedef _RTy return_type;
 
-            /// The argument types of the function as pack in std::tuple.
-            typedef std::tuple<_ATy...> argument_type;
+            /// The argument types of the function as pack in fu::identity.
+            typedef identity<_ATy...> argument_type;
 
             /// The function provided as std::function
             typedef std::function<_RTy(_ATy...)> function_type;
@@ -70,6 +74,11 @@ namespace fu
         struct unwrap_function_impl<_RTy(_CTy::*)(_ATy...) const>
             : unwrap_function_impl<_RTy(_ATy...)> { };
 
+        /// Pack in fu::identity
+        template<typename _RTy, typename... _ATy>
+        struct unwrap_function_impl<identity<_RTy, _ATy...>>
+            : unwrap_function_impl<_RTy(_ATy...)> { };
+
         /// Unwrap through pointer of functor.
         template<typename Function>
         static auto select_best_unwrap_unary_arg(int)
diff --git a/test.cpp b/test.cpp
index 6617237..a47e91d 100644
--- a/test.cpp
+++ b/test.cpp
@@ -42,19 +42,19 @@ void ProtoCastSpell(int id, Callback<SpellCastResult> const& callback)
     callback(SPELL_FAILED_SUCCESS);
 }
 
-/*Continuable<SpellCastResult>*/ int CastSpell(int id)
+Continuable<Callback<SpellCastResult>>
+CastSpell(int id)
 {
-    auto lam = [=](Callback<SpellCastResult> const& callback)
+    auto tt = 1;
+        /*make_continuable([=](Callback<SpellCastResult> const& callback)
     {
         std::cout << "Cast " << id << std::endl;
 
         // on success call the callback with SPELL_FAILED_SUCCESS
         callback(SPELL_FAILED_SUCCESS);
-    };
+    });*/
 
-    auto ct = make_continuable(std::move(lam));
-
-    return detail::ContinuableFactory<decltype(lam), void, std::tuple<Callback<SpellCastResult> const&>>::CreateFrom(std::move(lam));
+    return Continuable<Callback<SpellCastResult>>();
 }
 
 void ProtoMoveTo(int point, Callback<bool> const& callback)
@@ -173,14 +173,29 @@ int main(int argc, char** argv)
     wrapped2();
     */
 
-
-    typedef Continuable<Callback<bool>> cont;
+    typedef Continuable<Callback<bool>> cont123;
 
     // typedef Continuable<Callback<bool>>::type myty1;
     // typedef Continuable<Callback<bool>, float>::type myty2;
 
+    // Continuable<Callback<SpellCastResult>>
+    CastSpell(63362)
+        .then([](SpellCastResult result)
+        {
 
-    CastSpell(2);
+
+            return CastSpell(63362);
+        })
+        .then([](SpellCastResult result)
+        {
+            // Wraps a callback function into a continuable
+            return make_continuable([=](Callback<SpellCastResult> callback)
+            {
+
+
+
+            });
+        });
 
     return 0;
 }