Compiler discrepancy concerning type-deduction - c++

Question

I'm trying to construct an object from a templated class which should be of iterator-type based on the container that is being passed through its constructor. To do so, I use a deduction guide which extracts the iterator member-type.
This seems to work on both Clang and GCC. The problem is that when making some seemingly unrelated changes to this class, the code no longer compiles on Clang (but does on some versions of GCC). Here is the code, which I unfortunately couldn't make much smaller:
#include <array>
#include <iterator>
#include <type_traits>
template<typename It>
using category_t = typename std::iterator_traits<It>::iterator_category;
//
template<typename Iter>
struct is_random_access_iter
: std::is_convertible<
category_t<Iter>,
std::random_access_iterator_tag> {};
template<typename T>
struct has_random_access_iter
: is_random_access_iter<typename T::iterator> {};
template<typename T>
struct is_unary_type
: std::conjunction<
std::is_default_constructible<T>,
std::is_copy_constructible<T>> {};
//
template<typename Iter>
inline constexpr auto is_random_access_iter_v
= bool{is_random_access_iter<Iter>{}};
template<typename T>
inline constexpr auto has_random_access_iter_v
= bool{has_random_access_iter<T>{}};
template<typename T>
inline constexpr auto is_unary_type_v
= bool{is_unary_type<T>{}};
//
template<typename It, int Size,
typename = std::enable_if_t<is_random_access_iter<It>{}>>
struct derp {
// constexpr derp() = default;
template<typename T,
typename = std::enable_if_t<is_unary_type<T>{}>,
typename = std::enable_if_t<has_random_access_iter_v<T>>>
// typename = std::enable_if_t<is_random_access_iter_v<typename T::iterator>>>
constexpr explicit derp(T& herp)
: iter{herp.begin()} {}
It iter;
};
template<typename T>
derp(T) -> derp<typename T::iterator, std::tuple_size<T>{}>;
template<typename T>
struct wrap {
constexpr wrap() = default;
constexpr explicit wrap(T& herp)
: herp{herp} {}
derp<typename T::iterator, std::tuple_size<T>{}> herp;
};
auto main() -> int {
auto arr = std::array<int, 3>{};
wrap{arr};
}
One of the problems comes to light when uncommenting the default constructor of derp. It seems as if derp is being instantiated by its own type, instead of the iterator-type from the passed-in container:
GCC ARM 7.2.1:
<source>:44:9: required by substitution of 'template<class T, class, class> constexpr derp<int*, 3, void>::derp(T&) [with T = const derp<int*, 3, void>; <template-parameter-1-2> = void; <template-parameter-1-3> = <missing>]'
<source>:66:13: required from here
<source>:16:8: error: no type named 'iterator' in 'const struct derp<int*, 3, void>'
Clang:
<source>:17:41: error: no type named 'iterator' in 'derp<int *, 3, void>'
: is_random_access_iter<typename T::iterator> {};
~~~~~~~~~~~~^~~~~~~~
<source>:44:37: note: in instantiation of template class 'has_random_access_iter<const derp<int *, 3, void>>' requested here
typename = std::enable_if_t<has_random_access_iter<T>{}>>
^
<source>:46:24: note: in instantiation of default argument for 'derp<const derp<int *, 3, void>, void>' required here
constexpr explicit derp(T& herp)
The code no longer compiles on Clang and GCC ARM 7.2.1. It does however compile on GCC trunk. Why does enabling the default constructor cause a compilation error? And why does GCC >= 11.1 seems to be unaffected?
Live example