1

我正在尝试让自己熟悉 boost::hana。作为练习，我想创建一个函数，该函数将使用用户提供的比较函数从 hana::tuple 中删除重复项。我面临的问题与使用hana::type_c's 将类型存储为对象有关。这是我所拥有的

#include <boost/hana/equal.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/unpack.hpp>
#include <boost/hana/pair.hpp>
#include <boost/hana/any_of.hpp>
#include <boost/hana/second.hpp>
#include <boost/hana/fold.hpp>
#include <boost/hana/core/make.hpp>
#include <boost/hana/core/tag_of.hpp>

#include <iostream>

template <class>
struct what_is;

namespace hana = boost::hana;

// simply push back an element to the sequence
auto push_back = [](auto seq, auto t) {

    using namespace boost::hana;
    return unpack(seq, [&](auto&&... element){return make<typename tag_of<decltype(seq)>::type>(element..., t);});
};

// this is the main function
auto remove_duplicates = [](auto seq, auto comp) {

    using namespace boost::hana;

    auto f = [&](auto state, auto el){
        return if_( any_of(state, partial(comp, el)),
                   [=](){return state;},
                   [=](){return push_back(state, el);})();
    };

    return fold(seq, make<typename tag_of<decltype(seq)>::type>(), f);
};

// user-defined comparison function
// elements are considered equal if only second element of pairs are equal
auto comp_pair = [](auto&& t1, auto&& t2) {

    using namespace boost::hana;
    return equal(second(t1), second(t2));
};


int main() {

    auto my_tuple1 = hana::tuple_t<int, float, double, int, float>;
    auto no_dups1 = remove_duplicates(my_tuple1, hana::equal); // this is fine, decltype(no_dups1) -> tuple< type<int>, type<float>, type<double> >

    auto my_tuple2 = hana::tuple_t< hana::pair<int, int>, hana::pair<float, int>, hana::pair<float, float> >;
//    auto no_dups2 = remove_duplicates(my_tuple2, comp_pair); // what I want here is tuple< type<pair<int, int>>, type<pair<float, float>> >
}

最后一行产生了问题，因为没有第二个元素可以从 a 中提取hana::type<pair<X,Y>>。为此，我必须创建一个非常丑陋的序列，例如tuple< pair<type<int>, type<int>>, pair<type<double>, type<int>>, pair<type<float>, type<double>> >. 正如您可以想象的那样，这可能会很快变得很糟糕，例如，如果我有一个序列tuple<int, pair<X,Y>, double, float>等。有什么方法可以创建一个统一的方法来处理这个问题？我来自 MPL/fusion 背景，在那里我可以直接使用类型而无需包装类型。谢谢

4

1 回答 1

3

与 Fusion 不同，Hana 不会将值隐式转换为类型。一般来说，这很好，因为这意味着您可以使用更具表现力的值语法。另一方面，对于某些您确实想要提取包装类型的用例，您必须使用 Hana 显式执行此操作，而 Fusion 在后台为您执行此操作。

对于您要实现的目标，我看到了两种选择。第一个解决方案是更改您的comp_pair函数，以便它解开对本身：

template <typename T1, typename U1, typename T2, typename U2>
constexpr auto comp_pair(hana::basic_type<hana::pair<T1, U1>>,
                         hana::basic_type<hana::pair<T2, U2>>)
{
    return hana::type_c<U1> == hana::type_c<U2>;
}

...

auto no_dups2 = remove_duplicates(my_tuple2, [](auto pair1, auto pair2) {
    return comp_pair(pair1, pair2);
});

第二种解决方案，我觉得更习惯用语，实际上是把你的类型作为对象来保存：

// This could arguably be part of Hana, just like we provide tuple_t
template <typename T, typename U>
constexpr auto pair_t = hana::make_pair(hana::type_c<T>, hana::type_c<U>);

auto tuple2 = hana::make_tuple(pair_t<int, int>, pair_t<double, int>, pair_t<float, double>);
auto nodups2 = remove_duplicates(tuple2, [](auto p1, auto p2) {
  return hana::second(p1) == hana::second(p2);
});

然而，你说：

正如您可以想象的那样，这可能会很快变得很糟糕，例如，如果我有一个序列tuple<int, pair<X,Y>, double, float>等。有什么方法可以创建一个统一的方法来处理这个问题？

我不确定我是否关注这里。您是说您可能想要拥有类似的东西tuple<type<int>, pair<type<X>, type<Y>>, type<double>, type<float>>，并且正在寻找实现此目标的通用方法吗？如果是这样，那么我必须说我高度怀疑有更好的方法来实现你想要做的任何事情。如果您提供更多上下文，我可以尝试提供帮助。

希望这可以帮助！

于 2016-12-04T05:29:50.387 回答