diff --git a/include/rosa/support/tokenized_storages.hpp b/include/rosa/support/tokenized_storages.hpp
index 63cf40f..32b73b2 100755
--- a/include/rosa/support/tokenized_storages.hpp
+++ b/include/rosa/support/tokenized_storages.hpp
@@ -1,501 +1,620 @@
 //===-- rosa/support/tokenized_storages.hpp ---------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file rosa/support/tokenized_storages.hpp
 ///
 /// \author David Juhasz (david.juhasz@tuwien.ac.at)
 ///
 /// \date 2017-2019
 ///
 /// \brief Definition of storage helper template for storing values in a
 /// type-safe way based on type tokens.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef ROSA_SUPPORT_TOKENIZED_STORAGES_HPP
 #define ROSA_SUPPORT_TOKENIZED_STORAGES_HPP
 
 #include "rosa/support/type_token.hpp"
 
 #include <memory>
 #include <vector>
 
 namespace rosa {
 
 /// Defines a simple interface for storing and accessing values of different
 /// types.
 ///
 /// While the interface provides features to access values and know their
 /// types, it is the users responsibility to use particular values according to
 /// their actual types. No facilities for type-safe access of values is
 /// provided by the class.
 ///
 /// \see \c rosa::TokenizedStorage for a type-safe specialization of the
 /// interface.
 class AbstractTokenizedStorage {
 protected:
   /// Protected constructor restricts instantiation for derived classes.
   AbstractTokenizedStorage(void) noexcept = default;
 
 public:
   /// No copying and moving of \c rosa::AbstractTokenizedStorage instances.
   ///@{
   AbstractTokenizedStorage(const AbstractTokenizedStorage&) = delete;
   AbstractTokenizedStorage &operator=(const AbstractTokenizedStorage&) = delete;
   AbstractTokenizedStorage(AbstractTokenizedStorage&& Other) = delete;
   AbstractTokenizedStorage &operator=(AbstractTokenizedStorage&&) = delete;
   ///@}
 
   /// Destroys \p this object.
   virtual ~AbstractTokenizedStorage(void) noexcept = default;
 
   /// Tells how many values are stored in \p this object.
   ///
   /// \return number of values stored in \p this object
   virtual size_t size(void) const noexcept = 0;
 
   /// Tells the type of the value stored at a position.
   ///
   /// \param Pos the index of the value whose type is to returned
   ///
   /// \return \c rosa::TypeNumber for the value stored at index \p Pos
   ///
   /// \pre \p Pos is a valid index:\code
   /// Pos < size()
   /// \endcode
   virtual TypeNumber typeAt(const token_size_t Pos) const noexcept = 0;
 
   /// Provides an untyped pointer for the value stored at a position.
   ///
   /// \param Pos the index of the value to return an untyped pointer for
   ///
   /// \return untyped pointer for the value stored at index \p Pos
   ///
   /// \pre \p Pos is a valid index:\code
   /// Pos < size()
   /// \endcode
   virtual void *pointerTo(const token_size_t Pos) noexcept = 0;
 
   /// Provides a constant untyped pointer for the value stored at a position.
   ///
   /// \param Pos the index of the value to return an untyped pointer for
   ///
   /// \return constant untyped pointer for the value stored at index \p Pos
   ///
   /// \pre \p Pos is a valid index:\code
   /// Pos < Offsets.size()
   /// \endcode
   virtual const void *pointerTo(const token_size_t Pos) const noexcept = 0;
 };
 
 /// Template class storing values and providing dynamic type-safe access to
 /// them in a lightweight way based on type tokens.
 ///
 /// \see rosa/support/type_token.hpp
 ///
 /// \tparam Types types whose values are to be stored
 template <typename... Types> class TokenizedStorage;
 
+/// \defgroup TokenizedStorageForTypeList Implementation of
+/// rosa::TokenizedStorageForTypeList
+///
+/// \brief Transforms a \c rosa::TypeList instance to the corresponding
+/// \c rosa::TokenizedStorage instance.
+///
+/// A \c rosa::TypeList \c List instance can be turned into a corresponding \c
+/// rosa::TokenizedStorage instance as \code
+/// typename TokenizedStorageForTypeList<List>::Type
+/// \endcode
+///
+/// For example, the following expression evaluates to `true`: \code
+/// std::is_same_v<typename TokenizedStorageForTypeList<TypeList<T1, T2>>::Type,
+///                TokenizedStorage<T1, T2>>
+/// \endcode
+///@{
+
+/// Declaration of the template.
+///
+/// \tparam List \c rosa::TypeList to transform
+template <typename List> struct TokenizedStorageForTypeList;
+
+/// Implementation of the template for \c rosa::TypeList instances.
+template <typename... Ts>
+struct TokenizedStorageForTypeList<TypeList<Ts...>> {
+  using Type = TokenizedStorage<Ts...>;
+};
+
+///@}
+
 /// Nested namespace with implementation for \c rosa::TokenizedStorage, consider
 /// it private.
 namespace {
 
 /// Initializes a pre-allocated memory area with values from constant lvalue
 /// references.
 ///
 /// \tparam Types types whose values are to be stored
 ///
 /// \param Arena pre-allocated memory area to store values to
 /// \param Ts the values to store in \p Arena
 ///
 /// \note \p Arena needs to be a valid pointer to a memory area big enough for
 /// values of \p Types.
 template <typename... Types>
 inline void createArenaElements(void *const Arena,
                                 const Types &... Ts) noexcept;
 
 /// \defgroup createLvalueArenaElement Implementation of creating lvalue arena elements
 ///
 /// Stores values from constant lvalue references into a pre-allocated memory
 /// area.
 ///
 /// \note To be used by the implementation of \c createArenaElements.
 ///
 /// \todo Document these functions.
 ///@{
 
 /// \note This terminal case is used for both constant lvalue references and
 /// value references.
 template <size_t Pos>
 inline void createArenaElement(void *const,
                                const std::vector<size_t> &Offsets) {
   ASSERT(Pos == Offsets.size());
 }
 
 template <size_t Pos, typename Type, typename... Types>
 inline void createArenaElement(void *const Arena,
                                const std::vector<size_t> &Offsets,
                                const Type &T, const Types &... Ts) noexcept {
   ASSERT(Arena != nullptr && Pos < Offsets.size());
   new (static_cast<Type *>(static_cast<void *>(static_cast<uint8_t *>(Arena) +
                                                Offsets[Pos]))) Type(T);
   createArenaElement<Pos + 1>(Arena, Offsets, Ts...);
 }
 
 template <size_t Pos, AtomValue V, typename... Types>
 inline void
 createArenaElement(void *const Arena, const std::vector<size_t> &Offsets,
                    const AtomConstant<V> &, const Types &... Ts) noexcept {
   ASSERT(Arena != nullptr && Pos < Offsets.size());
   *static_cast<AtomValue *>(
       static_cast<void *>(static_cast<uint8_t *>(Arena) + Offsets[Pos])) = V;
   createArenaElement<Pos + 1>(Arena, Offsets, Ts...);
 }
 
 ///@}
 
 /// Implementation of the template.
 ///
 /// \tparam Types types of values to store
 ///
 /// \param Arena pre-allocated memory area to store values to
 /// \param Ts values to store in \p Arena
 ///
 /// \pre \p Arena is not \p nullptr.
 template <typename... Types>
 inline void createArenaElements(void *const Arena,
                                 const Types &... Ts) noexcept {
   ASSERT(Arena != nullptr);
   createArenaElement<0>(Arena, TokenizedStorage<Types...>::Offsets, Ts...);
 }
 
 /// Initializes a pre-allocated memory area with values from rvalue references.
 ///
 /// \tparam Types types whose values are to be stored
 ///
 /// \param Arena pre-allocated memory area to store values to
 /// \param Ts the values to store in \p Arena
 ///
 /// \note \p Arena needs to be a valid pointer to a memory area big enough for
 /// values of \p Types.
 template <typename... Types>
 inline void createArenaElements(void *const Arena, Types &&... Ts) noexcept;
 
 /// \defgroup createRvalueArenaElement Implementation of creating rvalue arena elements
 ///
 /// Stores values from rvalue references into a pre-allocated memory area.
 ///
 /// \note To be used by the implementation of \c createArenaElements.
 ///
 /// \todo Document these functions.
 ///@{
 
 template <size_t Pos, typename Type, typename... Types>
 inline void createArenaElement(void *const Arena,
                                const std::vector<size_t> &Offsets, Type &&T,
                                Types &&... Ts) noexcept {
   ASSERT(Arena != nullptr && Pos < Offsets.size());
   new (static_cast<Type *>(static_cast<void *>(
       static_cast<uint8_t *>(Arena) + Offsets[Pos]))) Type(std::move(T));
   createArenaElement<Pos + 1>(Arena, Offsets, std::move(Ts)...);
 }
 
 template <size_t Pos, AtomValue V, typename... Types>
 inline void createArenaElement(void *const Arena,
                                const std::vector<size_t> &Offsets,
                                AtomConstant<V> &&, Types &&... Ts) noexcept {
   ASSERT(Arena != nullptr && Pos < Offsets.size());
   *static_cast<AtomValue *>(
       static_cast<void *>(static_cast<uint8_t *>(Arena) + Offsets[Pos])) = V;
   createArenaElement<Pos + 1>(Arena, Offsets, std::move(Ts)...);
 }
 
 ///@}
 
 /// Implementation of the template.
 ///
 /// \tparam Types types of values to store
 ///
 /// \param Arena pre-allocated memory area to store values to
 /// \param Ts values to store in \p Arena
 ///
 /// \pre \p Arena is not \c nullptr.
 template <typename... Types>
 inline void createArenaElements(void *const Arena, Types &&... Ts) noexcept {
   ASSERT(Arena != nullptr);
   createArenaElement<0>(Arena, TokenizedStorage<Types...>::Offsets,
                         std::move(Ts)...);
 }
 
 /// Destroys values allocated by \c createArenaElements.
 ///
 /// \tparam Types types whose values are stored in \p Arena
 ///
 /// \param Arena the memory area to destroy values from
 ///
 /// \note \p Arena needs to be a valid pointer to a memory area where values of
 /// \p Types are stored.
 template <typename... Types>
 inline void destroyArenaElements(void *const Arena) noexcept;
 
 /// \defgroup destroyArenaElement Implementation of destroying arena elements
 ///
 /// Destroys values from a memory area.
 ///
 /// \note To be used by the implementation of \c destroyArenaElements.
 ///
 /// \todo Document these functions.
 ///@{
 
 template <size_t Pos>
 inline void destroyArenaElement(void *const,
                                 const std::vector<size_t> &Offsets) noexcept {
   ASSERT(Pos == Offsets.size());
 }
 
 template <size_t Pos, typename Type, typename... Types>
 inline void destroyArenaElement(void *const Arena,
                                 const std::vector<size_t> &Offsets) noexcept {
   ASSERT(Arena != nullptr && Pos < Offsets.size());
   static_cast<Type *>(
       static_cast<void *>(static_cast<uint8_t *>(Arena) + Offsets[Pos]))
       ->~Type();
   destroyArenaElement<Pos + 1, Types...>(Arena, Offsets);
 }
 
 ///@}
 
 /// Implementation of the template.
 ///
 /// \tparam Types types of values to destroy
 ///
 /// \param Arena the memory area to destroy values from
 ///
 /// \pre \p Arena is not \c nullptr.
 template <typename... Types>
 inline void destroyArenaElements(void *const Arena) noexcept {
   ASSERT(Arena != nullptr);
   destroyArenaElement<0, Types...>(Arena, TokenizedStorage<Types...>::Offsets);
 }
 
 } // End namespace
 
 /// Implementation of the template \c rosa::TokenizedStorage as a
 /// specialization of \c rosa::AbstractTokenizedStorage.
 ///
 /// The class provides facilities for storing values and providing type-safe
 /// access to them.
 ///
 /// \tparam Types types of values to store
 template <typename... Types>
 class TokenizedStorage : public AbstractTokenizedStorage {
 public:
   /// \c rosa::Token for the stored values.
-  static constexpr Token ST =
-      TypeToken<typename std::decay<Types>::type...>::Value;
+  static constexpr Token ST = TypeToken<std::decay_t<Types>...>::Value;
 
   /// Byte offsets to access stored values in \c rosa::TokenizedStorage::Arena.
   static const std::vector<size_t> Offsets;
 
 private:
   /// A BLOB storing all the values one after the other.
   void *const Arena;
 
   /// Generates byte offsets for accessing values stored in
   /// \c rosa::TokenizedStorage::Arena.
   ///
   /// \return \c std::vector containing byte offsets for accessing values stored
   /// in \c rosa::TokenizedStorage::Arena
   static std::vector<size_t> offsets(void) noexcept {
     Token T = ST;                      // Need a mutable copy.
     const token_size_t N = lengthOfToken(T); // Number of types encoded in \c T.
     std::vector<size_t> O(N);          // Allocate vector of proper size.
     // Do nothing for 0 elements.
     if (N > 0) {
       token_size_t I = 0; // Start indexing from position \c 0.
       O[0] = 0; // First offset is always \c 0.
       while (I < N - 1) {
         ASSERT(I + 1 < O.size() && lengthOfToken(T) == N - I);
         // Calculate next offset based on the previous one.
         // \note The offset of the last value is stored at `O[N - 1]`, which is
         // set when `I == N - 2`. Hence the limit of the loop.
         O[I + 1] = O[I] + sizeOfHeadOfToken(T);
         dropHeadOfToken(T), ++I;
       }
       ASSERT(I + 1 == O.size() && lengthOfToken(T) == 1);
     }
     return O;
   }
 
 public:
   /// Creates an instance with default values.
   ///
   /// \note This constructor requires that all actual template arguments \p
   /// Types... are default constructible.
   TokenizedStorage(void) noexcept
       : Arena(::operator new(sizeOfValuesOfToken(ST))) {
     ASSERT(Arena != nullptr); // Sanity check.
     createArenaElements(Arena, Types()...);
   }
 
   /// Creates an instance from constant lvalue references.
   ///
   /// \param Ts values to store
-  TokenizedStorage(const Types &... Ts) noexcept
+  TokenizedStorage(const std::decay_t<Types> &... Ts) noexcept
       : Arena(::operator new(sizeOfValuesOfToken(ST))) {
     ASSERT(Arena != nullptr); // Sanity check.
     createArenaElements(Arena, Ts...);
   }
 
   /// Creates an instance from rvalue references.
   ///
   /// \param Ts values to store
-  TokenizedStorage(Types &&... Ts) noexcept
+  TokenizedStorage(std::decay_t<Types> &&... Ts) noexcept
       : Arena(::operator new(sizeOfValuesOfToken(ST))) {
     ASSERT(Arena != nullptr); // Sanity check.
     createArenaElements(Arena, std::move(Ts)...);
   }
 
   /// No copying and moving of \c rosa::TokenizedStorage instances.
   ///
   /// \note This restriction may be relaxed as moving should be easy to
   /// implement, only requires the possiblity to validate Arena pointer.
   ///@{
   TokenizedStorage(const TokenizedStorage&) = delete;
   TokenizedStorage &operator=(const TokenizedStorage&) = delete;
   TokenizedStorage(TokenizedStorage&& Other) = delete;
   TokenizedStorage &operator=(TokenizedStorage&&) = delete;
   ///@}
 
   // Destroys \p this object.
   ~TokenizedStorage(void) {
-    destroyArenaElements<Types...>(Arena);
+    destroyArenaElements<std::decay_t<Types>...>(Arena);
     ::operator delete(Arena);
   }
 
   /// Tells how many values are stored in \p this object.
   ///
   /// \return number of values stored in \p this object
   size_t size(void) const noexcept override {
     return Offsets.size();
   }
 
   /// Tells the type of the value stored at a position.
   ///
   /// \param Pos the index of the value whose type is to returned
   ///
   /// \return \c rosa::TypeNumber for the value stored at index \p Pos
   ///
   /// \pre \p Pos is a valid index:\code
   /// Pos < size()
   /// \endcode
   TypeNumber typeAt(const token_size_t Pos) const noexcept override {
     ASSERT(Pos < size());
     Token TT = ST;
     dropNOfToken(TT, Pos);
     return headOfToken(TT);
   }
 
   /// Provides an untyped pointer for the value stored at a position.
   ///
   /// \param Pos the index of the value to return an untyped pointer for
   ///
   /// \return untyped pointer for the value stored at index \p Pos
   ///
   /// \pre \p Pos is a valid index:\code
   /// Pos < size()
   /// \endcode
   void *pointerTo(const token_size_t Pos) noexcept override {
     ASSERT(Pos < size());
     return static_cast<uint8_t *>(Arena) + Offsets[Pos];
   }
 
   /// Provides a constant untyped pointer for the value stored at a position.
   ///
   /// \param Pos the index of the value to return an untyped pointer for
   ///
   /// \return constant untyped pointer for the value stored at index \p Pos
   ///
   /// \pre \p Pos is a valid index:\code
   /// Pos < Offsets.size()
   /// \endcode
   const void *pointerTo(const token_size_t Pos) const noexcept override {
     ASSERT(Pos < size());
     return static_cast<const uint8_t *>(Arena) + Offsets[Pos];
   }
 
   /// Tells if the value stored at a given index is of a given type.
   ///
   /// \note Any \c rosa::AtomConstant is encoded in \c rosa::Token as
   /// the \c rosa::AtomValue wrapped into it.
   ///
   /// \tparam T type to match against
   ///
   /// \param Pos index the type of the value at is to be matched against \p Type
   ///
   /// \return if the value at index \p Pos of type \p T
   ///
   /// \pre \p Pos is a valid index:\code
   /// Pos < Offsets.size()
   /// \endcode
   template <typename T> bool isTypeAt(const size_t Pos) const noexcept {
     ASSERT(Pos < size());
     Token TT = ST;
     dropNOfToken(TT, Pos);
     return isHeadOfTokenTheSameType<T>(TT);
   }
 
   /// Gives a reference of a value of a given type stored at a given index.
   ///
   /// \note The constant variant of the function relies on this implementation,
   /// the function may not modify \p this object!
   ///
   /// \tparam T type to give a reference of
   ///
   /// \param Pos index to set the reference for
   ///
   /// \return reference of \p T for the value stored at index \p Pos
   ///
   /// \pre \p Pos is a valid index and the value at index \p Pos is of type
   /// \p T:
   /// \code
   /// Pos < Size && isTypeAt<T>(Pos)
   /// \endcode
   template <typename T> T &valueAt(const token_size_t Pos) noexcept {
     ASSERT(Pos < size() && isTypeAt<T>(Pos));
     return *static_cast<T *>(pointerTo(Pos));
   }
 
   /// Gives a constant reference of a value of a given type stored at a given
   /// index.
   ///
   /// \tparam T type to give a reference of
   ///
   /// \param Pos index to set the reference for
   ///
   /// \return constant reference of \p T for the value stored at index \p Pos
   ///
   /// \pre \p Pos is a valid index and the value at index \p Pos is of type
   /// \p T:
   /// \code
   /// Pos < Size && isTypeAt<T>(Pos)
   /// \endcode
   template <typename T>
   const T &valueAt(const token_size_t Pos) const noexcept {
     // \note Just use the non-const implementation as that does not modify
     // \p this object.
     return const_cast<TokenizedStorage *>(this)->valueAt<T>(Pos);
   }
 };
 
 // Implementation of the static member field \c rosa::TokenizedStorage::Offsets.
 template <typename... Types>
 const std::vector<size_t>
     TokenizedStorage<Types...>::Offsets = TokenizedStorage<Types...>::offsets();
 
+/// Specialization of the template \c rosa::TokenizedStorage for storing
+/// nothing.
+///
+/// \note The specialization implements the interface defined by \c
+/// rosa::AbstractTokenizedStorage but most of the functions cannot be called
+/// because nothing is stored in instances of the class.
+template <> class TokenizedStorage<> : public AbstractTokenizedStorage {
+public:
+  /// \c rosa::Token for the stored values.
+  static constexpr Token ST = TypeToken<>::Value;
+
+  /// Byte offsets to access stored values in \c rosa::TokenizedStorage::Arena.
+  static const std::vector<size_t> Offsets;
+
+  /// Creates an instance.
+  TokenizedStorage(void) noexcept {}
+
+  /// No copying and moving of \c rosa::TokenizedStorage instances.
+  ///
+  /// \note This restriction may be relaxed as moving should be easy to
+  /// implement, only requires the possiblity to validate Arena pointer.
+  ///@{
+  TokenizedStorage(const TokenizedStorage &) = delete;
+  TokenizedStorage &operator=(const TokenizedStorage &) = delete;
+  TokenizedStorage(TokenizedStorage &&Other) = delete;
+  TokenizedStorage &operator=(TokenizedStorage &&) = delete;
+  ///@}
+
+  // Destroys \p this object.
+  ~TokenizedStorage(void) {}
+
+  /// Tells how many values are stored in \p this object.
+  ///
+  /// \return `0`
+  size_t size(void) const noexcept override { return 0; }
+
+  /// Tells the type of the value stored at a position.
+  ///
+  /// \pre Do not call.
+  TypeNumber typeAt(const token_size_t) const noexcept override {
+    ASSERT(false);
+    return TypeNumber(0);
+  }
+
+  /// Provides an untyped pointer for the value stored at a position.
+  ///
+  /// \pre Do not call.
+  void *pointerTo(const token_size_t) noexcept override {
+    ASSERT(false);
+    return nullptr;
+  }
+
+  /// Provides a constant untyped pointer for the value stored at a position.
+  ///
+  /// \pre Do not call.
+  const void *pointerTo(const token_size_t) const noexcept override {
+    ASSERT(false);
+    return nullptr;
+  }
+
+  /// Tells if the value stored at a given index is of a given type.
+  ///
+  /// \pre Do not call.
+  template <typename> bool isTypeAt(const size_t) const noexcept {
+    ASSERT(false);
+    return false;
+  }
+
+  /// Gives a reference of a value of a given type stored at a given index.
+  ///
+  /// \tparam T type to give a reference of
+  /// \pre Do not call.
+  template <typename T> T &valueAt(const token_size_t) noexcept {
+    ASSERT(false);
+    return *static_cast<T *>(nullptr);
+  }
+
+  /// Gives a constant reference of a value of a given type stored at a given
+  /// index.
+  ///
+  /// \tparam T type to give a reference of
+  ///
+  /// \pre Do not call.
+  template <typename T> const T &valueAt(const token_size_t) const noexcept {
+    // \note Just use the non-const implementation as that does not modify
+    // \p this object.
+    return *static_cast<T *>(nullptr);
+  }
+};
+
 } // End namespace rosa
 
 #endif // ROSA_SUPPORT_TOKENIZED_STORAGES_HPP
diff --git a/lib/support/tokenized_storages.cpp b/lib/support/tokenized_storages.cpp
index ceb8a47..59d8eb6 100755
--- a/lib/support/tokenized_storages.cpp
+++ b/lib/support/tokenized_storages.cpp
@@ -1,20 +1,25 @@
 //===-- support/tokenized_storages.cpp --------------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file support/tokenized_storages.cpp
 ///
 /// \author David Juhasz (david.juhasz@tuwien.ac.at)
 ///
-/// \date 2017
+/// \date 2017-2019
 ///
 /// \brief Implementation of rosa/support/tokenized_storages.hpp.
 ///
-/// \note Empty implementation, source file here to have a compile database
-///       entry for rosa/support/tokenized_storages.hpp.
-///
 //===----------------------------------------------------------------------===//
 
 #include "rosa/support/tokenized_storages.hpp"
+
+namespace rosa {
+
+// Implementation of the static member field \c
+// rosa::TokenizedStorage<>::Offsets.
+const std::vector<size_t> TokenizedStorage<>::Offsets = std::vector<size_t>(0);
+
+} // End namespace rosa
\ No newline at end of file