Negating requires expressions in C++20 concepts

In C++20 concepts, you can negate a requires expression using the ! operator to specify that a type should not satisfy certain requirements. This is useful when you want to enforce that a type does not have a particular property or does not support a specific operation.

Here's an example that demonstrates negating a requires expression:

1#include <concepts>
2#include <iostream>
3
4template <typename T>
5concept NotAddable = !requires(T a, T b) {
6  a + b;
7};
8
9template <NotAddable T>
10void add(T a, T b) {
11  std::cout << "Cannot add values of this type\n";
12}
13
14template <typename T>
15void add(T a, T b) {
16  std::cout << "Result: " << a + b << '\n';
17}
18
19int main() {
20  add(1, 2);
21  add("Hello", " world");
22}

1Result: 3
2Cannot add values of this type

In this example, the NotAddable concept is defined using a negated requires expression. It specifies that a type T satisfies the concept if the expression a + b is not valid for instances a and b of type T.

The first overload of the add function is constrained by the NotAddable concept, so it will be called when the provided type does not support the + operator. The second overload is unconstrained and will be called for types that do support the + operator.

As you can see, the negated requires expression allows us to specify that a type should not satisfy certain requirements, providing a way to handle types that do not support specific operations or have certain properties.