boost::fusion::map 允许重复键

根据boost：：fusion：：map docs：

对于每个键，映射最多可以包含一个元素。

在实践中，很容易违反这一点。

我能够定义以下类型：

using map_type = fusion::map<
    fusion::pair<int, char>
  , fusion::pair<int, char>
  , fusion::pair<int, char>>;

并使用以下重复键实例化它：

map_type m(
    fusion::make_pair<int>('X')
  , fusion::make_pair<int>('Y')
  , fusion::make_pair<int>('Z'));

使用 fusion::for_each 遍历映射显示数据结构确实包含 3 对，每个键的类型为 int：

struct Foo
{
    template<typename Pair>
    void operator()(const Pair& p) const
    {
        std::cout << typeid(typename Pair::first_type).name() << "=" << p.second << 'n';
    }
};
fusion::for_each(m, Foo {});

输出：

i=X
i=Y
i=Z

我本来希望对密钥唯一性static_assert，但显然并非如此。

• 这是为什么呢？

• 如何确保没有人可以使用重复的密钥实例化fusion::map？

完整工作示例：（在大肠杆菌上）

#include <boost/fusion/container.hpp>
#include <boost/fusion/include/for_each.hpp>
#include <iostream>
namespace fusion = ::boost::fusion;
struct Foo
{
    template<typename Pair>
    void operator()(const Pair& p) const
    {
        std::cout << typeid(typename Pair::first_type).name() << "=" << p.second << 'n';
    }
};
int main()
{
    using map_type = fusion::map<
        fusion::pair<int, char>
      , fusion::pair<int, char>
      , fusion::pair<int, char>>;
    map_type m(
        fusion::make_pair<int>('X')
      , fusion::make_pair<int>('Y')
      , fusion::make_pair<int>('Z'));
    fusion::for_each(m, Foo {});
    return 0;
}

由于下面的评论，这里有一些关于我实际想要实现的目标的进一步细节。

这个想法是自动生成FIX序列化代码。

给定的字段类型在任何给定的FIX消息中只能存在一次 - 因此需要static_assert

激励示例：（关于大肠杆菌）

#include <boost/fusion/container.hpp>
#include <boost/fusion/sequence.hpp>
#include <boost/fusion/include/for_each.hpp>
#include <boost/mpl/transform.hpp>
#include <iostream>
namespace fusion = ::boost::fusion;
namespace mpl    = ::boost::mpl;
template<class Field>
struct MakePair
{
    using type = typename fusion::result_of::make_pair<Field, typename Field::Type>::type;
};
template<class Fields>
struct Map
{
    using pair_sequence = typename mpl::transform<Fields, MakePair<mpl::_1>>::type;
    using type          = typename fusion::result_of::as_map<pair_sequence>::type;
};
///////////////////////////
template<typename... Fields>
class Message
{
public:
    template<class Field>
    void set(const typename Field::Type& val)
    {
        fusion::at_key<Field>(_fields) = val;
    }
    void serialise()
    {
        fusion::for_each(_fields, Serialiser {});
    }
private:
    struct Serialiser
    {
        template<typename Pair>
        void operator()(const Pair& pair) const
        {
            using Field = typename Pair::first_type;
            std::cout << Field::Tag << "=" << pair.second << "|";
        }
    };
    using FieldsVector = fusion::vector<Fields...>;
    using FieldsMap    = typename Map<FieldsVector>::type;
    FieldsMap _fields;
    static_assert(fusion::result_of::size<FieldsMap>::value == fusion::result_of::size<FieldsVector>::value,
            "message must be constructed from unique types"); // this assertion doesn't work
};
///////////////////////////
#define MSG_FIELD(NAME, TYPE, TAG)  
    struct NAME                     
    {                               
        using Type = TYPE;          
        static const int Tag = TAG; 
    };
MSG_FIELD(MsgType, char,   35)
MSG_FIELD(Qty,     int,    14)
MSG_FIELD(Price,   double, 44)
using Quote = Message<MsgType, Qty, Price>;
///////////////////////////
int main()
{
    Quote q;
    q.set<MsgType>('a');
    q.set<Qty>(5);
    q.set<Price>(1.23);
    q.serialise();
    return 0;
}