vc++ fail, C++ (vc++)

Language: Layout:

//Microsoft (R) C/C++ Optimizing Compiler Version 19.00.23506 for x86

#include <iostream>
#include <functional>

namespace detail
{
	// Reason to use an enum class rahter than just an int is so as to ensure
	// there will not be any clashes resulting in an ambigious overload.
	enum class enabler
	{
		enabled
	};
}
#define ENABLE_IF(...) std::enable_if_t<(__VA_ARGS__), detail::enabler> = detail::enabler::enabled
#define ENABLE_IF_DEFINITION(...) std::enable_if_t<(__VA_ARGS__), detail::enabler>

namespace detail
{
	template <typename T, bool IS_BUILTIN>
	class is_value
	{
		T item_to_find;
		std::function<bool(T const& lhs, T const& rhs)> predicate;
	public:
		constexpr is_value(T item_to_find, std::function<bool(T, T)> predicate)
			: item_to_find(item_to_find)
			, predicate(predicate)
		{}

constexpr bool one_of() const
		{
			return false;
		}

template <typename T1, typename...Ts>
		constexpr bool one_of(T1 const & item, Ts const&...args) const
		{
			return predicate(item_to_find, item) ? true : one_of(args...);
		}
	};

template <typename T>
	class is_value<T, false>
	{
		T const& item_to_find;
		std::function<bool(T const& lhs, T const& rhs)> predicate;
	public:
		constexpr is_value(T const& item_to_find, std::function<bool(T const&, T const&)> predicate)
			: item_to_find(item_to_find)
			, predicate(predicate)
		{}

constexpr bool one_of() const
		{
			return false;
		}

template <typename T1, typename...Ts>
		constexpr bool one_of(T1 const & item, Ts const&...args) const
		{
			return predicate(item_to_find, item) ? true : one_of(args...);
		}
	};
}

// Find if a value is one of one of the values in the variadic parameter list.
// There is one overload for builtin types and one for classes.  This is so
// that you can use builtins for template parameters.
//
// Complexity is O(n).
//
// Usage:
//
//   if (is_value(1).one_of(3, 2, 1)) { /* do something */ }
//
template <typename T, ENABLE_IF(!std::is_class<T>::value)>
constexpr auto const is_value(T item_to_find, std::function<bool(T, T)> predicate = [](T lhs, T rhs) { return lhs == rhs; })
{
	return detail::is_value<T, true>(item_to_find, predicate);
}

template <typename T, ENABLE_IF(std::is_class<T>::value)>
constexpr auto const is_value(T const& item_to_find, std::function<bool(T const&, T const&)> predicate = [](T const& lhs, T const& rhs) { return lhs == rhs; })
{
	return detail::is_value<T, false>(item_to_find, predicate);
}

template <int I, ENABLE_IF(is_value(I).one_of(3,2,1))>
    void fn()
{
}

int main()
{
    fn<3>();
    std::cout << "Hello, world!\n" << is_value(3).one_of(3,2,1);
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 2,32 sec, absolute service time: 2,36 sec