#include <string>
#include <iostream>

enum _n_Height  { n_Height };
enum _n_Weight  { n_Weight };
enum _n_Name    { n_Name };

struct Fake_Struct { void operator []( Fake_Struct const& ); };

template < class _Tx, class _Name, class _Super = Fake_Struct >
  struct Struct : _Super
    {
      using _Super::operator[];

      _Tx val_;
      _Tx& operator []( _Name n ) { return val_; }

      Struct() : val_(_Tx()) {}
    };

typedef 
  Struct< int, _n_Height, Struct < float, _n_Weight, Struct < std::string, _n_Name > > >
  MyStruct;


int main()
  {

    MyStruct s;

    s[n_Height]  = 10;
    s[n_Weight]  = 20.3;
    s[n_Name]    = "name";

    std::cout
      << s[n_Height]  << std::endl
      << s[n_Weight]  << std::endl
      << s[n_Name]    << std::endl
      ;

    return 0;

  }

int main()
  {
    Scord< _sf_iHeight, Scord<_sf_fWeight, Scord<_sf_szName> > > s;

    sf_iHeight[s] = 10;
    sf_fWeight[s] = 20.3;
    sf_szName[s] = "jony";

    std::cout
      << sf_iHeight[s]  << std::endl
      << sf_fWeight[s]  << std::endl
      << sf_szName[s]   << std::endl
      << std::endl
      ;
 
    return 0;
  }

#define TEGGO_SFIELD(name,type) \
  struct _sf_##name : Sfield< type, _sf_##name > {}; \
  /*static*/ _sf_##name const sf_##name = _sf_##name()

template < class _Key >
  struct _Scord_Value
    {
      typename _Key::_Type sf_value_;
      _Scord_Value() : sf_value_(typename _Key::_Type()) {}
    };

template < class _Tp, class _Self >
  struct Sfield
    {
      typedef _Tp _Type;
      template < class _Value >
        _Type& operator[](_Value &val) const
        {
          return static_cast<_Scord_Value<_Self>&>(val).sf_value_;
        };
    };

struct _Scord_Fake {};

template < class _Key, class _Lst = _Scord_Fake >
  struct Scord : _Scord_Value<_Key>, _Lst 
    {
    };

TEGGO_SFIELD(iHeight, int);
TEGGO_SFIELD(fWeight, float);
TEGGO_SFIELD(szName,  std::string);

>
> #include <string>
> #include <iostream>
>
> enum _n_Height  { n_Height };
> enum _n_Weight  { n_Weight };
> enum _n_Name    { n_Name };
>
> struct Fake_Struct { void operator []( Fake_Struct const& ); };
>
> template < class _Tx, class _Name, class _Super = Fake_Struct >
>   struct Struct : _Super
>     {
>       using _Super::operator[];
>
>       _Tx val_;
>       _Tx& operator []( _Name n ) { return val_; }
>
>       Struct() : val_(_Tx()) {}
>     };
>
> typedef
>   Struct< int, _n_Height, Struct < float, _n_Weight, Struct < std::string, _n_Name > > >
>   MyStruct;
>
>
> int main()
>   {
>
>     MyStruct s;
>
>     s[n_Height]  = 10;
>     s[n_Weight]  = 20.3;
>     s[n_Name]    = "name";
>
>     std::cout
>       << s[n_Height]  << std::endl
>       << s[n_Weight]  << std::endl
>       << s[n_Name]    << std::endl
>       ;
>
>     return 0;
>
>   }
>

> Выкриков — 'баян' и тухлых помидоров я не боюсь, ибо действительно прикольно.

1. Сам факт, что до объявления кортежа нужно объявить имена его членов, а при объявлении объявить имена и их типы убивают всю идею на корню. Я не вижу, чем приведенный выше кортеж лучше, чем обычное
   

   struct my_struct
   {
        int height;
        float weight;
        std::string name;
   };

   
   Я вижу лишь что на описание этой же структуры в оригинальном коде ушло больше писанины без какой либо пользы.
   
2. Практическая применимость такого кортежа в шаблонном коде близка к абсолютному нулю. Ничего не стоит в compile time определить количество членов boost::tuple и проитерироваться по его членам, так как индексом его членов является целое, результаты арифметических операций над которым вычисляются в compile time. По приведенному кортежу невозможно проитерироваться в generic коде, так как нужно знать имена членов. Возвращемся к тому, что индексы должны быть простыми целыми.
   С другой стороны целочисленные индексы не убивают возможности использовать осмысленные имена. boost::tuple:
   

   typedef tuple<int, float, std::string> my_struct;
   enum { height, weight, name };
   // ...
   my_struct s;
   get<height>(s) = 1;

   
   Я не вижу недостатка в том, что вместо operator[] для доступа к членам используется get<>(), так как реально никакого практического смыла в operator[] нет из-за того, что он не может использоваться в generic коде который ожидает семантику operator[] как у встроенных типов.

typedef tuple<int, float, std::string> my_struct;
enum { height, weight, name };
// ...
my_struct s;
get<height>(s) = 1;

enum stop_t  { cmd_stop = 0x1001 };
enum start_t { cmd_start = 0x2000 };
enum pause_t { cmd_pause = 0x40000 };

get<N>(t)

where t is a tuple object and N is a constant integral expression specifying the index of the element to be accessed. Depending on whether t is const or not, get returns the Nth element as a reference to const or non-const type. The index of the first element is 0 and thus N must be between 0 and k-1, where k is the number of elements in the tuple. Violations of these constrains are detected at compile time.

Каждый желающий запостить идею или пример кода должен приложить подробно разжёванное описание (понятное для кофейников), а так же примеры на которых доступно показано чем его идея лучше чем boost. Примеры должны быть написаны в терминах буста с использованием буста и на задачах решаемых бустом. Отсутствие буста в примерах и идее, а так же непонимание почитателями буста, почему таковое кому либо может быть интересно, карается всеобщем порицанием и удалением.

class name_t   {};
class number_t {};
tagged_tuple<std::string, name_t, int, number_t> s;
s.get<name_t>() = "hello world";
s.get<number_t>() = 2005;
assert(s.get<0>() == s.get<name_t>());
assert(s.get<1>() == s.get<number_t>());

boost::tuple<std::string, int> s;
cin  >> s;
cout << s;

#include <boost/tuple/tuple.hpp>
#include <boost/tuple/tuple_io.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/preprocessor/arithmetic/mul.hpp>
#include <boost/preprocessor/punctuation/comma_if.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/find.hpp>
#include <boost/mpl/unique.hpp>
#include <boost/mpl/size.hpp>
#include <Boost/mpl/at.hpp>
#include <boost/type_traits/is_same.hpp>
#include <string>
#include <iostream>

#ifndef FAKIE_TAGGED_TUPLE_MAX_ARITY
# define FAKIE_TAGGED_TUPLE_MAX_ARITY 10
#elif FAKIE_TAGGED_TUPLE_MAX_ARITY > 10
#error boost::tuples doesn't support arity > 10
#endif

namespace fakie
{
    template<typename Types, typename Names, typename Base>
    struct tagged_tuple_detail 
        : virtual Base
        , boost::enable_if_c<boost::mpl::size<Types>::type::value == boost::mpl::size<Names>::type::value>
        , boost::enable_if<boost::is_same<boost::mpl::unique<Types>, Types> >
    {
        using Base::get;

        template<typename T>
        typename boost::tuples::access_traits<
            typename boost::mpl::at_c<
                Types, 
                boost::mpl::find<Names, T>::type::pos::value
            >::type
        >::non_const_type get ()
        {
            return boost::tuples::get<boost::mpl::find<Names, T>::type::pos::value>(*this);
        }

        template<typename T>
        typename boost::tuples::access_traits<
            typename boost::mpl::at_c<
                Types, 
                boost::mpl::find<Names, T>::type::pos::value
            >::type
        >::const_type get () const
        {
            return boost::tuples::get<boost::mpl::find<Names, T>::type::pos::value>(*this);
        }
    };

#define FAKIE_TAGGED_TUPLE_DETAIL_TYPES(z, n, text)\
    BOOST_PP_COMMA_IF(n) BOOST_PP_CAT(text, BOOST_PP_MUL(2, n))

#define FAKIE_TAGGED_TUPLE_DETAIL_VALUES(z, n, text)\
    BOOST_PP_COMMA_IF(n) BOOST_PP_CAT(text, BOOST_PP_ADD(BOOST_PP_MUL(2, n), 1))

#define FAKIE_TAGGED_TUPLE_DETAIL_MPL_2_TUPLE(z, n, text)\
    BOOST_PP_COMMA_IF(n)\
    typename boost::mpl::if_<\
        boost::is_same<BOOST_PP_CAT(text, BOOST_PP_MUL(2, n)), boost::mpl::na>,\
        boost::tuples::null_type,\
        BOOST_PP_CAT(text, BOOST_PP_MUL(2, n))\
    >::type

    template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PP_MUL(2, FAKIE_TAGGED_TUPLE_MAX_ARITY), typename T, boost::mpl::na)>
    struct tagged_tuple
        : tagged_tuple_detail
        <
            boost::mpl::vector<BOOST_PP_REPEAT(FAKIE_TAGGED_TUPLE_MAX_ARITY, FAKIE_TAGGED_TUPLE_DETAIL_TYPES, T)>,
            boost::mpl::vector<BOOST_PP_REPEAT(FAKIE_TAGGED_TUPLE_MAX_ARITY, FAKIE_TAGGED_TUPLE_DETAIL_VALUES, T)>,
            boost::tuple<BOOST_PP_REPEAT(FAKIE_TAGGED_TUPLE_MAX_ARITY, FAKIE_TAGGED_TUPLE_DETAIL_MPL_2_TUPLE, T)>
        >
    {
    };

#undef FAKIE_TAGGED_TUPLE_DETAIL_TYPES
#undef FAKIE_TAGGED_TUPLE_DETAIL_VALUES
#undef FAKIE_TAGGED_TUPLE_DETAIL_MPL_2_TUPLE
}

class name_t {};
class value_t {};
class weight_t {};

int main()
{
    using namespace fakie;

    tagged_tuple<std::string, name_t, int, value_t, double, weight_t> s;
    
    s.get<name_t>()   = "Hello World";
    s.get<value_t>()  = 2005;
    s.get<weight_t>() = 2.34543;

    std::cout << s;

    return k;
}