Исправить ошибку в коде из книги

#pragma once
 
#include <cstddef>
#include <array>
 
template <typename T, std::size_t N>
struct DotProductT
{
    static inline T Result(T const * a, T const * b)
    {
        return *a * *b + DotProductT<T, N - 1>::Result(a + 1, b + 1);
    }
};
 
template <typename T>
struct DotProductT <T, 0>
{
    static inline T Result(T const *, T const *)
    {
        return T{};
    }
};
 
template <typename T, std::size_t N>
auto DotProduct(std::array<T, N> const & x,
                std::array<T, N> const & y)
{
    return DotProductT<T, N>::Result(x.begin(), y.begin() )
    // return DotProductT<T, N>::Result(&*x.begin(), &*y.begin() );
}

template <typename T, std::size_t N>
auto DotProduct(T (&x)[N], T (&y)[N] )
{
    return DotProductT<T, N>::Result(x, y);
}

 return DotProductT<T, N>::Result(std::to_address(x.begin()), std::to_address(y.begin()));

    template <typename It1, typename It2>
    static inline T Result(It1 a, It2 b)
    {
        return *a * *b + DotProductT<T, N - 1>::Result(a + 1, b + 1);
    }

template <typename TArray> //requires std::is_array_v<T>
auto DotProduct(TArray &x, TArray &y)
{
    //constexpr size_t N = std::size(std::declval<TArray>());
    constexpr size_t N = sizeof(x) / sizeof(x[0]);
    using T = std::iter_value_t<decltype(std::begin(x))>;
    return DotProductT<T, N>::Result(std::begin(x), std::begin(y));
}

template <typename T, std::size_t N>
struct DotProductT
{
    static inline auto Result(T a, T b) -> decltype (*a * *b)
    {
        return *a * *b + DotProductT<T, N - 1>::Result(a + 1, b + 1);
    }
};
 
template <typename T>
struct DotProductT <T, 0>
{
    static inline auto Result(T a, T b) -> decltype (*a * *b)
    {
        return {};
    }
};
 
template <typename T, std::size_t N>
auto DotProduct(std::array<T, N> const & x,
                std::array<T, N> const & y)
{
    return DotProductT<T, N>::Result(x.begin(), y.begin());
}

template <typename T, std::size_t N>
auto DotProduct(std::array<T, N> const & x,
                std::array<T, N> const & y)
{
    return DotProductT<typename std::array<T, N>::const_iterator, N>::Result(x.begin(), y.begin());
}

template <std::size_t N>
struct DotProductT
{
    template <typename T> static inline auto Result(T a, T b) -> decltype (*a * *b)
    {
        return *a * *b + DotProductT<N - 1>::Result(a + 1, b + 1);
    }
};
 
template <>
struct DotProductT <0>
{
    template <typename T> static inline auto Result(T a, T b) -> decltype (*a * *b)
    {
        return {};
    }
};
 
template <typename T, std::size_t N>
auto DotProduct(std::array<T, N> const & x,
                std::array<T, N> const & y)
{
    return DotProductT<N>::Result(x.begin(), y.begin());
}