c++ - `boost::hana` 模板函数的内省(introspection)

Question

我想知道一个类型是否定义了一个带有模板参数的成员函数，但模板参数受 SFINAE 的约束。

示例我有一个类型 A 和一个函数 foo

struct A{
   template<typename T>
   std::enable_if<Condition<T>,ReturnType> foo(T t){ ... }
};

Condition 是一些条件，例如std::is_pos_v

现在我正在使用 boost::hana::is_valid 来判断一个类型是否有一个成员函数，比如 foo() 或 foo( int) 但是当使用模板参数时我迷路了。

我想写这样的东西

auto has_foo = hana::is_valid([](auto t) -> delctype(hana::traits::declval(t).foo(???)){});
has_foo(hana::type_c<A>); // <-- I want this to return true

问题是我应该用什么代替 ??? ？

---

编译器可能无法“证明”类型 A 满足:“对于每个满足 Condition 的类型 T是一个成员函数 A::foo(T)"

所以为了让编译器更容易，我很乐意至少“证明”对于类型 A 成立:“有一个类型 T 这样有一个成员函数 A::foo(T)"

不幸的是，这在我的示例中仍然很难，因为这需要证明存在满足 Condition 的类型。

那么，为了内省(introspection)的目的，是否可以忽略SFIANE？然后我可以选择一个任意类型并测试是否存在，例如A::foo(int)。

Answer 1

如前所述，除了编写编译器插件和自己遍历 AST 之外，没有为这种自省(introspection)提供的工具。

你当然可以使用 hana::is_valid如果您提供具体的 T 来生成完整且有效的表达式。

我提供了一个额外的示例，它允许提供一个“概念”，假设某种设施可以为您输入的任何“概念”提供具体的 T。不过这有点难以实现。

#include <boost/hana.hpp>
#include <type_traits>
#include <utility>

namespace hana = boost::hana;
using hana::Sequence;


struct A {
    template <typename T>
    std::enable_if_t<Sequence<T>::value, void> foo(T) { }
};

struct B {
    template <typename T>
    void bar(T) { }
};


template <typename T>
auto has_foo_1 = hana::is_valid([](auto&& a)
    -> decltype(std::forward<decltype(a)>(a).foo(std::declval<T>())) { });


template <template <typename, typename> typename Concept>
auto declval_concept_impl = int{};

template <>
auto declval_concept_impl<Sequence> = hana::tuple<>{};

template <template <typename, typename> typename Concept>
using declval_concept = std::add_rvalue_reference_t<decltype(declval_concept_impl<Concept>)>;

template <template <typename, typename> typename Concept>
auto has_foo_2 = hana::is_valid([](auto&& a)
    -> decltype(std::forward<decltype(a)>(a).foo(declval_concept<Concept>{})) { });

int main() {
    A a;
    B b;

    static_assert(    has_foo_1<hana::tuple<>>(a));
    static_assert(not has_foo_1<hana::tuple<>>(b));
    static_assert(    has_foo_2<Sequence>(a));
    static_assert(not has_foo_2<Sequence>(b));
}