Рекурсивный вызов constexpr функции

struct Test {
    const int test = 0; 
    constexpr Test(int _test) :test(_test) {}
    constexpr Test() : test(1) {}
};
 
//любой из вариантов бы завести:
template <const Test & argtest> constexpr Test funcTest() {
    if (argtest.test < 4) return Test{ argtest.test + 1 };// - это работает                                                        
    //return funcTest < Test{argtest.test + 1}> ();//это нет
    
    //static 
    //constexpr auto temp = Test{ argtest.test + 1 };
    //return funcTest <temp> (); //и это нет - что со static, что без static
    return  Test(argtest.test + 1);
};
 
template <const Test * argtest> constexpr Test* funcTestP() {
    if (argtest->test < 4) return &Test{ argtest->test + 1 };// - это работает
        //return funcTestP < &Test{ argtest->test + 1 } > ();//это нет
    return  &Test(argtest->test + 1);
};
 
constexpr Test t;
constexpr Test T = funcTest<t>();
constexpr Test* Tt = funcTestP<&t>();
 
//работающая классика:
struct Ta {
    const int heap = 0;
    const Ta* tail = nullptr;
};
template <const int N> constexpr Ta genList() {
    if constexpr (N > 3) return Ta{ N,&(genList<N - 2>()) };
    else return Ta{ N,&(genList<N - 1>()) };
    //return (N > 3) ? Ta{ N,&(D3<N - 2>()) } : Ta{ N,&(D3<N - 1>()) };//размечтался
}
template <> constexpr Ta genList<0>() { return Ta{ 0,nullptr }; }
constexpr Ta t_= genList<5>();

return &Test{ argtest->test + 1 };// - это работает

constexpr std::array<int, 5>  a = {1,2,2,3,4};
constexpr auto  b = magicVoodooConstexprFunc<a>();//результат: {1,3,4}; auto ==std::array<int, 3> ;magicVoodooConstexprFunс(a)-разумеется тоже пойдет.

struct Tp {};
 
Tp obj;
 
template <Tp * p>
void foo() {}
 
int main()
{
    foo<&obj>();
}

....static constexpr auto temp = Test{ argtest.test + 1 };....

template <typename Seq>
struct make_array;
 
template <typename T, T... Vs>
struct make_array<std::integer_sequence<T, Vs...>>
{
    static constexpr T value[] = { Vs... };
};
 
using arr = std::integer_sequence<int, 1, 2, 2, 3, 4>;
 
int main()
{
    for(auto v : make_array<arr>::value)
    {
        std::cout << v << ' ';
    }
}

//Max contribution from Luc Danton, Joel Falcou, Toby Speight, HolyBlackCat. My respect for him.
//https://stackoverflow.com/questions/9644477/how-to-check-whether-a-class-has-specified-nested-class-definition-or-typedef-in
//https://stackoverflow.com/questions/50471075/constexpr-variadic-template-and-unpacking-stdarray 
//https://stackoverflow.com/questions/57131705/how-to-check-if-specific-overload-of-an-operator-exists-at-compile-time-in-c
#include <iostream>
#include <array> 
using namespace std;
constexpr array<int, 5> a = {1,2,2,3,4}; constexpr int b = 5;
 
template <class ...T> class TPack {};
template<class T> using TPackCheckArray =
TPack<typename T::size_type, typename T::value_type, decltype(&T::size)>;
template <class T> using TBracketPointer=const typename T::value_type& (T::*)(typename T::size_type) const noexcept;
 
template<class T, class R = void> struct enable_if_type {typedef R type;}; 
template<class T> using enable_if_type_t =typename enable_if_type<T>::type;
 
template<class T, class Enable = void> struct conditionsArrayTemp : false_type {};
template<class T>struct conditionsArrayTemp
<T, enable_if_type_t <
pair<TPackCheckArray<T>, decltype((TBracketPointer<T>)& T::operator[])>
>>:true_type {};
 
template<class T > constexpr bool conditionsArray = conditionsArrayTemp<T>::value
&& is_integral_v<typename T::size_type>;
template<class T> using TconditionsArray = enable_if_t<conditionsArray<T>>;
template<class T> using TNOconditionsArray = enable_if_t<!conditionsArray<T>>;
 
template <class Tsize, Tsize Size, const auto& Arr, Tsize Index>
constexpr bool indexOnce() {
    for (auto i =0; i != Index; ++i) if (Arr[i] == Arr[Index]) return false;
    for (auto i = Index + 1; i != Size; ++i) if (Arr[i] == Arr[Index]) return false; 
    return true;
}
 
template <class T, class Tsize, class Tvalue, Tsize Size, const T& Arr, Tsize Index = 0, typename... Tpack>
constexpr auto uniqueDataArray(Tpack &&... vpack)   {
    if constexpr (Index==Size) return array<Tvalue, sizeof...(Tpack)>{ forward<Tpack>(vpack)... };
    else {
        if constexpr(indexOnce<Tsize,Size,Arr,Index>()) 
            return uniqueDataArray<T,Tsize, Tvalue, Size, Arr, Index + 1>(forward<Tpack>(vpack)..., Arr[Index]);
        else 
            return uniqueDataArray<T, Tsize, Tvalue, Size, Arr, Index + 1>(forward<Tpack>(vpack)...);
    }
}
template <typename T, const T& Arr,
/*enable_if_t<conditionsArray<T>,int> v=0*/
TconditionsArray<T>* = nullptr>
constexpr auto uniqueDataArray() {
    return uniqueDataArray<T, typename T::size_type, typename T::value_type, Arr.size(), Arr, 0>();
}
template<typename T, const T& Arr, TNOconditionsArray<T>* = nullptr>
constexpr auto uniqueDataArray() {
    /*static_assert(false, "This is all wrong! U shouldn't be up here!");*/
    return 0;
}
template<typename T,const T Arr> constexpr auto uniqueDataArray() {
    /*static_assert(false,"U go down a dark road, bro!");*/
    return 1;
}
 
#define MAGIC(a) uniqueDataArray<decltype(a),decltype(a)::size_type,decltype(a)::value_type, a.size(), a>();
#define MAGIC1(a) uniqueDataArray<decltype(a),a>();
 
int main() {
    constexpr auto a0 = uniqueDataArray<decltype(a), a>();
    constexpr auto a1 = uniqueDataArray<decltype(b), b>();
    constexpr auto a2 = MAGIC(a);
    constexpr auto a3 = MAGIC1(a);
    constexpr auto a4 = MAGIC1(b);  
    auto r = a1 + a4 + 1;
}