diff --git a/examples/async_all_hashes.cpp b/examples/async_all_hashes.cpp
index cf46465c..1ec73210 100644
--- a/examples/async_all_hashes.cpp
+++ b/examples/async_all_hashes.cpp
@@ -50,7 +50,7 @@ auto make_hset_arg(foo const& p)
 net::awaitable<void> create_hashes()
 {
    std::vector<foo> posts(20000);
-   resp::request<events> req;
+   request<events> req;
    req.flushall();
    for (auto i = 0; i < std::ssize(posts); ++i) {
       std::string const name = "posts:" + std::to_string(i);
@@ -73,7 +73,7 @@ net::awaitable<void> create_hashes()
 
 net::awaitable<void> read_hashes_coro()
 {
-   resp::request<events> req;
+   request<events> req;
    req.keys("posts:*");
 
    auto ex = co_await this_coro::executor;
@@ -90,7 +90,7 @@ net::awaitable<void> read_hashes_coro()
    //print(keys.result);
 
    // Generates the request to retrieve all hashes.
-   resp::request<events> pv;
+   request<events> pv;
    for (auto const& o : keys.result)
       pv.hvals(o);
    pv.quit();
@@ -109,14 +109,14 @@ net::awaitable<void> read_hashes_coro()
 
 void read_hashes(net::io_context& ioc)
 {
-   resp::request<events> req;
+   request<events> req;
    req.keys("posts:*");
 
    tcp::resolver resv(ioc);
    auto const r = resv.resolve("127.0.0.1", "6379");
    tcp::socket socket {ioc};
    net::connect(socket, r);
-   resp::write(socket, req);
+   write(socket, req);
 
    std::string buffer;
 
@@ -124,7 +124,7 @@ void read_hashes(net::io_context& ioc)
    resp::read(socket, buffer, keys);
 
    // Generates the request to retrieve all hashes.
-   resp::request<events> pv;
+   request<events> pv;
    for (auto const& o : keys.result)
       pv.hvals(o);
    pv.quit();
diff --git a/examples/async_basic.cpp b/examples/async_basic.cpp
index 55ebd9e2..9141c79e 100644
--- a/examples/async_basic.cpp
+++ b/examples/async_basic.cpp
@@ -32,10 +32,8 @@ public:
    using event_type = events;
    receiver(std::shared_ptr<connection<events>> conn) : conn_{conn} { }
 
-   void on_hello(events ev, resp::response_array::data_type& v) noexcept override
+   void on_hello(events ev, resp::array_type& v) noexcept override
    {
-      print(v, "HELLO");
-
       auto f = [](auto& req)
       {
 	 req.ping(events::one);
@@ -46,10 +44,10 @@ public:
       conn_->send(f);
    }
 
-   void on_ping(events ev, resp::response_simple_string::data_type& s) noexcept override
+   void on_ping(events ev, resp::simple_string_type& s) noexcept override
       { std::cout << "PING: " << s << std::endl; }
 
-   void on_quit(events ev, resp::response_simple_string::data_type& s) noexcept override
+   void on_quit(events ev, resp::simple_string_type& s) noexcept override
       { std::cout << "QUIT: " << s << std::endl; }
 };
 
diff --git a/examples/async_events.cpp b/examples/async_events.cpp
index aaf6dd94..62e6288f 100644
--- a/examples/async_events.cpp
+++ b/examples/async_events.cpp
@@ -23,7 +23,7 @@ enum class myevents
 net::awaitable<void> example()
 {
    try {
-      resp::request<myevents> req;
+      request<myevents> req;
       req.rpush("list", {1, 2, 3});
       req.lrange("list", 0, -1, myevents::interesting1);
       req.sadd("set", std::set<int>{3, 4, 5});
@@ -34,7 +34,7 @@ net::awaitable<void> example()
       tcp::resolver resv(ex);
       tcp_socket socket {ex};
       co_await net::async_connect(socket, resv.resolve("127.0.0.1", "6379"));
-      co_await resp::async_write(socket, req);
+      co_await async_write(socket, req);
 
       std::string buffer;
       for (;;) {
@@ -47,7 +47,7 @@ net::awaitable<void> example()
 	    } break;
 	    case myevents::interesting2:
 	    {
-	       resp::response_set<int> res;
+	       resp::response_basic_set<int> res;
 	       co_await resp::async_read(socket, buffer, res);
 	       print(res.result, "Interesting2");
 	    } break;
diff --git a/examples/async_pubsub.cpp b/examples/async_pubsub.cpp
index ae8e7a56..834aca0f 100644
--- a/examples/async_pubsub.cpp
+++ b/examples/async_pubsub.cpp
@@ -19,7 +19,7 @@ enum class myevents
 , ignore
 };
 
-void fill(resp::request<myevents>& req)
+void fill(request<myevents>& req)
 {
    req.ping(myevents::one);
    req.rpush("list", {1, 2, 3});
@@ -38,7 +38,7 @@ public:
    : conn_{conn}
    { }
 
-   void on_hello(myevents ev, resp::response_array::data_type& v) noexcept override
+   void on_hello(myevents ev, resp::array_type& v) noexcept override
    {
       print(v);
       conn_->send(fill);
diff --git a/examples/async_reconnect.cpp b/examples/async_reconnect.cpp
index 1d4821d3..d46ce483 100644
--- a/examples/async_reconnect.cpp
+++ b/examples/async_reconnect.cpp
@@ -22,7 +22,7 @@ net::awaitable<void> example1()
    auto ex = co_await this_coro::executor;
    for (;;) {
       try {
-	 resp::request<events> req;
+	 request<events> req;
 	 req.quit();
 
 	 tcp::resolver resv(ex);
diff --git a/examples/sync_basic.cpp b/examples/sync_basic.cpp
index 574f53b3..c492259d 100644
--- a/examples/sync_basic.cpp
+++ b/examples/sync_basic.cpp
@@ -15,7 +15,7 @@ enum class events {ignore};
 int main()
 {
    try {
-      resp::request<events> req;
+      request<events> req;
       req.hello();
       req.set("Password", {"12345"});
       req.get("Password");
@@ -25,10 +25,10 @@ int main()
       net::ip::tcp::resolver resv(ioc);
       net::ip::tcp::socket socket {ioc};
       net::connect(socket, resv.resolve("127.0.0.1", "6379"));
-      resp::write(socket, req);
+      write(socket, req);
 
       std::string buffer;
-      resp::response_flat_map<std::string> hello;
+      resp::response_map hello;
       resp::read(socket, buffer, hello);
       print(hello.result);
 
diff --git a/include/aedis/aedis.hpp b/include/aedis/aedis.hpp
index 1e2de279..22e70620 100644
--- a/include/aedis/aedis.hpp
+++ b/include/aedis/aedis.hpp
@@ -14,3 +14,4 @@
 #include <aedis/write.hpp>
 #include <aedis/connection.hpp>
 #include <aedis/receiver_base.hpp>
+#include <aedis/response_types.hpp>
diff --git a/include/aedis/connection.hpp b/include/aedis/connection.hpp
index 249378df..e0aea8db 100644
--- a/include/aedis/connection.hpp
+++ b/include/aedis/connection.hpp
@@ -13,7 +13,7 @@
 #include "config.hpp"
 #include "type.hpp"
 #include "request.hpp"
-#include "response.hpp"
+#include "response_buffers.hpp"
 
 namespace aedis {
 
@@ -25,13 +25,15 @@ private:
    net::ip::tcp::socket socket_;
    std::string buffer_;
    resp::response_buffers resps_;
-   std::queue<resp::request<Event>> reqs_;
+   std::queue<request<Event>> reqs_;
    bool reconnect_ = true;
 
-   void finish_coro()
+   void reset()
    {
       socket_.close();
       timer_.cancel();
+      reqs_.push({});
+      reqs_.front().hello();
    }
 
    template <class Receiver>
@@ -53,7 +55,7 @@ private:
 	    net::redirect_error(net::use_awaitable, ec));
 
 	 if (ec) {
-	    finish_coro();
+	    reset();
 	    recv.on_error(ec);
 	    timer.expires_after(wait_interval);
 	    co_await timer.async_wait(net::use_awaitable);
@@ -69,7 +71,7 @@ private:
 	    net::use_awaitable);
 
 	 if (ec) {
-	    finish_coro();
+	    reset();
 	    recv.on_error(ec);
 	    timer.expires_after(wait_interval);
 	    co_await timer.async_wait(net::use_awaitable);
@@ -113,4 +115,3 @@ public:
 };
 
 } // aedis
-
diff --git a/include/aedis/read.hpp b/include/aedis/read.hpp
index ec76a11a..63abfc50 100644
--- a/include/aedis/read.hpp
+++ b/include/aedis/read.hpp
@@ -25,7 +25,7 @@
 #include "type.hpp"
 #include "parser.hpp"
 #include "request.hpp"
-#include "response.hpp"
+#include "response_buffers.hpp"
 
 namespace aedis { namespace resp {
 
@@ -255,7 +255,7 @@ async_reader(
    Storage& buffer,
    ResponseBuffers& resps,
    Receiver& recv,
-   std::queue<resp::request<typename Receiver::event_type>>& reqs,
+   std::queue<request<typename Receiver::event_type>>& reqs,
    boost::system::error_code& ec)
 {
    using event_type = typename Receiver::event_type;
diff --git a/include/aedis/receiver_base.hpp b/include/aedis/receiver_base.hpp
index 48c6bfaf..a43e7c3f 100644
--- a/include/aedis/receiver_base.hpp
+++ b/include/aedis/receiver_base.hpp
@@ -23,28 +23,29 @@ public:
    using event_type = Event;
 
    // Array
-   virtual void on_lrange(Event ev, resp::response_array::data_type& v) noexcept { }
-   virtual void on_hello(Event ev, resp::response_array::data_type& v) noexcept {}
+   virtual void on_lrange(Event ev, resp::array_type& v) noexcept { }
+   virtual void on_hello(Event ev, resp::array_type& v) noexcept {}
 
    // Simple string
-   virtual void on_ping(Event ev, resp::response_simple_string::data_type& v) noexcept { }
-   virtual void on_quit(Event ev, resp::response_simple_string::data_type& v) noexcept { }
+   virtual void on_ping(Event ev, resp::simple_string_type& v) noexcept { }
+   virtual void on_quit(Event ev, resp::simple_string_type& v) noexcept { }
 
    // Number
    virtual void on_rpush(Event ev, resp::response_number::data_type& v) noexcept { }
 
-   virtual void on_push(command cmd, Event ev, resp::response_array::data_type& v) noexcept { }
-   virtual void on_set(command cmd, Event ev, resp::response_array::data_type& v) noexcept { }
-   virtual void on_attribute(command cmd, Event ev, resp::response_array::data_type& v) noexcept { }
-   virtual void on_simple_error(command cmd, Event ev, resp::response_simple_error::data_type& v) noexcept { }
-   virtual void on_double(command cmd, Event ev, resp::response_double::data_type& v) noexcept { }
-   virtual void on_big_number(command cmd, Event ev, resp::response_big_number::data_type& v) noexcept { }
-   virtual void on_boolean(command cmd, Event ev, resp::response_bool::data_type& v) noexcept {  }
-   virtual void on_blob_string(command cmd, Event ev, resp::response_blob_string::data_type& v) noexcept { }
-   virtual void on_blob_error(command cmd, Event ev, resp::response_blob_error::data_type& v) noexcept { }
-   virtual void on_verbatim_string(command cmd, Event ev, resp::response_verbatim_string::data_type& v) noexcept { }
-   virtual void on_streamed_string_part(command cmd, Event ev, resp::response_streamed_string_part::data_type& v) noexcept { }
+   virtual void on_set(command cmd, Event ev, resp::array_type& v) noexcept { }
+   virtual void on_double(command cmd, Event ev, resp::double_type& v) noexcept { }
+   virtual void on_big_number(command cmd, Event ev, resp::big_number_type& v) noexcept { }
+   virtual void on_boolean(command cmd, Event ev, resp::bool_type& v) noexcept {  }
+   virtual void on_blob_string(command cmd, Event ev, resp::blob_string_type& v) noexcept { }
+   virtual void on_verbatim_string(command cmd, Event ev, resp::verbatim_string_type& v) noexcept { }
+   virtual void on_streamed_string_part(command cmd, Event ev, resp::streamed_string_part_type& v) noexcept { }
    virtual void on_error(boost::system::error_code ec) { }
+
+   virtual void on_push(Event ev, resp::array_type& v) noexcept { }
+   virtual void on_simple_error(command cmd, Event ev, resp::response_simple_error::data_type& v) noexcept { }
+   virtual void on_blob_error(command cmd, Event ev, resp::response_blob_error::data_type& v) noexcept { }
+   virtual void on_null(command cmd, Event ev) noexcept { }
 };
 
 } // aedis
diff --git a/include/aedis/request.hpp b/include/aedis/request.hpp
index 646b6860..a04417b6 100644
--- a/include/aedis/request.hpp
+++ b/include/aedis/request.hpp
@@ -131,6 +131,8 @@ void assemble(std::string& ret, std::string_view cmd, std::string_view key)
    assemble(ret, cmd, {key}, std::cbegin(dummy), std::cend(dummy));
 }
 
+} // resp
+
 // TODO: Make the write functions friend of this class and make the
 // payload private.
 template <class Event>
@@ -643,5 +645,4 @@ public:
    }
 };
 
-} // resp
 } // aedis
diff --git a/include/aedis/response.hpp b/include/aedis/response.hpp
index 2aad707f..b7068d75 100644
--- a/include/aedis/response.hpp
+++ b/include/aedis/response.hpp
@@ -192,8 +192,6 @@ public:
    data_type result;
 };
 
-using response_number = response_basic_number<long long int>;
-
 template<
    class CharT = char,
    class Traits = std::char_traits<CharT>,
@@ -207,8 +205,6 @@ public:
    data_type result;
 };
 
-using response_blob_string = response_basic_blob_string<char>;
-
 template<
    class CharT = char,
    class Traits = std::char_traits<CharT>,
@@ -222,8 +218,6 @@ public:
    data_type result;
 };
 
-using response_blob_error = response_basic_blob_error<char>;
-
 template<
    class CharT = char,
    class Traits = std::char_traits<CharT>,
@@ -238,8 +232,6 @@ public:
    data_type result;
 };
 
-using response_simple_string = response_basic_simple_string<char>;
-
 template<
    class CharT = char,
    class Traits = std::char_traits<CharT>,
@@ -255,9 +247,7 @@ public:
    data_type result;
 };
 
-using response_simple_error = response_basic_simple_error<char>;
-
-// Big number use strings at the moment as the underlying storage.
+// Big number uses strings at the moment as the underlying storage.
 template <
    class CharT = char,
    class Traits = std::char_traits<CharT>,
@@ -273,8 +263,6 @@ public:
    data_type result;
 };
 
-using response_big_number = response_basic_big_number<char>;
-
 // TODO: Use a double instead of string.
 template <
    class CharT = char,
@@ -291,8 +279,6 @@ public:
    data_type result;
 };
 
-using response_double = response_basic_double<char>;
-
 template<
    class CharT = char,
    class Traits = std::char_traits<CharT>,
@@ -307,8 +293,6 @@ public:
    data_type result;
 };
 
-using response_verbatim_string = response_basic_verbatim_string<char>;
-
 template<
    class CharT = char,
    class Traits = std::char_traits<CharT>,
@@ -323,30 +307,6 @@ public:
    data_type result;
 };
 
-using response_streamed_string_part = response_basic_streamed_string_part<char>;
-
-template <
-   class Key,
-   class Compare = std::less<Key>,
-   class Allocator = std::allocator<Key>
-   >
-class response_set : public response_base {
-private:
-   void add(std::string_view s)
-   {
-      Key r;
-      from_string_view(s, r);
-      result.insert(std::end(result), std::move(r));
-   }
-
-   void on_simple_string_impl(std::string_view s) override { add(s); }
-   void on_blob_string_impl(std::string_view s) override { add(s); }
-   void select_set_impl(int n) override { }
-
-public:
-   std::set<Key, Compare, Allocator> result;
-};
-
 class response_bool : public response_base {
 private:
    void on_bool_impl(std::string_view s) override
@@ -417,13 +377,65 @@ public:
    data_type result;
 };
 
-using response_array = response_basic_array<std::string>;
+template <
+   class T,
+   class Allocator = std::allocator<T>
+   >
+class response_basic_map : public response_base {
+private:
+   void add(std::string_view s = {})
+   {
+      T r;
+      from_string_view(s, r);
+      result.emplace_back(std::move(r));
+   }
 
-template <class T, class Allocator = std::allocator<T>>
-using response_flat_map = response_basic_array<T, Allocator>;
+   void select_map_impl(int n) override { }
 
-template <class T, class Allocator = std::allocator<T>>
-using response_flat_set = response_basic_array<T, Allocator>;
+   // We also have to enable arrays, the hello command for example
+   // returns a map that has an embeded array.
+   void select_array_impl(int n) override { }
+
+   void on_simple_string_impl(std::string_view s) override { add(s); }
+   void on_number_impl(std::string_view s) override { add(s); }
+   void on_double_impl(std::string_view s) override { add(s); }
+   void on_bool_impl(std::string_view s) override { add(s); }
+   void on_big_number_impl(std::string_view s) override { add(s); }
+   void on_verbatim_string_impl(std::string_view s = {}) override { add(s); }
+   void on_blob_string_impl(std::string_view s = {}) override { add(s); }
+
+public:
+   using data_type = std::vector<T, Allocator>;
+   data_type result;
+};
+
+template <
+   class T,
+   class Allocator = std::allocator<T>
+   >
+class response_basic_set : public response_base {
+private:
+   void add(std::string_view s = {})
+   {
+      T r;
+      from_string_view(s, r);
+      result.emplace_back(std::move(r));
+   }
+
+   void select_set_impl(int n) override { }
+
+   void on_simple_string_impl(std::string_view s) override { add(s); }
+   void on_number_impl(std::string_view s) override { add(s); }
+   void on_double_impl(std::string_view s) override { add(s); }
+   void on_bool_impl(std::string_view s) override { add(s); }
+   void on_big_number_impl(std::string_view s) override { add(s); }
+   void on_verbatim_string_impl(std::string_view s = {}) override { add(s); }
+   void on_blob_string_impl(std::string_view s = {}) override { add(s); }
+
+public:
+   using data_type = std::vector<T, Allocator>;
+   data_type result;
+};
 
 template <class T, std::size_t N>
 class response_static_array : public response_base {
@@ -455,7 +467,7 @@ template <
    class T,
    std::size_t N
    >
-class response_static_flat_map : public response_base {
+class response_basic_static_map : public response_base {
 private:
    int i_ = 0;
 
@@ -472,182 +484,6 @@ public:
    std::array<T, 2 * N> result;
 };
 
-template <class Event>
-struct response_id {
-   command cmd;
-   type t;
-   Event event;
-};
-
-class response_buffers {
-private:
-   // TODO: Use a variant to store all responses.
-   response_tree tree_;
-   response_array array_;
-   response_array push_;
-   response_array set_;
-   response_array map_;
-   response_array attribute_;
-   response_simple_string simple_string_;
-   response_simple_error simple_error_;
-   response_number number_;
-   response_double double_;
-   response_bool bool_;
-   response_big_number big_number_;
-   response_blob_string blob_string_;
-   response_blob_error blob_error_;
-   response_verbatim_string verbatim_string_;
-   response_streamed_string_part streamed_string_part_;
-
-public:
-   // When the id is from a transaction the type of the message is not
-   // specified.
-   template <class Event>
-   response_base* get(response_id<Event> id)
-   {
-      if (id.cmd == command::exec)
-        return &tree_;
-
-      switch (id.t) {
-         case type::push: return &push_;
-         case type::set: return &set_;
-         case type::map: return &map_;
-         case type::attribute: return &attribute_;
-         case type::array: return &array_;
-         case type::simple_error: return &simple_error_;
-         case type::simple_string: return &simple_string_;
-         case type::number: return &number_;
-         case type::double_type: return &double_;
-         case type::big_number: return &big_number_;
-         case type::boolean: return &bool_;
-         case type::blob_error: return &blob_error_;
-         case type::blob_string: return &blob_string_;
-	 case type::verbatim_string: return &verbatim_string_;
-	 case type::streamed_string_part: return &streamed_string_part_;
-	 default: {
-            throw std::runtime_error("response_buffers");
-	    return nullptr;
-	 }
-      }
-   }
-
-   template <
-      class Event,
-      class Receiver>
-   void
-   forward_transaction(
-      std::queue<response_id<Event>> ids,
-      Receiver& recv)
-   {
-      while (!std::empty(ids)) {
-        std::cout << ids.front() << std::endl;
-        ids.pop();
-      }
-
-      tree_.result.clear();
-   }
-
-   template <
-      class Event,
-      class Receiver>
-   void
-   forward(
-      response_id<Event> const& id,
-      Receiver& recv)
-   {
-      // TODO: Handle null.
-      switch (id.t) {
-         case type::push:
-	    recv.on_push(id.cmd, id.event, push_.result);
-	    push_.result.clear();
-	    break;
-         case type::set:
-	    recv.on_set(id.cmd, id.event, set_.result);
-	    set_.result.clear();
-	    break;
-         case type::map:
-	 {
-	    switch (id.cmd) {
-	       case command::hello: recv.on_hello(id.event, map_.result); break;
-	       default: {assert(false);}
-	    }
-	    map_.result.clear();
-	 } break;
-         case type::attribute:
-	    recv.on_attribute(id.cmd, id.event, attribute_.result);
-	    attribute_.result.clear();
-	    break;
-         case type::array:
-	 {
-	    switch (id.cmd) {
-	       case command::lrange: recv.on_lrange(id.event, array_.result); break;
-	       default: {assert(false);}
-	    }
-	    array_.result.clear();
-	 } break;
-         case type::simple_error:
-	    recv.on_simple_error(id.cmd, id.event, simple_error_.result);
-	    simple_error_.result.clear();
-	    break;
-         case type::simple_string:
-	 {
-	    switch (id.cmd) {
-	       case command::ping: recv.on_ping(id.event, simple_string_.result); break;
-	       case command::quit: recv.on_quit(id.event, simple_string_.result); break;
-	       default: {assert(false);}
-	    }
-	    simple_string_.result.clear();
-	 } break;
-         case type::number:
-	 {
-	    switch (id.cmd) {
-	       case command::rpush: recv.on_rpush(id.event, number_.result); break;
-	       default: {assert(false);}
-	    }
-	 } break;
-         case type::double_type:
-	    recv.on_double(id.cmd, id.event, double_.result);
-	    break;
-         case type::big_number:
-	    recv.on_big_number(id.cmd, id.event, big_number_.result);
-	    big_number_.result.clear();
-	    break;
-         case type::boolean:
-	    recv.on_boolean(id.cmd, id.event, bool_.result);
-	    bool_.result = false;
-	    break;
-         case type::blob_error:
-	    recv.on_blob_error(id.cmd, id.event, blob_error_.result);
-	    blob_error_.result.clear();
-	    break;
-         case type::blob_string:
-	    recv.on_blob_string(id.cmd, id.event, blob_string_.result);
-	    blob_string_.result.clear();
-	    break;
-	 case type::verbatim_string:
-	    recv.on_verbatim_string(id.cmd, id.event, verbatim_string_.result);
-	    verbatim_string_.result.clear();
-	    break;
-	 case type::streamed_string_part:
-	    recv.on_streamed_string_part(id.cmd, id.event, streamed_string_part_.result);
-	    streamed_string_part_.result.clear();
-	    break;
-	 default:{}
-      }
-   }
-};
-
 } // resp
 } // aedis
 
-template <class Event>
-std::ostream&
-operator<<(std::ostream& os, aedis::resp::response_id<Event> const& id)
-{
-   os
-      << std::left << std::setw(15) << id.cmd
-      << std::left << std::setw(20) << id.t
-      << std::left << std::setw(4) << (int)id.event
-   ;
-   return os;
-}
diff --git a/include/aedis/response_buffers.hpp b/include/aedis/response_buffers.hpp
new file mode 100644
index 00000000..3d6939c4
--- /dev/null
+++ b/include/aedis/response_buffers.hpp
@@ -0,0 +1,210 @@
+/* Copyright (c) 2019 - 2021 Marcelo Zimbres Silva (mzimbres at gmail dot com)
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#pragma once
+
+#include "type.hpp"
+#include "command.hpp"
+#include "response_types.hpp"
+
+namespace aedis { namespace resp {
+
+template <class Event>
+struct response_id {
+   command cmd;
+   type t;
+   Event event;
+};
+
+class response_buffers {
+private:
+   // TODO: Use a variant to store all responses.
+   response_tree tree_;
+   response_array array_;
+   response_array push_;
+   response_array set_;
+   response_array map_;
+   response_array attribute_;
+   response_simple_string simple_string_;
+   response_simple_error simple_error_;
+   response_number number_;
+   response_double double_;
+   response_bool bool_;
+   response_big_number big_number_;
+   response_blob_string blob_string_;
+   response_blob_error blob_error_;
+   response_verbatim_string verbatim_string_;
+   response_streamed_string_part streamed_string_part_;
+   response_ignore ignore_;
+
+public:
+   // When the id is from a transaction the type of the message is not
+   // specified.
+   template <class Event>
+   response_base* get(response_id<Event> const& id)
+   {
+      if (id.cmd == command::exec)
+        return &tree_;
+
+      switch (id.t) {
+         case type::push: return &push_;
+         case type::set: return &set_;
+         case type::map: return &map_;
+         case type::attribute: return &attribute_;
+         case type::array: return &array_;
+         case type::simple_error: return &simple_error_;
+         case type::simple_string: return &simple_string_;
+         case type::number: return &number_;
+         case type::double_type: return &double_;
+         case type::big_number: return &big_number_;
+         case type::boolean: return &bool_;
+         case type::blob_error: return &blob_error_;
+         case type::blob_string: return &blob_string_;
+	 case type::verbatim_string: return &verbatim_string_;
+	 case type::streamed_string_part: return &streamed_string_part_;
+	 case type::null: return &ignore_;
+	 default: {
+            throw std::runtime_error("response_buffers");
+	    return nullptr;
+	 }
+      }
+   }
+
+   template <
+      class Event,
+      class Receiver>
+   void
+   forward_transaction(
+      std::queue<response_id<Event>> ids,
+      Receiver& recv)
+   {
+      while (!std::empty(ids)) {
+        std::cout << ids.front() << std::endl;
+        ids.pop();
+      }
+
+      tree_.result.clear();
+   }
+
+   template <
+      class Event,
+      class Receiver>
+   void
+   forward(
+      response_id<Event> const& id,
+      Receiver& recv)
+   {
+      switch (id.t) {
+         case type::push:
+	 {
+	    assert(id.t == type::invalid);
+	    recv.on_push(id.event, push_.result);
+	    push_.result.clear();
+	 } break;
+         case type::set:
+	 {
+	    recv.on_set(id.cmd, id.event, set_.result);
+	    set_.result.clear();
+	 } break;
+         case type::map:
+	 {
+	    switch (id.cmd) {
+	       case command::hello: recv.on_hello(id.event, map_.result); break;
+	       default: {assert(false);}
+	    }
+	    map_.result.clear();
+	 } break;
+         case type::array:
+	 {
+	    switch (id.cmd) {
+	       case command::lrange: recv.on_lrange(id.event, array_.result); break;
+	       default: {assert(false);}
+	    }
+	    array_.result.clear();
+	 } break;
+         case type::simple_string:
+	 {
+	    switch (id.cmd) {
+	       case command::ping: recv.on_ping(id.event, simple_string_.result); break;
+	       case command::quit: recv.on_quit(id.event, simple_string_.result); break;
+	       default: {assert(false);}
+	    }
+	    simple_string_.result.clear();
+	 } break;
+         case type::number:
+	 {
+	    switch (id.cmd) {
+	       case command::rpush: recv.on_rpush(id.event, number_.result); break;
+	       default: {assert(false);}
+	    }
+	 } break;
+         case type::double_type:
+	 {
+	    recv.on_double(id.cmd, id.event, double_.result);
+	 } break;
+         case type::big_number:
+	 {
+	    recv.on_big_number(id.cmd, id.event, big_number_.result);
+	    big_number_.result.clear();
+	 } break;
+         case type::boolean:
+	 {
+	    recv.on_boolean(id.cmd, id.event, bool_.result);
+	    bool_.result = false;
+	 } break;
+         case type::blob_string:
+	 {
+	    recv.on_blob_string(id.cmd, id.event, blob_string_.result);
+	    blob_string_.result.clear();
+	 } break;
+	 case type::verbatim_string:
+	 {
+	    recv.on_verbatim_string(id.cmd, id.event, verbatim_string_.result);
+	    verbatim_string_.result.clear();
+	 } break;
+	 case type::streamed_string_part:
+	 {
+	    recv.on_streamed_string_part(id.cmd, id.event, streamed_string_part_.result);
+	    streamed_string_part_.result.clear();
+	 } break;
+         case type::simple_error:
+	 {
+	    recv.on_simple_error(id.cmd, id.event, simple_error_.result);
+	    simple_error_.result.clear();
+	 } break;
+         case type::blob_error:
+	 {
+	    recv.on_blob_error(id.cmd, id.event, blob_error_.result);
+	    blob_error_.result.clear();
+	 } break;
+         case type::null:
+	 {
+	    recv.on_null(id.cmd, id.event);
+	 } break;
+         case type::attribute:
+	 {
+	    throw std::runtime_error("Attribute are not supported yet.");
+	 } break;
+	 default:{}
+      }
+   }
+};
+
+} // resp
+} // aedis
+
+template <class Event>
+std::ostream&
+operator<<(std::ostream& os, aedis::resp::response_id<Event> const& id)
+{
+   os
+      << std::left << std::setw(15) << id.cmd
+      << std::left << std::setw(20) << id.t
+      << std::left << std::setw(4) << (int)id.event
+   ;
+   return os;
+}
diff --git a/include/aedis/response_types.hpp b/include/aedis/response_types.hpp
index 50e399c0..2cd79d62 100644
--- a/include/aedis/response_types.hpp
+++ b/include/aedis/response_types.hpp
@@ -7,20 +7,37 @@
 
 #pragma once
 
-#include <set>
-#include <list>
-#include <array>
-#include <vector>
-#include <string>
-#include <ostream>
-#include <numeric>
-#include <type_traits>
-#include <string_view>
-#include <charconv>
-#include <iomanip>
+#include "response.hpp"
 
 namespace aedis { namespace resp {
 
+using response_array = response_basic_array<std::string>;
+using response_map = response_basic_map<std::string>;
+using response_set = response_basic_set<std::string>;
+
+using response_number = response_basic_number<long long int>;
+using response_blob_string = response_basic_blob_string<char>;
+using response_blob_error = response_basic_blob_error<char>;
+using response_simple_string = response_basic_simple_string<char>;
+using response_simple_error = response_basic_simple_error<char>;
+using response_big_number = response_basic_big_number<char>;
+using response_double = response_basic_double<char>;
+using response_verbatim_string = response_basic_verbatim_string<char>;
+using response_streamed_string_part = response_basic_streamed_string_part<char>;
+
+
+using array_type = response_array::data_type;
+using map_type = response_map::data_type;
+using set_type = response_set::data_type;
+
+using blob_string_type = response_blob_string::data_type;
+using simple_string_type = response_simple_string::data_type;
+using big_number_type = response_big_number::data_type;
+using double_type = response_double::data_type;
+using verbatim_string_type = response_verbatim_string::data_type;
+using streamed_string_part_type = response_streamed_string_part::data_type;
+using bool_type = response_bool::data_type;
+
 } // resp
 } // aedis
 
diff --git a/include/aedis/write.hpp b/include/aedis/write.hpp
index b3464c48..72aae6c0 100644
--- a/include/aedis/write.hpp
+++ b/include/aedis/write.hpp
@@ -15,7 +15,7 @@
 
 #include <boost/beast/core/stream_traits.hpp>
 
-namespace aedis { namespace resp {
+namespace aedis {
 
 template<
    class SyncWriteStream,
@@ -71,15 +71,13 @@ async_write(
    return net::async_write(stream, net::buffer(req.payload), token);
 }
 
-} // resp
-
 template <
   class AsyncReadStream,
   class Event>
 struct writer_op {
    AsyncReadStream& stream;
    net::steady_timer& st;
-   std::queue<resp::request<Event>>* reqs;
+   std::queue<request<Event>>* reqs;
 
    template <class Self>
    void operator()(
@@ -129,7 +127,7 @@ template <
    >
 auto async_writer(
    AsyncWriteStream& stream,
-   std::queue<resp::request<Event>>& reqs,
+   std::queue<request<Event>>& reqs,
    net::steady_timer& writeTrigger,
    CompletionToken&& token =
       net::default_completion_token_t<typename AsyncWriteStream::executor_type>{})
@@ -146,7 +144,7 @@ auto async_writer(
 // Returns true if a write has been triggered.
 template <class Event, class Filler>
 bool queue_writer(
-   std::queue<resp::request<Event>>& reqs,
+   std::queue<request<Event>>& reqs,
    Filler filler,
    net::steady_timer& st)
 {
diff --git a/tests/general.cpp b/tests/general.cpp
index 34005385..c19a6bda 100644
--- a/tests/general.cpp
+++ b/tests/general.cpp
@@ -36,7 +36,7 @@ net::awaitable<void> test_list()
 {
    std::vector<int> list {1 ,2, 3, 4, 5, 6};
 
-   resp::request<events> p;
+   request<events> p;
    p.hello("3");
    p.flushall();
    p.rpush("a", list);
@@ -117,7 +117,7 @@ net::awaitable<void> test_set()
    tcp_socket socket {ex};
    co_await async_connect(socket, rr);
 
-   resp::request<events> p;
+   request<events> p;
    p.hello("3");
    p.flushall();
    p.set("s", {test_bulk1});
@@ -424,7 +424,7 @@ net::awaitable<void> set()
    {
       std::string cmd {"~5\r\n+orange\r\n+apple\r\n+one\r\n+two\r\n+three\r\n"};
       test_tcp_socket ts {cmd};
-      resp::response_set<std::string> res;
+      resp::response_set res;
       co_await resp::async_read(ts, buffer, res);
       check_equal(res.result, {"orange", "apple", "one", "two", "three"}, "set");
    }
@@ -432,7 +432,7 @@ net::awaitable<void> set()
    {
       std::string cmd {"~5\r\n+orange\r\n+apple\r\n+one\r\n+two\r\n+three\r\n"};
       test_tcp_socket ts {cmd};
-      resp::response_flat_set<std::string> res;
+      resp::response_set res;
       co_await resp::async_read(ts, buffer, res);
       check_equal(res.result, {"orange", "apple", "one", "two", "three"}, "set (flat)");
    }
@@ -440,7 +440,7 @@ net::awaitable<void> set()
    {
       std::string cmd {"~0\r\n"};
       test_tcp_socket ts {cmd};
-      resp::response_set<std::string> res;
+      resp::response_set res;
       co_await resp::async_read(ts, buffer, res);
       check_equal(res.result, {}, "set (empty)");
    }
@@ -452,7 +452,7 @@ net::awaitable<void> map()
    {
       std::string cmd {"%7\r\n$6\r\nserver\r\n$5\r\nredis\r\n$7\r\nversion\r\n$5\r\n6.0.9\r\n$5\r\nproto\r\n:3\r\n$2\r\nid\r\n:203\r\n$4\r\nmode\r\n$10\r\nstandalone\r\n$4\r\nrole\r\n$6\r\nmaster\r\n$7\r\nmodules\r\n*0\r\n"};
       test_tcp_socket ts {cmd};
-      resp::response_flat_map<std::string> res;
+      resp::response_map res;
       co_await resp::async_read(ts, buffer, res);
       check_equal(res.result, {"server", "redis", "version", "6.0.9", "proto", "3", "id", "203", "mode", "standalone", "role", "master", "modules"}, "map (flat)");
    }
@@ -460,7 +460,7 @@ net::awaitable<void> map()
    {
       std::string cmd {"%0\r\n"};
       test_tcp_socket ts {cmd};
-      resp::response_flat_map<std::string> res;
+      resp::response_map res;
       co_await resp::async_read(ts, buffer, res);
       check_equal(res.result, {}, "map (flat - empty)");
    }