In case you're interested.
Here's the code of the complete example that I'm trying to get working:

#include <iostream>

#include <boost/msm/front/state_machine_def.hpp>
#include <boost/msm/back/state_machine.hpp>

namespace msm = boost::msm;
namespace mpl = boost::mpl;

// events
struct EventNumber1 {    // int number!
  EventNumber1(int num_) : num{num_} {}
  int getNum() const { return num; }
private:
  int num;
};

struct EventNumber2 {    // double number!
  EventNumber2(double num_) : num{num_} {}
  double getNum() const { return num; }
private:
  double num;
};

typedef EventNumber2 MyEvent;     // using doubles

// StateBase -- a base (parent) state
struct StateBase : public msm::front::state<> {
  StateBase(const std::string& stateName = "") : stateName{stateName} {}

  template <typename Event, typename FSM>
  void on_entry(const Event&, FSM&) {
    std::cout << "Entering " << stateName << std::endl;
  }
 
  template <typename Event, typename FSM>
  void on_exit(const Event&, FSM&) {
    std::cout << "Leaving  " << stateName << std::endl;
  }

private:
  std::string stateName;
};


#if 0
// not used (just an idea)
template <typename T>
struct StateMachineFront_Base : public msm::front::state_machine_def<StateMachineFront_Base<T>>
{
  StateMachineFront_Base(const std::string& stateMachineName = "") : stateMachineName{stateMachineName} {}

  template <typename Event, typename FSM>
  void on_entry(const Event&, FSM&) {
    std::cout << "Entering " << stateMachineName << std::endl;
  }
 
  template <typename Event, typename FSM>
  void on_exit(const Event&, FSM&) {
    std::cout << "Leaving  " << stateMachineName << std::endl;
  }
 
 private:
  std::string stateMachineName;
};
#endif


template <typename EventT>
struct Machine_ : public msm::front::state_machine_def<Machine_<EventT> > {

  Machine_(const std::string& stateMachineName = "Machine_") : stateMachineName{stateMachineName} {}
 
  template <typename Event, typename FSM>
  void on_entry(const Event&, FSM&) {
    std::cout << "Entering " << stateMachineName << std::endl;
  }
 
  template <typename Event, typename FSM>
  void on_exit(const Event&, FSM&) {
    std::cout << "Leaving  " << stateMachineName << std::endl;
  }

  // states
  struct StateInitial : public StateBase {
    StateInitial(const std::string name = "StateInitial") : StateBase{name} {}
  };

  struct StateEven : public StateBase {
    StateEven(const std::string name = "StateEven") : StateBase{name} {}
  };

  struct StateOdd : public StateBase {
    StateOdd(const std::string name = "StateOdd") : StateBase{name} {}
  };

  struct StateFloat : public StateBase {
    StateFloat(const std::string name = "StateFloat") : StateBase{name} {}
  };

  // guards
  bool guardToEven(const EventT& num) {
    const long long x = static_cast<long long>(num.getNum());
    return ((x == num.getNum()) // is Integral type
            && ((x % 2) == 0));
  }

  bool guardToOdd(const EventT& num) {
    const long long x = static_cast<long long>(num.getNum());
    return ((x == num.getNum()) // is Integral type
            && ((x % 2) != 0));
  }

  bool guardToFloat(const EventT& num) {
    const long long x = static_cast<long long>(num.getNum());
    return (x != num.getNum()); // is Floating type
  }

  typedef StateInitial initial_state;

  struct transition_table : mpl::vector<
    g_row<StateInitial, EventT, StateEven,  &Machine_<EventT>::guardToEven>,
    g_row<StateInitial, EventT, StateOdd,   &Machine_<EventT>::guardToOdd>,
    g_row<StateInitial, EventT, StateFloat, &Machine_<EventT>::guardToFloat>,
   
    g_row<StateEven,    EventT, StateEven,  &Machine_<EventT>::guardToEven>,
    g_row<StateEven,    EventT, StateOdd,   &Machine_<EventT>::guardToOdd>,
    g_row<StateEven,    EventT, StateFloat, &Machine_<EventT>::guardToFloat>,

    g_row<StateOdd,     EventT, StateEven,  &Machine_<EventT>::guardToEven>,
    g_row<StateOdd,     EventT, StateOdd,   &Machine_<EventT>::guardToOdd>,
    g_row<StateOdd,     EventT, StateFloat, &Machine_<EventT>::guardToFloat>,

    g_row<StateFloat,   EventT, StateEven,  &Machine_<EventT>::guardToEven>,
    g_row<StateFloat,   EventT, StateOdd,   &Machine_<EventT>::guardToOdd>,
    g_row<StateFloat,   EventT, StateFloat, &Machine_<EventT>::guardToFloat>
    >{};

private:
  std::string stateMachineName;
};

typedef msm::back::state_machine<Machine_<MyEvent>> Machine;

template <typename T>
void postEvents(Machine& machine)
{
  for (T i; std::cin >> i; ) {
    machine.process_event(MyEvent{i});
  }
}

int main()
{
  Machine machine;
  machine.start();

  postEvents<double>(machine);
 
  machine.stop();
  return 0;
}