C++概念的通配符，表示“接受此模板参数的任何内容”

Question

是否有一种方法允许带有模板参数的概念与提供的任何模板参数一致？

template<class Me, class TestAgainst>
concept derived_from_or_same_as = 
    std::same_as<Me, TestAgainst> ||
    std::derived_from<Me, TestAgainst>;

template<class P, class First, class Second>
concept Pair = requires(P p) {
    requires derived_from_or_same_as<decltype(p.first), First>;
    requires derived_from_or_same_as<decltype(p.second), Second>;
};

// this works well
void doWithPairOfA(const Pair<A, A> auto& p) { /* */ }

用例[b]-接受任何有效的对，对内部类型没有限制：

// this is *pseudo code* as Pair<auto, auto> is not allowed
void doWithAnyPair(const Pair<auto, auto> auto& p) { /* */ }

不幸的是，auto在C++20中不允许作为模板参数占位符。

所以对 目前还不是解决方案。

// Any as wildcard
foo(lst: List[Any]) -> List[str]

// '?' as wildcard
List<String> foo(List<?> lst)

// not as good as with concepts above, this allows only "pair" of A and A
// **but rejects sub-types of A, which is not good**
// and there is no check that this is actually a pair (can be added with SFINAE)
template<template<class, class> typename PAIR>
void doWithPairOfA(const PAIR<A, A>& p) { /* */ }

// not as good as we would wish - we do allow any kind of "pair"
// but there is no check that this is actually a pair (can be added with SFINAE)
template<template<class, class> typename PAIR, typename ANY1, typename ANY2>
void doWithAnyPair(const PAIR<ANY1, ANY2>& p) { /* */ }

概念能提供更好的解决方案吗？

_{¹关于模板的相关问题（前C++20)：模板接受C++中的“任何东西”}

Answer 1

您可以通过修改对概念来接受和检查标记类型any来实现通配符行为。

让我们首先将Any声明为标记类，不需要实现它。

class Any;

现在我们可以创建一个type_matches概念来检查类型T是否与给定的类型a匹配，其规则如下：

null

template<class Me, class TestAgainst>
concept type_matches =
    std::same_as<TestAgainst, Any> ||
    std::same_as<Me, TestAgainst>  ||
    std::derived_from<Me, TestAgainst>;

template<class P, class First, class Second>
concept Pair = requires(P p) {
    requires type_matches<decltype(p.first), First>;
    requires type_matches<decltype(p.second), Second>;
};

// can be called with a Pair of As or sub-type of As
void doWithPairOfA(const Pair<A, A> auto& p) { /* */ }

用例[b]-接受任何有效的对，对内部类型没有限制：

void doWithAnyPair(const Pair<Any, Any> auto& p) { /* */ }

代码:https://godbolt.org/z/higx9f