Deduction guide for the template class std::valarray<T> - c++

Question

In the C++ Standard there is the following deduction guide for the template class std::valarray<T>:
template<class T, size_t cnt> valarray(const T(&)[cnt], size_t) -> valarray<T>;
However among the constructors of the class there is only the following appropriate constructor (or am I mistaken?)
valarray(const T&, size_t);
However if to run the following demonstrative program with a similar deduction guide
#include <iostream>
#include <utility>
template <typename T>
struct A
{
A( const T &, size_t ) { std::cout << "A<T>()\n"; }
};
template<class T, size_t cnt>
A(const T(&)[cnt], size_t) -> A<T>;
int main()
{
int a[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
A obj( a, std::size( a ) );
}
the gcc compiler issues error
rog.cc:17:12: error: invalid conversion from 'int*' to 'int' [-fpermissive]
17 | A obj( a, std::size( a ) );
| ^
| |
| int*
prog.cc:7:8: note: initializing argument 1 of 'A<T>::A(const T&, size_t) [with T = int; size_t = long unsigned int]'
7 | A( const T &, size_t ) { std::cout << "A<T>()\n"; }
| ^~~~~~~~~
So a question arises whether it is a defect of the C++ Standard, or a bug of the compiler or I missed something.

Answer 1

Using the example given by https://en.cppreference.com/w/cpp/numeric/valarray/deduction_guides, we can look at the compiler output without optimizations to see which constructor is called:
int a[] = {1, 2, 3};
std::valarray va(a, 3);
https://godbolt.org/z/rtgeoi
main:
[...]
call std::valarray<int>::valarray(int const*, unsigned long)
[...]
C++ arrays decay to pointers to their first element very easily. However, without the deduction guide, the type deduced from the implicit guides would be std::valarray<int[3]> (the guide generated from valarray(const T&, size_t) wins because it does not need the array-to-pointer conversion). This can be demonstrated in your example, if we have both the A(const T&, std::size_t); and A(const T*, std::size_t); constructors:
template <typename T>
struct A
{
A(const T&, std::size_t);
A(const T*, std::size_t);
};
int main()
{
int a[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
A obj(a, 10);
}
// Result:
call A<int [10]>::A(int const (&) [10], unsigned long)
https://godbolt.org/z/nlFlVT
Adding the deduction guide correctly deduces the intended int instead of int[10]: https://godbolt.org/z/efj557

Answer 2

However among the constructors of the class there is only the following appropriate constructor (or am I mistaken?)
There's also this one:
valarray( const T* vals, std::size_t count );
Which does match, when the array you pass in decays to a pointer, allowing the cppreference example to compile.