diff --git a/examples/basic-system/basic-system.cpp b/examples/basic-system/basic-system.cpp
index 06fe52a..1938e47 100644
--- a/examples/basic-system/basic-system.cpp
+++ b/examples/basic-system/basic-system.cpp
@@ -1,66 +1,69 @@
 /*******************************************************************************
  *
  * File:     basic-system.cpp
  *
  * Contents: A simple example on the basic System and Unit classes of the RoSA
  *           Core library.
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
 #include "rosa/config/version.h"
+
 #include "rosa/core/Unit.h"
 #include "rosa/core/System.hpp"
+
 #include "rosa/support/log.h"
 #include "rosa/support/terminal_colors.h"
+
 #include <iostream>
 
 using namespace rosa;
 using namespace rosa::terminal;
 
 // A dummy wrapper for testing System.
 // NOTE: Since we test System directly here, we need to get access to its
 // protected members. That we do by imitating to be a decent subclass of
 // System, while calling protected member functions on an object of a type from
 // which we actually don't inherit.
 struct SystemTester : protected System {
   static constexpr AtomValue UnitKind = atom("unit");
 
   static Unit &createMyUnit(System *S,
                             const std::string &Name = std::string()) {
     return ((SystemTester *)S)
         ->createUnit<Unit>([&Name](const size_t Id, System &S) noexcept {
           // NOTE: If Name is empty, construct a name with the number of the
           // Unit being created right now.
           const std::string N(
               Name.empty()
                   ? "Unit_" + std::to_string(S.numberOfConstructedUnits())
                   : Name);
           return new Unit(UnitKind, Id, N, S);
         });
   }
 
   static void destroyMyUnit(System *S, Unit &U) {
     ((SystemTester *)S)->destroyUnit(U);
   }
 };
 
 int main(void) {
   LOG_INFO_STREAM << library_string() << " -- " << Color::Red
                   << "simple example" << Color::Default << std::endl;
 
   std::unique_ptr<System> S = System::createSystem("Sys");
   System *SP = S.get();
   Unit &Unit1 = SystemTester::createMyUnit(SP),
        &Unit2 = SystemTester::createMyUnit(SP, "Second"),
        &Unit3 = SystemTester::createMyUnit(SP);
   SystemTester::destroyMyUnit(SP, Unit1);
   SystemTester::destroyMyUnit(SP, Unit3);
   LOG_INFO_STREAM << "Dumping Unit2" << std::endl << Unit2 << std::endl;
   SystemTester::destroyMyUnit(SP, Unit2);
   return 0;
 }
 
diff --git a/examples/messaging/messaging.cpp b/examples/messaging/messaging.cpp
index cd4f1e6..4ba3fb5 100644
--- a/examples/messaging/messaging.cpp
+++ b/examples/messaging/messaging.cpp
@@ -1,140 +1,143 @@
 /*******************************************************************************
  *
  * File:     messaging.cpp
  *
  * Contents: An example showcasing features related to Messages.
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
 #include "rosa/config/version.h"
+
 #include "rosa/core/MessageHandler.hpp"
+
 #include "rosa/support/log.h"
 #include "rosa/support/terminal_colors.h"
+
 #include <iostream>
 
 using namespace rosa;
 using namespace rosa::terminal;
 
 int main(void) {
   LOG_INFO_STREAM << library_string() << " -- " << Color::Red
                   << "messaging" << Color::Default << std::endl;
 
   auto &Log = LOG_INFO_STREAM << std::endl;
 
   // Message interface.
   auto PMsg = Message::create<uint8_t, uint16_t>(1, 2);
   auto &Msg = *PMsg;
   Log << "Checking on a 'Message with TypeList<<uint8_t, uint16_t>>':"
       << std::endl
       << "  Size: " << Msg.Size << std::endl
       << "  Pos 0 is uint8_t: " << Msg.isTypeAt<uint8_t>(0) << std::endl
       << "  Pos 1 is uint16_t: " << Msg.isTypeAt<uint16_t>(1) << std::endl
       << "  Pos 2 is uint32_t: " << Msg.isTypeAt<uint32_t>(1) << std::endl
       << "  Value at pos 0: " << PRINTABLE(uint8_t)(Msg.valueAt<uint8_t>(0))
       << std::endl
       << "  Value at pos 1: " << Msg.valueAt<uint16_t>(1) << std::endl
       << std::endl;
 
   // MessageMatcher.
   using MyMatcher = MsgMatcher<uint8_t, uint16_t>;
   Log << "Matching against 'TypeList<uint8_t, uint16_t>':" << std::endl
       << "  matching: " << MyMatcher::doesStronglyMatch(Msg) << std::endl;
   auto Vs = MyMatcher::extractedValues(Msg);
   Log << "  value: '(" << PRINTABLE(uint8_t)(std::get<0>(Vs)) << ", "
       << std::get<1>(Vs) << ")'" << std::endl
       << std::endl;
 
   using MyWrongMatcher = MsgMatcher<uint8_t, uint8_t>;
   Log << "Matching against 'TypeList<uint8_t, uint8_t>':" << std::endl
       << "  matching: " << MyWrongMatcher::doesStronglyMatch(Msg) << std::endl
       << std::endl;
 
   using MyAtom = AtomConstant<atom("atom")>;
   const MyAtom &A = MyAtom::Value;
   using MyNAtom = AtomConstant<atom("noatom")>;
   auto PAMsg = Message::create(A);
   auto &AMsg = *PAMsg;
   Log << "Checking on a 'Message with TypeList<AtomConstant<atom(\"atom\")>>':"
       << std::endl
       << "  Size: " << AMsg.Size << std::endl
       << "  Pos 0 is 'AtomValue': " << AMsg.isTypeAt<AtomValue>(0) << std::endl
       << "  Pos 0 is 'AtomConstant<atom(\"noatom\")>': "
       << AMsg.isTypeAt<MyNAtom>(0) << std::endl
       << std::endl;
 
   using MyAtomMatcher = MsgMatcher<MyAtom>;
   Log << "Matching against 'TypeList<AtomConstant<atom(\"atom\")>>':"
       << std::endl
       << "  matching: " << MyAtomMatcher::doesStronglyMatch(AMsg) << std::endl
       << "  value: '("
       << to_string(std::get<0>(MyAtomMatcher::extractedValues(AMsg))) << ")'"
       << std::endl
       << std::endl;
 
   using MyWrongAtomMatcher = MsgMatcher<MyNAtom>;
   Log << "Matching against 'TypeList<AtomConstant<atom(\"noatom\")>>':"
       << std::endl
       << "  matching: " << MyWrongAtomMatcher::doesStronglyMatch(AMsg)
       << std::endl
       << std::endl;
 
   // Invoker.
   auto IP = Invoker::wrap(Invoker::F<MyAtom>([&Log](MyAtom) noexcept->void {
     Log << "** Handling 'Message with TypeList<AtomConstant<atom(\"atom\")>>'."
         << std::endl;
   }));
   auto &I = *IP; // Get a reference from the pointer.
   Log << "Invoking a function of signature 'void(AtomConstant<atom(\"atom\")>) "
          "noexcept':"
       << std::endl
       << "  with 'Message with TypeList<uint8_t, uint16_t>'" << std::endl
       << "    does Message match Invoker: " << I.match(Msg) << std::endl
       << "    invoking..." << std::endl;
   I(Msg);
   Log << "  with 'Message with TypeList<AtomConstant<atom(\"atom\")>>'..."
       << std::endl
       << "    does Message match Invoker: " << I.match(AMsg) << std::endl
       << "    invoking..." << std::endl;
   I(AMsg);
   Log << std::endl;
 
   // MessageHandler.
   MessageHandler Handler{
       Invoker::F<uint8_t, uint16_t>([&Log](uint8_t, uint16_t) {
         Log << "** Handling 'Message with TypeList<uint8_t, uint16_t>'"
             << std::endl;
       }),
       Invoker::F<MyAtom>([&Log](MyAtom) {
         Log << "** Handling 'Message with "
                "TypeList<AtomConstant<atom(\"atom\")>>'" << std::endl;
       })};
   auto PANMsg = Message::create(MyNAtom::Value);
   auto &ANMsg = *PANMsg;
   Log << "Handling Messages with 'MessageHandler "
          "{ Invoker::F<uint8_t, uint16_t>, "
          "Invoker::F<AtomConstant<atom(\"atom\")>> }':"
       << std::endl
       << "  'Message with TypeList<uint8_t, uint16_t>'" << std::endl
       << "    can handle: " << Handler.canHandle(Msg) << std::endl
       << "    handling..." << std::endl;
   Handler(Msg);
   Log << "  'Message with TypeList<AtomConstant<atom(\"atom\")>>'" << std::endl
       << "    can handle: " << Handler.canHandle(AMsg) << std::endl
       << "    handling..." << std::endl;
   Handler(AMsg);
   Log << "  'Message with TypeList<AtomConstant<atom(\"noatom\")>>'"
       << std::endl
       << "    can handle: " << Handler.canHandle(ANMsg) << std::endl
       << "    handling..." << std::endl;
   Handler(ANMsg);
   Log << std::endl;
 
   Log << "Terminating, destroying automatic variables." << std::endl;
 
   return 0;
 }
 
diff --git a/examples/type-facilities/type-facilities.cpp b/examples/type-facilities/type-facilities.cpp
index 9d1a552..26b321c 100644
--- a/examples/type-facilities/type-facilities.cpp
+++ b/examples/type-facilities/type-facilities.cpp
@@ -1,86 +1,88 @@
 /*******************************************************************************
  *
  * 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 TypeNumber TN = TypeNumberOf<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 number information of AtomConstants:"
       << std::endl;
   using Atom1 = AtomConstant<atom("atom1")>;
   using Atom2 = AtomConstant<atom("atom2")>;
   Log << "  std::is_same<Atom1, Atom2>::value: "
       << std::is_same<Atom1, Atom2>::value << std::endl
       << "  TypeNumberOf<Atom1>::Value: "
       << PRINTABLE_TN(TypeNumberOf<Atom1>::Value) << std::endl
       << "  TypeNumberOf<Atom2>::Value: "
       << PRINTABLE_TN(TypeNumberOf<Atom2>::Value) << std::endl
       << "  name: " << TypeForNumber<TypeNumberOf<Atom1>::Value>::Name
       << std::endl
       << std::endl;
 
   Log << "Type token information on 'TypeList<uint8_t, uint16_t>':"
       << std::endl;
   // Token is generated statically.
   constexpr Token T = TypeToken<uint8_t, uint16_t>::Value;
   STATIC_ASSERT((T == TypeListToken<TypeList<uint8_t, uint16_t>>::Value),
                 "alias template definition is wrong");
   Token T_ = T; // 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
         << "  length: " << lengthOfToken(T_) << std::endl
         << "  full size: " << sizeOfValuesOfToken(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;
 }