diff --git a/data/c++.m4 b/data/c++.m4
index dd051e16..020160c9 100644
--- a/data/c++.m4
+++ b/data/c++.m4
@@ -157,25 +157,37 @@ m4_define([b4_public_types_declare],
     /// Token type.
     typedef token::yytokentype token_type;
 
-    /// A complete symbol, with its type.
-    template <typename Exact>
-    struct symbol_base_type
+    /// A complete symbol.
+    ///
+    /// Expects its Base type to provide access to the symbol type
+    /// via type_get().
+    ///
+    /// Provide access to semantic value]b4_locations_if([ and location])[.
+    template <typename Base>
+    struct basic_symbol : Base
     {
       /// Default constructor.
-      inline symbol_base_type ();
+      inline basic_symbol ();
+]b4_locations_if([
+      /// Constructor.
+      inline basic_symbol (const location_type& l);])[
 
-      /// Constructor.]b4_locations_if([
-      inline symbol_base_type (const location_type& l);])[
-      inline symbol_base_type (]b4_join(
+      /// Copy constructor.
+      inline basic_symbol (const basic_symbol& other);
+
+      /// Constructor for valueless symbols.
+      inline basic_symbol (]b4_join(
+        [typename Base::value_type t],
+        b4_locations_if([const location_type& l]))[);
+
+      /// Constructor for symbols with semantic value.
+      inline basic_symbol (]b4_join(
+        [typename Base::value_type t],
         [const semantic_type& v],
         b4_locations_if([const location_type& l]))[);
 
-      /// Return this with its exact type.
-      const Exact& self () const;
-      Exact& self ();
-
-      /// Return the type of this symbol.
-      int type_get () const;
+      /// Destructive move, \a s is emptied.
+      inline void move (basic_symbol& s);
 
       /// The semantic value.
       semantic_type value;]b4_locations_if([
@@ -184,36 +196,33 @@ m4_define([b4_public_types_declare],
       location_type location;])[
     };
 
-    /// External form of a symbol: its type and attributes.
-    struct symbol_type : symbol_base_type<symbol_type>
+    /// Type access provider for token (enum) based symbols.
+    struct by_type
     {
-      /// The parent class.
-      typedef symbol_base_type<symbol_type> super_type;
-
       /// Default constructor.
-      inline symbol_type ();
+      inline by_type ();
 
-      /// Destructive move, \a s is emptied.
-      inline void move (symbol_type& s);
+      /// Copy constructor.
+      inline by_type (const by_type& other);
 
-      /// Constructor for tokens with semantic value.
-      inline symbol_type (]b4_join([token_type t],
-                                   [const semantic_type& v],
-                                   b4_locations_if([const location_type& l]))[);
-
-      /// Constructor for valueless tokens.
-      inline symbol_type (]b4_join([token_type t],
-                                   b4_locations_if([const location_type& l]))[);
+      /// Constructor.
+      inline by_type (token_type t);
 
       /// The symbol type.
       int type;
 
-      /// The symbol type.
-      inline int type_get_ () const;
+      /// The type (corresponding to \a type).
+      inline int type_get () const;
 
       /// The token.
       inline token_type token () const;
+
+      typedef token_type value_type;
     };
+
+    /// "External" symbols: returned by the scanner.
+    typedef basic_symbol<by_type> symbol_type;
+
 ]b4_symbol_constructor_declare])
 
 
@@ -221,110 +230,102 @@ m4_define([b4_public_types_declare],
 # ----------------------
 # Provide the implementation needed by the public types.
 m4_define([b4_public_types_define],
-[[  inline
+[[inline
   ]b4_parser_class_name[::syntax_error::syntax_error (]b4_locations_if([const location_type& l, ])[const std::string& m)
     : std::runtime_error (m)]b4_locations_if([
     , location (l)])[
   {}
 
-  // symbol_base_type.
-  template <typename Exact>
+  // basic_symbol.
+  template <typename Base>
   inline
-  ]b4_parser_class_name[::symbol_base_type<Exact>::symbol_base_type ()
-    : value()]b4_locations_if([
-    , location()])[
-  {
-  }]b4_locations_if([[
+  ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol ()
+    : value ()
+  {}
+]b4_locations_if([
+  template <typename Base>
+  inline
+  ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (const location_type& l)
+    : value ()
+    , location (l)
+  {}])[
 
-  template <typename Exact>
+  template <typename Base>
   inline
-  ]b4_parser_class_name[::symbol_base_type<Exact>::symbol_base_type (const location_type& l)
-    : value()
-    , location(l)
+  ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (const basic_symbol& other)
+    : Base (other)
+    , value ()]b4_locations_if([
+    , location (other.location)])[
   {
-  }]])[
+    ]b4_variant_if([b4_symbol_variant([other.type_get ()], [value], [copy],
+                                      [other.value])],
+                   [value = other.value;])[
+  }
 
-  template <typename Exact>
+
+  template <typename Base>
   inline
-  ]b4_parser_class_name[::symbol_base_type<Exact>::symbol_base_type (]b4_join(
+  ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join(
+          [typename Base::value_type t],
           [const semantic_type& v],
           b4_locations_if([const location_type& l]))[)
-    : value(v)]b4_locations_if([
-    , location(l)])[
+    : Base (t)
+    , value ()]b4_locations_if([
+    , location (l)])[
   {
+    (void) v; /* FIXME: */
+    ]b4_variant_if([b4_symbol_variant([this->type_get ()], [value], [copy],
+                                      [v])],
+                   [value = v;])[
   }
 
-  template <typename Exact>
+  template <typename Base>
   inline
-  const Exact&
-  ]b4_parser_class_name[::symbol_base_type<Exact>::self () const
-  {
-    return static_cast<const Exact&>(*this);
-  }
-
-  template <typename Exact>
-  inline
-  Exact&
-  ]b4_parser_class_name[::symbol_base_type<Exact>::self ()
-  {
-    return static_cast<Exact&>(*this);
-  }
-
-  template <typename Exact>
-  inline
-  int
-  ]b4_parser_class_name[::symbol_base_type<Exact>::type_get () const
-  {
-    return self ().type_get_ ();
-  }
-
-  // symbol_type.
-  inline
-  ]b4_parser_class_name[::symbol_type::symbol_type ()
-    : super_type ()
-    , type ()
-  {
-  }
-
-  inline
-  ]b4_parser_class_name[::symbol_type::symbol_type (]b4_join(
-                [token_type t],
-                b4_locations_if([const location_type& l]))[)
-    : super_type (]b4_locations_if([l])[)
-    , type (yytranslate_ (t))
-  {
-  }
-
-  inline
-  ]b4_parser_class_name[::symbol_type::symbol_type (]b4_join(
-                 [token_type t],
-                 [const semantic_type& v],
-                 b4_locations_if([const location_type& l]))[)
-    : super_type (v]b4_locations_if([, l])[)
-    , type (yytranslate_ (t))
-  {
-  }
+  ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join(
+          [typename Base::value_type t],
+          b4_locations_if([const location_type& l]))[)
+    : Base (t)]b4_locations_if([
+    , location (l)])[
+  {}
 
+  template <typename Base>
   inline
   void
-  ]b4_parser_class_name[::symbol_type::move (symbol_type& s)
+  ]b4_parser_class_name[::basic_symbol<Base>::move (basic_symbol& s)
   {
-    ]b4_variant_if([b4_symbol_variant([[s.type]], [value], [build], [s.value])],
-                   [value = s.value;])[
-    type = s.type;]b4_locations_if([
+    this->type = s.type_get ();]b4_locations_if([
     location = s.location;])[
+    ]b4_variant_if([b4_symbol_variant([s.type_get ()], [value], [build],
+                                      [s.value])],
+                   [value = s.value;])[
   }
 
+  // by_type.
+  inline
+  ]b4_parser_class_name[::by_type::by_type ()
+     : type ()
+  {}
+
+  inline
+  ]b4_parser_class_name[::by_type::by_type (const by_type& other)
+    : type (other.type)
+  {}
+
+  inline
+  ]b4_parser_class_name[::by_type::by_type (token_type t)
+    : type (yytranslate_ (t))
+  {}
+
   inline
   int
-  ]b4_parser_class_name[::symbol_type::type_get_ () const
+  ]b4_parser_class_name[::by_type::type_get () const
   {
     return type;
   }
 ]b4_token_ctor_if([[
   inline
   ]b4_parser_class_name[::token_type
-  ]b4_parser_class_name[::symbol_type::token () const
+  ]b4_parser_class_name[::by_type::token () const
   {
     // YYTOKNUM[NUM] -- (External) token number corresponding to the
     // (internal) symbol number NUM (which must be that of a token).  */
diff --git a/data/lalr1.cc b/data/lalr1.cc
index 91cb5cf0..930119f1 100644
--- a/data/lalr1.cc
+++ b/data/lalr1.cc
@@ -254,40 +254,44 @@ b4_location_define])])[
     /// \brief Display a symbol type, value and location.
     /// \param yyo    The output stream.
     /// \param yysym  The symbol.
-    template <typename Exact>
+    template <typename Base>
     void yy_print_ (std::ostream& yyo,
-                    const symbol_base_type<Exact>& yysym) const;
+                    const basic_symbol<Base>& yysym) const;
 #endif
 
     /// \brief Reclaim the memory associated to a symbol.
     /// \param yymsg     Why this token is reclaimed.
     ///                  If null, print nothing.
     /// \param s         The symbol.
-    template <typename Exact>
+    template <typename Base>
     inline void yy_destroy_ (const char* yymsg,
-                             symbol_base_type<Exact>& yysym) const;
+                             basic_symbol<Base>& yysym) const;
 
-    /// Element of the stack: a state and its attributes.
-    struct stack_symbol_type : symbol_base_type<stack_symbol_type>
+  private:
+    /// Type access provider for state based symbols.
+    struct by_state
     {
-      /// The parent class.
-      typedef symbol_base_type<stack_symbol_type> super_type;
-
       /// Default constructor.
-      inline stack_symbol_type ();
+      inline by_state ();
 
       /// Constructor.
-      inline stack_symbol_type (]b4_join([state_type s],
-                                         [const semantic_type& v],
-                                         b4_locations_if([const location_type& l]))[);
+      inline by_state (state_type s);
+
+      /// Copy constructor.
+      inline by_state (const by_state& other);
 
       /// The state.
       state_type state;
 
       /// The type (corresponding to \a state).
-      inline int type_get_ () const;
+      inline int type_get () const;
+
+      typedef state_type value_type;
     };
 
+    /// "Internal" symbol: element of the stack.
+    typedef basic_symbol<by_state> stack_symbol_type;
+
     /// Stack type.
     typedef stack<stack_symbol_type> stack_type;
 
@@ -506,33 +510,29 @@ m4_if(b4_prefix, [yy], [],
 
 ]b4_token_ctor_if([], [b4_public_types_define])[
 
-  // stack_symbol_type.
-  ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type ()
-    : super_type ()
-    , state ()
-  {
-  }
+  // by_state.
+  ]b4_parser_class_name[::by_state::by_state ()
+    : state ()
+  {}
 
-  ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type (]b4_join(
-                 [state_type s],
-                 [const semantic_type& v],
-                 b4_locations_if([const location_type& l]))[)
-    : super_type (v]b4_locations_if([, l])[)
-    , state (s)
-  {
-  }
+  ]b4_parser_class_name[::by_state::by_state (const by_state& other)
+    : state (other.state)
+  {}
+
+  ]b4_parser_class_name[::by_state::by_state (state_type s)
+    : state (s)
+  {}
 
   int
-  ]b4_parser_class_name[::stack_symbol_type::type_get_ () const
+  ]b4_parser_class_name[::by_state::type_get () const
   {
     return yystos_[state];
   }
 
-
-  template <typename Exact>
+  template <typename Base>
   void
   ]b4_parser_class_name[::yy_destroy_ (const char* yymsg,
-                                       symbol_base_type<Exact>& yysym) const
+                                       basic_symbol<Base>& yysym) const
   {
     if (yymsg)
       YY_SYMBOL_PRINT (yymsg, yysym);
@@ -551,10 +551,10 @@ m4_if(b4_prefix, [yy], [],
   }
 
 #if ]b4_api_PREFIX[DEBUG
-  template <typename Exact>
+  template <typename Base>
   void
   ]b4_parser_class_name[::yy_print_ (std::ostream& yyo,
-                                     const symbol_base_type<Exact>& yysym) const
+                                     const basic_symbol<Base>& yysym) const
   {
     std::ostream& yyoutput = yyo;
     YYUSE (yyoutput);
@@ -579,16 +579,14 @@ m4_if(b4_prefix, [yy], [],
     if (m)
       YY_SYMBOL_PRINT (m, sym);
 ]b4_variant_if(
-[[    yystack_.push (stack_symbol_type (]b4_join(
-                    [s],
-                    [semantic_type()],
-                    b4_locations_if([sym.location]))[));
-    ]b4_symbol_variant([[yystos_[s]]], [[yystack_[0].value]],
-                       [build], [sym.value])],
-[[    yystack_.push (stack_symbol_type (]b4_join(
-                      [s],
-                      [sym.value],
-                      b4_locations_if([sym.location]))[));]])[
+[[
+  stack_symbol_type ss (]b4_join([s],
+      [sym.value], b4_locations_if([sym.location]))[);
+  ]b4_symbol_variant([sym.type_get ()], [sym.value], [destroy], [])[;
+  yystack_.push (ss);
+]],
+[[    yystack_.push (stack_symbol_type (]b4_join([s],
+                         [sym.value], b4_locations_if([sym.location]))[));]])[
   }
 
   void
@@ -597,12 +595,12 @@ m4_if(b4_prefix, [yy], [],
     if (m)
       YY_SYMBOL_PRINT (m, s);
 ]b4_variant_if(
-[[    yystack_.push (stack_symbol_type (]b4_join(
-                       [s.state],
-                       [semantic_type()],
-                       b4_locations_if([s.location]))[));
-    ]b4_symbol_variant([[yystos_[s.state]]], [[yystack_[0].value]],
-                       [build], [s.value])],
+[[
+  stack_symbol_type ss (]b4_join([s.state],
+      [s.value], b4_locations_if([s.location]))[);
+  ]b4_symbol_variant([s.type_get ()], [s.value], [destroy], [])[;
+  yystack_.push (ss);
+]],
 [    yystack_.push (s);])[
   }
 
@@ -730,7 +728,7 @@ b4_dollar_popdef])[]dnl
         YYCDEBUG << "Reading a token: ";
         try
           {]b4_token_ctor_if([[
-            symbol_type yylookahead = ]b4_lex[;
+            symbol_type yylookahead (]b4_lex[);
             yyla.move (yylookahead);]], [[
             yyla.type = yytranslate_ (]b4_lex[);]])[
           }