Клонировать тип данных так, что бы в нём отсутствовал квалификатор volatile

#include <iostream>
#include <string>
#include <type_traits>
 
 
template<typename T, unsigned = std::is_pointer_v<T> | (std::is_reference_v<T> << 1)>
struct recursive_remove_volatile;
 
 
template<typename T>
struct recursive_remove_volatile<T, 0u> //non pointer, non reference
{
    using type = std::remove_volatile_t<T>;
};
 
 
template<typename T>
struct recursive_remove_volatile<T, 1u> //pointer
{
    using sub_type = typename recursive_remove_volatile<std::remove_pointer_t<T>>::type;
    using type = std::conditional_t<std::is_const_v<T>, sub_type * const, sub_type *>;
};
 
template<typename T>
struct recursive_remove_volatile<T, 2u> //reference
{
    using sub_type = typename recursive_remove_volatile<std::remove_reference_t<T>>::type;
    using type = sub_type &;
};
 
 
template<typename T>
using recursive_remove_volatile_t = typename recursive_remove_volatile<T>::type;
 
 
//-----------------------------------------------------------------------------------
//вывод имени типа сделан под gcc только для этого теста
 
std::string extract_type_name(char const * n)
{
    std::string res(n);
    res.erase(0, res.find("= ") + 2);
    res.resize(res.find(";"));
    return res;
}
 
 
template<typename T>
std::string get_type_name()
{
    return extract_type_name(__PRETTY_FUNCTION__);
}
 
 
template<typename T>
void test()
{
    std::cout << get_type_name<T>() << " --> " << get_type_name<recursive_remove_volatile_t<T>>() << std::endl;
}
 
int main () 
{
    test<int>();
    test<int volatile>();
    test<int *>();
    test<int volatile *>();
    test<int volatile *>();
    test<int volatile * volatile>();
    test<int volatile * volatile * volatile>();
    test<int volatile * volatile const * volatile>();    
    test<int const volatile * volatile const &>();
}

template<typename T, typename = void>
struct recursive_remove_volatile
{
    using type = std::remove_volatile_t<T>;
};
 
template<typename T>
struct recursive_remove_volatile<T, std::enable_if_t<std::is_pointer_v<T>>> //pointer
{
    using sub_type = typename recursive_remove_volatile<std::remove_pointer_t<T>>::type;
    using type = std::conditional_t<std::is_const_v<T>, sub_type * const, sub_type *>;
};
 
template<typename T>
struct recursive_remove_volatile<T, std::enable_if_t<std::is_reference_v<T>>> //reference
{
    using sub_type = typename recursive_remove_volatile<std::remove_reference_t<T>>::type;
    using type = sub_type &;
};

template<typename T>
struct recursive_remove_volatile
{
    using type = std::remove_volatile_t<T>;
};
 
template<typename T> requires(std::is_pointer_v<T>)
struct recursive_remove_volatile<T> //pointer
{
    using sub_type = typename recursive_remove_volatile<std::remove_pointer_t<T>>::type;
    using type = std::conditional_t<std::is_const_v<T>, sub_type * const, sub_type *>;
};
 
template<typename T> requires(std::is_reference_v<T>)
struct recursive_remove_volatile<T> //reference
{
    using sub_type = typename recursive_remove_volatile<std::remove_reference_t<T>>::type;
    using type = sub_type &;
};

template<typename TRes, typename... TArgs>
struct recursive_remove_volatile<TRes(TArgs...), void> 
{
    using type = TRes(typename recursive_remove_volatile<TArgs>::type...);
};

using t = ::tools::no_volatile_t<bool&&>;
std::cout << "type = '" << tools::type_name<t>() << "'\n";

template<typename T, size_t Sz> 
struct recursive_remove_volatile<T[Sz]> 
{
    using sub_type = typename recursive_remove_volatile<T>::type;
    using type = sub_type[Sz];
};