Question

template<class... Ts, class T>
constexpr auto contains(T&&){
  auto types = hana::to<hana::tuple_tag>(hana::tuple_t<Ts...>);
  return hana::bool_c<hana::find(types, hana::type_c<T>) != hana::nothing>;
}

auto ht = hana::make_tuple(1,2,3,'c');

auto ht1 = hana::filter(ht, [](auto t){
  return contains<int,float,double>(t);
});
//prints 0
std::cout << hana::size(ht1) << std::endl;

我不确定我是否正确使用了助推器，但contains似乎有效。

std::cout << contains<int,float,double>(5) << std::endl;   // 1
std::cout << contains<int,float,double>('c') << std::endl; // 0
std::cout << contains<int,float,double>(5.0f) << std::endl; // 1

为什么ht1 0的大小？

Answer 1

这里的问题实际上与Hana无关，它与推断通用引用的方式有关。只是为了清理事物，hana::type_c<T> == hana::type_c<U>恰好等同于std::is_same<T, U>{}。比较hana::type时，没有引用或cv-qualifier删除。您可以查看这些规则的各种文章（例如this或this）。

现在，让我通过您的代码修改一些内容，并附上评论。首先，

  auto types = hana::to<hana::tuple_tag>(hana::tuple_t<Ts...>);

是多余的，因为您已经使用hana::tuple创建了hana::tuple_t。因此，hana::tuple_t<T...>仅足够。其次，有这一行：

  return hana::bool_c<hana::find(types, hana::type_c<T>) != hana::nothing>;

而不是检查hana::find(...) != hana::nothing，而是使用hana::contains，它会更好地表达您的意图，也可能更加优化。一般而言，特别是与Hana的元编程库，不要试图推断什么会更快。尽可能清楚地表明你的意图，并希望我在实施方面正确地完成我的工作:-)。因此，您最终将获得

return hana::bool_c<hana::contains(types, hana::type_c<T>)>;

现在，hana::bool_c<...>确实是多余的，因为hana::contains已经返回布尔值integral_constant。因此，上述等同于更简单的

return hana::contains(types, hana::type_c<T>);

最后，将所有位放在一起并简化，你得到

template<class... Ts, class T>
constexpr auto contains(T&&){
  return hana::contains(hana::tuple_t<Ts...>, hana::type_c<T>);
}

我个人并不喜欢将T&&作为参数，当你想要的只是那个对象的类型时。实际上，这会迫使你实际提供一个对象到contains函数，这在某些情况下可能会很笨拙（如果你没有一个对象怎么办？）。此外，将值与类型进行比较可能会令人困惑：

contains<int, char, double>(3.5) // wtf, 3.5 is not in [int, char, double]!

相反，如果是我自己的代码，我会写下面的内容：

template<class... Ts, class T>
constexpr auto contains(T type){
  return hana::contains(hana::tuple_t<Ts...>, type);
}

// and then use it like
contains<int, char, double>(hana::type_c<double>)

但这是你的功能界面的一部分，我想你比我知道你的需求在接口方面更好。

Answer 2

问题是T&&，我认为它会将类型推断为T&类型，这意味着hana::type_c<T> != hana::type_c<T&>解决方法是离开&&因为它们是template<class... Ts, class T> constexpr auto contains(T){ auto types = hana::tuple_t<Ts...>; return hana::find(types, hana::type_c<T>) != hana::nothing; }不必要的。

padding

Answer 3

只是为了添加您的回答，您的ht1正在调用contains并t左值。以下演示了传递右值和左值的T&&：

#include<boost/hana.hpp>

namespace hana = boost::hana;

template<class T>
void test1(T&&) {
  static_assert(hana::type_c<T> == hana::type_c<int>, "");
}

int main() {
  static_assert(hana::type_c<int> != hana::type_c<int&&>, "");
  test1(5);
  int x = 5;
  test1(x); //fails
}

clang输出：

main.cpp:7:3: error: static_assert failed ""
  static_assert(hana::type_c<T> == hana::type_c<int>, "");
  ^             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
main.cpp:14:3: note: in instantiation of function template specialization 'test1<int &>' requested here
  test1(x); //fails
  ^
1 error generated.

过滤增强hana中的元组

3 个答案: