V>        template <typename BoolType, std::enable_if_t<is_bool_v<BoolType>, int> = 0>
V>        Element(BoolType value);
V>        template <typename IntType, std::enable_if_t<is_int_v<IntType>, int> = 0>
V>        Element(IntType value);
V>        template <typename UintType, std::enable_if_t<is_uint_v<UintType>, int> = 0>
V>        Element(UintType value);
V>        template <typename FloatType, std::enable_if_t<is_float_v<FloatType>, int> = 0>
V>        Element(FloatType value);
V>        ...
V>

V>        template <BoolType ValueType>
V>        Element(ValueType value);
V>        template <IntType ValueType>
V>        Element(ValueType value);
V>        template <UintType ValueType>
V>        Element(ValueType value);
V>        template <FloatType ValueType>
V>        Element(ValueType value);
V>        ...
V>

#include <type_traits>
using namespace std;

template<typename T> concept Arithmetic = is_arithmetic_v<T>;
template<typename T> concept Integral = Arithmetic<T> and is_integral_v<T>;

void with_concept(Arithmetic auto){}
void with_concept(Integral auto){}

template<typename T> enable_if_t<is_arithmetic_v<T>> with_sfinae(T){}
template<typename T> enable_if_t<is_arithmetic_v<T> and is_integral_v<T>> with_sfinae(T){}

int main()
{
    with_concept(1);
    with_concept(1.0);
    
    // with_sfinae(1); // error: call of overloaded 'with_sfinae(int)' is ambiguous
    with_sfinae(1.0);
}

template <typename T>
  requires std::is_standard_layout_v<T>
void fun(T v);
 
template <typename T>
  requires std::is_standard_layout_v<T>
        && std::is_trivial_v<T>
void fun(T v);

fun(1); // compiler error: ambiguous call

template <typename T>
concept standard_layout 
  = std::is_standard_layout_v<T>;
 
template <typename T>
  requires standard_layout<T>
void fun(T v);
 
template <typename T>
  requires standard_layout<T> && std::is_trivial_v<T>
void fun(T v);
 
int main()
{
  fun(1); // Вторая перегрузка так как более точная
}

        template <typename BoolType, std::enable_if_t<is_bool_v<BoolType>, int> = 0>
        Element(BoolType value);
        template <typename IntType, std::enable_if_t<is_int_v<IntType>, int> = 0>
        Element(IntType value);
        template <typename UintType, std::enable_if_t<is_uint_v<UintType>, int> = 0>
        Element(UintType value);
        template <typename FloatType, std::enable_if_t<is_float_v<FloatType>, int> = 0>
        Element(FloatType value);
        ...

        template <BoolType ValueType>
        Element(ValueType value);
        template <IntType ValueType>
        Element(ValueType value);
        template <UintType ValueType>
        Element(ValueType value);
        template <FloatType ValueType>
        Element(ValueType value);
        ...