std::enable_if for std::is_integral and its negation both show as ambiguous candidate overloads

I have some API that serializes values. I have created a wrapper that helps by having a simple one method that should accept all supported types.

Most types require explicit implementation, but all integer types are accepted by single method on that API. I wrote this code:

// Used to allow for human readable error on missing overload
template<typename T>
struct fail_if_invoked : std::false_type
{ };

// This overload should get selected if value is not integer type and explicit overload does not exist
template<typename TVal, typename std::enable_if<!std::is_integral<TVal>::value>::type* = nullptr>
void accept_value(TVal && vadd)
{
    static_assert(fail_if_invoked<TVal>::value, "Missing implementation for this type");
}

// This overload should handle all integer types
template<typename TInteger, typename std::enable_if<std::is_integral<TInteger>::value>::type* = nullptr>
void accept_value(TInteger num)
{
    ...
}

void accept_value(const char*) 
{
    ...
}

However, when unsigned int is the argument to accept_value, I get an error about ambiguous call, for these overloads:

my_helper.h:37:10: note: candidate function [with TVal = unsigned short &, $1 = nullptr]
    void accept_value(TVal && vadd)
         ^
my_helper.h:44:10: note: candidate function [with TInteger = unsigned short, $1 = nullptr]
    void accept_value(TInteger num)
         ^
my_helper.h:59:10: note: candidate function
    void accept_value(double num)
         ^
my_helper.h:79:10: note: candidate function
    void accept_value(bool num)

I sort of understand the bool and double, although it wasn't an issue when I had explicit overloads for everything. But why is the void add_value(TVal && vadd) still in the list when !std::is_integral<TVal> should disable it?

And is it even possible to have generic implementation for all integral types while also having bool and double overloads?

You need to wrap the template parameter in std::decay_t to get the raw type without any reference or const, because std::integral<int&> will evaluate to false.

Update - additional explanation

The signature accept_value(TVal && vadd) accepts the parameter using an rvalue-reference (often called a universal reference). If you pass a variable of type int, TVal will deduce to int&. If you pass a literal integer like 1, TVal will deduce to int. Without the std::decay_t, this will cause different results when std::is_integral is evaluated. Overload resolution will behave accordingly.

End Update

Sample Code

#include <iostream>

// Used to allow for human readable error on missing overload
template<typename T>
struct fail_if_invoked : std::false_type
{ };

// This overload should get selected if value is not integer type and explicit overload does not ex\
ist
template<typename TVal,
         typename std::enable_if<!std::is_integral<std::decay_t<TVal>>::value>::type* = nullptr>
void accept_value(TVal && vadd)
{
    static_assert(fail_if_invoked<TVal>::value, "Missing implementation for this type");
}

// This overload should handle all integer types
template<typename TInteger,
         typename std::enable_if<std::is_integral<std::decay_t<TInteger>>::value>::type* = nullptr>
void accept_value(TInteger num)
{
}

int main(int argc, const char *argv[]) {
    int a{};
    accept_value(a);
    accept_value(1);
    accept_value("char");
    return 0;
}

Output

/work/so/scratch/src/p1.cpp:16:5: error: static assertion
      failed due to requirement 'fail_if_invoked<const char (&)[5]>::value': Missing
      implementation for this type
    static_assert(fail_if_invoked<TVal>::value, "Missing implementation for this type");
    ^             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/work/so/scratch/src/p1.cpp:30:5: note: in instantiation of
      function template specialization 'accept_value<const char (&)[5], nullptr>' requested here
    accept_value("char");
    ^
1 error generated.

Update

As an aside, this gets much easier with c++20

template<class T> requires (not std::is_integral_v<std::decay_t<T>>)
void accept_value(T&& vadd)
{
    static_assert(std::is_integral_v<std::decay_t<T>>, "Missing implementation for this type");
}

template<class T> requires (std::is_integral_v<std::decay_t<T>>)
void accept_value(T&& num)
{
}