template< typename T >
struct can_be_on_stack
    : mpl::bool_c< (sizeof(T) <= sizeof(double)) >
{
};

// use 'if_' to choose where to store 'T' member
template< typename T >
struct lightweight
   : private mpl::if_<
          can_be_on_stack<T>
        , stack_holder<T>
        , heap_holder<T>
        >::type
{
   // ...
};

meta 
  bool can_be_on_stack(typename T) {
        return (sizeof(T) <= sizeof(double)); 
  }
meta
  typename optimal_holder(typename T) 
   { return can_be_on_stack(T)? tack_holder<T>:heap_holder<T>; }

template< typename T > 
   struct lightweight : private optimal_holder<T>
   {
   };

template<typename T> metacode
T power(T b, unsigned n) {
  T r = 1;
  for (int k = 0; k<n; ++k) r *= b;
  return r;
}
float a1[power(2, 3)]; // OK: Same as a1[8]

meta
 typename $power(b, unsigned n) 
{
  $typeof(b) r = 1;
  for (int k = 0; k<n; ++k) r *= b;
  return r;
}
float a1[$power(2, 3)]; // OK: Same as a1[8][/b]

struct smart_enum
{
  int  v;
  enum values 
  {  
    v_undefined,
    v_bold,
    v_normal
  };

  smart_enum() v(v_undefined) {}
  smart_enum(int i):v(i) {} 

  static smart_enum from_string(const char* str) 
  {
     int v = v_undefined;
     if( stricmp("bold",str) == 0 )
       v = v_bold;
     else if( stricmp("normal",str) == 0 )
       v = v_normal;
     return my_enum(v);
  }
  const char* to_string() {...}
};

  enum weight 
  {  
    v_undefined,
    v_bold,
    v_normal
  };
  typedef smart_enum< weight > weight_type;

CS>>meta 
CS>>  bool can_be_on_stack(typename T) {
CS>>        return (sizeof(T) <= sizeof(double)); 
CS>>  }
CS>>meta
CS>>  typename optimal_holder(typename T) 
CS>>   { return can_be_on_stack(T)? tack_holder<T>:heap_holder<T>; }

CS>>template< typename T > 
CS>>   struct lightweight : private optimal_holder<T>
CS>>   {
CS>>   };
CS>>

stdmeta::type
To manipulate C++ types

MS>>Да, кстати, символы '$' и '@' в C++ совсем не задействованы. Целых 2 ASCII-символа!

template<typename T> T power(T b, unsigned n) // doesn't need any additional keywords
{
  T r = 1;
  for (int k = 0; k<n; ++k) r *= b;
  return r;
}

float a1[$power(2, 3)];       // Same as a1[8], meta
. . .
double v1 = power(2.76, 3);   // runtime, 2.76^3
. . .
const int v1 = 10;
const int v2 = $power(2, v2); // meta
. . .
int v1 = 10;
int v2 = $power(2, v1);       // Compile error

CS>struct smart_enum
CS>{
CS>  int  v;
CS>  enum values 
CS>  {  
CS>    v_undefined,
CS>    v_bold,
CS>    v_normal
CS>  };

CS>  smart_enum() v(v_undefined) {}
CS>  smart_enum(int i):v(i) {} 

CS>  static smart_enum from_string(const char* str) 
CS>  {
CS>     int v = v_undefined;
CS>     if( stricmp("bold",str) == 0 )
CS>       v = v_bold;
CS>     else if( stricmp("normal",str) == 0 )
CS>       v = v_normal;
CS>     return my_enum(v);
CS>  }
CS>  const char* to_string() {...}
CS>};
CS>

CS>  enum weight 
CS>  {  
CS>    v_undefined,
CS>    v_bold,
CS>    v_normal
CS>  };
CS>  typedef smart_enum< weight > weight_type;
CS>

  macro<typename E> E from_string(const char* str) 
  {
     $for_each(E.$enum_member m)
     {
        if( stricmp(m.$literal.$substr(2, $npos), str) == 0 ) return m;
        else
     }
     return E.$enum_member[0];
  }

  enum weight 
  {  
    v_undefined,
    v_bold,
    v_normal
  };

  // Explicit Instantiation if desired
  macro<> from_string<weight>(const char* str);

  . . .
  // Use:
  weight w = $from_string<weight>(str);

  // Resulting code (implicitly generated):
  weight from_string<weight>(const char* str) 
  {
        if( stricmp("undefined", str) == 0 ) return weight.v_undefined;
        else
        if( stricmp("bold", str) == 0 ) return weight.v_bold;
        else
        if( stricmp("normal", str) == 0 ) return weight.v_normal;
        else
     return weight.v_undefined;
  }

MS>  macro<typename E> E from_string(const char* str) 
MS>  {
MS>     $for_each(E.$enum_member m)
MS>     {
MS>        if( stricmp(m.$literal.$substr(2, $npos), str) == 0 ) return m;
MS>        else
MS>     }
MS>     return E.$enum_member[0];
MS>  }

MS>  enum weight 
MS>  {  
MS>    v_undefined,
MS>    v_bold,
MS>    v_normal
MS>  };

MS>  // Explicit Instantiation if desired
MS>  macro<> from_string<weight>(const char* str);

MS>  . . .
MS>  // Use:
MS>  weight w = $from_string<weight>(str);
MS>

template<typename E>
  E from_string(const char* str) 
{
     #for each m in E.$enum_member do
       if( stricmp(##m.$literal, str) == 0 ) return m;
       else
     #endfor
     return E.$enum_member[0];
}