Why can normal functions not have "auto" arguments if "lambda Expressions" can in C++?

Question

I realized that the "lambda Expressions" accept arguments of the type auto. For example:

auto add = [](const auto& x, const auto& y) 
{
    return x + y;
}

So I tried normal functions, but it didn’t work:

auto add(const auto& x, const auto& y)
{
    return x + y; // Não compila
} 

Could someone explain to me why this?

Answer 1

First, auto for standard parameters exists to cover the fact that there is no way to specify generic types using template. But that was up to c++17, for that changed in c++20, with the possibility of specify them within the lambda:

auto sum = []<typename T, typename U>(T a, U b) { return a + b; };

Still in c++20, the functionality c++-Concepts entered the language, and together came the possibility to declare normal functions with the syntax of auto:

auto square(auto a, auto b) -> decltype(a + b)
{
    return a + b;
}

Alternatively, you can write the same function above using c++templates:

template <typename T, typename U>
auto sum(T a, U b) -> decltype(a + b)
{
    return a + b;
}

Answer 2

This is a matter of logic. Why, for example, the functions have the return set:

int main(){

    //Na main o retorno é de um inteiro, se o programa executar normalmente retorna 0.
    auto v1 = 56; //O auto é um tipo indefinido, tem que ser inicializada para saber qual tipo.

    return 0; 
}

In this example you asked in your question.

auto add(const auto& x, const auto& y)
{
    return x + y; //não compila porque o auto é indefinido então o compilador não vai saber qual
    //é o retorno. Mesmo usando em parâmetros também não dá certo
} 

auto add = [](const auto& x, const auto& y) //Já aqui nessa parte ele aceita.
{
    //Uma parte porque ela é inicializada como uma função.
    //A outra em forma de função não lambda não acontece pois o compilador não irá saber se é 
    //um retorno, por exemplo, int, double, float, char, const char* entre outros.
    return x + y;
}

Already in a template:

template <typename in, typename out> out func(in _valor){
    //...
    //Podemos usar o template em retorno e em entrada pois quando for chamar
    //indicaremos o tipo a cada typename como float para entrada e int para saída.
}