diff --git a/include/boost/iterator/indirect_iterator.hpp b/include/boost/iterator/indirect_iterator.hpp
index c3558e2..ac63aef 100644
--- a/include/boost/iterator/indirect_iterator.hpp
+++ b/include/boost/iterator/indirect_iterator.hpp
@@ -7,115 +7,107 @@
 #ifndef BOOST_INDIRECT_ITERATOR_23022003THW_HPP
 #define BOOST_INDIRECT_ITERATOR_23022003THW_HPP
 
+#include <iterator>
+#include <type_traits>
+
 #include <boost/iterator/iterator_adaptor.hpp>
 
 #include <boost/pointee.hpp>
 #include <boost/indirect_reference.hpp>
 
-#include <boost/detail/indirect_traits.hpp>
 #include <boost/core/use_default.hpp>
 
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/has_xxx.hpp>
-
-#include <iterator>
-#include <type_traits>
-
 namespace boost {
 namespace iterators {
 
-  template <class Iter, class Value, class Category, class Reference, class Difference>
-  class indirect_iterator;
+template< typename Iter, typename Value, typename Category, typename Reference, typename Difference >
+class indirect_iterator;
 
-  namespace detail
-  {
-    template <class Iter, class Value, class Category, class Reference, class Difference>
-    struct indirect_base
-    {
-        typedef typename std::iterator_traits<Iter>::value_type dereferenceable;
+namespace detail {
 
-        typedef iterator_adaptor<
-            indirect_iterator<Iter, Value, Category, Reference, Difference>
-          , Iter
-          , typename ia_dflt_help<
-                Value, pointee<dereferenceable>
-            >::type
-          , Category
-          , typename ia_dflt_help<
-                Reference
-              , mpl::eval_if<
-                    std::is_same<Value,use_default>
-                  , indirect_reference<dereferenceable>
-                  , std::add_lvalue_reference<Value>
-                >
-            >::type
-          , Difference
-        > type;
-    };
+template< typename Iter, typename Value, typename Category, typename Reference, typename Difference >
+struct indirect_base
+{
+    using dereferenceable = typename std::iterator_traits< Iter >::value_type;
 
-    template <>
-    struct indirect_base<int, int, int, int, int> {};
-  } // namespace detail
+    using type = iterator_adaptor<
+        indirect_iterator< Iter, Value, Category, Reference, Difference >,
+        Iter,
+        detail::ia_dflt_help_t<
+            Value,
+            pointee< dereferenceable >
+        >,
+        Category,
+        detail::ia_dflt_help_t<
+            Reference,
+            detail::ia_eval_if_default<
+                Value,
+                indirect_reference< dereferenceable >,
+                std::add_lvalue_reference< Value >
+            >
+        >,
+        Difference
+    >;
+};
+
+} // namespace detail
 
 
-  template <
-      class Iterator
-    , class Value = use_default
-    , class Category = use_default
-    , class Reference = use_default
-    , class Difference = use_default
-  >
-  class indirect_iterator
-    : public detail::indirect_base<
+template<
+    typename Iterator,
+    typename Value = use_default,
+    typename Category = use_default,
+    typename Reference = use_default,
+    typename Difference = use_default
+>
+class indirect_iterator :
+    public detail::indirect_base<
         Iterator, Value, Category, Reference, Difference
-      >::type
-  {
-      typedef typename detail::indirect_base<
-          Iterator, Value, Category, Reference, Difference
-      >::type super_t;
+    >::type
+{
+    using super_t = typename detail::indirect_base<
+        Iterator, Value, Category, Reference, Difference
+    >::type;
 
-      friend class iterator_core_access;
+    friend class iterator_core_access;
 
-   public:
-      indirect_iterator() {}
+public:
+    indirect_iterator() = default;
 
-      indirect_iterator(Iterator iter)
-        : super_t(iter) {}
+    indirect_iterator(Iterator iter) :
+        super_t(iter)
+    {}
 
-      template <
-          class Iterator2, class Value2, class Category2
-        , class Reference2, class Difference2
-      >
-      indirect_iterator(
-          indirect_iterator<
-               Iterator2, Value2, Category2, Reference2, Difference2
-          > const& y
-        , typename enable_if_convertible<Iterator2, Iterator>::type* = 0
-      )
-        : super_t(y.base())
-      {}
+    template<
+        typename Iterator2,
+        typename Value2,
+        typename Category2,
+        typename Reference2,
+        typename Difference2,
+        typename = typename enable_if_convertible< Iterator2, Iterator >::type
+    >
+    indirect_iterator(indirect_iterator< Iterator2, Value2, Category2, Reference2, Difference2 > const& y) :
+        super_t(y.base())
+    {}
 
-  private:
-      typename super_t::reference dereference() const
-      {
-          return **this->base();
-      }
-  };
+private:
+    typename super_t::reference dereference() const
+    {
+        return **this->base();
+    }
+};
 
-  template <class Iter>
-  inline
-  indirect_iterator<Iter> make_indirect_iterator(Iter x)
-  {
-    return indirect_iterator<Iter>(x);
-  }
+template< typename Iter >
+inline indirect_iterator< Iter > make_indirect_iterator(Iter x)
+{
+    return indirect_iterator< Iter >(x);
+}
 
-  template <class Traits, class Iter>
-  inline
-  indirect_iterator<Iter,Traits> make_indirect_iterator(Iter x, Traits* = 0)
-  {
-    return indirect_iterator<Iter, Traits>(x);
-  }
+template< typename Value, typename Iter >
+inline indirect_iterator< Iter, Value > make_indirect_iterator(Iter x)
+{
+    return indirect_iterator< Iter, Value >(x);
+}
 
 } // namespace iterators