diff --git a/examples/messaging/messaging.cpp b/examples/messaging/messaging.cpp
index 7c99255..92cc1b3 100644
--- a/examples/messaging/messaging.cpp
+++ b/examples/messaging/messaging.cpp
@@ -1,139 +1,136 @@
 /*******************************************************************************
  *
  * 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/Invoker.hpp"
 #include "rosa/support/log.h"
 #include "rosa/support/terminal_colors.h"
 #include <iostream>
 
 using namespace rosa;
 using namespace rosa::terminal;
 
 // A simple implementation of the Message interface with two hardcoded types.
 class MyMessage : public Message {
   const uint8_t U8;   // First value
   const uint16_t U16; // Second value
 public:
   MyMessage(const uint8_t U8, const uint16_t U16)
       : Message(U8, U16), U8(U8), U16(U16) {}
 
   const void *getPointerTo(const size_t Pos) const noexcept override {
     switch (Pos) {
     default:
       ROSA_CRITICAL("wrong position");
     case 0:
       return &U8;
     case 1:
       return &U16;
     }
   }
 };
 
 class MyAtomMessage : public Message {
   const AtomValue A; // First value
 public:
   template <AtomValue V>
   MyAtomMessage(AtomConstant<V> C) : Message(C), A(V) {}
 
   const void *getPointerTo(const size_t Pos) const noexcept override {
     switch (Pos) {
     default:
       ROSA_CRITICAL("wrong position");
     case 0:
       return &A;
     }
   }
 };
 
 int main(void) {
   LOG_INFO_STREAM << library_string() << " -- " << Color::Red
                   << "messaging" << Color::Default << std::endl;
 
   auto &Log = LOG_TRACE_STREAM << std::endl;
 
   MyMessage Msg(1, 2);
   Log << "Checking on 'MyMessage(1, 2)' that is of '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.getValueAt<uint8_t>(0))
       << std::endl
       << "  Value at pos 1: " << Msg.getValueAt<uint16_t>(1) << std::endl
       << std::endl;
 
   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")>;
   MyAtomMessage AMsg(A);
   Log << "Checking on 'MyAtomMessage(AtomConstant<atom(\"atom\")>::Value)' "
          "that is of '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;
 
-  // FIXME: Is this a compiler bug,
-  // cannot use Invoker::wrap<MyAtom>([&](MyAtom)...  ???
-  auto WrapFix = Invoker::wrap<MyAtom>;
-  auto IP = WrapFix([&Log](MyAtom) noexcept->void {
+  auto IP = Invoker::wrap(Invoker::F<MyAtom>([&Log](MyAtom) noexcept->void {
     Log << "** Lambda-function called via Invoker." << std::endl;
-  });
+  }));
   auto &I = *IP; // Get a reference from the pointer.
   Log << "Invoking a function of signature 'void(MyAtom) 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<MyAtom>'..." << std::endl
       << "    does Message match Invoker: " << I.match(AMsg) << std::endl
       << "    invoking..." << std::endl;
   I(AMsg);
 
   return 0;
 }
 
diff --git a/include/rosa/core/Invoker.hpp b/include/rosa/core/Invoker.hpp
index 136e998..82ba840 100644
--- a/include/rosa/core/Invoker.hpp
+++ b/include/rosa/core/Invoker.hpp
@@ -1,150 +1,156 @@
 /*******************************************************************************
  *
  * File:     Invoker.hpp
  *
  * Contents: Definition of Invoker interface and its implementation.
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
 #ifndef ROSA_CORE_INVOKER_HPP
 #define ROSA_CORE_INVOKER_HPP
 
 #include "rosa/core/MessageMatcher.hpp"
 #include "rosa/support/log.h"
 #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 Message.
 // NOTE: Invoker instances are supposed to be owned by Message handlers, and
 // not being used directly from user code.
 class Invoker {
 protected:
   // Protected ctor, only subclasses can instantiate.
   Invoker(void) noexcept;
 
 public:
   // Dtor.
   virtual ~Invoker(void);
 
   // Enumeration of possible results of an invocation.
   enum class Result { NoMatch, Invoked };
 
+  // Type alias for a smart-pointer for Invoker.
+  using invoker_t = std::unique_ptr<const Invoker>;
+
   // Type alias for Result.
   using result_t = Result;
 
   // Tells if Msg can be used to invoke F.
   virtual bool match(const Message &Msg) const noexcept = 0;
 
   // Invokes F with Msg if Msg can be used to invoke F.
   virtual result_t operator()(const Message &Msg) const noexcept = 0;
 
   // Instantiates an implementation of Invoker with the given function.
   // NOTE: As there is no empty Message, no Invoker wraps a function without an
   // argument.
   template <typename T, typename... Ts>
-  static std::unique_ptr<Invoker>
-  wrap(std::function<void(T, Ts...) noexcept> &&F) noexcept;
+  static invoker_t wrap(std::function<void(T, Ts...) noexcept> &&F) noexcept;
+
+  // Convenience template alias for casting callable stuff to function objects
+  // for wrapping.
+  template <typename... Ts> using F = std::function<void(Ts...) noexcept>;
 };
 
 // Nested namespace with Invoker implementation and helper templates, consider
 // it private.
 namespace {
 
 // Implementation of the Invoker interface, for functions with different
 // signature.
 // NOTE: As there is no empty Message, no Invoker wraps a function without an
 // argument.
 template <typename Fun> class InvokerImpl;
 
 // Empty struct just to store a sequence of numbers in compile time as template
 // arguments.
 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 Seq.
 template <size_t... S> struct GenSeq<0, S...> { using Type = Seq<S...>; };
 
 // Specialization of InvokerImpl template for std::function.
 // NOTE: No std::function<void(void) noexcept>.
 template <typename T, typename... Ts>
 class InvokerImpl<std::function<void(T, Ts...) noexcept>> final
     : public Invoker {
 
   // Type alias for the stored function.
   using function_t = std::function<void(T, Ts...) noexcept>;
 
   // Type alias for correctly typed argument-tuples as obtained from Messages.
   using args_t = std::tuple<const T &, const Ts &...>;
 
   // Alias for MessageMatcher for the arguments of the stored function.
   using Matcher = MsgMatcher<T, Ts...>;
 
   // The wrapped function.
   const function_t F;
 
   // Helper function invoking F by unpacking Args with the help of actual
   // template arguments.
   // PRE: sizeof...(S) == std::tuple_size<args_t>::value
   template <size_t... S>
   inline void invokeFunction(Seq<S...>, const args_t &Args) const noexcept;
 
 public:
   // Ctor.
   InvokerImpl(function_t &&F) noexcept : F(F) {
     ASSERT(bool(F)); // Sanity check.
   }
 
   // Dtor.
   ~InvokerImpl(void) = default;
 
   // Tells if Msg can be used to invoke F.
   bool match(const Message &Msg) const noexcept override {
     return Matcher::doesStronglyMatch(Msg);
   };
 
   // Invokes F with Msg if Msg can be used to invoke F.
   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));
       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...) noexcept>>::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>
-std::unique_ptr<Invoker>
+Invoker::invoker_t
 Invoker::wrap(std::function<void(T, Ts...) noexcept> &&F) noexcept {
   return std::unique_ptr<Invoker>(
       new InvokerImpl<std::function<void(T, Ts...) noexcept>>(std::move(F)));
 }
 
 } // End namespace rosa
 
 #endif // ROSA_CORE_INVOKER_HPP