diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 8f99ea8..eb5ec40 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -1,3 +1,4 @@
 # Add the different subdirectories
 add_subdirectory(basic-system)
+add_subdirectory(type-facilities)
 
diff --git a/examples/type-facilities/CMakeLists.txt b/examples/type-facilities/CMakeLists.txt
new file mode 100644
index 0000000..de84c63
--- /dev/null
+++ b/examples/type-facilities/CMakeLists.txt
@@ -0,0 +1,4 @@
+add_executable(type-facilities type-facilities.cpp)
+ROSA_add_library_dependencies(type-facilities ROSAConfig)
+ROSA_add_library_dependencies(type-facilities ROSASupport)
+
diff --git a/examples/type-facilities/type-facilities.cpp b/examples/type-facilities/type-facilities.cpp
new file mode 100644
index 0000000..2522eee
--- /dev/null
+++ b/examples/type-facilities/type-facilities.cpp
@@ -0,0 +1,71 @@
+/*******************************************************************************
+ *
+ * File:     type-facilities.cpp
+ *
+ * Contents: An example showcasing various type-related support facilities.
+ *
+ * Copyright 2017
+ *
+ * Author: David Juhasz (david.juhasz@tuwien.ac.at)
+ *
+ ******************************************************************************/
+
+#include "rosa/config/version.h"
+#include "rosa/support/log.h"
+#include "rosa/support/terminal_colors.h"
+#include "rosa/support/type_token.hpp"
+#include <iostream>
+
+using namespace rosa;
+using namespace rosa::terminal;
+
+int main(void) {
+  LOG_INFO_STREAM << library_string() << " -- " << Color::Red
+                  << "type facilities" << Color::Default << std::endl;
+
+  auto &Log = LOG_TRACE_STREAM << std::endl;
+  Log << "NumberOfBuiltinTypes: " << NumberOfBuiltinTypes << std::endl
+      << "TokenBits: " << token::TokenBits << std::endl
+      << "RepresentationBits: " << token::RepresentationBits << std::endl
+      << "MaxTokenizableListSize: " << token::MaxTokenizableListSize
+      << std::endl
+      << std::endl;
+
+  Log << "Type number information on 'uint8_t':" << std::endl;
+  constexpr type_nr_t TN = TypeNumber<uint8_t>::Value;
+  Log << "  type number: " << PRINTABLE_TN(TN) << std::endl
+      << "  size: " << TypeForNumber<TN>::Size << std::endl
+      << "  name: " << TypeForNumber<TN>::Name << std::endl
+      << std::endl;
+
+  Log << "Type token information on 'TypeList<uint8_t, uint16_t>':"
+      << std::endl;
+  // Token is generated statically.
+  constexpr token_t Token = TypeToken<uint8_t, uint16_t>::Token;
+  STATIC_ASSERT((Token == TypeListToken<TypeList<uint8_t, uint16_t>>::Token),
+                "alias template definition is wrong");
+  token_t T = Token; // We need a non-const value for dropping head later.
+  // Iterate over encoded entries in Token.
+  while (!emptyToken(T)) {
+    Log << "  token: " << PRINTABLE_TOKEN(T) << std::endl
+        << "  valid: " << validToken(T) << std::endl
+        << "  empty: " << emptyToken(T) << std::endl
+        << "  full size: " << sizeOfToken(T) << std::endl
+        << "  head type number: " << PRINTABLE_TN(typeNumberOfHeadOfToken(T))
+        << std::endl
+        << "  size of head: " << sizeOfHeadOfToken(T) << std::endl
+        << "  name of head: " << nameOfHeadOfToken(T) << std::endl
+        << "  is head uint8_t: " << isHeadOfTokenTheSameType<uint8_t>(T)
+        << std::endl
+        << "  is head uint16_t: " << isHeadOfTokenTheSameType<uint16_t>(T)
+        << std::endl
+        << "Dropping head..." << std::endl;
+    dropHeadOfToken(T);
+  }
+  // Here when Token became empty.
+  Log << "  token: " << PRINTABLE_TOKEN(T) << std::endl
+      << "  empty: " << emptyToken(T) << std::endl;
+
+  return 0;
+}
+
diff --git a/include/rosa/support/atom.hpp b/include/rosa/support/atom.hpp
index 1cc0cef..d003d92 100644
--- a/include/rosa/support/atom.hpp
+++ b/include/rosa/support/atom.hpp
@@ -1,131 +1,129 @@
 /*******************************************************************************
  *
  * File:     atom.hpp
  *
  * Contents: Facility for atoms, short strings statically encoded as integers.
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
- * This implementation is based on the Atom implementation of CAF.
+ * This implementation is based on the atom implementation of CAF.
  * TODO: Check license.
  *
  ******************************************************************************/
 
 #ifndef ROSA_SUPPORT_ATOM_HPP
 #define ROSA_SUPPORT_ATOM_HPP
 
 #include "rosa/support/debug.hpp"
-#include <string>
-
 
 // Atoms can be used to turn short string literals into statically generated
 // types. The literals may consist of at most 10 non-special characters, legal
 // characters are _0-9A-Za-z and the whitespace character. Special characters
 // are turned into whitespace, which may result in different string literals
 // being encoded into the same integer value, if any of those contain at least
 // one special character. Note that the usage of special characters in the
 // string literals used to create atoms cannot be checked by the compiler.
 //
 // Example:
 //
 // constexpr AtomValue NameValue = atom("name");
 // using NameAtom = AtomConstant<NameValue>;
 //
 // [](NameAtom){ std::cout << "Argument of type NameAtom"; }(NameAtom::Value)
 //
 
 namespace rosa {
 
 // Maximal length of valid atom strings.
 constexpr size_t MaxAtomLength = 10;
 
 // Underlying integer type of atom values.
 using atom_t = uint64_t;
 
 // Turn atom_t into a strongly typed enumeration, so atom_t values casted to
 // AtomValue may be used in a type-safe way.
 enum class AtomValue : atom_t {};
 
 // Anonymous namespace with implementational details, consider it private.
 namespace {
 
 // Encodes ASCII characters to 6-bit encoding.
 constexpr unsigned char AtomEncodingTable[] = {
 /*     ..0 ..1 ..2 ..3 ..4 ..5 ..6 ..7 ..8 ..9 ..A ..B ..C ..D ..E ..F  */
 /* 0.. */  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 /* 1.. */  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 /* 2.. */  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 /* 3.. */  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 0,  0,  0,  0,  0,  0,
 /* 4.. */  0, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
 /* 5.. */ 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,  0,  0,  0,  0, 37,
 /* 6.. */  0, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
 /* 7.. */ 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,  0,  0,  0,  0,  0};
 
 // Decodes 6-bit characters to ASCII
 constexpr char AtomDecodingTable[] = " 0123456789"
                                      "ABCDEFGHIJKLMNOPQRSTUVWXYZ_"
                                      "abcdefghijklmnopqrstuvwxyz";
 
 // Encodes one character and updates the integer representation.
 constexpr atom_t nextInterim(atom_t Current, size_t CharCode) {
   return (Current << 6) | AtomEncodingTable[(CharCode <= 0x7F) ? CharCode : 0];
 }
 
 // Encodes a C-string into an integer value to be used as AtomValue.
 constexpr atom_t atomValue(const char *CStr, atom_t Interim = 0xF) {
   return (*CStr == '\0')
              ? Interim
              : atomValue(CStr + 1,
                          nextInterim(Interim, static_cast<size_t>(*CStr)));
 }
 
 } // End namespace
 
 // Converts an AtomValue into string.
 std::string to_string(const AtomValue &What);
 
 // Creates an AtomValue from the given string.
 AtomValue atom_from_string(const std::string &S);
 
 // Creates an AtomValue from the given string literal.
 template <size_t Size>
 constexpr AtomValue atom(char const (&Str)[Size]) {
   // Last character is the NULL terminator.
   STATIC_ASSERT(Size <= MaxAtomLength + 1,
                 "Too many characters in atom definition");
   return static_cast<AtomValue>(atomValue(Str));
 }
 
 // Lifts an AtomValue to a compile-time constant.
 template <AtomValue V>
 struct AtomConstant {
   constexpr AtomConstant() {
     // nop
   }
 
   // Returns the wrapped value.
   constexpr operator AtomValue() const { return V; }
 
   // Returns the wrapped value as an integer as type atom_t.
   static constexpr atom_t uint_value() { return static_cast<atom_t>(V); }
 
   // Returns an instance *of this constant* (*not* an `AtomValue`).
   static const AtomConstant Value;
 };
 
 // Implementation of the static member field Value of AtomConstant.
 template <AtomValue V>
 const AtomConstant<V> AtomConstant<V>::Value = AtomConstant<V>{};
 
 // Converts an AtomConstant into string.
 template <AtomValue V>
 std::string to_string(const AtomConstant<V> &) {
   return to_string(V);
 }
 
 } // End namespace rosa
 
 #endif // ROSA_SUPPORT_ATOM_HPP
 
diff --git a/include/rosa/support/debug.hpp b/include/rosa/support/debug.hpp
index e15e2ee..dcbed4a 100644
--- a/include/rosa/support/debug.hpp
+++ b/include/rosa/support/debug.hpp
@@ -1,89 +1,89 @@
 /*******************************************************************************
  *
  * File:     debug.hpp
  *
  * Contents: Facility for debugging
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
 #ifndef ROSA_SUPPORT_DEBUG_HPP
 #define ROSA_SUPPORT_DEBUG_HPP
 
 #include "rosa/config/config.h"
-#include "rosa/support/types.hpp"
+#include "rosa/support/type_helper.hpp"
 #include "rosa/support/terminal_colors.h"
 #include <array>
 #include <ostream>
 
 namespace rosa {
 
 // Returns an output stream to use for debugging.
 std::ostream &dbgs(void);
 
 // Prints an array to the ostream.
 template <typename T, size_t size>
 std::ostream &operator<<(std::ostream &os, const std::array<T, size> &arr) {
   os << '[';
   for (unsigned I = 0; I < size; ++I) {
     if (I) {
       os << ',';
     }
     os << (PRINTABLE(T)) arr[I];
   }
   os << ']';
   return os;
 }
 
 } // End namespace rosa
 
 #ifndef ROSA_ENABLE_ASSERTIONS
 #define ASSERT(stmt) ROSA_IGNORE_UNUSED(stmt)
 #elif defined(ROSA_WINDOWS)
 #define ASSERT(stmt)                                                           \
   if (static_cast<bool>(stmt) == false) {                                      \
     rosa::dbgs() << rosa::terminal::Color::Default << __FILENAME__ << ":"      \
                  << __LINE__ << ": requirement failed: '" << #stmt << "'"      \
                  << std::endl;                                                 \
     ::abort();                                                                 \
   }                                                                            \
   ROSA_VOID_STMT
 #else // defined(ROSA_LINUX)
 #include <execinfo.h>
 #define ASSERT(stmt)                                                           \
   if (static_cast<bool>(stmt) == false) {                                      \
     rosa::dbgs() << rosa::terminal::Color::Default << __FILENAME__ << ":"      \
                  << __LINE__ << ": requirement failed: '" << #stmt << "'"      \
                  << std::endl;                                                 \
     void *array[20];                                                           \
     auto bt_size = ::backtrace(array, 20);                                     \
     ::backtrace_symbols_fd(array, bt_size, 2);                                 \
     ::abort();                                                                 \
   }                                                                            \
   ROSA_VOID_STMT
 #endif // defined(ROSA_ENABLE_ASSERTIONS)
 
 #ifndef NDEBUG
 #define DEBUG(X)                                                               \
   do {                                                                         \
     X;                                                                         \
   } while (false)
 #define DEBUGVAR(V)                                                            \
   do {                                                                         \
     rosa::dbgs() << rosa::terminal::Color::Default << #V << " ("               \
                  << __FILENAME__ << ":" << __LINE__ << "): " << (V)            \
                  << std::endl;                                                 \
   } while (false)
 #else // defined(NDEBUG)
 #define DEBUG(X) ROSA_IGNORE_UNUSED(X)
 #define DEBUGVAR(X) ROSA_IGNORE_UNUSED(X)
 #endif // defined(NDEBUG)
 
 // Static assertions are always emitted to the code.
 #define STATIC_ASSERT(COND, DIAG) static_assert((COND), DIAG)
 
 #endif // ROSA_SUPPORT_DEBUG_HPP
 
diff --git a/include/rosa/support/math.hpp b/include/rosa/support/math.hpp
new file mode 100644
index 0000000..d2aa41c
--- /dev/null
+++ b/include/rosa/support/math.hpp
@@ -0,0 +1,28 @@
+/*******************************************************************************
+ *
+ * File:     math.hpp
+ *
+ * Contents: Math helpers.
+ *
+ * Copyright 2017
+ *
+ * Author: David Juhasz (david.juhasz@tuwien.ac.at)
+ *
+ ******************************************************************************/
+
+#ifndef ROSA_SUPPORT_MATH_HPP
+#define ROSA_SUPPORT_MATH_HPP
+
+#include <cstdlib>
+
+namespace rosa {
+
+// Computes log base 2 of an integer as a constexpr.
+constexpr size_t log2(const size_t N) {
+  return ((N < 2) ? 1 : 1 + log2(N / 2));
+}
+
+} // End namespace rosa
+
+#endif // ROSA_SUPPORT_MATH_HPP
+
diff --git a/include/rosa/support/squashed_int.hpp b/include/rosa/support/squashed_int.hpp
new file mode 100644
index 0000000..94bf918
--- /dev/null
+++ b/include/rosa/support/squashed_int.hpp
@@ -0,0 +1,69 @@
+/******************************************************************************
+ *
+ * File:     squashed_int.hpp
+ *
+ * Contents: Facilities for squashing integer types into standard equivalents.
+ *
+ * Copyright 2017
+ *
+ * Author: David Juhasz (david.juhasz@tuwien.ac.at)
+ *
+ * This implementation is based on the squashed_int implementation of CAF.
+ * TODO: Check license.
+ *
+ ******************************************************************************/
+
+#ifndef ROSA_SUPPORT_SQUASHED_INT_HPP
+#define ROSA_SUPPORT_SQUASHED_INT_HPP
+
+#include "rosa/support/type_list.hpp"
+#include "rosa/support/type_pair.hpp"
+
+namespace rosa {
+
+// Compile-time list of integer types.
+// NOTE: This list is used to select a proper type as type_nr_t,
+// always make sure that type_nr_t remains correct whenever changing the list.
+using IntegerTypesBySize = TypeList< // bytes
+    unit_t,                          // 0
+    TypePair<int8_t, uint8_t>,       // 1
+    TypePair<int16_t, uint16_t>,     // 2
+    unit_t,                          // 3
+    TypePair<int32_t, uint32_t>,     // 4
+    unit_t,                          // 5
+    unit_t,                          // 6
+    unit_t,                          // 7
+    TypePair<int64_t, uint64_t>      // 8
+    >;
+
+// Squashes integer types into [u]int_[8|16|32|64]_t equivalents.
+template <class T> struct SquashedInt {
+  using TPair = typename TypeListAt<IntegerTypesBySize, sizeof(T)>::Type;
+  using Type =
+      typename std::conditional<std::is_signed<T>::value, typename TPair::First,
+                                typename TPair::Second>::type;
+};
+
+// Convenience alias for obtaining a squashed int type.
+template <class T>
+using squashed_int_t = typename SquashedInt<T>::Type;
+
+// Replaces all integral types with their corresponding squashed integer.
+template <typename List> struct SquashedTypeList;
+
+template <> struct SquashedTypeList<EmptyTypeList> {
+  using Type = EmptyTypeList;
+};
+
+template <typename T, typename... Ts>
+struct SquashedTypeList<TypeList<T, Ts...>> {
+  using SquashedT = typename std::conditional<std::is_integral<T>::value,
+                                              squashed_int_t<T>, T>::type;
+  using Type = typename TypeListPush<
+      SquashedT, typename SquashedTypeList<TypeList<Ts...>>::Type>::Type;
+};
+
+} // End namespace rosa
+
+#endif // ROSA_SUPPORT_SQUASHED_INT_HPP
+
diff --git a/include/rosa/support/types.hpp b/include/rosa/support/type_helper.hpp
similarity index 68%
copy from include/rosa/support/types.hpp
copy to include/rosa/support/type_helper.hpp
index 3fe00af..fc55969 100644
--- a/include/rosa/support/types.hpp
+++ b/include/rosa/support/type_helper.hpp
@@ -1,46 +1,50 @@
 /*******************************************************************************
  *
- * File:     types.hpp
+ * File:     type_helper.hpp
  *
- * Contents: Facility for type-related things
+ * Contents: Helper facilities for type-related stuff.
  *
- * Copyright 2016
+ * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
-#ifndef ROSA_SUPPORT_TYPES_HPP
-#define ROSA_SUPPORT_TYPES_HPP
+#ifndef ROSA_SUPPORT_TYPE_HELPER_HPP
+#define ROSA_SUPPORT_TYPE_HELPER_HPP
 
 #include <cstdint>
 
 namespace rosa {
 
+/* ************************************************************************** *
+ *                                 Printable                                  *
+ * ************************************************************************** */
+
 // A value of type [u]int8_t is treated as a character when being put to an
 // output stream, which can result in invisible characters being printed. To
 // avoid that, such a value needs to be casted to a wider type. It can be done
 // by using the following template to find a target type to cast our value to.
 // NOTE: There is a preprocessor macro below which can be used instead of the
 // tedious typename stuff.
 template <typename T>
 struct PrintableType {
   typedef T type;
 };
 
 template <>
 struct PrintableType<uint8_t> {
   typedef unsigned int type;
 };
 
 template <>
 struct PrintableType<int8_t> {
   typedef int type;
 };
 
 #define PRINTABLE(T) typename PrintableType<T>::type
 
 } // End namespace rosa
 
-#endif // ROSA_SUPPORT_TYPES_HPP
+#endif // ROSA_SUPPORT_TYPE_HELPER_HPP
 
diff --git a/include/rosa/support/type_list.hpp b/include/rosa/support/type_list.hpp
new file mode 100644
index 0000000..1afba61
--- /dev/null
+++ b/include/rosa/support/type_list.hpp
@@ -0,0 +1,199 @@
+/*******************************************************************************
+ *
+ * File:     type_list.hpp
+ *
+ * Contents: Facilities for types representing lists of types.
+ *
+ * Copyright 2017
+ *
+ * Author: David Juhasz (david.juhasz@tuwien.ac.at)
+ *
+ * This implementation is partially based on the 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.
+template <typename... Ts> struct TypeList {
+  constexpr TypeList() {
+    // nop
+  }
+};
+
+// Denotes the empty list.
+using EmptyTypeList = TypeList<>;
+
+// Gets element at index Pos of List.
+template <size_t Pos, typename... Ts> struct TypeListAtImpl;
+
+template <size_t Pos, typename T, typename... Ts>
+struct TypeListAtImpl<Pos, T, Ts...> {
+  using Type = typename TypeListAtImpl<Pos - 1, Ts...>::Type;
+};
+
+template <typename T, typename... Ts> struct TypeListAtImpl<0, T, Ts...> {
+  using Type = T;
+};
+
+template <size_t Pos> struct TypeListAtImpl<Pos> { using Type = none_t; };
+
+template <typename List, size_t Pos> struct TypeListAt;
+
+template <size_t Pos, typename... Ts> struct TypeListAt<TypeList<Ts...>, Pos> {
+  using Type = typename TypeListAtImpl<Pos, Ts...>::Type;
+};
+
+// Finds the first element of type What beginning at index Pos.
+template <size_t Pos, typename X, typename... Ts> struct TypeListIndexOfImpl;
+
+template <size_t Pos, typename X> struct TypeListIndexOfImpl<Pos, X> {
+  static constexpr int Value = -1;
+};
+
+template <size_t Pos, typename X, typename... Ts>
+struct TypeListIndexOfImpl<Pos, X, X, Ts...> {
+  static constexpr int Value = Pos;
+};
+
+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;
+};
+
+template <typename List, typename T> struct TypeListIndexOf;
+
+template <typename... Ts, typename T>
+struct TypeListIndexOf<TypeList<Ts...>, T> {
+  static constexpr int Value = TypeListIndexOfImpl<0, T, Ts...>::Value;
+};
+
+// Gets the first element of List.
+template <typename List> struct TypeListHead;
+
+template <> struct TypeListHead<EmptyTypeList> { using Type = none_t; };
+
+template <typename T, typename... Ts>
+struct TypeListHead<TypeList<T, Ts...>> {
+  using Type = T;
+};
+
+// Gets the tail of List.
+template <typename List> struct TypeListTail;
+
+template <> struct TypeListTail<TypeList<>> { using Type = EmptyTypeList; };
+
+template <typename T, typename... Ts>
+struct TypeListTail<TypeList<T, Ts...>> {
+  using Type = TypeList<Ts...>;
+};
+
+// Extends a TypeList with a type, in the front or in the back depending on the
+// order of the template arguments.
+template <typename List, typename T>
+struct TypeListPush;
+
+template <typename... Ts, typename T>
+struct TypeListPush<TypeList<Ts...>, T> {
+  using Type = TypeList<Ts...,T>;
+};
+
+template <typename T, typename... Ts>
+struct TypeListPush<T, TypeList<Ts...>> {
+  using Type = TypeList<T, Ts...>;
+};
+
+// Drops the first N element of List.
+template <size_t N, typename List> struct TypeListDrop;
+
+template <size_t N> struct TypeListDrop<N, EmptyTypeList> {
+  using Type = EmptyTypeList;
+};
+
+template <size_t N, typename T, typename... Ts>
+struct TypeListDrop<N, TypeList<T, Ts...>> {
+  using Type = typename std::conditional<
+      N == 0, TypeList<Ts...>,
+      typename TypeListDrop<N - 1, TypeList<Ts...>>::Type>::type;
+};
+
+// Gets the number of template parameters of List.
+template <typename List>
+struct TypeListSize;
+
+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 list is empty.
+template <typename List> struct TypeListEmpty {
+  static constexpr bool Value = std::is_same<EmptyTypeList, List>::value;
+};
+
+// Tells if List contains type T.
+template <typename List, typename T> struct TypeListContains;
+
+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;
+};
+
+// Tells if ListA is a subset of ListB
+template <typename ListA, typename ListB, bool Fwd = true>
+struct TypeListSubsetOf;
+
+template <typename List>
+struct TypeListSubsetOf<EmptyTypeList, List, true> {
+  static constexpr bool Value = true;
+};
+
+template <typename ListA, typename ListB>
+struct TypeListSubsetOf<ListA, ListB, false> {
+  static constexpr bool Value = false;
+};
+
+template <typename T, typename... Ts, typename List>
+struct TypeListSubsetOf<TypeList<T, Ts...>, List>
+    : TypeListSubsetOf<TypeList<Ts...>, List,
+                       TypeListContains<List, T>::Value> {};
+
+// Finds the first element satisfying Pred
+
+template <template <typename> class Pred, typename... Ts>
+struct TypeListFindImpl;
+
+template <template <typename> class Pred> struct TypeListFindImpl<Pred> {
+  using Type = none_t;
+};
+
+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;
+};
+
+template <typename List, template <typename> class Pred>
+struct TypeListFind;
+
+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_numbers.hpp b/include/rosa/support/type_numbers.hpp
new file mode 100644
index 0000000..f01b5af
--- /dev/null
+++ b/include/rosa/support/type_numbers.hpp
@@ -0,0 +1,155 @@
+/******************************************************************************
+ *
+ * File:     type_numbers.hpp
+ *
+ * Contents: Facilities for registering supported types and representing them
+ *           with numbers.
+ *
+ * Copyright 2017
+ *
+ * Author: David Juhasz (david.juhasz@tuwien.ac.at)
+ *
+ * This implementation is partially based on the type_number implementation of
+ * CAF.
+ * TODO: Check license.
+ *
+ ******************************************************************************/
+
+#ifndef ROSA_SUPPORT_TYPE_NUMBERS_HPP
+#define ROSA_SUPPORT_TYPE_NUMBERS_HPP
+
+#include "rosa/support/atom.hpp"
+#include "rosa/support/math.hpp"
+#include "rosa/support/squashed_int.hpp"
+#include "rosa/support/type_helper.hpp"
+#include "rosa/support/types.hpp"
+#include <array>
+#include <string>
+
+namespace rosa {
+
+// Compile-time list of all built-in types.
+// NOTE: Appending new types to the end of this list maintains backward
+// compatibility in the sense that old builtin types have the same type number
+// associated to them in both the old and new versions. But changing any of
+// the already present types in the list breaks that backward compatibility.
+// Should compatibility be broken, step TypeNumberVersion below!
+// NOTE: Keep this list in sync with the definition of NumberedTypeNames.
+using BuiltinTypes = TypeList<AtomValue,   // atom
+                              int16_t,     // i16
+                              int32_t,     // i32
+                              int64_t,     // i64
+                              int8_t,      // i8
+                              long double, // ldouble
+                              std::string, // str
+                              uint16_t,    // u16
+                              uint32_t,    // u32
+                              uint64_t,    // u64
+                              uint8_t,     // u8
+                              unit_t,      // unit
+                              bool,        // bool
+                              double,      // double
+                              float        // float
+                              >;
+
+// Indicates the version number of BuiltinTypes. Software with the same version
+// number are supposed to have backward compatible type numbering.
+// NOTE: See note above on backward compatiblity of BultinTypes.
+constexpr size_t TypeNumberVersion = 0;
+
+// The number of built-in types.
+static constexpr size_t NumberOfBuiltinTypes =
+    TypeListSize<BuiltinTypes>::Value;
+
+// Anonymous namespace for helper facilities, consider it private.
+namespace {
+
+// Tells if T is not UnitType.
+template <typename T> struct IsNotUnitType {
+  static constexpr bool Value = !std::is_same<T, UnitType>::value;
+};
+
+} // End namespace
+
+// Integer type to store type numbers.
+// NOTE: The narrowest unsigned integer type that is wide enough to represent
+// NumberOfBuiltinTypes different values.
+using type_nr_t =
+    typename TypeListFind<typename TypeListDrop<log2(NumberOfBuiltinTypes) / 8,
+                                                IntegerTypesBySize>::Type,
+                          IsNotUnitType>::Type::Second;
+
+// A type to cast type numbers into in order to output them to streams as
+// numbers and not ASCII-codes.
+// NOTE: Use it for safety, necessary for printing uint8_t values.
+using printable_tn_t = PRINTABLE(type_nr_t);
+
+// Helper preprocessor macro to cast type numbers into printable_tn_t.
+#define PRINTABLE_TN(N) static_cast<printable_tn_t>(N)
+
+// Computes the type number for T.
+// NOTE: TypeNumber is the index of T in BuiltinTypes starting from 1,
+// index 0 indicates a non-builtin type.
+template <typename T, bool IsIntegral = std::is_integral<T>::value>
+struct TypeNumber {
+  static constexpr type_nr_t Value =
+      static_cast<type_nr_t>(TypeListIndexOf<BuiltinTypes, T>::Value + 1);
+};
+
+template <typename T> struct TypeNumber<T, true> {
+  using Type = squashed_int_t<T>;
+
+  static constexpr type_nr_t Value =
+      static_cast<type_nr_t>(TypeListIndexOf<BuiltinTypes, Type>::Value + 1);
+};
+
+template <> struct TypeNumber<bool, true> {
+  static constexpr type_nr_t Value =
+      static_cast<type_nr_t>(TypeListIndexOf<BuiltinTypes, bool>::Value + 1);
+};
+
+template <AtomValue V> struct TypeNumber<AtomConstant<V>, false> {
+  static constexpr type_nr_t Value = TypeNumber<AtomValue>::Value;
+};
+
+// List of all type names, indexed via TypeNumber.
+// NOTE: Keep this definition in sync with BuiltinTypes.
+constexpr std::array<const char *, NumberOfBuiltinTypes> NumberedTypeNames {{
+  "atom",
+  "i16",
+  "i32",
+  "i64",
+  "i8",
+  "ldouble",
+  "str",
+  "u16",
+  "u32",
+  "u64",
+  "u8",
+  "unit",
+  "bool",
+  "double",
+  "float"
+}};
+
+// Tells if the given TypeNumber is valid in the software.
+// NOTE: A type number generated by an incompatible version may be valid but
+// supposed to denote a type different than that in the current software.
+constexpr bool validTypeNumber(const type_nr_t TypeNumber) {
+  return 0 < TypeNumber && TypeNumber <= NumberOfBuiltinTypes;
+}
+
+// Computes the corresponding builtin type with some information from a type
+// number.
+// PRE: validTypeNumber(TypeNumber)
+template <type_nr_t TypeNumber> struct TypeForNumber {
+  STATIC_ASSERT(validTypeNumber(TypeNumber), "not a valid type number");
+  using Type = typename TypeListAt<BuiltinTypes, TypeNumber - 1>::Type;
+  static constexpr size_t Size = sizeof(Type);
+  static constexpr const char *Name = NumberedTypeNames[TypeNumber - 1];
+};
+
+} // End namespace rosa
+
+#endif // ROSA_SUPPORT_TYPE_NUMBERS_HPP
+
diff --git a/include/rosa/support/type_pair.hpp b/include/rosa/support/type_pair.hpp
new file mode 100644
index 0000000..3bfff8c
--- /dev/null
+++ b/include/rosa/support/type_pair.hpp
@@ -0,0 +1,35 @@
+/******************************************************************************
+ *
+ * File:     type_pair.hpp
+ *
+ * Contents: Facilities for types representing pairs of types.
+ *
+ * Copyright 2017
+ *
+ * Author: David Juhasz (david.juhasz@tuwien.ac.at)
+ *
+ * This implementation is based on the type_pair implementation of CAF.
+ * TODO: Check license.
+ *
+ ******************************************************************************/
+
+#ifndef ROSA_SUPPORT_TYPE_PAIR_HPP
+#define ROSA_SUPPORT_TYPE_PAIR_HPP
+
+namespace rosa {
+
+template <typename F, typename S>
+struct TypePair {
+  using First = F;
+  using Second = S;
+};
+
+template <typename F, typename S>
+struct ToTypePair {
+  using Type = TypePair<F, S>;
+};
+
+} // End namespace rosa
+
+#endif // ROSA_SUPPORT_TYPE_PAIR_HPP
+
diff --git a/include/rosa/support/type_token.hpp b/include/rosa/support/type_token.hpp
new file mode 100644
index 0000000..6d6046e
--- /dev/null
+++ b/include/rosa/support/type_token.hpp
@@ -0,0 +1,154 @@
+/******************************************************************************
+ *
+ * File:     type_token.hpp
+ *
+ * Contents: Facilities for encoding TypeLists as unsigned integer values.
+ *
+ * Copyright 2017
+ *
+ * Author: David Juhasz (david.juhasz@tuwien.ac.at)
+ *
+ ******************************************************************************/
+
+#ifndef ROSA_SUPPORT_TYPE_TOKEN_HPP
+#define ROSA_SUPPORT_TYPE_TOKEN_HPP
+
+#include "rosa/support/type_numbers.hpp"
+
+namespace rosa {
+
+// NOTE on compatibility between different versions of the type token
+// implementation:
+// Different software versions produce compatible type tokens as long as
+// backward compatibility of BuiltinTypes is maintained (denoted by
+// TypeNumberVersion, see a note on that) and the type token implementation
+// uses the same type as token_t (boiling down to the same token::TokenBits
+// value) and the same 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.
+
+// 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 token_t.
+using token_t = uint64_t;
+
+// Sanity check in case someone would change token_t.
+STATIC_ASSERT(std::is_unsigned<token_t>::value,
+              "token_t is not an unsigned integer");
+
+// 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 uint8_t values.
+using printable_token_t = PRINTABLE(token_t);
+
+// Helper preprocessor macro to cast tokens into printable_token_t.
+#define PRINTABLE_TOKEN(T) static_cast<printable_token_t>(T)
+
+// Nested namespace for protecting constants related to type tokens.
+namespace token {
+
+// The number of bits in one token.
+constexpr size_t TokenBits = sizeof(token_t) * 8;
+
+// The number of bits a builtin type can be uniquely encoded into, that is any
+// valid 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 BuiltinTypes is
+// extended.
+constexpr size_t RepresentationBits = log2(NumberOfBuiltinTypes) + 1;
+
+// Maximal size of uniquely tokenizable TypeList.
+constexpr size_t MaxTokenizableListSize = TokenBits / RepresentationBits;
+
+} // End namespace token
+
+// Generates a token, unsigned integer representation, for the TypeList.
+// NOTE: The TypeList cannot have more than MaxTokenizableListSize elements and
+// must be a subset of BuiltinTypes with respect to squashed integers.
+// NOTE: A generated token uniquely represents a list of types, except for
+// AtomConstant types. Observe that any AtomConstant is encoded as the type
+// AtomValue. The type information on all separate AtomConstant types are lost
+// and replaced by the AtomValue type whose actual value needs to be considered
+// in order to obtain the original AtomConstant type and so the full type
+// information on the encoded TypeList.
+template <typename List> struct TypeListTokenImpl;
+
+template <> struct TypeListTokenImpl<EmptyTypeList> {
+  static constexpr token_t Token = 0;
+};
+
+template <typename T, typename... Ts>
+struct TypeListTokenImpl<TypeList<T, Ts...>> {
+  static constexpr token_t Token =
+      (TypeListTokenImpl<TypeList<Ts...>>::Token << token::RepresentationBits) |
+      TypeNumber<T>::Value;
+};
+
+template <typename List> struct TypeListToken;
+
+template <typename... Ts> struct TypeListToken<TypeList<Ts...>> {
+  // NOTE: TypeNumber is computed against squased_int_t for integral types, so
+  // let's do the same here.
+  using List = typename SquashedTypeList<TypeList<Ts...>>::Type;
+  STATIC_ASSERT((TypeListSize<List>::Value <= token::MaxTokenizableListSize &&
+                 TypeListSubsetOf<List, BuiltinTypes>::Value),
+                "not a valid list of types");
+  static constexpr token_t Token = TypeListTokenImpl<List>::Token;
+};
+
+// Convenience template turning a list of types into a TypeList to generate
+// TypeListToken for it.
+template <typename... Ts> using TypeToken = TypeListToken<TypeList<Ts...>>;
+
+// Anonymous namespace with helper facilities, consider it private.
+namespace {
+
+// Extracts the type number of the first encoded type of Token.
+// NOTE: The returned type number is not validated.
+inline type_nr_t typeNumberOfHeadOfToken(const token_t Token) {
+  return static_cast<type_nr_t>(Token & ((1 << token::RepresentationBits) - 1));
+}
+
+} // End namespace
+
+
+// Tells if the given Token is valid, can be decoded by the current software.
+// NOTE: Validation gives a correct result only when Token was generated by a
+// compatible software (see note above).
+bool validToken(const token_t Token);
+
+// Tells if the token does encode an empty list.
+bool emptyToken(const token_t Token);
+
+// Tells the full memory size of the list encoded in the token.
+// PRE: validToken(Token)
+size_t sizeOfToken(const token_t Token);
+
+// Tells the memory size of the first type encoded in the token.
+// PRE: !empty(Token) && validToken(Token)
+size_t sizeOfHeadOfToken(const token_t Token);
+
+// Tells the name of the first type encoded in the token.
+// PRE: !empty(Token) && validToken(Token)
+const char *nameOfHeadOfToken(const token_t Token);
+
+// Drops the head element of the encoded list.
+void dropHeadOfToken(token_t &Token);
+
+// Tells if the head of the encoded list is of type T.
+// PRE: !empty(Token) && validToken(Token)
+template <typename T>
+bool isHeadOfTokenTheSameType(const token_t Token) {
+  ASSERT(!emptyToken(Token) && validToken(Token));
+  return TypeNumber<T>::Value == typeNumberOfHeadOfToken(Token);
+}
+
+} // End namespace rosa
+
+#endif // ROSA_SUPPORT_TYPE_TOKEN_HPP
+
diff --git a/include/rosa/support/types.hpp b/include/rosa/support/types.hpp
index 3fe00af..2aa6a0e 100644
--- a/include/rosa/support/types.hpp
+++ b/include/rosa/support/types.hpp
@@ -1,46 +1,313 @@
 /*******************************************************************************
  *
  * File:     types.hpp
  *
- * Contents: Facility for type-related things
+ * Contents: Implementation of some basic convenience types.
  *
- * Copyright 2016
+ * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
+ * This implementation is partially based on the implementation of
+ * corresponding parts of CAF.
+ * TODO: Check license.
+ *
  ******************************************************************************/
 
 #ifndef ROSA_SUPPORT_TYPES_HPP
 #define ROSA_SUPPORT_TYPES_HPP
 
-#include <cstdint>
+#include "rosa/support/debug.hpp"
+#include <string>
 
 namespace rosa {
 
-// A value of type [u]int8_t is treated as a character when being put to an
-// output stream, which can result in invisible characters being printed. To
-// avoid that, such a value needs to be casted to a wider type. It can be done
-// by using the following template to find a target type to cast our value to.
-// NOTE: There is a preprocessor macro below which can be used instead of the
-// tedious typename stuff.
-template <typename T>
-struct PrintableType {
-  typedef T type;
+/* ************************************************************************** *
+ *                                   Unit                                     *
+ * ************************************************************************** */
+
+// Unit is analogous to void, but can be safely returned, stored, etc.
+// to enable higher-order abstraction without cluttering code with
+// exceptions for void (which can't be stored, for example).
+struct UnitType {
+  constexpr UnitType() noexcept {
+    // nop
+  }
+
+  constexpr UnitType(const UnitType &) noexcept {
+    // nop
+  }
+
+  template <class T> explicit constexpr UnitType(T &&) noexcept {
+    // nop
+  }
+
+  template <class... Ts>
+  constexpr UnitType operator()(Ts &&...) const noexcept {
+    return {};
+  }
 };
 
-template <>
-struct PrintableType<uint8_t> {
-  typedef unsigned int type;
+using unit_t = UnitType;
+
+static constexpr unit_t unit = unit_t{}; // NOLINT
+
+inline std::string to_string(const unit_t &) { return "unit"; }
+
+template <typename T> struct LiftVoid { using Type = T; };
+
+template <> struct LiftVoid<void> { using Type = unit_t; };
+
+template <typename T> struct UnliftVoid { using Type = T; };
+
+template <> struct UnliftVoid<unit_t> { using Type = void; };
+
+/* ************************************************************************** *
+ *                                   None                                     *
+ * ************************************************************************** */
+
+// Represents "nothing", e.g., for clearing an Optional by assigning none.
+struct NoneType {
+  constexpr NoneType() {
+    // nop
+  }
+  constexpr explicit operator bool() const { return false; }
 };
 
-template <>
-struct PrintableType<int8_t> {
-  typedef int type;
+using none_t = NoneType;
+
+static constexpr none_t none = none_t{}; // NOLINT
+
+inline std::string to_string(const none_t &) { return "none"; }
+
+/* ************************************************************************** *
+ *                                 Optional                                   *
+ * ************************************************************************** */
+
+// A C++17 compatible optional implementation.
+template <class T> class Optional {
+public:
+  using Type = T;
+
+  // Creates an instance without value.
+  Optional(const none_t & = none) : Valid(false) {
+    // nop
+  }
+
+  // Creates an valid instance from value.
+  template <class U, class E = typename std::enable_if<
+                         std::is_convertible<U, T>::value>::type>
+  Optional(U X) : Valid(false) {
+    cr(std::move(X));
+  }
+
+  Optional(const Optional &Other) : Valid(false) {
+    if (Other.Valid) {
+      cr(Other.Value);
+    }
+  }
+
+  Optional(Optional &&Other) noexcept(
+      std::is_nothrow_move_constructible<T>::value)
+      : Valid(false) {
+    if (Other.Valid) {
+      cr(std::move(Other.Value));
+    }
+  }
+
+  ~Optional() { destroy(); }
+
+  Optional &operator=(const Optional &Other) {
+    if (Valid) {
+      if (Other.Valid) {
+        Value = Other.Value;
+      } else {
+        destroy();
+      }
+    } else if (Other.Valid) {
+      cr(Other.Value);
+    }
+    return *this;
+  }
+
+  Optional &operator=(Optional &&Other) noexcept(
+      std::is_nothrow_destructible<T>::value
+          &&std::is_nothrow_move_assignable<T>::value) {
+    if (Valid) {
+      if (Other.Valid) {
+        Value = std::move(Other.Value);
+      } else {
+        destroy();
+      }
+    } else if (Other.Valid) {
+      cr(std::move(Other.Value));
+    }
+    return *this;
+  }
+
+  // Checks whether this object contains a value.
+  explicit operator bool() const { return Valid; }
+
+  // Checks whether this object does not contain a value.
+  bool operator!() const { return !Valid; }
+
+  // Returns the value.
+  // PRE: Valid
+  T &operator*() {
+    ASSERT(Valid);
+    return Value;
+  }
+
+  // Returns the value.
+  // PRE: Valid
+  const T &operator*() const {
+    ASSERT(Valid);
+    return Value;
+  }
+
+  // Returns the value.
+  // PRE: Valid
+  const T *operator->() const {
+    ASSERT(Valid);
+    return &Value;
+  }
+
+  // Returns the value.
+  // PRE: Valid
+  T *operator->() {
+    ASSERT(Valid);
+    return &Value;
+  }
+
+  // Returns the value.
+  // PRE: Valid
+  T &value() {
+    ASSERT(Valid);
+    return Value;
+  }
+
+  // Returns the value.
+  // PRE: Valid
+  const T &value() const {
+    ASSERT(Valid);
+    return Value;
+  }
+
+  // Returns the value if Valid, otherwise returns DefaultValue.
+  const T &valueOr(const T &DefaultValue) const {
+    return Valid ? Value() : DefaultValue;
+  }
+
+private:
+  void destroy() {
+    if (Valid) {
+      Value.~T();
+      Valid = false;
+    }
+  }
+
+  template <class V> void cr(V &&X) {
+    ASSERT(!Valid);
+    Valid = true;
+    new (&Value) T(std::forward<V>(X));
+  }
+
+  bool Valid;
+  union {
+    T Value;
+  };
+};
+
+// Template specialization to allow Optional to hold a reference
+// rather than an actual value with minimal overhead.
+template <typename T> class Optional<T &> {
+public:
+  using Type = T;
+
+  Optional(const none_t & = none) : Value(nullptr) {
+    // nop
+  }
+
+  Optional(T &X) : Value(&X) {
+    // nop
+  }
+
+  Optional(T *X) : Value(X) {
+    // nop
+  }
+
+  Optional(const Optional &Other) = default;
+
+  Optional &operator=(const Optional &Other) = default;
+
+  explicit operator bool() const { return Value != nullptr; }
+
+  bool operator!() const { return !Value; }
+
+  T &operator*() {
+    ASSERT(Value);
+    return *Value;
+  }
+
+  const T &operator*() const {
+    ASSERT(Value);
+    return *Value;
+  }
+
+  T *operator->() {
+    ASSERT(Value);
+    return Value;
+  }
+
+  const T *operator->() const {
+    ASSERT(Value);
+    return Value;
+  }
+
+  T &value() {
+    ASSERT(Value);
+    return *Value;
+  }
+
+  const T &value() const {
+    ASSERT(Value);
+    return *Value;
+  }
+
+  const T &valueOr(const T &DefaultValue) const {
+    return Value ? Value() : DefaultValue;
+  }
+
+private:
+  T *Value;
 };
 
-#define PRINTABLE(T) typename PrintableType<T>::type
+// Template specialization to allow Optional to implement a flag for void.
+template <> class Optional<void> {
+public:
+  using Type = unit_t;
+
+  Optional(none_t = none) : Value(false) {
+    // nop
+  }
+
+  Optional(unit_t) : Value(true) {
+    // nop
+  }
+
+  Optional(const Optional &Other) = default;
+
+  Optional &operator=(const Optional &Other) = default;
+
+  explicit operator bool() const { return Value; }
+
+  bool operator!() const { return !Value; }
+
+private:
+  bool Value;
+};
 
 } // End namespace rosa
 
 #endif // ROSA_SUPPORT_TYPES_HPP
 
diff --git a/lib/support/CMakeLists.txt b/lib/support/CMakeLists.txt
index b698397..d7448ea 100644
--- a/lib/support/CMakeLists.txt
+++ b/lib/support/CMakeLists.txt
@@ -1,7 +1,8 @@
 add_library(ROSASupport
   debug.cpp
   terminal_colors.cpp
   log.cpp
   atom.cpp
+  type_token.cpp
   )
 
diff --git a/lib/support/atom.cpp b/lib/support/atom.cpp
index 8e5a933..968aacc 100644
--- a/lib/support/atom.cpp
+++ b/lib/support/atom.cpp
@@ -1,50 +1,50 @@
 /*******************************************************************************
  *
  * File:     atom.cpp
  *
  * Contents: Implementation of non-static part of atom facilities.
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
- * This implementation is based on the Atom implementation of CAF.
+ * This implementation is based on the atom implementation of CAF.
  * TODO: Check license.
  *
  ******************************************************************************/
 
 #include "rosa/support/atom.hpp"
 #include <cstring>
 
 namespace rosa {
 
 std::string to_string(const AtomValue &What) {
   auto X = static_cast<atom_t>(What);
   std::string S;
   S.reserve(MaxAtomLength + 1);
   // Don't read characters before we found the leading 0xF.
   // First four bits set?
   bool ReadChars = ((X & 0xF000000000000000) >> 60) == 0xF;
   uint64_t Mask = 0x0FC0000000000000;
   for (int BitShift = 54; BitShift >= 0; BitShift -= 6, Mask >>= 6) {
     if (ReadChars) {
       S += AtomDecodingTable[(X & Mask) >> BitShift];
     } else if (((X & Mask) >> BitShift) == 0xF) {
       ReadChars = true;
     }
   }
   return S;
 }
 
 AtomValue atom_from_string(const std::string &S) {
   if (S.size() > MaxAtomLength) {
     return atom("");
   }
   char AtomBuf[MaxAtomLength + 1];
   std::memcpy(AtomBuf, S.c_str(), S.size());
   AtomBuf[S.size()] = '\0';
   return atom(AtomBuf);
 }
 
 } // End namespace rosa
 
diff --git a/lib/support/type_token.cpp b/lib/support/type_token.cpp
new file mode 100644
index 0000000..8fbd0d8
--- /dev/null
+++ b/lib/support/type_token.cpp
@@ -0,0 +1,112 @@
+/******************************************************************************
+ *
+ * File:     type_token.cpp
+ *
+ * Contents: Runtime part of type token handling.
+ *
+ * Copyright 2017
+ *
+ * Author: David Juhasz (david.juhasz@tuwien.ac.at)
+ *
+ ******************************************************************************/
+
+#include "rosa/support/type_token.hpp"
+
+// FIXME: Automatically generate a proper number of cases for the functions
+// with a big number of mechanical cases in them below.
+
+namespace rosa {
+
+using namespace token;
+
+bool validToken(const token_t Token) {
+  token_t T = Token;
+  bool Valid = true;
+  while (Valid && !emptyToken(T)) {
+    Valid &= validTypeNumber(typeNumberOfHeadOfToken(T));
+    dropHeadOfToken(T);
+  }
+  return Valid;
+}
+
+bool emptyToken(const token_t Token) { return Token == 0; }
+
+size_t sizeOfToken(const token_t Token) {
+  ASSERT(validToken(Token));
+  token_t T = Token;
+  size_t S = 0;
+  while (!emptyToken(T)) {
+    S += sizeOfHeadOfToken(T);
+    dropHeadOfToken(T);
+  }
+  return S;
+}
+
+#define SIZECASE(N)                                                            \
+  {                                                                            \
+  case N:                                                                      \
+    return TypeForNumber<N>::Size;                                             \
+  }
+
+size_t sizeOfHeadOfToken(const token_t Token) {
+  ASSERT(!emptyToken(Token) && validToken(Token));
+  switch (typeNumberOfHeadOfToken(Token)) {
+  default: {
+    // Should never come here when Token is valid and the case-list
+    // below covers BuiltinTypes.
+    ROSA_CRITICAL("unknown type number");
+  }
+    SIZECASE(1);
+    SIZECASE(2);
+    SIZECASE(3);
+    SIZECASE(4);
+    SIZECASE(5);
+    SIZECASE(6);
+    SIZECASE(7);
+    SIZECASE(8);
+    SIZECASE(9);
+    SIZECASE(10);
+    SIZECASE(11);
+    SIZECASE(12);
+    SIZECASE(13);
+    SIZECASE(14);
+    SIZECASE(15);
+  }
+}
+
+#define NAMECASE(N)                                                            \
+  {                                                                            \
+  case N:                                                                      \
+    return TypeForNumber<N>::Name;                                             \
+  }
+
+const char *nameOfHeadOfToken(const token_t Token) {
+  ASSERT(!emptyToken(Token) && validToken(Token));
+  switch (typeNumberOfHeadOfToken(Token)) {
+  default: {
+    // Should never come here when Token is valid and the case-list
+    // below covers BuiltinTypes.
+    ROSA_CRITICAL("unknown type number");
+  }
+    NAMECASE(1);
+    NAMECASE(2);
+    NAMECASE(3);
+    NAMECASE(4);
+    NAMECASE(5);
+    NAMECASE(6);
+    NAMECASE(7);
+    NAMECASE(8);
+    NAMECASE(9);
+    NAMECASE(10);
+    NAMECASE(11);
+    NAMECASE(12);
+    NAMECASE(13);
+    NAMECASE(14);
+    NAMECASE(15);
+  }
+}
+
+void dropHeadOfToken(token_t &Token) { Token >>= RepresentationBits; }
+
+} // End namespace rosa
+