C++20 concept : requires expression and perfect forwarding

Question

FYI: C++17 std::is_invocable_v does exactly what i was expecting.

Imagine a concept to check if the invocation of a callable object is possible with specific argument types:

template <typename Fn, typename... Args>
concept has_request_interface = requires (Fn request, Args&&... args)
{
    { std::invoke(request, std::forward<Args>(args)...) }-> Status;
};

versus

template <typename Fn, typename... Args>
concept has_request_interface = requires (Fn request, Args... args)
{
    { std::invoke(request, args...) }-> Status;
};

Is it meaningful using perfect forwarding in requires expressions ?

It seems to me that the answer is yes because the request callable object may expect rvalues for some arguments.

But does the requires (Fn request, Args... args) behave as a function declaration regarding the lvalue nature of args... ?

Answer 1

It will behave exactly like what it looks like. That's kind of the point of a requires expression: to make these things look like C++. So it will behave like C++.

What matters is how you use the concept. That is, when you requires some template based on it, you should invoke the concept correctly. For example:

template<typename Func, typename ...Args
void constrained(Func func, Args &&...args)
  requires has_request_interface<Func, Args...>
{
  Status status = func(std::forward<Args>(args)...);
}

So yes, if you want forwarding through the concept to work, your concept needs to use && and forwarding.