#include <iostream>
//First, some boilerplate to do easy argument dependent lookup of `begin` in a context where `std::begin` is visible:
 
    #include <utility>
    #include <iterator>
    namespace adl_details {
      using std::begin; using std::end;
      template<class R>
      decltype(begin(std::declval<R>())) adl_begin(R&&r){
        return begin(std::forward<R>(r));
      }
      template<class R>
      decltype(end(std::declval<R>())) adl_end(R&&r){
        return end(std::forward<R>(r));
      }
    }
    using adl_details::adl_begin;
    using adl_details::adl_end;
//This is required to reasonably emulate how range-based `for(:)` loops find their begin/end iterators.  By packaging it up like this, we reduce boilerplate below.
 
//Next, some C++1y style utility aliases:
 
    template<class>struct sink {using type=void;};
    template<class X>using sink_t=typename sink<X>::type;
    template<bool b, class T=void>using enable_if_t=typename std::enable_if<b,T>::type;
//`sink_t` takes any type, and throws it away replacing it with `void`.
 
//`enable_if_t` removes annoying `typename` spam below.
 
//In an industrial strength library, we'd put this in `detail`s, and have a 1-type-argument version that dispatches to it.  But I don't care:
 
    template<class I,class=void> struct is_iterator:std::false_type{};
    template<> struct is_iterator<void*,void>:std::false_type{};
    template<> struct is_iterator<void const*,void>:std::false_type{};
    template<> struct is_iterator<void volatile*,void>:std::false_type{};
    template<> struct is_iterator<void const volatile*,void>:std::false_type{};
    template<class I>struct is_iterator<I,
      sink_t< typename std::iterator_traits<I>::value_type >
    >:std::true_type{};
//`is_iterator` doesn't do heavy auditing of the `iterator_traits` of `I`.  But it is enough.
 
    template<class R>
    using begin_t=decltype(adl_begin(std::declval<R&>()));
    template<class R>
    using end_t=decltype(adl_end(std::declval<R&>()));
//These two type aliases make the stuff below less annoying.
 
//Again, in industrial strength libraries, put 2-arg-with-`void` into `details`:
 
    template<class R,class=void> struct has_iterator:std::false_type{};
    template<class R>
    struct has_iterator<
      R,
      enable_if_t<
        is_iterator<begin_t<R>>::value
        && is_iterator<end_t<R>>::value
        // && std::is_same<begin_t<R>,end_t<R>>::value
      >
    >:std::true_type{};
//Note the commented out line in the `enable_if_t` above.  I left that out to allow asymmetric iteration to work, where the `end` is a type that has a different `operator==` overload.  Such is being considered for C++17: it allows really, really efficient algorithms on null-terminated strings (for example).
 
//Finally, the final output:
 
    template<class R>using iterator_t=enable_if_t<has_iterator<R>::type, begin_t<R>>;
//which evaluates to the iterator of the iterable range `R` iff it has one.
 
//There are cases where this won't work, but they are pathological.
 
int main() {
	int X[3];
	std::cout << has_iterator<decltype(X)>::value << "\n";
	begin_t<decltype(X)> x;
	std::cout << is_iterator<int*>::value << is_iterator<begin_t<decltype(X)>>::value << "\n";
	std::cout << is_iterator<void*>::value << "\n";
	std::cout << is_iterator<int>::value << "\n";
	return 0;
}

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