diff --git a/include/rosa/core/Invoker.hpp b/include/rosa/core/Invoker.hpp
index 9f35ca3..365e133 100644
--- a/include/rosa/core/Invoker.hpp
+++ b/include/rosa/core/Invoker.hpp
@@ -1,258 +1,257 @@
 //===-- rosa/core/Invoker.hpp -----------------------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file rosa/core/Invoker.hpp
 ///
 /// \author David Juhasz (david.juhasz@tuwien.ac.at)
 ///
 /// \date 2017-2019
 ///
 /// \brief Facilities for providing actual arguments for functions as
 ///        \c rosa::Messageobjects.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef ROSA_CORE_INVOKER_HPP
 #define ROSA_CORE_INVOKER_HPP
 
 #include "rosa/core/MessageMatcher.hpp"
 
 #include "rosa/support/log.h"
 #include "rosa/support/sequence.hpp"
 
 #include <functional>
 #include <memory>
 
 namespace rosa {
 
 /// Wraps a function and provides a simple interface to invoke the stored
 /// function by passing actual arguments as a \c rosa::Message object.
 ///
 /// \note A \c rosa::Invoker instance is supposed to be owned by a
 /// \c rosa::MessageHandler instance, and not being used directly from user
 /// code.
 class Invoker {
 protected:
   /// Creates an instance.
   ///
   /// \note Protected constructor restricts instantiation to derived classes.
   Invoker(void) noexcept;
 
 public:
   /// Destroys \p this object.
   virtual ~Invoker(void);
 
   /// Possible results of an invocation.
   enum class Result {
     NoMatch, ///< The wrapped function could not be invoked
     Invoked  ///< The wrapped function has been invoked
   };
 
   /// Type alias for a smart-pointer for \c rosa::Invoker.
   using invoker_t = std::unique_ptr<const Invoker>;
 
   /// Type alias for \c rosa::Invoker::Result.
   using result_t = Result;
 
   /// Tells if a \c rosa::Message object can be used to invoke the function
   /// wrapped in \p this object.
   ///
   /// \param Msg \c rosa::Message to check
   ///
   /// \return whether \p Msg can be used to invoke the wrapped function
   virtual bool match(const Message &Msg) const noexcept = 0;
 
   /// Tries to invoke the wrapped function with a \c rosa::Message object.
   ///
   /// The wrapped function is invoked if the actual \c rosa::Message object can
   /// be used to invoke it.
   ///
   /// \param Msg \c rosa::Message to try to invoke the wrapped function with
   ///
   /// \return whether the wrapped function could be invoked with \p Msg
   virtual result_t operator()(const Message &Msg) const noexcept = 0;
 
   /// Instantiates an implementation of \c rosa::Invoker with the given
   /// function.
   ///
   /// \note As there is no empty \c rosa::Message, no \c rosa::Invoker wraps a
   /// function without any argument.
   ///
   /// \todo Enforce F does not potentially throw exception.
   ///
   /// \tparam T type of the first mandatory argument
   /// \tparam Ts types of any further arguments
   ///
   /// \param F function to wrap
   ///
   /// \return new \c rosa::Invoker::invoker_t object created from the given
   /// function
   template <typename T, typename... Ts>
   static invoker_t wrap(std::function<void(T, Ts...)> &&F) noexcept;
 
   /// Convenience template alias for casting callable stuff to function objects
   /// for wrapping.
   ///
   /// \tparam Ts types of arguments
   ///
   /// \todo Should make it possible to avoid using an explicit conversion for
   /// the arguments of wrap.
   template <typename... Ts> using F = std::function<void(Ts...)>;
 
 
   /// Convenience template for preparing non-static member functions into
   /// function objects for wrapping.
   ///
   /// \tparam C type whose non-static member the function is
   /// \tparam Ts types of arguments
   ///
   /// \see \c THISMEMBER
   template <typename C, typename... Ts>
   static inline F<Ts...> M(C *O, void (C::*Fun)(Ts...) noexcept) noexcept;
 };
 
 /// Convenience preprocessor macro for the typical use of \c rosa::Invoker::M.
 /// It can be used inside a class to turn a non-static member function into a
 /// function object capturing this pointer, so using the actual object when
 /// handling a \c rosa::Message.
 ///
 /// \param FUN the non-static member function to wrap
 ///
 /// \note Inside the class \c MyClass, use\code
 /// THISMEMBER(fun)
 /// \endcode instead of\code
 /// Invoker::M(this, &MyClass::fun)
 /// \endcode
 #define THISMEMBER(FUN)                                                        \
   Invoker::M(this, &std::decay<decltype(*this)>::type::FUN)
 
 /// Nested namespace with implementation of \c rosa::Invoker and helper
 /// templates, consider it private.
 namespace {
 
 /// \defgroup InvokerImpl Implementation for rosa::Invoker
 ///
 /// Implements the \c rosa::Invoker interface for functions with different
 /// signatures.
 ///
 ///@{
 
 /// Declaration of \c rosa::InvokerImpl implementing \c rosa::Invoker.
 ///
 /// \tparam Fun function to wrap
 template <typename Fun> class InvokerImpl;
 
 /// Implementation of \c rosa::InvokerImpl for \c std::function.
 ///
 /// \tparam T type of the first mandatory argument
 /// \tparam Ts types of further arguments
 ///
 /// \note As there is no empty \c rosa::Message, no \c rosa::Invoker wraps a
 /// function without any argument, i.e., no
 /// \c std::function<void(void)>.
 template <typename T, typename... Ts>
 class InvokerImpl<std::function<void(T, Ts...)>> final
     : public Invoker {
 
   /// Type alias for the stored function.
   using function_t = std::function<void(T, Ts...)>;
 
   /// Type alias for correctly typed argument-tuples as obtained from
   /// \c rosa::Message.
   using args_t = std::tuple<const T &, const Ts &...>;
 
   /// Alias for \c rosa::MessageMatcher for the arguments of the stored
   /// function.
   using Matcher = MsgMatcher<T, Ts...>;
 
   /// The wrapped function.
   const function_t F;
 
   /// Invokes \c InvokerImpl::F by unpacking arguments from a \c std::tuple with
   /// the help of the actual template arguments.
   ///
   /// \tparam S sequence of numbers indexing \c std::tuple for arguments
   ///
   /// \param Args arguments to invoke \c InvokerImpl::F with
   ///
   /// \pre the length of \p S and size of \p Args are matching:\code
   /// sizeof...(S) == std::tuple_size<args_t>::value
   /// \endcode
   template <size_t... S>
   inline void invokeFunction(Seq<S...>, const args_t &Args) const noexcept;
 
 public:
   /// Creates an instance.
   ///
   /// \param F function to wrap
   ///
   /// \pre \p F is valid:\code
   /// bool(F)
   /// \endcode
   InvokerImpl(function_t &&F) noexcept : F(F) {
     ASSERT(bool(F)); // Sanity check.
   }
 
   /// Destroys \p this object.
   ~InvokerImpl(void) = default;
 
   /// Tells if a \c rosa::Message object can be used to invoke the function
   /// wrapped in \p this object.
   ///
   /// \param Msg \c rosa::Message to check
   ///
   /// \return whether \p Msg can be used to invoke the wrapped function
   bool match(const Message &Msg) const noexcept override {
     return Matcher::doesStronglyMatch(Msg);
   };
 
   /// Tries to invoke the wrapped function with a \c rosa::Message object.
   ///
   /// The wrapped function is invoked if the actual \c rosa::Message object can
   /// be used to invoke it.
   ///
   /// \param Msg \c rosa::Message to try to invoke the wrapped function with
   ///
   /// \return whether the wrapped function could be invoked with \p Msg
   result_t operator()(const Message &Msg) const noexcept override {
     if (match(Msg)) {
       LOG_TRACE("Invoking with matching arguments");
-      invokeFunction(typename GenSeq<sizeof...(Ts) + 1>::Type(),
-                     Matcher::extractedValues(Msg));
+      invokeFunction(seq_t<sizeof...(Ts) + 1>(), Matcher::extractedValues(Msg));
       return result_t::Invoked;
     } else {
       LOG_TRACE("Tried to invoke with non-matching arguments");
       return result_t::NoMatch;
     }
   }
 };
 
 template <typename T, typename... Ts>
 template <size_t... S>
 void InvokerImpl<std::function<void(T, Ts...)>>::invokeFunction(
     Seq<S...>, const args_t &Args) const noexcept {
   ASSERT(sizeof...(S) == std::tuple_size<args_t>::value); // Sanity check.
   F(std::get<S>(Args)...);
 }
 
 ///@}
 
 } // End namespace
 
 template <typename T, typename... Ts>
 Invoker::invoker_t
 Invoker::wrap(std::function<void(T, Ts...)> &&F) noexcept {
   return std::unique_ptr<Invoker>(
       new InvokerImpl<std::function<void(T, Ts...)>>(std::move(F)));
 }
 
 template <typename C, typename... Ts>
 Invoker::F<Ts...> Invoker::M(C *O, void (C::*Fun)(Ts...) noexcept) noexcept {
   return [ O, Fun ](Ts... Vs) noexcept->void { (O->*Fun)(Vs...); };
 }
 } // End namespace rosa
 
 #endif // ROSA_CORE_INVOKER_HPP
diff --git a/include/rosa/support/sequence.hpp b/include/rosa/support/sequence.hpp
index 5764a80..62b8408 100755
--- a/include/rosa/support/sequence.hpp
+++ b/include/rosa/support/sequence.hpp
@@ -1,51 +1,57 @@
 //===-- rosa/support/sequence.hpp -------------------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file rosa/support/sequence.hpp
 ///
 /// \author David Juhasz (david.juhasz@tuwien.ac.at)
 ///
-/// \date 2017
+/// \date 2017-2019
 ///
 /// \brief Template facilities to statically generate a sequence of numbers.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef ROSA_SUPPORT_SEQUENCE_HPP
 #define ROSA_SUPPORT_SEQUENCE_HPP
 
 #include <cstddef>
 
 namespace rosa {
 
 /// \defgroup Seq Implementation of rosa::Seq
 ///
 /// Facility to statically generate sequences of numbers.
 ///
 ///@{
 
 /// Template with an empty struct to store a sequence of numbers in compile time
 /// as template arguments.
 ///
 /// Generate a sequence of numbers from `0` up to (including) `(N - 1)` like
 /// \code
 /// typename GenSeq<N>::Type
 /// \endcode
 template <size_t...> struct Seq {};
 
 /// Sequence generator, the general case when counting down by extending the
 /// sequence.
 template <size_t N, size_t... S> struct GenSeq : GenSeq<N - 1, N - 1, S...> {};
 
 /// Sequence generator, the terminal case when storing the generated sequence
 /// into \c Seq.
 template <size_t... S> struct GenSeq<0, S...> { using Type = Seq<S...>; };
 
 ///@}
 
+/// Convenience template alias for using \c rosa::GenSeq to obtain an instance
+/// of \c rosa::Seq.
+///
+/// \see \c rosa::Seq and \c rosa::GenSeq
+template <size_t... S> using seq_t = typename GenSeq<S...>::Type;
+
 } // End namespace rosa
 
 #endif // ROSA_SUPPORT_SEQUENCE_HPP
diff --git a/include/rosa/support/type_list.hpp b/include/rosa/support/type_list.hpp
index 3e35a19..b3e8107 100644
--- a/include/rosa/support/type_list.hpp
+++ b/include/rosa/support/type_list.hpp
@@ -1,444 +1,468 @@
 //===-- rosa/support/type_list.hpp ------------------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file rosa/support/type_list.hpp
 ///
 /// \author David Juhasz (david.juhasz@tuwien.ac.at)
 ///
-/// \date 2017
+/// \date 2017-2019
 ///
 /// \brief Facilities for types representing lists of types.
 ///
 /// \note This implementation is partially based on the \c type_list
 /// implementation of CAF.
 /// \todo Check license.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef ROSA_SUPPORT_TYPE_LIST_HPP
 #define ROSA_SUPPORT_TYPE_LIST_HPP
 
 #include "rosa/support/debug.hpp"
 #include "rosa/support/types.hpp"
 
 #include <type_traits>
 
 namespace rosa {
 
 /// A list of types.
 ///
 /// \tparam Ts types to make a list of
 template <typename... Ts> struct TypeList {
   /// Constructor, needs to do nothing.
   constexpr TypeList(void) {}
 };
 
 /// The empty \c rosa::Typelist.
 using EmptyTypeList = TypeList<>;
 
 /// \defgroup TypeListAtImpl Implementation of rosa::TypeListAt
 ///
 /// \brief Gets the type at index \p Pos from a list of types.
 ///
 /// \note Only to be used by the implementation of \c rosa::TypeListAt.
 ///@{
 
 /// Declaration of the template.
 ///
 /// \tparam Pos index to take the element from
 /// \tparam Ts types
 template <size_t Pos, typename... Ts> struct TypeListAtImpl;
 
 /// Definition for the general case when \p Pos is not \c 0 and there is type in
 /// the list.
 template <size_t Pos, typename T, typename... Ts>
 struct TypeListAtImpl<Pos, T, Ts...> {
   using Type = typename TypeListAtImpl<Pos - 1, Ts...>::Type;
 };
 
 /// Specialization for the case when \p Pos is \c 0.
 template <typename T, typename... Ts> struct TypeListAtImpl<0, T, Ts...> {
   using Type = T;
 };
 
 /// Specialization for the case when there is no more type.
 ///
 /// In this case, the found type is \c rosa::none_t.
 template <size_t Pos> struct TypeListAtImpl<Pos> { using Type = none_t; };
 
 ///@}
 
 /// \defgroup TypeListAt Definition of rosa::TypeListAt
 ///
 /// \brief Gets the element at index \p Pos of \p List.
 ///
 ///
 /// The type at index \c Pos in a \c rosa::TypeList \c List can be obtained as
 /// \code
 /// typename TypeListAt<List, Pos>::Type
 /// \endcode
 ///
 /// \note The resulting type is \c rosa::none_t if \code
 /// TypeListSize<List>::Value < Pos
 /// \endcode
 ///@{
 
 /// Declaration of the template.
 ///
 /// \tparam List \c rosa::TypeList to take an element from
 /// \tparam Pos index to take the element from
 template <typename List, size_t Pos> struct TypeListAt;
 
 /// Implementation using \c rosa::TypeListAtImpl.
 template <size_t Pos, typename... Ts> struct TypeListAt<TypeList<Ts...>, Pos> {
   using Type = typename TypeListAtImpl<Pos, Ts...>::Type;
 };
 
 ///@}
 
 /// \defgroup TypeListIndexOfImpl Implementation of rosa::TypeListIndexOf
 ///
 /// \brief Tells the index of the first occurence of a type in a list of types.
 ///
 /// \note Only to be used by the implementation of \c rosa::TypeListIndexOf.
 ///@{
 
 /// Declaration of the template.
 ///
 /// \tparam Pos the number types already being checked from the beginning of the
 ///             list
 /// \tparam X type to search for
 /// \tparam Ts remaining list of types
 template <size_t Pos, typename X, typename... Ts> struct TypeListIndexOfImpl;
 
 /// Specialization for the case when the list is over.
 ///
 /// In this case, the found index is \c -1.
 template <size_t Pos, typename X> struct TypeListIndexOfImpl<Pos, X> {
   static constexpr int Value = -1;
 };
 
 /// Specialization for the case when the first type in the remaining list
 /// is a match.
 template <size_t Pos, typename X, typename... Ts>
 struct TypeListIndexOfImpl<Pos, X, X, Ts...> {
   static constexpr int Value = Pos;
 };
 
 /// Implementation for the general case when need to continue looking.
 template <size_t Pos, typename X, typename T, typename... Ts>
 struct TypeListIndexOfImpl<Pos, X, T, Ts...> {
   static constexpr int Value = TypeListIndexOfImpl<Pos + 1, X, Ts...>::Value;
 };
 
 ///@}
 
 /// \defgroup TypeListIndexOf Definition of rosa::TypeListIndexOf
 ///
 /// \brief Tells the index of the first occurence of type in a
 /// \c rosa::TypeList.
 ///
 /// The index of the first occurence of type \c T in \c rosa::TypeList \c List
 /// can be obtained as \code
 /// TypeListIndexOf<List, T>::Value
 /// \endcode
 ///
 /// \note The resulting index is \c -1 if \c T is not present in \c List.
 ///@{
 
 /// Declaration of the template.
 ///
 /// \tparam List \c rosa::TypeList to search in
 /// \tparam T type to search for
 template <typename List, typename T> struct TypeListIndexOf;
 
 /// Implementation of the template using \c rosa::TypeListIndexOfImpl.
 template <typename... Ts, typename T>
 struct TypeListIndexOf<TypeList<Ts...>, T> {
   static constexpr int Value = TypeListIndexOfImpl<0, T, Ts...>::Value;
 };
 
 ///@}
 
 /// \defgroup TypeListHead Implementation of rosa::TypeListHead
 ///
 /// \brief Gets the first element of a \c rosa::TypeList.
 ///
 /// The first element of a \c rosa::TypeList \c List can be obtained as \code
 /// typename TypeListHead<List>::Type
 /// \endcode
 ///
 /// \note The resulting type is \c rosa::none_t if \c List is
 /// \c rosa::EmptyTypeList.
 ///@{
 
 /// Declaration of the template.
 ///
 /// \tparam List \c rosa::TypeList to get the first element of
 template <typename List> struct TypeListHead;
 
 /// Specialization for \c rosa::EmptyTypeList.
 ///
 /// In this case, the found type is \c rosa::none_t.
 template <> struct TypeListHead<EmptyTypeList> { using Type = none_t; };
 
 /// Implementation for a non-empty \c rosa::TypeList.
 template <typename T, typename... Ts> struct TypeListHead<TypeList<T, Ts...>> {
   using Type = T;
 };
 
 ///@}
 
 /// \defgroup TypeListTail Implementation of rosa::TypeListTail
 ///
 /// \brief Gets the tail of a \c rosa::TypeList.
 ///
 /// The tail of a \c rosa::TypeList \c List, that is \c List except for its
 /// first element, can be obtained as \code
 /// typename TypeListTail<List>::Type
 /// \endcode
 ///
 /// \note If \c List is \c rosa::EmptyTypeList, then the resulting type is also
 /// \c rosa::EmptyTypeList.
 ///@{
 
 /// Declaration of the template.
 ///
 /// \tparam List \c rosa::TypeList to take the tail of
 template <typename List> struct TypeListTail;
 
 /// Specialization for \c rosa::EmptyTypeList.
 ///
 /// In this case, the resulting type is \c rosa::EmptyTypeList.
 template <> struct TypeListTail<EmptyTypeList> { using Type = EmptyTypeList; };
 
 /// Implementation for a non-empty \c rosa::TypeList.
 template <typename T, typename... Ts> struct TypeListTail<TypeList<T, Ts...>> {
   using Type = TypeList<Ts...>;
 };
 
 ///@}
 
 /// \defgroup TypeListPush Implementation of rosa::TypeListPush
 ///
 /// \brief Extends a \c rosa::TypeList with a type.
 ///
 /// Whether the new type is pushed in the front or in the back of the
 /// \c rosa::TypeList depends on the order of template arguments, as shown in
 /// the following example: \code
 /// using List = TypeList<A>
 /// typename TypeListPush<List, T>::Type; // TypeList<A, T>
 /// typename TypeListPush<T, List>::Type; // TypeList<T, A>
 /// \endcode
 ///@{
 
 /// Declaration of the template.
 ///
 /// \tparam P a type if \p Q is a \c rosa::TypeList, a \c rosa::TypeList
 /// otherwise
 /// \tparam Q a type if \p P is a \c rosa::TypeList, a \c rosa::TypeList
 /// otherwise
 template <typename P, typename Q> struct TypeListPush;
 
 /// Implementation for the case when pushing at the back of the
 /// \c rosa::TypeList.
 template <typename... Ts, typename T> struct TypeListPush<TypeList<Ts...>, T> {
   using Type = TypeList<Ts..., T>;
 };
 
 /// Implementation for the case when pushing to the front of the
 /// \c rosa::TypeList.
 template <typename T, typename... Ts> struct TypeListPush<T, TypeList<Ts...>> {
   using Type = TypeList<T, Ts...>;
 };
 
 ///@}
 
 /// \defgroup TypeListDrop Implementation of rosa::TypeListDrop
 ///
 /// \brief Drops some elements from the beginning of a \c rosa::TypeList.
 ///
 /// The first \c N types of a \c rosa::TypeList \c List can be dropped as \code
 /// typename TypeListDrop<N, List>::Type
 /// \endcode
 ///@{
 
 /// Declaration of the template.
 ///
 /// \tparam N number of types to drop
 /// \tparam List \c rosa::TypeList to drop the first \p N element of
 template <size_t N, typename List> struct TypeListDrop;
 
 /// Specialization for \c rosa::EmptyTypeList.
 template <size_t N> struct TypeListDrop<N, EmptyTypeList> {
   using Type = EmptyTypeList;
 };
 
 /// Implementation for a non-empty \c rosa::TypeList.
 template <size_t N, typename T, typename... Ts>
 struct TypeListDrop<N, TypeList<T, Ts...>> {
   using Type = typename std::conditional<
       N == 0, TypeList<T, Ts...>,
       typename TypeListDrop<N - 1, TypeList<Ts...>>::Type>::type;
 };
 
 ///@}
 
+/// \defgroup TypeListConcat Implementation of rosa::TypeListConcat
+///
+/// \brief Concatenates two \c rosa::TypeList instances.
+///
+/// Two instances of \c rosa::TypeList \c List1 and \c List2 can be
+/// concatenated as \code
+/// typename TypeListConcat<List1, List2>::Type
+/// \endcode
+///@{
+
+/// Declaration of the template
+///
+/// \tparam List1 the first instance of \c rosa::TypeList
+/// \tparam List2 the second instance of \c rosa::TypeList
+template <typename List1, typename List2> struct TypeListConcat;
+
+/// Implementation of the template for \c rosa::TypeList instances.
+template <typename... As, typename... Bs>
+struct TypeListConcat<TypeList<As...>, TypeList<Bs...>> {
+  using Type = TypeList<As..., Bs...>;
+};
+
+///@}
+
 /// \defgroup TypeListSize Implementation of rosa::TypeListSize
 ///
 /// \brief Tells the number of types stored in a \c rosa::TypeList.
 ///
 /// The size of a \c rosa::TypeList \c List can be obtained as \code
 /// TypeListSize<List>::Value
 /// \endcode
 ///@{
 
 /// Declaration of the template.
 ///
 /// \tparam List \c rosa::TypeList to get the size of
 template <typename List> struct TypeListSize;
 
 /// Implementation of the template.
 template <typename... Ts> struct TypeListSize<TypeList<Ts...>> {
   static constexpr size_t Value = sizeof...(Ts);
 };
 
 template <typename... Ts> constexpr size_t TypeListSize<TypeList<Ts...>>::Value;
 
 ///@}
 
 /// Tests whether a \c rosa::TypeList is empty.
 ///
 /// \tparam List \c rosa::TypeList to check
 template <typename List> struct TypeListEmpty {
   /// Denotes whether \p List is an empty \c rosa::TypeList or not.
   static constexpr bool Value = std::is_same<EmptyTypeList, List>::value;
 };
 
 /// \defgroup TypeListContains Implementation of rosa::TypeListContains
 ///
 /// \brief Tells if a \c rosa::TypeList contains a given type.
 ///
 /// Whether a \c rosa::TypeList \c List contains the type \c T can be checked as
 /// \code
 /// TypeListContains<List, T>::Value
 /// \endcode
 ///@{
 
 /// Declaration of the template.
 ///
 /// \tparam List \c rosa::TypeList to search in
 /// \tparam T type to search for
 template <typename List, typename T> struct TypeListContains;
 
 /// Implementation of the template.
 template <typename... Ts, typename T>
 struct TypeListContains<TypeList<Ts...>, T> {
   static constexpr bool Value =
       std::conditional<TypeListIndexOf<TypeList<Ts...>, T>::Value == -1,
                        std::false_type, std::true_type>::type::value;
 };
 
 ///@}
 
 /// \defgroup TypeListSubsetOf Implementation of rosa::TypeListSubsetOf
 ///
 /// \brief Tells if a \c rosa::TypeList is a subset of another one.
 ///
 /// Whether a \c rosa::TypeList \c ListA is a subset of another
 /// \c rosa::TypeList \c ListB can be checked as \code
 /// TypeListSubsetOf<ListA, ListB>::Value
 /// \endcode
 ///@{
 
 /// Declaration of the template.
 ///
 /// \tparam ListA \c rosa::TypeList to check if is a subset of \p ListB
 /// \tparam ListB \c rosa::TypeList to check if is a superset of \p ListA
 /// \tparam Fwd always use the default value!
 template <typename ListA, typename ListB, bool Fwd = true>
 struct TypeListSubsetOf;
 
 /// Specialization for the case when all the elements of the original \p ListA
 /// was found in \p ListB.
 template <typename List> struct TypeListSubsetOf<EmptyTypeList, List, true> {
   static constexpr bool Value = true;
 };
 
 /// Specializaton for the case when an element of the original \p ListA cannot
 /// be found in \p ListB.
 template <typename ListA, typename ListB>
 struct TypeListSubsetOf<ListA, ListB, false> {
   static constexpr bool Value = false;
 };
 
 /// Definition for the general case.
 template <typename T, typename... Ts, typename List>
 struct TypeListSubsetOf<TypeList<T, Ts...>, List>
     : TypeListSubsetOf<TypeList<Ts...>, List,
                        TypeListContains<List, T>::Value> {};
 
 ///@}
 
 /// \defgroup TypeListFindImpl Implementation of rosa::TypeListFind
 ///
 /// \brief Finds the first type in a list of types that satisfies a predicate.
 ///
 /// \note Only to be used by the implementation of \c rosa::TypeListFind.
 ///@{
 
 /// Declaration of the template.
 ///
 /// \tparam Pred the predicate to check types against
 /// \tparam Ts list of types to check
 template <template <typename> class Pred, typename... Ts>
 struct TypeListFindImpl;
 
 /// Specialization for the case when no more types remain to check.
 template <template <typename> class Pred> struct TypeListFindImpl<Pred> {
   using Type = none_t;
 };
 
 /// Implementation for the general case when there is a type to check.
 template <template <typename> class Pred, typename T, typename... Ts>
 struct TypeListFindImpl<Pred, T, Ts...> {
   using Type = typename std::conditional<
       Pred<T>::Value, T, typename TypeListFindImpl<Pred, Ts...>::Type>::type;
 };
 
 ///@}
 
 /// \defgroup TypeListFind Definition of rosa::TypeListFind
 ///
 /// \brief Finds the first element satisfying a predicate in a
 /// \c rosa::TypeList.
 ///
 /// The first type satisfying a predicate \c Pred in a \c rosa::TypeList
 /// \c List can be obtained as \code
 /// typename TypeListFind<List, Pred>::Type
 /// \endcode
 ///
 /// \note The resulting type is \c rosa::none_t if no type in \c List satisfies
 /// \c Pred.
 ///@{
 
 /// Declaration of the template.
 ///
 /// \tparam List \c rosa::TypeList to search in
 /// \tparam Pred predicate to check elements against
 template <typename List, template <typename> class Pred> struct TypeListFind;
 
 /// Implementation of the template using \c rosa::TypeListFindImpl.
 template <typename... Ts, template <typename> class Pred>
 struct TypeListFind<TypeList<Ts...>, Pred> {
   using Type = typename TypeListFindImpl<Pred, Ts...>::Type;
 };
 
 ///@}
 
 } // End namespace rosa
 
 #endif // ROSA_SUPPORT_TYPE_LIST_HPP
diff --git a/include/rosa/support/type_token.hpp b/include/rosa/support/type_token.hpp
index ee08886..cc4aeaf 100644
--- a/include/rosa/support/type_token.hpp
+++ b/include/rosa/support/type_token.hpp
@@ -1,288 +1,306 @@
 //===-- rosa/support/type_token.hpp -----------------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file rosa/support/type_token.hpp
 ///
 /// \author David Juhasz (david.juhasz@tuwien.ac.at)
 ///
 /// \date 2017-2019
 ///
 /// \brief Facilities for encoding TypeLists as unsigned integer values.
 ///
 /// \note **On the compatibility between different versions of the type token
 /// implementation:**
 /// Different software versions produce compatible type tokens as long as
 /// *backward compatibility* of \c rosa::BuiltinTypes is maintained (denoted by
 /// \c rosa::TypeNumberVersion) and the type token implementation uses the same
 /// type as \c rosa::token_t (boiling down to the same \c rosa::token::TokenBits
 /// value) and the same \c rosa::token::RepresentationBits value. Thus,
 /// interacting software need to cross-validate the aforementioned values to
 /// check compatibility. Interoperation between compatible sofware is limited
 /// to backward compatiblity, that is builtin types defined in both software
 /// versions are handled correctly but a newer system may produce a type token
 /// which is invalid in an old one. Therefore, tokens obtained from a compatible
 /// remote system need to be validated.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef ROSA_SUPPORT_TYPE_TOKEN_HPP
 #define ROSA_SUPPORT_TYPE_TOKEN_HPP
 
 #include "rosa/support/type_numbers.hpp"
 
 namespace rosa {
 
 /// Integer type to store type tokens.
 ///
 /// \note The trade-off between the binary overhead of type encoding and the
 /// maximal size of encodable lists can be tuned by using unsigned integer types
 /// of different widths as \c rosa::token_t.
 using token_t = uint64_t;
 
 /// Sanity check in case someone would change \c rosa::token_t.
 STATIC_ASSERT(std::is_unsigned<token_t>::value,
               "token_t is not an unsigned integer");
 
 /// Turn \c rosa::token_t into a strongly typed enumeration.
 ///
 /// Values of \c rosa::token_t casted to \c rosa::Token can be used in a
 /// type-safe way.
 enum class Token : token_t {};
 
 /// A type to cast tokens into in order to output them to streams as
 /// numbers and not ASCII-codes.
 ///
 /// \note Use it for safety, necessary for printing \c uint8_t values.
 using printable_token_t = printable_t<token_t>;
 
 /// Casts a \c rosa::Token into \c rosa::printable_token_t.
 ///
 /// \param T \c rosa::Token to cast
 #define PRINTABLE_TOKEN(T) static_cast<printable_token_t>(T)
 
 /// Converts a \c rosa::Token into \c std::string.
 ///
 /// \param T \c rosa::Token to convert
 ///
 /// \return \c std::string representing \p T
 inline std::string to_string(const Token T) {
   return std::to_string(static_cast<token_t>(T));
 }
 
 /// Encloses constants related to the implementation of \c rosa::Token.
 namespace token {
 
 /// The number of bits in one \c rosa::Token.
 constexpr size_t TokenBits = sizeof(Token) * 8;
 
 /// The number of bits a builtin type can be uniquely encoded into, that is any
 /// valid \c rosa::TypeNumber can fit into.
 ///
 /// \note There is one extra bit position added for encoding so that providing a
 /// better chance to maintain backward comaptibility when \c rosa::BuiltinTypes
 /// is extended.
 constexpr size_t RepresentationBits = log2(NumberOfBuiltinTypes) + 1;
 
 /// Maximal size of uniquely tokenizable \c rosa::TypeList.
 constexpr size_t MaxTokenizableListSize = TokenBits / RepresentationBits;
 
 } // End namespace token
 
 /// Integer type to store length of a \c rosa::Token.
 ///
 /// \note The narrowest unsigned integer type that is wide enough to
 /// represent \c rosa::token::MaxTokenizableListSize different values.
 using token_size_t = typename TypeListFind<
     typename TypeListDrop<log2(token::MaxTokenizableListSize) / 8 + 1,
                           IntegerTypesBySize>::Type,
     IsNotNoneType>::Type::Second;
 
 /// \defgroup TypeListTokenImpl Implementation of rosa::TypeListToken
 ///
 /// \brief Generates a \c rosa::Token for a squashed \c rosa::TypeList.
 ///
 /// \note Only to be used by the implementation of \c rosa::TypeListToken.
 ///@{
 
 /// Declaration of the template.
 ///
 /// \tparam List \c rosa::TypeList to generate \c rosa::Token for
 template <typename List> struct TypeListTokenImpl;
 
 /// Specialization for \c rosa::EmptyTypeList.
 template <> struct TypeListTokenImpl<EmptyTypeList> {
   static constexpr Token Value = static_cast<Token>(0);
 };
 
 /// Specialization for a non-empty \c rosa::TypeList.
 template <typename T, typename... Ts>
 struct TypeListTokenImpl<TypeList<T, Ts...>> {
   static constexpr TypeNumber TN = TypeNumberOf<T>::Value;
   // Check if the generated type number is valid.
   STATIC_ASSERT(validTypeNumber(TN), "non-builtin type");
   static constexpr Token Value = static_cast<Token>(
       (static_cast<token_t>(TypeListTokenImpl<TypeList<Ts...>>::Value)
        << token::RepresentationBits) |
       static_cast<type_nr_t>(TN));
 };
 
 ///@}
 
 /// \name TypeListToken
 ///
 /// \brief Generates a \c rosa::Token for a \c rosa::TypeList.
 ///
 /// \c rosa::Token for a \c rosa::TypeList \c List can be obtained as \code
 /// TypeListToken<List>::Value
 /// \endcode
 ///
 /// \note The \c rosa::TypeList cannot have more than
 /// \c rosa::token::MaxTokenizableListSize elements and must be a subset of
 /// \c rosa::BuiltinTypes with respect to squashed integers.
 ///
 /// \note A generated \c rosa::Token uniquely represents a list of types, except
 /// for \c rosa::AtomConstant types. Observe that any \c rosa::AtomConstant is
 /// encoded as the type \c rosa::AtomValue. The type information on all separate
 /// \c rosa::AtomConstant types are lost and replaced by the \c rosa::AtomValue
 /// type whose actual value needs to be used in order to obtain the original
 /// \c rosa::AtomConstant type and so the full type information on the encoded
 /// \c rosa::TypeList.
 ///
 ///@{
 
 /// Declaration of the template.
 ///
 /// \tparam List \c rosa::TypeList to generate \c rosa::Token for
 template <typename List> struct TypeListToken;
 
 /// Implementation using \c rosa::TypeListTokenImpl.
 template <typename... Ts> struct TypeListToken<TypeList<Ts...>> {
   /// \note \c rosa::TypeNumber is computed against \c rosa::squased_t, so let's
   /// do the same here.
   using List = typename SquashedTypeList<TypeList<Ts...>>::Type;
   /// Check the length of the list here.
   /// \note Type validation is done one-by-one in \c rosa::TypeListTokenImpl.
   STATIC_ASSERT((TypeListSize<List>::Value <= token::MaxTokenizableListSize),
                 "too long list of types");
   /// The \c rosa::Token for \p List.
   static constexpr Token Value = TypeListTokenImpl<List>::Value;
 };
 
 ///@}
 
 /// Convenience template to generate \c rosa::Token for a list of types.
 template <typename... Ts> using TypeToken = TypeListToken<TypeList<Ts...>>;
 
 /// Tells if a given \c rosa::Token is valid.
 ///
 /// A \c rosa::Token is considered valid if it can be decoded by the current
 /// software.
 ///
 /// \note Validation gives a correct result only when \p T was generated by a
 /// compatible software.
 ///
 /// \sa Note for type_token.hpp on compatibility.
 ///
 /// \param T \c rosa::Token to validate
 ///
 /// \return if \p T is valid
 bool validToken(const Token T);
 
 /// Tells if a \c rosa::Token does encode an empty list of types.
 ///
 /// \param T \c rosa::Token to check
 ///
 /// \return if \p T encodes an empty list of types
 bool emptyToken(const Token T);
 
 /// Tells how many types are encoded in a \c rosa::Token.
 ///
 /// \param T \c rosa::Token to check
 ///
 /// \return how many types are encoded in \p T
 token_size_t lengthOfToken(const Token T);
 
 /// Tells the full memory size of the types encoded in a \c rosa::Token.
 ///
 /// The full memory size of the types encoded in a \c rosa::Token is the sum of
 /// the separate memory sizes of all the types encoded in the \c rosa::Token.
 ///
 /// \param T \c rosa::Token to check
 ///
 /// \return full memory size of the types encoded in \p T
 ///
 /// \pre \p T is valid:\code
 /// validToken(T)
 /// \endcode
 size_t sizeOfValuesOfToken(const Token T);
 
 /// Extracts the \c rosa::TypeNumber of the first encoded type of a
 /// \c rosa::Token.
 ///
 /// \note The returned type number is not validated.
 ///
 /// \param T \c rosa::Token to take the first \c rosa::TypeNumber from
 ///
 /// \return the first \c rosa::TypeNumber encoded in \p T
 inline TypeNumber headOfToken(const Token T) {
   return static_cast<TypeNumber>(static_cast<token_t>(T) &
                                  ((1 << token::RepresentationBits) - 1));
 }
 
 /// Tells the memory size of the first type encoded in a \c rosa::Token.
 ///
 /// \param T \c rosa::Token to check the first encoded type of
 ///
 /// \return memory size of the first type encoded in \p T
 ///
 /// \pre \p T is not empty and valid:\code
 /// !empty(T) && validToken(T)
 /// \endcode
 size_t sizeOfHeadOfToken(const Token T);
 
 /// Gives the textual representation of the first type encoded in a
 /// \c rosa::Token.
 ///
 /// \param T \c rosa::Token to take the name of its first encoded type
 ///
 /// \return textual representation of the first type encoded in \p T
 ///
 /// \pre \p T is not empty and valid:\code
 /// !empty(T) && validToken(T)
 /// \endcode
 const char *nameOfHeadOfToken(const Token T);
 
 /// Updates a \c rosa::Token by dropping its first encoded type.
 ///
 /// \param [in,out] T \c rosa::Token to drop the first encoded type of
 void dropHeadOfToken(Token &T);
 
 /// Updates a \c rosa::Token by dropping a number of its first encoded types
 ///
 /// \param [in,out] T \c rosa::Token to drop the first \p N encoded types of
 /// \param N the number of types to drop from \p T
 void dropNOfToken(Token &T, const size_t N);
 
+/// Tells what type is encoded at Position \p Pos in the \c rosa::Token \p T
+///
+/// \param T \c rosa::Token to check
+/// \param Pos the position to check
+///
+/// \return \c rosa::TypeNumber of the type encodeded at position \p Pos of \c
+/// rosa::Token \p T
+///
+/// \pre \p T is valid and it encodes \p Pos types: \code
+/// validToken(T) && Pos < static_cast<size_t>(lengthOfToken(T))
+/// \endcode
+inline TypeNumber typeAtPositionOfToken(const Token T, const size_t Pos) {
+  ASSERT(validToken(T) && Pos < static_cast<size_t>(lengthOfToken(T)));
+  Token TT = T;
+  dropNOfToken(TT, Pos);
+  return headOfToken(TT);
+}
+
 /// Tells if the first encoded type of a \c rosa::Token is a given type.
 ///
 /// \tparam Type type to match the first encoded type of \p T against
 ///
 /// \param T \c rosa::Token whose first encoded type is to be matched against
 /// \p Type
 ///
 /// \return if the first encoded type of \p T is \p Type
 ///
 /// \pre \p T is not empty and valid:\code
 /// !empty(T) && validToken(T)
 /// \endcode
 template <typename Type> bool isHeadOfTokenTheSameType(const Token T) {
   ASSERT(!emptyToken(T) && validToken(T));
   return TypeNumberOf<Type>::Value == headOfToken(T);
 }
 
 } // End namespace rosa
 
 #endif // ROSA_SUPPORT_TYPE_TOKEN_HPP