Arun's questions

Estou aprendendo sobre requisitos aninhados em conceitos c++. Considere o trecho de código abaixo:

#include <concepts>
#include <iostream>

// Nested requirement
template <typename... Ts>
concept VariadicAddable = requires(Ts... vs)
{
    (... + vs);                         // + operator is provided
    requires sizeof...(Ts) > 1;         // Atleast two arguments are provided
};

template <VariadicAddable... Ts>
auto add_variadic(Ts... vs)
{
    return (... + vs);
}

int main()
{
    std::cout << add_variadic(1, 2) << std::endl;   // Expecting no failure here
    //std::cout << add_variadic(1) << std::endl;    // Expecting failure here
}

Estou recebendo erros ao compilar isso... (Godbolt, msvc vs17.10 com opção c++20)

<source>(20): error C2672: 'add_variadic': no matching overloaded function found
<source>(13): note: could be 'auto add_variadic(Ts...)'
<source>(20): note: the associated constraints are not satisfied
<source>(12): note: the constraint was not satisfied

Também tentei uma variação de especificação da mesma restrição, como abaixo:

template <typename... Ts>
concept VariadicAddable = (sizeof...(Ts) > 1) && requires(Ts... vs)
{
    (... + vs);  // + operator is provided
};

Estou recebendo erro semelhante nesse caso também. Alguém tem ideia do que estou perdendo?

Considere o seguinte trecho de código.

template <typename T>
concept IsRValue = std::is_rvalue_reference_v<T>;

void funTakingRValues(IsRValue auto&& val)
{
    std::cout << val << std::endl;
}

int main()
{
    auto && x = 5;
    std::cout << "Is rvalue reference = " << std::is_rvalue_reference_v<decltype(x)> << std::endl;
    funTakingRValues(std::forward<decltype(x)>(x));
}

Neste caso, xé considerada uma referência de valor r com base no resultado da instrução cout. Mas a restrição IsRValue que depende do mesmo tipo de traço não é satisfeita. O que está acontecendo?

Considere o seguinte trecho de código:

int x = 10;
std::cout << "Is Integral = " << std::is_integral_v<decltype(x)> << std::endl;
int & y = x;
std::cout << "Is Integral  = " << std::is_integral_v<decltype(y)> << std::endl;

Aqui xé considerado um tipo integral, mas ynão é.
Alguma explicação de por que isso acontece?