The revised approach here is to use a traits class to tell the library when to use heterogenous lookups. This is necessarily formed of both compile-time and run-time components. The primary requirement is that if the traits determine that heterogenous lookup is invalid, then the semantics of homogenous lookup should be preserved as much as possible.

The compile-time lookup is necessary not just for performance or simplicity of use, but because some types cannot use the fallback of the existing homogenous find implementation, such as unique_ptr<T> and T*. It is best to ban these at compile-time rather than finding out at run-time that they can't be used.

The run-time lookup is necessary because hash types may be stateful so the correct answer to the question "Is heterogenous lookup valid" may depend on the state of the hasher. In this case, it must be legal for the fallback of the existing homogenous find to be used, necessitating that only types which can be implicitly converted to K be permitted.

namespace std {
    enum class hash_traits_result {
        always_true,
        always_false,
        runtime
    };
    template<typename T> struct hash_traits {
        template<typename A, typename B> struct heterogenous {
            static constexpr hash_traits_result result = hash_traits_result::always_false;
        };
    };
    template<> struct hash_traits<std::hash<>> {
        template<typename A, typename B> struct heterogenous;
    };
    template<typename T> struct hash_traits<std::hash<>>::heterogenous<std::unique_ptr<T>, T*> {
        static constexpr hash_traits_result result = hash_traits_result::always_true;
    };
}
struct mah_hasher {
    bool do_the_right_thing;
};
template<> struct hash_traits<mah_hasher>::heterogenous<X, Y> {
    static constexpr hash_traits_result result = hash_traits_result::runtime;
    bool operator()(const mah_hasher& ref) {
        return ref.do_the_right_thing;
    }
};

template<typename T> iterator find(T&& t);
If hash_traits<F>::heterogenous<K, typename std::decay<T>::type>::result is always_false, remove from overload set.
If it is always_true, continue with heterogenous lookup.
If it is runtime, then static_assert(is_convertible<K, T&&>::result). If hash_traits<F>::heterogenous<K, typename std::decay<T>::type>()(f) is true, continue with heterogenous lookup. Else, return homogenous find(std::forward<T>(t));

Mirror for const_iterator version of find, and const/non-const erase. For indexing operator, the selection logic is valid, but in a heterogenous lookup, insertion is impossible, so throw instead if there was no element found.

Also included is the hash diamond discussed in the previous version of this paper.