diff --git a/CMakeLists.txt b/CMakeLists.txt
index a0dcf84..bedf55b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -24,7 +24,6 @@ target_link_libraries(boost_iterator
         Boost::mpl
         Boost::optional
         Boost::smart_ptr
-        Boost::static_assert
         Boost::type_traits
         Boost::utility
 )
diff --git a/example/node_iterator2.hpp b/example/node_iterator2.hpp
index 1f5d834..86bfc9e 100644
--- a/example/node_iterator2.hpp
+++ b/example/node_iterator2.hpp
@@ -6,11 +6,7 @@
 
 # include "node.hpp"
 # include <boost/iterator/iterator_facade.hpp>
-
-# ifndef BOOST_NO_SFINAE
-#  include <boost/type_traits/is_convertible.hpp>
-#  include <boost/utility/enable_if.hpp>
-# endif
+# include <type_traits>
 
 template <class Value>
 class node_iter
@@ -33,21 +29,13 @@ class node_iter
     template <class OtherValue>
     node_iter(
         node_iter<OtherValue> const& other
-# ifndef BOOST_NO_SFINAE
-      , typename boost::enable_if<
-            boost::is_convertible<OtherValue*,Value*>
+      , typename std::enable_if<
+            std::is_convertible<OtherValue*,Value*>::value
           , enabler
         >::type = enabler()
-# endif
     )
       : m_node(other.m_node) {}
 
-
-# if !BOOST_WORKAROUND(__GNUC__, == 2)
- private: // GCC2 can't grant friendship to template member functions
-    friend class boost::iterator_core_access;
-# endif
-
     template <class OtherValue>
     bool equal(node_iter<OtherValue> const& other) const
     {
diff --git a/example/node_iterator3.hpp b/example/node_iterator3.hpp
index 3ae7bec..9d224b4 100644
--- a/example/node_iterator3.hpp
+++ b/example/node_iterator3.hpp
@@ -6,11 +6,7 @@
 
 # include "node.hpp"
 # include <boost/iterator/iterator_adaptor.hpp>
-
-# ifndef BOOST_NO_SFINAE
-#  include <boost/type_traits/is_convertible.hpp>
-#  include <boost/utility/enable_if.hpp>
-# endif
+# include <type_traits>
 
 template <class Value>
 class node_iter
@@ -38,12 +34,10 @@ class node_iter
     template <class OtherValue>
     node_iter(
         node_iter<OtherValue> const& other
-# ifndef BOOST_NO_SFINAE
-      , typename boost::enable_if<
-            boost::is_convertible<OtherValue*,Value*>
+      , typename std::enable_if<
+            std::is_convertible<OtherValue*,Value*>::value
           , enabler
         >::type = enabler()
-# endif
     )
       : super_t(other.base()) {}
 
diff --git a/include/boost/indirect_reference.hpp b/include/boost/indirect_reference.hpp
index 3279cd0..21f0904 100644
--- a/include/boost/indirect_reference.hpp
+++ b/include/boost/indirect_reference.hpp
@@ -13,7 +13,6 @@
 
 # include <boost/detail/is_incrementable.hpp>
 # include <boost/iterator/iterator_traits.hpp>
-# include <boost/type_traits/remove_cv.hpp>
 # include <boost/mpl/eval_if.hpp>
 # include <boost/pointee.hpp>
 
diff --git a/include/boost/iterator/counting_iterator.hpp b/include/boost/iterator/counting_iterator.hpp
index 65c11e9..9af9e77 100644
--- a/include/boost/iterator/counting_iterator.hpp
+++ b/include/boost/iterator/counting_iterator.hpp
@@ -5,19 +5,14 @@
 #ifndef COUNTING_ITERATOR_DWA200348_HPP
 # define COUNTING_ITERATOR_DWA200348_HPP
 
+# include <type_traits>
+
 # include <boost/config.hpp>
-# include <boost/static_assert.hpp>
+# include <boost/detail/workaround.hpp>
 # ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
 # include <limits>
-# elif !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
-# include <boost/type_traits/is_convertible.hpp>
-# else
-# include <boost/type_traits/is_arithmetic.hpp>
 # endif
-# include <boost/type_traits/is_integral.hpp>
 # include <boost/type_traits/type_identity.hpp>
-# include <boost/type_traits/conditional.hpp>
-# include <boost/type_traits/integral_constant.hpp>
 # include <boost/detail/numeric_traits.hpp>
 # include <boost/iterator/iterator_adaptor.hpp>
 
@@ -39,7 +34,7 @@ namespace detail
   struct is_numeric_impl
   {
       // For a while, this wasn't true, but we rely on it below. This is a regression assert.
-      BOOST_STATIC_ASSERT(::boost::is_integral<char>::value);
+      static_assert(std::is_integral<char>::value, "");
 
 # ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
 
@@ -50,11 +45,11 @@ namespace detail
 #  if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
       BOOST_STATIC_CONSTANT(
           bool, value = (
-              boost::is_convertible<int,T>::value
-           && boost::is_convertible<T,int>::value
+              std::is_convertible<int,T>::value
+           && std::is_convertible<T,int>::value
       ));
 #  else
-      BOOST_STATIC_CONSTANT(bool, value = ::boost::is_arithmetic<T>::value);
+      BOOST_STATIC_CONSTANT(bool, value = std::is_arithmetic<T>::value);
 #  endif
 
 # endif
@@ -62,7 +57,7 @@ namespace detail
 
   template <class T>
   struct is_numeric
-    : boost::integral_constant<bool, ::boost::iterators::detail::is_numeric_impl<T>::value>
+    : std::integral_constant<bool, ::boost::iterators::detail::is_numeric_impl<T>::value>
   {};
 
 #  if defined(BOOST_HAS_LONG_LONG)
@@ -116,7 +111,7 @@ namespace detail
   {
       typedef typename detail::ia_dflt_help<
           CategoryOrTraversal
-        , typename boost::conditional<
+        , typename std::conditional<
               is_numeric<Incrementable>::value
             , boost::type_identity<random_access_traversal_tag>
             , iterator_traversal<Incrementable>
@@ -125,7 +120,7 @@ namespace detail
 
       typedef typename detail::ia_dflt_help<
           Difference
-        , typename boost::conditional<
+        , typename std::conditional<
               is_numeric<Incrementable>::value
             , numeric_difference<Incrementable>
             , iterator_difference<Incrementable>
@@ -225,7 +220,7 @@ class counting_iterator
     difference_type
     distance_to(counting_iterator<OtherIncrementable, CategoryOrTraversal, Difference> const& y) const
     {
-        typedef typename boost::conditional<
+        typedef typename std::conditional<
             detail::is_numeric<Incrementable>::value
           , detail::number_distance<difference_type, Incrementable, OtherIncrementable>
           , detail::iterator_distance<difference_type, Incrementable, OtherIncrementable>
diff --git a/include/boost/iterator/detail/config_def.hpp b/include/boost/iterator/detail/config_def.hpp
index bd04b75..75d2198 100644
--- a/include/boost/iterator/detail/config_def.hpp
+++ b/include/boost/iterator/detail/config_def.hpp
@@ -46,9 +46,7 @@
 
 #endif
 
-#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x5A0))                      \
-    || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \
-    || BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))                \
+#if (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \
     || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
 
 # define BOOST_NO_LVALUE_RETURN_DETECTION
@@ -83,46 +81,4 @@
 
 #endif
 
-#if BOOST_WORKAROUND(__MWERKS__, <=0x2407)
-#  define BOOST_NO_IS_CONVERTIBLE // "is_convertible doesn't work for simple types"
-#endif
-
-#if BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4) && !defined(__EDG_VERSION__)   \
-    || BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
-#  define BOOST_NO_IS_CONVERTIBLE_TEMPLATE // The following program fails to compile:
-
-#  if 0 // test code
-    #include <boost/type_traits/is_convertible.hpp>
-    template <class T>
-    struct foo
-    {
-        foo(T);
-
-        template <class U>
-        foo(foo<U> const& other) : p(other.p) { }
-
-        T p;
-    };
-
-    bool x = boost::is_convertible<foo<int const*>, foo<int*> >::value;
-#  endif
-
-#endif
-
-
-#if !defined(BOOST_MSVC) && (defined(BOOST_NO_SFINAE) || defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_IS_CONVERTIBLE_TEMPLATE))
-# define BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
-#endif
-
-# if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
-
-// GCC-2.95 (obsolete) eagerly instantiates templated constructors and conversion
-// operators in convertibility checks, causing premature errors.
-//
-// Borland's problems are harder to diagnose due to lack of an
-// instantiation stack backtrace.  They may be due in part to the fact
-// that it drops cv-qualification willy-nilly in templates.
-#  define BOOST_NO_ONE_WAY_ITERATOR_INTEROP
-# endif
-
 // no include guard; multiple inclusion intended
diff --git a/include/boost/iterator/detail/config_undef.hpp b/include/boost/iterator/detail/config_undef.hpp
index a32529c..6a0c3ab 100644
--- a/include/boost/iterator/detail/config_undef.hpp
+++ b/include/boost/iterator/detail/config_undef.hpp
@@ -11,11 +11,7 @@
 // 23/02/03 thw
 //
 
-#undef BOOST_NO_IS_CONVERTIBLE
-#undef BOOST_NO_IS_CONVERTIBLE_TEMPLATE
-#undef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
 #undef BOOST_NO_LVALUE_RETURN_DETECTION
-#undef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
 
 #ifdef BOOST_ITERATOR_CONFIG_DEF
 # undef BOOST_ITERATOR_CONFIG_DEF
diff --git a/include/boost/iterator/detail/enable_if.hpp b/include/boost/iterator/detail/enable_if.hpp
deleted file mode 100644
index dcc9adb..0000000
--- a/include/boost/iterator/detail/enable_if.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-// (C) Copyright David Abrahams 2002.
-// (C) Copyright Jeremy Siek    2002.
-// (C) Copyright Thomas Witt    2002.
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-#ifndef BOOST_ENABLE_IF_23022003THW_HPP
-#define BOOST_ENABLE_IF_23022003THW_HPP
-
-#include <boost/config.hpp>
-#include <boost/iterator/detail/config_def.hpp>
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_IS_CONVERTIBLE)
-#include <boost/type_traits/type_identity.hpp>
-#endif
-
-//
-// Boost iterators uses its own enable_if cause we need
-// special semantics for deficient compilers.
-// 23/02/03 thw
-//
-
-namespace boost
-{
-
-  namespace iterators
-  {
-    //
-    // Base machinery for all kinds of enable if
-    //
-    template<bool>
-    struct enabled
-    {
-      template<typename T>
-      struct base
-      {
-        typedef T type;
-      };
-    };
-
-    //
-    // For compilers that don't support "Substitution Failure Is Not An Error"
-    // enable_if falls back to always enabled. See comments
-    // on operator implementation for consequences.
-    //
-    template<>
-    struct enabled<false>
-    {
-      template<typename T>
-      struct base
-      {
-#ifdef BOOST_NO_SFINAE
-        typedef T type;
-
-        // This way to do it would give a nice error message containing
-        // invalid overload, but has the big disadvantage that
-        // there is no reference to user code in the error message.
-        //
-        // struct invalid_overload;
-        // typedef invalid_overload type;
-        //
-#endif
-      };
-    };
-
-
-    template <class Cond,
-              class Return>
-    struct enable_if
-# if !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_IS_CONVERTIBLE)
-      : enabled<(Cond::value)>::template base<Return>
-# else
-      : boost::type_identity<Return>
-# endif
-    {
-    };
-
-  } // namespace iterators
-
-} // namespace boost
-
-#include <boost/iterator/detail/config_undef.hpp>
-
-#endif // BOOST_ENABLE_IF_23022003THW_HPP
diff --git a/include/boost/iterator/detail/facade_iterator_category.hpp b/include/boost/iterator/detail/facade_iterator_category.hpp
index 9d41320..5e7cef1 100644
--- a/include/boost/iterator/detail/facade_iterator_category.hpp
+++ b/include/boost/iterator/detail/facade_iterator_category.hpp
@@ -10,16 +10,10 @@
 
 # include <boost/mpl/or.hpp>  // used in iterator_tag inheritance logic
 # include <boost/mpl/and.hpp>
-# include <boost/mpl/if.hpp>
 # include <boost/mpl/eval_if.hpp>
 # include <boost/mpl/identity.hpp>
 
-# include <boost/static_assert.hpp>
-
-# include <boost/type_traits/is_same.hpp>
-# include <boost/type_traits/is_const.hpp>
-# include <boost/type_traits/is_reference.hpp>
-# include <boost/type_traits/is_convertible.hpp>
+# include <type_traits>
 
 # include <boost/iterator/detail/config_def.hpp> // try to keep this last
 
@@ -84,24 +78,24 @@ template <class Traversal, class ValueParam, class Reference>
 struct iterator_facade_default_category
   : mpl::eval_if<
         mpl::and_<
-            is_reference<Reference>
-          , is_convertible<Traversal,forward_traversal_tag>
+            std::is_reference<Reference>
+          , std::is_convertible<Traversal,forward_traversal_tag>
         >
       , mpl::eval_if<
-            is_convertible<Traversal,random_access_traversal_tag>
+            std::is_convertible<Traversal,random_access_traversal_tag>
           , mpl::identity<std::random_access_iterator_tag>
           , mpl::if_<
-                is_convertible<Traversal,bidirectional_traversal_tag>
+                std::is_convertible<Traversal,bidirectional_traversal_tag>
               , std::bidirectional_iterator_tag
               , std::forward_iterator_tag
             >
         >
       , typename mpl::eval_if<
             mpl::and_<
-                is_convertible<Traversal, single_pass_traversal_tag>
+                std::is_convertible<Traversal, single_pass_traversal_tag>
 
                 // check for readability
-              , is_convertible<Reference, ValueParam>
+              , std::is_convertible<Reference, ValueParam>
             >
           , mpl::identity<std::input_iterator_tag>
           , mpl::identity<Traversal>
@@ -114,15 +108,15 @@ struct iterator_facade_default_category
 template <class T>
 struct is_iterator_category
   : mpl::or_<
-        is_convertible<T,std::input_iterator_tag>
-      , is_convertible<T,std::output_iterator_tag>
+        std::is_convertible<T,std::input_iterator_tag>
+      , std::is_convertible<T,std::output_iterator_tag>
     >
 {
 };
 
 template <class T>
 struct is_iterator_traversal
-  : is_convertible<T,incrementable_traversal_tag>
+  : std::is_convertible<T,incrementable_traversal_tag>
 {};
 
 //
@@ -138,17 +132,17 @@ struct iterator_category_with_traversal
     // Make sure this isn't used to build any categories where
     // convertibility to Traversal is redundant.  Should just use the
     // Category element in that case.
-    BOOST_STATIC_ASSERT((
-        !is_convertible<
+    static_assert(
+        !std::is_convertible<
               typename iterator_category_to_traversal<Category>::type
             , Traversal
-          >::value));
+          >::value, "");
 
-    BOOST_STATIC_ASSERT(is_iterator_category<Category>::value);
-    BOOST_STATIC_ASSERT(!is_iterator_category<Traversal>::value);
-    BOOST_STATIC_ASSERT(!is_iterator_traversal<Category>::value);
+    static_assert(is_iterator_category<Category>::value, "");
+    static_assert(!is_iterator_category<Traversal>::value, "");
+    static_assert(!is_iterator_traversal<Category>::value, "");
 #  if !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
-    BOOST_STATIC_ASSERT(is_iterator_traversal<Traversal>::value);
+    static_assert(is_iterator_traversal<Traversal>::value, "");
 #  endif
 };
 
@@ -157,17 +151,17 @@ struct iterator_category_with_traversal
 template <class Traversal, class ValueParam, class Reference>
 struct facade_iterator_category_impl
 {
-    BOOST_STATIC_ASSERT(!is_iterator_category<Traversal>::value);
+    static_assert(!is_iterator_category<Traversal>::value, "");
 
     typedef typename iterator_facade_default_category<
         Traversal,ValueParam,Reference
     >::type category;
 
-    typedef typename mpl::if_<
-        is_same<
+    typedef typename std::conditional<
+        std::is_same<
             Traversal
           , typename iterator_category_to_traversal<category>::type
-        >
+        >::value
       , category
       , iterator_category_with_traversal<category,Traversal>
     >::type type;
diff --git a/include/boost/iterator/filter_iterator.hpp b/include/boost/iterator/filter_iterator.hpp
index 18c6186..44ac1e7 100644
--- a/include/boost/iterator/filter_iterator.hpp
+++ b/include/boost/iterator/filter_iterator.hpp
@@ -7,20 +7,14 @@
 #ifndef BOOST_FILTER_ITERATOR_23022003THW_HPP
 #define BOOST_FILTER_ITERATOR_23022003THW_HPP
 
+#include <type_traits>
+
 #include <boost/iterator/iterator_adaptor.hpp>
 #include <boost/iterator/iterator_categories.hpp>
 
-#include <boost/type_traits/is_class.hpp>
-#include <boost/static_assert.hpp>
 #include <boost/config.hpp>
 #include <boost/config/workaround.hpp>
 
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-#define BOOST_ITERATOR_DETAIL_MOVE(_type, _value) static_cast< _type&& >(_value)
-#else
-#define BOOST_ITERATOR_DETAIL_MOVE(_type, _value) _value
-#endif
-
 namespace boost {
 namespace iterators {
 
@@ -37,7 +31,7 @@ namespace iterators {
           , Iterator
           , use_default
           , typename mpl::if_<
-                is_convertible<
+                std::is_convertible<
                     typename iterator_traversal<Iterator>::type
                   , random_access_traversal_tag
                 >
@@ -62,20 +56,20 @@ namespace iterators {
       filter_iterator() { }
 
       filter_iterator(Predicate f, Iterator x, Iterator end_ = Iterator())
-          : super_t(BOOST_ITERATOR_DETAIL_MOVE(Iterator, x)), m_predicate(BOOST_ITERATOR_DETAIL_MOVE(Predicate, f)), m_end(BOOST_ITERATOR_DETAIL_MOVE(Iterator, end_))
+          : super_t(std::move(x)), m_predicate(std::move(f)), m_end(std::move(end_))
       {
           satisfy_predicate();
       }
 
       filter_iterator(Iterator x, Iterator end_ = Iterator())
-        : super_t(BOOST_ITERATOR_DETAIL_MOVE(Iterator, x)), m_predicate(), m_end(BOOST_ITERATOR_DETAIL_MOVE(Iterator, end_))
+        : super_t(std::move(x)), m_predicate(), m_end(std::move(end_))
       {
         // Pro8 is a little too aggressive about instantiating the
         // body of this function.
 #if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
           // Don't allow use of this constructor if Predicate is a
           // function pointer type, since it will be 0.
-          BOOST_STATIC_ASSERT(is_class<Predicate>::value);
+          static_assert(std::is_class<Predicate>::value, "");
 #endif
           satisfy_predicate();
       }
@@ -119,19 +113,19 @@ namespace iterators {
   inline filter_iterator<Predicate,Iterator>
   make_filter_iterator(Predicate f, Iterator x, Iterator end = Iterator())
   {
-      return filter_iterator<Predicate,Iterator>(BOOST_ITERATOR_DETAIL_MOVE(Predicate, f), BOOST_ITERATOR_DETAIL_MOVE(Iterator, x), BOOST_ITERATOR_DETAIL_MOVE(Iterator, end));
+      return filter_iterator<Predicate,Iterator>(std::move(f), std::move(x), std::move(end));
   }
 
   template <class Predicate, class Iterator>
   inline filter_iterator<Predicate,Iterator>
   make_filter_iterator(
-      typename iterators::enable_if<
-          is_class<Predicate>
+      typename std::enable_if<
+          is_class<Predicate>::value
         , Iterator
       >::type x
     , Iterator end = Iterator())
   {
-      return filter_iterator<Predicate,Iterator>(BOOST_ITERATOR_DETAIL_MOVE(Iterator, x), BOOST_ITERATOR_DETAIL_MOVE(Iterator, end));
+      return filter_iterator<Predicate,Iterator>(std::move(x), std::move(end));
   }
 
 } // namespace iterators
diff --git a/include/boost/iterator/function_input_iterator.hpp b/include/boost/iterator/function_input_iterator.hpp
index 610c133..15175b2 100644
--- a/include/boost/iterator/function_input_iterator.hpp
+++ b/include/boost/iterator/function_input_iterator.hpp
@@ -9,10 +9,10 @@
 #ifndef BOOST_FUNCTION_INPUT_ITERATOR
 #define BOOST_FUNCTION_INPUT_ITERATOR
 
+#include <type_traits>
+#include <memory>
+
 #include <boost/config.hpp>
-#include <boost/assert.hpp>
-#include <boost/core/addressof.hpp>
-#include <boost/type_traits/conditional.hpp>
 #include <boost/function_types/is_function_pointer.hpp>
 #include <boost/function_types/result_type.hpp>
 #include <boost/iterator/iterator_facade.hpp>
@@ -20,10 +20,6 @@
 #include <boost/optional/optional.hpp>
 #include <boost/utility/result_of.hpp>
 
-#ifdef BOOST_RESULT_OF_USE_TR1
-#include <boost/type_traits/is_function.hpp>
-#endif
-
 namespace boost {
 
 namespace iterators {
@@ -41,7 +37,7 @@ namespace iterators {
         {
             typedef typename result_of<
 #ifdef BOOST_RESULT_OF_USE_TR1
-                typename boost::conditional<is_function<F>::value, F&, F>::type()
+                typename std::conditional<std::is_function<F>::value, F&, F>::type()
 #else
                 F&()
 #endif
@@ -60,7 +56,7 @@ namespace iterators {
         public:
             function_object_input_iterator() {}
             function_object_input_iterator(Function & f_, Input state_ = Input())
-                : f(boost::addressof(f_)), state(state_) {}
+                : f(std::addressof(f_)), state(state_) {}
 
             void increment() {
                 if (value)
@@ -130,13 +126,13 @@ namespace iterators {
 
     template <class Function, class Input>
     class function_input_iterator :
-        public boost::conditional<
+        public std::conditional<
             function_types::is_function_pointer<Function>::value,
             impl::function_pointer_input_iterator<Function,Input>,
             impl::function_object_input_iterator<Function,Input>
         >::type
     {
-        typedef typename boost::conditional<
+        typedef typename std::conditional<
             function_types::is_function_pointer<Function>::value,
             impl::function_pointer_input_iterator<Function,Input>,
             impl::function_object_input_iterator<Function,Input>
diff --git a/include/boost/iterator/function_output_iterator.hpp b/include/boost/iterator/function_output_iterator.hpp
index ea2a668..ad4adc3 100644
--- a/include/boost/iterator/function_output_iterator.hpp
+++ b/include/boost/iterator/function_output_iterator.hpp
@@ -13,13 +13,9 @@
 
 #include <cstddef>
 #include <iterator>
+#include <type_traits>
+
 #include <boost/config.hpp>
-#include <boost/core/enable_if.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/remove_cv.hpp>
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-#include <boost/type_traits/remove_reference.hpp>
-#endif
 
 namespace boost {
 namespace iterators {
@@ -31,29 +27,19 @@ namespace iterators {
 
     class output_proxy {
     public:
-      explicit output_proxy(UnaryFunction& f) BOOST_NOEXCEPT : m_f(f) { }
+      explicit output_proxy(UnaryFunction& f) noexcept : m_f(f) { }
 
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
       template <class T>
-      typename boost::disable_if_c<
-        boost::is_same< typename boost::remove_cv< T >::type, output_proxy >::value,
-        output_proxy const&
-      >::type operator=(const T& value) const {
-        m_f(value);
-        return *this;
-      }
-#else
-      template <class T>
-      typename boost::disable_if_c<
-        boost::is_same< typename boost::remove_cv< typename boost::remove_reference< T >::type >::type, output_proxy >::value,
+
+      typename std::enable_if<
+        !std::is_same< typename std::remove_cv< typename std::remove_reference< T >::type >::type, output_proxy >::value,
         output_proxy const&
       >::type operator=(T&& value) const {
         m_f(static_cast< T&& >(value));
         return *this;
       }
-#endif
 
-      BOOST_DEFAULTED_FUNCTION(output_proxy(output_proxy const& that), BOOST_NOEXCEPT : m_f(that.m_f) {})
+      BOOST_DEFAULTED_FUNCTION(output_proxy(output_proxy const& that), noexcept : m_f(that.m_f) {})
       BOOST_DELETED_FUNCTION(output_proxy& operator=(output_proxy const&))
 
     private:
diff --git a/include/boost/iterator/indirect_iterator.hpp b/include/boost/iterator/indirect_iterator.hpp
index e15ac87..f670839 100644
--- a/include/boost/iterator/indirect_iterator.hpp
+++ b/include/boost/iterator/indirect_iterator.hpp
@@ -14,16 +14,13 @@
 
 #include <boost/detail/indirect_traits.hpp>
 
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/add_reference.hpp>
-
 #include <boost/mpl/bool.hpp>
 #include <boost/mpl/identity.hpp>
 #include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/not.hpp>
 #include <boost/mpl/has_xxx.hpp>
 
 #include <iterator>
+#include <type_traits>
 
 #ifdef BOOST_MPL_CFG_NO_HAS_XXX
 # include <boost/shared_ptr.hpp>
@@ -57,9 +54,9 @@ namespace iterators {
           , typename ia_dflt_help<
                 Reference
               , mpl::eval_if<
-                    is_same<Value,use_default>
+                    std::is_same<Value,use_default>
                   , indirect_reference<dereferenceable>
-                  , add_reference<Value>
+                  , std::add_lvalue_reference<Value>
                 >
             >::type
           , Difference
diff --git a/include/boost/iterator/interoperable.hpp b/include/boost/iterator/interoperable.hpp
index 6f3c872..4bb8c89 100644
--- a/include/boost/iterator/interoperable.hpp
+++ b/include/boost/iterator/interoperable.hpp
@@ -7,11 +7,11 @@
 #ifndef BOOST_INTEROPERABLE_23022003THW_HPP
 # define BOOST_INTEROPERABLE_23022003THW_HPP
 
+# include <type_traits>
+
 # include <boost/mpl/bool.hpp>
 # include <boost/mpl/or.hpp>
 
-# include <boost/type_traits/is_convertible.hpp>
-
 # include <boost/iterator/detail/config_def.hpp> // must appear last
 
 namespace boost {
@@ -33,13 +33,10 @@ namespace iterators {
   //
   template <typename A, typename B>
   struct is_interoperable
-# ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
-    : mpl::true_
-# else
-    : mpl::or_<
-          is_convertible< A, B >
-        , is_convertible< B, A > >
-# endif
+    : std::integral_constant<
+          bool
+        , std::is_convertible< A, B >::value || std::is_convertible< B, A >::value
+      >
   {
   };
 
diff --git a/include/boost/iterator/is_iterator.hpp b/include/boost/iterator/is_iterator.hpp
index 5740b19..37cf197 100644
--- a/include/boost/iterator/is_iterator.hpp
+++ b/include/boost/iterator/is_iterator.hpp
@@ -16,15 +16,13 @@
 
 #include <cstddef>
 #include <boost/config.hpp>
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/type_traits/negation.hpp>
-#include <boost/type_traits/conjunction.hpp>
 #include <boost/type_traits/is_complete.hpp>
-#include <boost/type_traits/is_function.hpp>
 #if !defined(BOOST_NO_CXX17_ITERATOR_TRAITS)
 #include <iterator>
 #endif
 
+#include <type_traits>
+
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #pragma once
 #endif
@@ -68,10 +66,10 @@ struct is_iterator_impl :
 
 template< typename T >
 struct is_iterator_impl< T* > :
-    public boost::conjunction<
-        boost::is_complete< T >,
-        boost::negation< boost::is_function< T > >
-    >::type
+    std::integral_constant<
+        bool
+      , boost::is_complete<T>::value && !std::is_function<T>::value
+    >
 {
 };
 
diff --git a/include/boost/iterator/is_lvalue_iterator.hpp b/include/boost/iterator/is_lvalue_iterator.hpp
index 46f0483..26eccb2 100644
--- a/include/boost/iterator/is_lvalue_iterator.hpp
+++ b/include/boost/iterator/is_lvalue_iterator.hpp
@@ -6,19 +6,16 @@
 
 #include <boost/detail/workaround.hpp>
 
-#include <boost/type_traits/add_lvalue_reference.hpp>
 #include <boost/iterator/detail/any_conversion_eater.hpp>
 #include <boost/mpl/bool.hpp>
 #include <boost/mpl/aux_/lambda_support.hpp>
 
 #include <iterator>
+#include <type_traits>
 
 // should be the last #includes
-#include <boost/type_traits/integral_constant.hpp>
 #include <boost/iterator/detail/config_def.hpp>
 
-#ifndef BOOST_NO_IS_CONVERTIBLE
-
 namespace boost {
 
 namespace iterators {
@@ -39,11 +36,11 @@ namespace detail
 
 # define BOOST_LVALUE_PRESERVER(expr) detail::lvalue_preserver(expr,0)
 
-#else
+#else  // BOOST_NO_LVALUE_RETURN_DETECTION
 
 # define BOOST_LVALUE_PRESERVER(expr) expr
 
-#endif
+#endif  // BOOST_NO_LVALUE_RETURN_DETECTION
 
   // Guts of is_lvalue_iterator.  Value is the iterator's value_type
   // and the result is computed in the nested rebind template.
@@ -54,7 +51,7 @@ namespace detail
       // convertible to Value const&
       struct conversion_eater
       {
-          conversion_eater(typename add_lvalue_reference<Value>::type);
+          conversion_eater(typename std::add_lvalue_reference<Value>::type);
       };
 
       static char tester(conversion_eater, int);
@@ -137,14 +134,14 @@ namespace detail
 } // namespace detail
 
 template< typename T > struct is_lvalue_iterator
-: public ::boost::integral_constant<bool,::boost::iterators::detail::is_readable_lvalue_iterator_impl<T>::value>
+: public std::integral_constant<bool,::boost::iterators::detail::is_readable_lvalue_iterator_impl<T>::value>
 {
 public:
     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_lvalue_iterator,(T))
 };
 
 template< typename T > struct is_non_const_lvalue_iterator
-: public ::boost::integral_constant<bool,::boost::iterators::detail::is_non_const_lvalue_iterator_impl<T>::value>
+: public std::integral_constant<bool,::boost::iterators::detail::is_non_const_lvalue_iterator_impl<T>::value>
 {
 public:
     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_non_const_lvalue_iterator,(T))
@@ -157,8 +154,6 @@ using iterators::is_non_const_lvalue_iterator;
 
 } // namespace boost
 
-#endif
-
 #include <boost/iterator/detail/config_undef.hpp>
 
 #endif // IS_LVALUE_ITERATOR_DWA2003112_HPP
diff --git a/include/boost/iterator/is_readable_iterator.hpp b/include/boost/iterator/is_readable_iterator.hpp
index 26827c4..ed6db05 100644
--- a/include/boost/iterator/is_readable_iterator.hpp
+++ b/include/boost/iterator/is_readable_iterator.hpp
@@ -6,18 +6,15 @@
 
 #include <boost/mpl/bool.hpp>
 #include <boost/mpl/aux_/lambda_support.hpp>
-#include <boost/type_traits/add_lvalue_reference.hpp>
 
 #include <boost/iterator/detail/any_conversion_eater.hpp>
 
 #include <iterator>
+#include <type_traits>
 
 // should be the last #include
-#include <boost/type_traits/integral_constant.hpp>
 #include <boost/iterator/detail/config_def.hpp>
 
-#ifndef BOOST_NO_IS_CONVERTIBLE
-
 namespace boost {
 
 namespace iterators {
@@ -29,7 +26,7 @@ namespace detail
   template <class Value>
   struct is_readable_iterator_impl
   {
-      static char tester(typename add_lvalue_reference<Value>::type, int);
+      static char tester(typename std::add_lvalue_reference<Value>::type, int);
       static char (& tester(any_conversion_eater, ...) )[2];
 
       template <class It>
@@ -100,7 +97,7 @@ namespace detail
 } // namespace detail
 
 template< typename T > struct is_readable_iterator
-: public ::boost::integral_constant<bool,::boost::iterators::detail::is_readable_iterator_impl2<T>::value>
+: public std::integral_constant<bool,::boost::iterators::detail::is_readable_iterator_impl2<T>::value>
 {
 public:
     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_readable_iterator,(T))
@@ -112,8 +109,6 @@ using iterators::is_readable_iterator;
 
 } // namespace boost
 
-#endif
-
 #include <boost/iterator/detail/config_undef.hpp>
 
 #endif // IS_READABLE_ITERATOR_DWA2003112_HPP
diff --git a/include/boost/iterator/iterator_adaptor.hpp b/include/boost/iterator/iterator_adaptor.hpp
index db1c4da..2fcecb3 100644
--- a/include/boost/iterator/iterator_adaptor.hpp
+++ b/include/boost/iterator/iterator_adaptor.hpp
@@ -7,28 +7,13 @@
 #ifndef BOOST_ITERATOR_ADAPTOR_23022003THW_HPP
 #define BOOST_ITERATOR_ADAPTOR_23022003THW_HPP
 
-#include <boost/static_assert.hpp>
-
 #include <boost/core/use_default.hpp>
 
+#include <type_traits>
+
 #include <boost/iterator/iterator_categories.hpp>
 #include <boost/iterator/iterator_facade.hpp>
-#include <boost/iterator/detail/enable_if.hpp>
-
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/mpl/or.hpp>
-
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-
-#ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
-# include <boost/type_traits/remove_reference.hpp>
-#endif
-
-#include <boost/type_traits/add_reference.hpp>
 #include <boost/iterator/detail/config_def.hpp>
-
 #include <boost/iterator/iterator_traits.hpp>
 
 namespace boost {
@@ -41,13 +26,6 @@ namespace iterators {
 
 } // namespace iterators
 
-// the incompleteness of use_default causes massive problems for
-// is_convertible (naturally).  This workaround is fortunately not
-// needed for vc6/vc7.
-template<class To>
-struct is_convertible<use_default,To>
-  : mpl::false_ {};
-
 namespace iterators {
 
   namespace detail
@@ -102,41 +80,14 @@ namespace iterators {
   // false positives for user/library defined iterator types. See comments
   // on operator implementation for consequences.
   //
-#  if defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_SFINAE)
-
-  template <class From, class To>
-  struct enable_if_convertible
-  {
-      typedef boost::iterators::detail::enable_type type;
-  };
-
-#  elif BOOST_WORKAROUND(_MSC_FULL_VER, BOOST_TESTED_AT(13102292))
-
-  // For some reason vc7.1 needs us to "cut off" instantiation
-  // of is_convertible in a few cases.
   template<typename From, typename To>
   struct enable_if_convertible
-    : iterators::enable_if<
-        mpl::or_<
-            is_same<From,To>
-          , is_convertible<From, To>
-        >
-      , boost::iterators::detail::enable_type
-    >
-  {};
-
-#  else
-
-  template<typename From, typename To>
-  struct enable_if_convertible
-    : iterators::enable_if<
-          is_convertible<From, To>
+    : std::enable_if<
+          std::is_convertible<From, To>::value
         , boost::iterators::detail::enable_type
       >
   {};
 
-# endif
-
   //
   // Default template argument handling for iterator_adaptor
   //
@@ -147,7 +98,7 @@ namespace iterators {
     template <class T, class DefaultNullaryFn>
     struct ia_dflt_help
       : mpl::eval_if<
-            is_same<T, use_default>
+            std::is_same<T, use_default>
           , DefaultNullaryFn
           , mpl::identity<T>
         >
@@ -173,9 +124,9 @@ namespace iterators {
           , typename boost::iterators::detail::ia_dflt_help<
                 Value
               , mpl::eval_if<
-                    is_same<Reference,use_default>
+                    std::is_same<Reference,use_default>
                   , iterator_value<Base>
-                  , remove_reference<Reference>
+                  , std::remove_reference<Reference>
                 >
             >::type
 # else
@@ -192,9 +143,9 @@ namespace iterators {
           , typename boost::iterators::detail::ia_dflt_help<
                 Reference
               , mpl::eval_if<
-                    is_same<Value,use_default>
+                    std::is_same<Value,use_default>
                   , iterator_reference<Base>
-                  , add_reference<Value>
+                  , std::add_lvalue_reference<Value>
                 >
             >::type
 
@@ -209,7 +160,7 @@ namespace iterators {
     template <class Tr1, class Tr2>
     inline void iterator_adaptor_assert_traversal ()
     {
-      BOOST_STATIC_ASSERT((is_convertible<Tr1, Tr2>::value));
+      static_assert(std::is_convertible<Tr1, Tr2>::value, "");
     }
   }
 
@@ -220,7 +171,7 @@ namespace iterators {
   // versions of iterator_adaptor The idea is that when the user needs
   // to fiddle with the reference type it is highly likely that the
   // iterator category has to be adjusted as well.  Any of the
-  // following four template arguments may be ommitted or explicitly
+  // following four template arguments may be committed or explicitly
   // replaced by use_default.
   //
   //   Value - if supplied, the value_type of the resulting iterator, unless
diff --git a/include/boost/iterator/iterator_archetypes.hpp b/include/boost/iterator/iterator_archetypes.hpp
index 1d25915..d46f277 100644
--- a/include/boost/iterator/iterator_archetypes.hpp
+++ b/include/boost/iterator/iterator_archetypes.hpp
@@ -8,23 +8,17 @@
 
 #include <boost/iterator/iterator_categories.hpp>
 #include <boost/operators.hpp>
-#include <boost/static_assert.hpp>
 
 #include <boost/iterator/detail/facade_iterator_category.hpp>
 
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/add_const.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/type_traits/remove_cv.hpp>
+#include <type_traits>
 
 #include <boost/concept_archetype.hpp>
 
 #include <boost/mpl/bitand.hpp>
 #include <boost/mpl/int.hpp>
 #include <boost/mpl/equal_to.hpp>
-#include <boost/mpl/if.hpp>
 #include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/and.hpp>
 #include <boost/mpl/identity.hpp>
 
 #include <cstddef>
@@ -119,18 +113,18 @@ namespace detail
   template <class Value, class AccessCategory, class TraversalCategory>
   struct operator_brackets
     : mpl::eval_if<
-          is_convertible<TraversalCategory, random_access_traversal_tag>
+          std::is_convertible<TraversalCategory, random_access_traversal_tag>
         , mpl::eval_if<
               archetypes::has_access<
                   AccessCategory
                 , archetypes::writable_iterator_t
               >
             , mpl::identity<writable_operator_brackets<Value> >
-            , mpl::if_<
+            , std::conditional<
                   archetypes::has_access<
                       AccessCategory
                     , archetypes::readable_iterator_t
-                  >
+                  >::value
                 , readable_operator_brackets<Value>
                 , no_operator_brackets
               >
@@ -280,9 +274,9 @@ namespace detail
 
   template <class Value>
   struct convertible_type
-    : mpl::if_< is_const<Value>,
-                typename remove_const<Value>::type,
-                bogus_type >
+    : std::conditional< std::is_const<Value>::value,
+                        typename std::remove_const<Value>::type,
+                        bogus_type >
   {};
 
 } // namespace detail
@@ -312,9 +306,9 @@ struct iterator_access_archetype_impl<
     template <class Value>
     struct archetype
     {
-        typedef typename remove_cv<Value>::type value_type;
-        typedef Value                           reference;
-        typedef Value*                          pointer;
+        typedef typename std::remove_cv<Value>::type value_type;
+        typedef Value                                reference;
+        typedef Value*                               pointer;
 
         value_type operator*() const { return static_object<value_type>::get(); }
 
@@ -330,7 +324,7 @@ struct iterator_access_archetype_impl<
     template <class Value>
     struct archetype
     {
-        BOOST_STATIC_ASSERT(!is_const<Value>::value);
+        static_assert(!std::is_const<Value>::value, "");
         typedef void value_type;
         typedef void reference;
         typedef void pointer;
@@ -381,7 +375,7 @@ struct iterator_access_archetype_impl<archetypes::writable_lvalue_iterator_t>
             Value, archetypes::readable_lvalue_iterator_t
         >
     {
-        BOOST_STATIC_ASSERT((!is_const<Value>::value));
+        static_assert(!std::is_const<Value>::value, "");
     };
 };
 
@@ -392,7 +386,7 @@ struct iterator_archetype;
 template <class Value, class AccessCategory, class TraversalCategory>
 struct traversal_archetype_base
   : detail::operator_brackets<
-        typename remove_cv<Value>::type
+        typename std::remove_cv<Value>::type
       , AccessCategory
       , TraversalCategory
     >
@@ -419,8 +413,8 @@ namespace detail
               archetypes::has_access<
                   AccessCategory, archetypes::writable_iterator_t
               >
-            , remove_const<Value>
-            , add_const<Value>
+            , std::remove_const<Value>
+            , std::add_const<Value>
           >::type
         , typename access::reference
       >::type iterator_category;
diff --git a/include/boost/iterator/iterator_categories.hpp b/include/boost/iterator/iterator_categories.hpp
index baf805a..1fc53e6 100644
--- a/include/boost/iterator/iterator_categories.hpp
+++ b/include/boost/iterator/iterator_categories.hpp
@@ -16,10 +16,7 @@
 # include <boost/mpl/placeholders.hpp>
 # include <boost/mpl/aux_/lambda_support.hpp>
 
-# include <boost/type_traits/is_convertible.hpp>
-
-# include <boost/static_assert.hpp>
-
+#include <type_traits>
 #include <iterator>
 
 namespace boost {
@@ -77,19 +74,19 @@ namespace detail
   template <class Cat>
   struct old_category_to_traversal
     : mpl::eval_if<
-          is_convertible<Cat,std::random_access_iterator_tag>
+          std::is_convertible<Cat,std::random_access_iterator_tag>
         , mpl::identity<random_access_traversal_tag>
         , mpl::eval_if<
-              is_convertible<Cat,std::bidirectional_iterator_tag>
+              std::is_convertible<Cat,std::bidirectional_iterator_tag>
             , mpl::identity<bidirectional_traversal_tag>
             , mpl::eval_if<
-                  is_convertible<Cat,std::forward_iterator_tag>
+                  std::is_convertible<Cat,std::forward_iterator_tag>
                 , mpl::identity<forward_traversal_tag>
                 , mpl::eval_if<
-                      is_convertible<Cat,std::input_iterator_tag>
+                      std::is_convertible<Cat,std::input_iterator_tag>
                     , mpl::identity<single_pass_traversal_tag>
                     , mpl::eval_if<
-                          is_convertible<Cat,std::output_iterator_tag>
+                          std::is_convertible<Cat,std::output_iterator_tag>
                         , mpl::identity<incrementable_traversal_tag>
                         , void
                       >
@@ -107,7 +104,7 @@ namespace detail
 template <class Cat>
 struct iterator_category_to_traversal
   : mpl::eval_if< // if already convertible to a traversal tag, we're done.
-        is_convertible<Cat,incrementable_traversal_tag>
+        std::is_convertible<Cat,incrementable_traversal_tag>
       , mpl::identity<Cat>
       , boost::iterators::detail::old_category_to_traversal<Cat>
     >
@@ -146,19 +143,19 @@ struct iterator_traversal<mpl::_>
 template <class Traversal>
 struct pure_traversal_tag
   : mpl::eval_if<
-        is_convertible<Traversal,random_access_traversal_tag>
+        std::is_convertible<Traversal,random_access_traversal_tag>
       , mpl::identity<random_access_traversal_tag>
       , mpl::eval_if<
-            is_convertible<Traversal,bidirectional_traversal_tag>
+            std::is_convertible<Traversal,bidirectional_traversal_tag>
           , mpl::identity<bidirectional_traversal_tag>
           , mpl::eval_if<
-                is_convertible<Traversal,forward_traversal_tag>
+                std::is_convertible<Traversal,forward_traversal_tag>
               , mpl::identity<forward_traversal_tag>
               , mpl::eval_if<
-                    is_convertible<Traversal,single_pass_traversal_tag>
+                    std::is_convertible<Traversal,single_pass_traversal_tag>
                   , mpl::identity<single_pass_traversal_tag>
                   , mpl::eval_if<
-                        is_convertible<Traversal,incrementable_traversal_tag>
+                        std::is_convertible<Traversal,incrementable_traversal_tag>
                       , mpl::identity<incrementable_traversal_tag>
                       , void
                     >
diff --git a/include/boost/iterator/iterator_concepts.hpp b/include/boost/iterator/iterator_concepts.hpp
index 3c65553..ff039be 100644
--- a/include/boost/iterator/iterator_concepts.hpp
+++ b/include/boost/iterator/iterator_concepts.hpp
@@ -9,15 +9,7 @@
 #include <boost/concept_check.hpp>
 #include <boost/iterator/iterator_categories.hpp>
 
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_integral.hpp>
-
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/or.hpp>
-
-#include <boost/static_assert.hpp>
+#include <type_traits>
 
 // Use boost/limits to work around missing limits headers on some compilers
 #include <boost/limits.hpp>
@@ -144,8 +136,8 @@ namespace boost_concepts
   {
       typedef typename std::iterator_traits<Iterator>::difference_type difference_type;
 
-      BOOST_STATIC_ASSERT(boost::is_integral<difference_type>::value);
-      BOOST_STATIC_ASSERT(std::numeric_limits<difference_type>::is_signed);
+      static_assert(std::is_integral<difference_type>::value, "");
+      static_assert(std::numeric_limits<difference_type>::is_signed, "");
 
       BOOST_CONCEPT_ASSERT((
           boost::Convertible<
diff --git a/include/boost/iterator/iterator_facade.hpp b/include/boost/iterator/iterator_facade.hpp
index c4b5ae4..46bcf62 100644
--- a/include/boost/iterator/iterator_facade.hpp
+++ b/include/boost/iterator/iterator_facade.hpp
@@ -13,30 +13,19 @@
 #include <boost/iterator/iterator_categories.hpp>
 
 #include <boost/iterator/detail/facade_iterator_category.hpp>
-#include <boost/iterator/detail/enable_if.hpp>
-
-#include <boost/static_assert.hpp>
-#include <boost/core/addressof.hpp>
-
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/add_const.hpp>
-#include <boost/type_traits/add_pointer.hpp>
-#include <boost/type_traits/add_lvalue_reference.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/type_traits/is_pod.hpp>
 
 #include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/if.hpp>
 #include <boost/mpl/or.hpp>
 #include <boost/mpl/and.hpp>
 #include <boost/mpl/not.hpp>
 #include <boost/mpl/always.hpp>
 #include <boost/mpl/apply.hpp>
 #include <boost/mpl/identity.hpp>
+#include <boost/mpl/if.hpp>
 
 #include <cstddef>
+#include <type_traits>
+#include <memory>
 
 #include <boost/iterator/detail/config_def.hpp> // this goes last
 
@@ -64,7 +53,7 @@ namespace iterators {
     // The type trait checks if the category or traversal is at least as advanced as the specified required traversal
     template< typename CategoryOrTraversal, typename Required >
     struct is_traversal_at_least :
-        public boost::is_convertible< typename iterator_category_to_traversal< CategoryOrTraversal >::type, Required >
+        public std::is_convertible< typename iterator_category_to_traversal< CategoryOrTraversal >::type, Required >
     {};
 
     //
@@ -76,8 +65,8 @@ namespace iterators {
       , class Return
     >
     struct enable_if_interoperable :
-        public boost::iterators::enable_if<
-            is_interoperable< Facade1, Facade2 >
+        public std::enable_if<
+            is_interoperable<Facade1, Facade2>::value
           , Return
         >
     {};
@@ -91,12 +80,12 @@ namespace iterators {
       , class Return
     >
     struct enable_if_interoperable_and_random_access_traversal :
-        public boost::iterators::enable_if<
+        public std::enable_if<
             mpl::and_<
                 is_interoperable< Facade1, Facade2 >
               , is_traversal_at_least< typename iterator_category< Facade1 >::type, random_access_traversal_tag >
               , is_traversal_at_least< typename iterator_category< Facade2 >::type, random_access_traversal_tag >
-            >
+            >::value
           , Return
         >
     {};
@@ -117,13 +106,13 @@ namespace iterators {
             CategoryOrTraversal, ValueParam, Reference
         >::type iterator_category;
 
-        typedef typename remove_const<ValueParam>::type value_type;
+        typedef typename std::remove_const<ValueParam>::type value_type;
 
         // Not the real associated pointer type
         typedef typename mpl::eval_if<
             boost::iterators::detail::iterator_writability_disabled<ValueParam,Reference>
-          , add_pointer<const value_type>
-          , add_pointer<value_type>
+          , std::add_pointer<const value_type>
+          , std::add_pointer<value_type>
         >::type pointer;
 
 # if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)                          \
@@ -180,7 +169,7 @@ namespace iterators {
         // Provides (r++)->foo()
         value_type* operator->() const
         {
-            return boost::addressof(stored_value);
+            return std::addressof(stored_value);
         }
 
      private:
@@ -240,38 +229,15 @@ namespace iterators {
         }
 
         // Provides writability of *r++
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
         template <class T>
-        typename iterators::enable_if<
-            is_not_writable_postfix_increment_dereference_proxy< T >,
+        typename std::enable_if<
+            is_not_writable_postfix_increment_dereference_proxy<T>::value,
             writable_postfix_increment_dereference_proxy const&
         >::type operator=(T&& x) const
         {
             *this->stored_iterator = static_cast< T&& >(x);
             return *this;
         }
-#else
-        template <class T>
-        typename iterators::enable_if<
-            is_not_writable_postfix_increment_dereference_proxy< T >,
-            writable_postfix_increment_dereference_proxy const&
-        >::type operator=(T const& x) const
-        {
-            *this->stored_iterator = x;
-            return *this;
-        }
-
-        // This overload just in case only non-const objects are writable
-        template <class T>
-        typename iterators::enable_if<
-            is_not_writable_postfix_increment_dereference_proxy< T >,
-            writable_postfix_increment_dereference_proxy const&
-        >::type operator=(T& x) const
-        {
-            *this->stored_iterator = x;
-            return *this;
-        }
-#endif
 
      private:
         Iterator stored_iterator;
@@ -303,7 +269,7 @@ namespace iterators {
         // Provides (r++)->foo()
         value_type* operator->() const
         {
-            return boost::addressof(dereference_proxy.stored_value);
+            return std::addressof(dereference_proxy.stored_value);
         }
 
      private:
@@ -318,11 +284,11 @@ namespace iterators {
         static Reference r;
 
         template <class R>
-        static typename mpl::if_<
-            is_convertible<
+        static typename std::conditional<
+            std::is_convertible<
                 R const volatile*
               , Value const volatile*
-            >
+            >::value
           , char[1]
           , char[2]
         >::type& helper(R const&);
@@ -339,8 +305,8 @@ namespace iterators {
 # else
     template <class Reference, class Value>
     struct is_non_proxy_reference
-      : is_convertible<
-            typename remove_reference<Reference>::type
+      : std::is_convertible<
+            typename std::remove_reference<Reference>::type
             const volatile*
           , Value const volatile*
         >
@@ -367,20 +333,20 @@ namespace iterators {
       : mpl::eval_if<
             mpl::and_<
                 // A proxy is only needed for readable iterators
-                is_convertible<
+                std::is_convertible<
                     Reference
                     // Use add_lvalue_reference to form `reference to Value` due to
                     // some (strict) C++03 compilers (e.g. `gcc -std=c++03`) reject
                     // 'reference-to-reference' in the template which described in CWG
                     // DR106.
                     // http://www.open-std.org/Jtc1/sc22/wg21/docs/cwg_defects.html#106
-                  , typename add_lvalue_reference<Value const>::type
+                  , typename std::add_lvalue_reference<Value const>::type
                 >
 
                 // No multipass iterator can have values that disappear
                 // before positions can be re-visited
               , mpl::not_<
-                    is_convertible<
+                    std::is_convertible<
                         typename iterator_category_to_traversal<CategoryOrTraversal>::type
                       , forward_traversal_tag
                     >
@@ -405,10 +371,10 @@ namespace iterators {
         struct proxy
         {
             explicit proxy(Reference const & x) : m_ref(x) {}
-            Reference* operator->() { return boost::addressof(m_ref); }
+            Reference* operator->() { return std::addressof(m_ref); }
             // This function is needed for MWCW and BCC, which won't call
             // operator-> again automatically per 13.3.1.2 para 8
-            operator Reference*() { return boost::addressof(m_ref); }
+            operator Reference*() { return std::addressof(m_ref); }
             Reference m_ref;
         };
         typedef proxy result_type;
@@ -424,7 +390,7 @@ namespace iterators {
         typedef Pointer result_type;
         static result_type apply(T& x)
         {
-            return boost::addressof(x);
+            return std::addressof(x);
         }
     };
 
@@ -467,7 +433,8 @@ namespace iterators {
             mpl::and_<
                 // Really we want an is_copy_constructible trait here,
                 // but is_POD will have to suffice in the meantime.
-                boost::is_POD<ValueType>
+                std::is_standard_layout<ValueType>
+              , std::is_trivial<ValueType>
               , iterator_writability_disabled<ValueType,Reference>
             >
         >
@@ -476,8 +443,8 @@ namespace iterators {
     template <class Iterator, class Value, class Reference>
     struct operator_brackets_result
     {
-        typedef typename mpl::if_<
-            use_operator_brackets_proxy<Value,Reference>
+        typedef typename std::conditional<
+            use_operator_brackets_proxy<Value,Reference>::value
           , operator_brackets_proxy<Iterator>
           , Value
         >::type type;
@@ -498,19 +465,12 @@ namespace iterators {
     struct choose_difference_type
     {
         template <class I1, class I2>
-        struct apply
-          :
-# ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
-          iterator_difference<I1>
-# else
-          mpl::eval_if<
-              is_convertible<I2,I1>
-            , iterator_difference<I1>
-            , iterator_difference<I2>
-          >
-# endif
+        struct apply : mpl::eval_if<
+                           std::is_convertible<I2,I1>
+                         , iterator_difference<I1>
+                         , iterator_difference<I2>
+                       >
         {};
-
     };
 
     template <
@@ -528,17 +488,6 @@ namespace iterators {
 
 
   // Macros which describe the declarations of binary operators
-# ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
-#  define BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, enabler)       \
-    template <                                                              \
-        class Derived1, class V1, class TC1, class Reference1, class Difference1 \
-      , class Derived2, class V2, class TC2, class Reference2, class Difference2 \
-    >                                                                       \
-    prefix typename mpl::apply2<result_type,Derived1,Derived2>::type \
-    operator op(                                                            \
-        iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs   \
-      , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)
-# else
 #  define BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, enabler)   \
     template <                                                          \
         class Derived1, class V1, class TC1, class Reference1, class Difference1 \
@@ -551,7 +500,6 @@ namespace iterators {
     operator op(                                                        \
         iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs   \
       , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)
-# endif
 
 #  define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type)       \
     BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, boost::iterators::detail::enable_if_interoperable)
@@ -561,9 +509,12 @@ namespace iterators {
 
 #  define BOOST_ITERATOR_FACADE_PLUS_HEAD(prefix,args)              \
     template <class Derived, class V, class TC, class R, class D>   \
-    prefix typename boost::iterators::enable_if<                    \
-        boost::iterators::detail::is_traversal_at_least< TC, boost::iterators::random_access_traversal_tag >,  \
-        Derived                                                     \
+    prefix typename std::enable_if<                                 \
+        boost::iterators::detail::is_traversal_at_least<            \
+            TC                                                      \
+          , boost::iterators::random_access_traversal_tag           \
+        >::value                                                    \
+      , Derived                                                     \
     >::type operator+ args
 
   //
@@ -644,13 +595,13 @@ namespace iterators {
       }
 
       template <class Facade1, class Facade2>
-      static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::true_)
+      static bool equal(Facade1 const& f1, Facade2 const& f2, std::true_type)
       {
           return f1.equal(f2);
       }
 
       template <class Facade1, class Facade2>
-      static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::false_)
+      static bool equal(Facade1 const& f1, Facade2 const& f2, std::false_type)
       {
           return f2.equal(f1);
       }
@@ -663,14 +614,14 @@ namespace iterators {
 
       template <class Facade1, class Facade2>
       static typename Facade1::difference_type distance_from(
-          Facade1 const& f1, Facade2 const& f2, mpl::true_)
+          Facade1 const& f1, Facade2 const& f2, std::true_type)
       {
           return -f1.distance_to(f2);
       }
 
       template <class Facade1, class Facade2>
       static typename Facade2::difference_type distance_from(
-          Facade1 const& f1, Facade2 const& f2, mpl::false_)
+          Facade1 const& f1, Facade2 const& f2, std::false_type)
       {
           return f2.distance_to(f1);
       }
@@ -950,19 +901,13 @@ namespace iterators {
   // ----------------
   //
 
-# ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
-#  define BOOST_ITERATOR_CONVERTIBLE(a,b) mpl::true_()
-# else
-#  define BOOST_ITERATOR_CONVERTIBLE(a,b) is_convertible<a,b>()
-# endif
+#  define BOOST_ITERATOR_CONVERTIBLE(a,b) std::is_convertible<a,b>()
 
 # define BOOST_ITERATOR_FACADE_INTEROP(op, result_type, return_prefix, base_op) \
   BOOST_ITERATOR_FACADE_INTEROP_HEAD(inline, op, result_type)                   \
   {                                                                             \
       /* For those compilers that do not support enable_if */                   \
-      BOOST_STATIC_ASSERT((                                                     \
-          is_interoperable< Derived1, Derived2 >::value                         \
-      ));                                                                       \
+      static_assert(is_interoperable<Derived1, Derived2>::value, "");           \
       return_prefix iterator_core_access::base_op(                              \
           *static_cast<Derived1 const*>(&lhs)                                   \
         , *static_cast<Derived2 const*>(&rhs)                                   \
@@ -973,7 +918,7 @@ namespace iterators {
 # define BOOST_ITERATOR_FACADE_RELATION(op, return_prefix, base_op) \
   BOOST_ITERATOR_FACADE_INTEROP(                                    \
       op                                                            \
-    , boost::iterators::detail::always_bool2                                   \
+    , boost::iterators::detail::always_bool2                        \
     , return_prefix                                                 \
     , base_op                                                       \
   )
@@ -988,11 +933,12 @@ namespace iterators {
   BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(inline, op, result_type)                   \
   {                                                                             \
       /* For those compilers that do not support enable_if */                   \
-      BOOST_STATIC_ASSERT((                                                     \
+      static_assert(                                                            \
           is_interoperable< Derived1, Derived2 >::value &&                      \
           boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && \
-          boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value \
-      ));                                                                       \
+          boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value, \
+          ""                                                                    \
+      );                                                                        \
       return_prefix iterator_core_access::base_op(                              \
           *static_cast<Derived1 const*>(&lhs)                                   \
         , *static_cast<Derived2 const*>(&rhs)                                   \
@@ -1002,10 +948,10 @@ namespace iterators {
 
 # define BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(op, return_prefix, base_op) \
   BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS(                                    \
-      op                                                            \
-    , boost::iterators::detail::always_bool2                                   \
-    , return_prefix                                                 \
-    , base_op                                                       \
+      op                                                                          \
+    , boost::iterators::detail::always_bool2                                      \
+    , return_prefix                                                               \
+    , base_op                                                                     \
   )
 
   BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<, return 0 >, distance_from)
diff --git a/include/boost/iterator/minimum_category.hpp b/include/boost/iterator/minimum_category.hpp
index 15679bc..03720d9 100644
--- a/include/boost/iterator/minimum_category.hpp
+++ b/include/boost/iterator/minimum_category.hpp
@@ -4,9 +4,7 @@
 #ifndef BOOST_ITERATOR_MINIMUM_CATEGORY_HPP_INCLUDED_
 # define BOOST_ITERATOR_MINIMUM_CATEGORY_HPP_INCLUDED_
 
-# include <boost/static_assert.hpp>
-# include <boost/type_traits/is_convertible.hpp>
-# include <boost/type_traits/is_same.hpp>
+# include <type_traits>
 
 # include <boost/mpl/placeholders.hpp>
 # include <boost/mpl/aux_/lambda_support.hpp>
@@ -44,7 +42,7 @@ struct minimum_category_impl<true,true>
 {
     template <class T1, class T2> struct apply
     {
-        BOOST_STATIC_ASSERT((is_same<T1,T2>::value));
+        static_assert(std::is_same<T1,T2>::value, "");
         typedef T1 type;
     };
 };
@@ -68,8 +66,8 @@ template <class T1 = mpl::_1, class T2 = mpl::_2>
 struct minimum_category
 {
     typedef boost::iterators::detail::minimum_category_impl<
-        ::boost::is_convertible<T1,T2>::value
-      , ::boost::is_convertible<T2,T1>::value
+        std::is_convertible<T1,T2>::value
+      , std::is_convertible<T2,T1>::value
     > outer;
 
     typedef typename outer::template apply<T1,T2> inner;
diff --git a/include/boost/iterator/new_iterator_tests.hpp b/include/boost/iterator/new_iterator_tests.hpp
index 2091e59..eb87573 100644
--- a/include/boost/iterator/new_iterator_tests.hpp
+++ b/include/boost/iterator/new_iterator_tests.hpp
@@ -29,13 +29,11 @@
 //              (David Abrahams)
 
 # include <iterator>
-# include <boost/static_assert.hpp>
+# include <type_traits>
 # include <boost/concept_archetype.hpp> // for detail::dummy_constructor
 # include <boost/pending/iterator_tests.hpp>
 # include <boost/iterator/is_readable_iterator.hpp>
 # include <boost/iterator/is_lvalue_iterator.hpp>
-# include <boost/type_traits/is_same.hpp>
-# include <boost/mpl/bool.hpp>
 # include <boost/mpl/and.hpp>
 
 # include <boost/iterator/detail/config_def.hpp>
@@ -90,7 +88,7 @@ void readable_iterator_test(const Iterator i1, T v)
 
   // I think we don't really need this as it checks the same things as
   // the above code.
-  BOOST_STATIC_ASSERT(is_readable_iterator<Iterator>::value);
+  static_assert(is_readable_iterator<Iterator>::value, "");
 # endif
 }
 
@@ -125,12 +123,12 @@ void constant_lvalue_iterator_test(Iterator i, T v1)
   Iterator i2(i);
   typedef typename std::iterator_traits<Iterator>::value_type value_type;
   typedef typename std::iterator_traits<Iterator>::reference reference;
-  BOOST_STATIC_ASSERT((is_same<const value_type&, reference>::value));
+  static_assert(std::is_same<const value_type&, reference>::value, "");
   const T& v2 = *i2;
   BOOST_TEST(v1 == v2);
 # ifndef BOOST_NO_LVALUE_RETURN_DETECTION
-  BOOST_STATIC_ASSERT(is_lvalue_iterator<Iterator>::value);
-  BOOST_STATIC_ASSERT(!is_non_const_lvalue_iterator<Iterator>::value);
+  static_assert(is_lvalue_iterator<Iterator>::value, "");
+  static_assert(!is_non_const_lvalue_iterator<Iterator>::value, "");
 # endif
 }
 
@@ -140,19 +138,19 @@ void non_const_lvalue_iterator_test(Iterator i, T v1, T v2)
   Iterator i2(i);
   typedef typename std::iterator_traits<Iterator>::value_type value_type;
   typedef typename std::iterator_traits<Iterator>::reference reference;
-  BOOST_STATIC_ASSERT((is_same<value_type&, reference>::value));
+  static_assert(std::is_same<value_type&, reference>::value, "");
   T& v3 = *i2;
   BOOST_TEST(v1 == v3);
 
-  // A non-const lvalue iterator is not neccessarily writable, but we
+  // A non-const lvalue iterator is not necessarily writable, but we
   // are assuming the value_type is assignable here
   *i = v2;
 
   T& v4 = *i2;
   BOOST_TEST(v2 == v4);
 # ifndef BOOST_NO_LVALUE_RETURN_DETECTION
-  BOOST_STATIC_ASSERT(is_lvalue_iterator<Iterator>::value);
-  BOOST_STATIC_ASSERT(is_non_const_lvalue_iterator<Iterator>::value);
+  static_assert(is_lvalue_iterator<Iterator>::value, "");
+  static_assert(is_non_const_lvalue_iterator<Iterator>::value, "");
 # endif
 }
 
diff --git a/include/boost/iterator/transform_iterator.hpp b/include/boost/iterator/transform_iterator.hpp
index 5b2b810..cab87bc 100644
--- a/include/boost/iterator/transform_iterator.hpp
+++ b/include/boost/iterator/transform_iterator.hpp
@@ -9,28 +9,13 @@
 
 #include <boost/config.hpp>
 #include <boost/config/workaround.hpp>
-#include <boost/iterator/detail/enable_if.hpp>
 #include <boost/iterator/iterator_adaptor.hpp>
 #include <boost/iterator/iterator_categories.hpp>
-#include <boost/type_traits/function_traits.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/is_class.hpp>
-#include <boost/type_traits/is_function.hpp>
-#include <boost/type_traits/is_reference.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/type_traits/remove_reference.hpp>
 #include <boost/utility/result_of.hpp>
 
+#include <type_traits>
 #include <iterator>
 
-#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
-#include <boost/type_traits/is_base_and_derived.hpp>
-#endif
-
-#if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
-#include <boost/static_assert.hpp>
-#endif
-
 #include <boost/iterator/detail/config_def.hpp>
 
 
@@ -103,7 +88,7 @@ namespace iterators {
 #if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
         // don't provide this constructor if UnaryFunc is a
         // function pointer type, since it will be 0.  Too dangerous.
-        BOOST_STATIC_ASSERT(is_class<UnaryFunc>::value);
+        static_assert(std::is_class<UnaryFunc>::value, "");
 #endif
     }
 
@@ -149,8 +134,8 @@ namespace iterators {
   // function pointer in the iterator be 0, leading to a runtime
   // crash.
   template <class UnaryFunc, class Iterator>
-  inline typename iterators::enable_if<
-      is_class<UnaryFunc>   // We should probably find a cheaper test than is_class<>
+  inline typename std::enable_if<
+      std::is_class<UnaryFunc>::value   // We should probably find a cheaper test than is_class<>
     , transform_iterator<UnaryFunc, Iterator>
   >::type
   make_transform_iterator(Iterator it)
diff --git a/include/boost/iterator/zip_iterator.hpp b/include/boost/iterator/zip_iterator.hpp
index f5780ae..f97fb29 100644
--- a/include/boost/iterator/zip_iterator.hpp
+++ b/include/boost/iterator/zip_iterator.hpp
@@ -8,7 +8,6 @@
 #ifndef BOOST_ZIP_ITERATOR_TMB_07_13_2003_HPP_
 # define BOOST_ZIP_ITERATOR_TMB_07_13_2003_HPP_
 
-#include <stddef.h>
 #include <boost/iterator/iterator_traits.hpp>
 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/iterator/iterator_adaptor.hpp> // for enable_if_convertible
@@ -19,9 +18,6 @@
 #include <utility> // for std::pair
 #include <boost/fusion/adapted/boost_tuple.hpp> // for backward compatibility
 
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/remove_cv.hpp>
-
 #include <boost/mpl/at.hpp>
 #include <boost/mpl/fold.hpp>
 #include <boost/mpl/transform.hpp>
@@ -83,7 +79,7 @@ namespace iterators {
       struct result<This(Iterator)>
       {
         typedef typename
-          remove_cv<typename remove_reference<Iterator>::type>::type
+          std::remove_cv<typename std::remove_reference<Iterator>::type>::type
         iterator;
 
         typedef typename iterator_reference<iterator>::type type;
diff --git a/include/boost/pending/iterator_tests.hpp b/include/boost/pending/iterator_tests.hpp
index a683683..a810a3b 100644
--- a/include/boost/pending/iterator_tests.hpp
+++ b/include/boost/pending/iterator_tests.hpp
@@ -20,13 +20,10 @@
 //              (David Abrahams)
 
 # include <iterator>
-# include <boost/static_assert.hpp>
+# include <type_traits>
 # include <boost/concept_archetype.hpp> // for detail::dummy_constructor
 # include <boost/core/ignore_unused.hpp>
 # include <boost/core/lightweight_test.hpp>
-# include <boost/type_traits/is_same.hpp>
-# include <boost/type_traits/is_pointer.hpp>
-# include <boost/type_traits/is_reference.hpp>
 
 namespace boost {
 
@@ -143,10 +140,9 @@ template <bool is_pointer> struct lvalue_test
         typedef typename Iterator::reference reference;
         typedef typename Iterator::value_type value_type;
 # endif
-        BOOST_STATIC_ASSERT(boost::is_reference<reference>::value);
-        BOOST_STATIC_ASSERT((boost::is_same<reference,value_type&>::value
-                             || boost::is_same<reference,const value_type&>::value
-            ));
+        static_assert(std::is_reference<reference>::value, "");
+        static_assert(std::is_same<reference,value_type&>::value
+                      || std::is_same<reference,const value_type&>::value, "");
     }
 };
 
@@ -180,7 +176,7 @@ void forward_iterator_test(Iterator i, T v1, T v2)
 
  // borland doesn't allow non-type template parameters
 # if !defined(BOOST_BORLANDC) || (BOOST_BORLANDC > 0x551)
-  lvalue_test<(boost::is_pointer<Iterator>::value)>::check(i);
+  lvalue_test<std::is_pointer<Iterator>::value>::check(i);
 #endif
 }
 
diff --git a/include/boost/pointee.hpp b/include/boost/pointee.hpp
index 69efa94..b177e73 100644
--- a/include/boost/pointee.hpp
+++ b/include/boost/pointee.hpp
@@ -15,12 +15,10 @@
 
 # include <boost/detail/is_incrementable.hpp>
 # include <boost/iterator/iterator_traits.hpp>
-# include <boost/type_traits/add_const.hpp>
-# include <boost/type_traits/remove_cv.hpp>
-# include <boost/mpl/if.hpp>
 # include <boost/mpl/eval_if.hpp>
 
 #include <iterator>
+#include <type_traits>
 
 namespace boost {
 
@@ -49,13 +47,13 @@ namespace detail
 
       BOOST_STATIC_CONSTANT(bool, is_constant = sizeof(impl::test(*impl::x)) == 1);
 
-      typedef typename mpl::if_c<
+      typedef typename std::conditional<
 #  if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
           ::boost::detail::iterator_pointee<Iterator>::is_constant
 #  else
           is_constant
 #  endif
-        , typename add_const<value_type>::type
+        , typename std::add_const<value_type>::type
         , value_type
       >::type type;
   };
diff --git a/test/counting_iterator_test.cpp b/test/counting_iterator_test.cpp
index 09d4295..d26938a 100644
--- a/test/counting_iterator_test.cpp
+++ b/test/counting_iterator_test.cpp
@@ -30,13 +30,12 @@
 #include <boost/iterator/new_iterator_tests.hpp>
 
 #include <boost/next_prior.hpp>
-#include <boost/type_traits/conditional.hpp>
 #include <boost/detail/workaround.hpp>
 #include <boost/limits.hpp>
 
 #include <algorithm>
-#include <climits>
 #include <iterator>
+#include <type_traits>
 #include <stdlib.h>
 #ifndef BOOST_BORLANDC
 # include <boost/tuple/tuple.hpp>
@@ -68,7 +67,7 @@ struct unsigned_assert_nonnegative
 
 template <class T>
 struct assert_nonnegative
-  : boost::conditional<
+  : std::conditional<
         std::numeric_limits<T>::is_signed
       , signed_assert_nonnegative<T>
       , unsigned_assert_nonnegative<T>
diff --git a/test/detail/zip_iterator_test.ipp b/test/detail/zip_iterator_test.ipp
index 7e0d2f7..39c223c 100644
--- a/test/detail/zip_iterator_test.ipp
+++ b/test/detail/zip_iterator_test.ipp
@@ -8,6 +8,7 @@
 
 #include <boost/core/lightweight_test.hpp>
 
+#include <boost/type_traits/is_integral.hpp>
 #include <boost/assign/list_of.hpp>
 #include <boost/fusion/include/at.hpp>
 #include <boost/iterator/zip_iterator.hpp>
diff --git a/test/filter_iterator_test.cpp b/test/filter_iterator_test.cpp
index cf850bc..b0b1caf 100644
--- a/test/filter_iterator_test.cpp
+++ b/test/filter_iterator_test.cpp
@@ -7,15 +7,14 @@
 #include <boost/iterator/filter_iterator.hpp>
 #include <boost/iterator/reverse_iterator.hpp>
 #include <boost/iterator/new_iterator_tests.hpp>
-#include <boost/type_traits/is_convertible.hpp>
 #include <boost/concept_check.hpp>
 #include <boost/concept_archetype.hpp>
 #include <boost/iterator/iterator_concepts.hpp>
 #include <boost/iterator/iterator_archetypes.hpp>
 #include <boost/cstdlib.hpp>
 
+#include <type_traits>
 #include <deque>
-#include <iostream>
 
 using boost::dummyT;
 
@@ -229,12 +228,12 @@ int main()
         filter_iter(one_or_four(), array, array+N)
         , dummyT(1), dummyT(4));
 
-    BOOST_STATIC_ASSERT(
-        (!boost::is_convertible<
+    static_assert(
+        !std::is_convertible<
              boost::iterator_traversal<filter_iter>::type
            , boost::random_access_traversal_tag
-         >::value
-        ));
+         >::value,
+        "");
 
     //# endif
 
diff --git a/test/function_input_iterator_test.cpp b/test/function_input_iterator_test.cpp
index f64e9f5..6668d83 100644
--- a/test/function_input_iterator_test.cpp
+++ b/test/function_input_iterator_test.cpp
@@ -11,14 +11,12 @@
 
 #include <boost/config.hpp>
 
-#if !defined(BOOST_NO_CXX11_DECLTYPE)
 // Force boost::result_of use decltype, even on compilers that don't support N3276.
 // This enables this test to also verify if the iterator works with lambdas
 // on such compilers with this config macro. Note that without the macro result_of
 // (and consequently the iterator) is guaranteed to _not_ work, so this case is not
 // worth testing anyway.
 #define BOOST_RESULT_OF_USE_DECLTYPE
-#endif
 
 #include <boost/core/lightweight_test.hpp>
 #include <boost/iterator/function_input_iterator.hpp>
@@ -108,8 +106,6 @@ int main()
         BOOST_TEST_EQ(*it3, 54);
     }
 
-#if !defined(BOOST_NO_CXX11_LAMBDAS) && !defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) \
-    && defined(BOOST_RESULT_OF_USE_DECLTYPE)
     // test the iterator with lambda expressions
     int num = 42;
     auto lambda_generator = [&num] { return num++; };
@@ -123,7 +119,6 @@ int main()
     BOOST_TEST_EQ(generated.size(), 10u);
     for(std::size_t i = 0; i != 10; ++i)
         BOOST_TEST_EQ(generated[i], static_cast<int>(42 + i));
-#endif // BOOST_NO_CXX11_LAMBDAS
 
     return boost::report_errors();
 }
diff --git a/test/function_output_iterator_test.cpp b/test/function_output_iterator_test.cpp
index c18592d..c55c160 100644
--- a/test/function_output_iterator_test.cpp
+++ b/test/function_output_iterator_test.cpp
@@ -44,7 +44,6 @@ int main()
         BOOST_TEST_EQ(n, 6);
     }
 
-#if !defined(BOOST_NO_CXX11_LAMBDAS) && !defined(BOOST_NO_CXX11_AUTO_DECLARATIONS)
     {
         int n = 0;
         auto it = boost::iterators::make_function_output_iterator([&n](int x) { n -= x; });
@@ -57,7 +56,6 @@ int main()
 
         BOOST_TEST_EQ(n, -6);
     }
-#endif
 
 #if defined(__cpp_lib_concepts) && ( __cpp_lib_concepts >= 202002L )
     {
diff --git a/test/indirect_iter_member_types.cpp b/test/indirect_iter_member_types.cpp
index 240e664..261a510 100644
--- a/test/indirect_iter_member_types.cpp
+++ b/test/indirect_iter_member_types.cpp
@@ -9,12 +9,10 @@
 
 
 #include <boost/config.hpp>
-#include <iostream>
 
 #include <boost/iterator/indirect_iterator.hpp>
-#include <boost/static_assert.hpp>
 #include "static_assert_same.hpp"
-#include <boost/type_traits/same_traits.hpp>
+#include <type_traits>
 
 struct zow { };
 
@@ -40,10 +38,12 @@ int main()
     STATIC_ASSERT_SAME(Iter::pointer, int*);
     STATIC_ASSERT_SAME(Iter::difference_type, std::ptrdiff_t);
 
-    BOOST_STATIC_ASSERT((boost::is_convertible<Iter::iterator_category,
-             std::random_access_iterator_tag>::value));
-    BOOST_STATIC_ASSERT((boost::is_convertible<boost::iterator_traversal<Iter>::type,
-             boost::random_access_traversal_tag>::value));
+    static_assert(std::is_convertible<Iter::iterator_category,
+                                      std::random_access_iterator_tag>::value,
+                  "");
+    static_assert(std::is_convertible<boost::iterator_traversal<Iter>::type,
+                                      boost::random_access_traversal_tag>::value,
+                  "");
   }
   {
     typedef boost::indirect_iterator<int const**> Iter;
@@ -71,10 +71,12 @@ int main()
 
     STATIC_ASSERT_SAME(Iter::difference_type, std::ptrdiff_t);
 
-    BOOST_STATIC_ASSERT((boost::is_convertible<Iter::iterator_category,
-             std::random_access_iterator_tag>::value));
-    BOOST_STATIC_ASSERT((boost::is_convertible<boost::iterator_traversal<Iter>::type,
-             boost::random_access_traversal_tag>::value));
+    static_assert(std::is_convertible<Iter::iterator_category,
+                                      std::random_access_iterator_tag>::value,
+                  "");
+    static_assert(std::is_convertible<boost::iterator_traversal<Iter>::type,
+                                      boost::random_access_traversal_tag>::value,
+                  "");
   }
   {
     typedef boost::indirect_iterator<char**, int, std::random_access_iterator_tag, long&, short> Iter;
diff --git a/test/is_convertible_fail.cpp b/test/is_convertible_fail.cpp
index 757b5c6..89255fc 100644
--- a/test/is_convertible_fail.cpp
+++ b/test/is_convertible_fail.cpp
@@ -8,12 +8,13 @@
 //
 #include <boost/iterator/reverse_iterator.hpp>
 #include <boost/cstdlib.hpp>
+#include <type_traits>
 
 int main()
 {
     typedef boost::reverse_iterator<int*>  rev_iter1;
     typedef boost::reverse_iterator<char*> rev_iter2;
 
-    return boost::is_convertible<rev_iter1, rev_iter2>::value
+    return std::is_convertible<rev_iter1, rev_iter2>::value
         ? boost::exit_failure : boost::exit_success;
 }
diff --git a/test/is_lvalue_iterator.cpp b/test/is_lvalue_iterator.cpp
index 16de014..a0eea82 100644
--- a/test/is_lvalue_iterator.cpp
+++ b/test/is_lvalue_iterator.cpp
@@ -4,9 +4,7 @@
 
 #include <deque>
 #include <iterator>
-#include <iostream>
 #include <cstddef> // std::ptrdiff_t
-#include <boost/static_assert.hpp>
 #include <boost/noncopyable.hpp>
 #include <boost/iterator/is_lvalue_iterator.hpp>
 
@@ -91,58 +89,58 @@ struct constant_lvalue_iterator
 
 int main()
 {
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<v*>::value);
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<v const*>::value);
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<std::deque<v>::iterator>::value);
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<std::deque<v>::const_iterator>::value);
-    BOOST_STATIC_ASSERT(!boost::is_lvalue_iterator<std::back_insert_iterator<std::deque<v> > >::value);
-    BOOST_STATIC_ASSERT(!boost::is_lvalue_iterator<std::ostream_iterator<v> >::value);
-    BOOST_STATIC_ASSERT(!boost::is_lvalue_iterator<proxy_iterator<v> >::value);
-    BOOST_STATIC_ASSERT(!boost::is_lvalue_iterator<proxy_iterator<int> >::value);
+    static_assert(boost::is_lvalue_iterator<v*>::value, "");
+    static_assert(boost::is_lvalue_iterator<v const*>::value, "");
+    static_assert(boost::is_lvalue_iterator<std::deque<v>::iterator>::value, "");
+    static_assert(boost::is_lvalue_iterator<std::deque<v>::const_iterator>::value, "");
+    static_assert(!boost::is_lvalue_iterator<std::back_insert_iterator<std::deque<v> > >::value, "");
+    static_assert(!boost::is_lvalue_iterator<std::ostream_iterator<v> >::value, "");
+    static_assert(!boost::is_lvalue_iterator<proxy_iterator<v> >::value, "");
+    static_assert(!boost::is_lvalue_iterator<proxy_iterator<int> >::value, "");
 #ifndef BOOST_NO_LVALUE_RETURN_DETECTION
-    BOOST_STATIC_ASSERT(!boost::is_lvalue_iterator<value_iterator>::value);
+    static_assert(!boost::is_lvalue_iterator<value_iterator>::value, "");
 #endif
     // Make sure inaccessible copy constructor doesn't prevent
     // reference binding
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<noncopyable_iterator>::value);
+    static_assert(boost::is_lvalue_iterator<noncopyable_iterator>::value, "");
 
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<lvalue_iterator<v> >::value);
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<lvalue_iterator<int> >::value);
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<lvalue_iterator<char*> >::value);
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<lvalue_iterator<float> >::value);
+    static_assert(boost::is_lvalue_iterator<lvalue_iterator<v> >::value, "");
+    static_assert(boost::is_lvalue_iterator<lvalue_iterator<int> >::value, "");
+    static_assert(boost::is_lvalue_iterator<lvalue_iterator<char*> >::value, "");
+    static_assert(boost::is_lvalue_iterator<lvalue_iterator<float> >::value, "");
 
 
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<constant_lvalue_iterator<v> >::value);
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<constant_lvalue_iterator<int> >::value);
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<constant_lvalue_iterator<char*> >::value);
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<constant_lvalue_iterator<float> >::value);
+    static_assert(boost::is_lvalue_iterator<constant_lvalue_iterator<v> >::value, "");
+    static_assert(boost::is_lvalue_iterator<constant_lvalue_iterator<int> >::value, "");
+    static_assert(boost::is_lvalue_iterator<constant_lvalue_iterator<char*> >::value, "");
+    static_assert(boost::is_lvalue_iterator<constant_lvalue_iterator<float> >::value, "");
 
 
 
-    BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<v*>::value);
-    BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<v const*>::value);
-    BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<std::deque<v>::iterator>::value);
-    BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<std::deque<v>::const_iterator>::value);
-    BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<std::back_insert_iterator<std::deque<v> > >::value);
-    BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<std::ostream_iterator<v> >::value);
-    BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<proxy_iterator<v> >::value);
-    BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<proxy_iterator<int> >::value);
+    static_assert(boost::is_non_const_lvalue_iterator<v*>::value, "");
+    static_assert(!boost::is_non_const_lvalue_iterator<v const*>::value, "");
+    static_assert(boost::is_non_const_lvalue_iterator<std::deque<v>::iterator>::value, "");
+    static_assert(!boost::is_non_const_lvalue_iterator<std::deque<v>::const_iterator>::value, "");
+    static_assert(!boost::is_non_const_lvalue_iterator<std::back_insert_iterator<std::deque<v> > >::value, "");
+    static_assert(!boost::is_non_const_lvalue_iterator<std::ostream_iterator<v> >::value, "");
+    static_assert(!boost::is_non_const_lvalue_iterator<proxy_iterator<v> >::value, "");
+    static_assert(!boost::is_non_const_lvalue_iterator<proxy_iterator<int> >::value, "");
 #ifndef BOOST_NO_LVALUE_RETURN_DETECTION
-    BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<value_iterator>::value);
+    static_assert(!boost::is_non_const_lvalue_iterator<value_iterator>::value, "");
 #endif
-    BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<noncopyable_iterator>::value);
+    static_assert(!boost::is_non_const_lvalue_iterator<noncopyable_iterator>::value, "");
 
-    BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<lvalue_iterator<v> >::value);
+    static_assert(boost::is_non_const_lvalue_iterator<lvalue_iterator<v> >::value, "");
 #if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
-    BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<lvalue_iterator<int> >::value);
+    static_assert(boost::is_non_const_lvalue_iterator<lvalue_iterator<int> >::value, "");
 #endif
-    BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<lvalue_iterator<char*> >::value);
-    BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<lvalue_iterator<float> >::value);
+    static_assert(boost::is_non_const_lvalue_iterator<lvalue_iterator<char*> >::value, "");
+    static_assert(boost::is_non_const_lvalue_iterator<lvalue_iterator<float> >::value, "");
 
-    BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<v> >::value);
-    BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<int> >::value);
-    BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<char*> >::value);
-    BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<float> >::value);
+    static_assert(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<v> >::value, "");
+    static_assert(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<int> >::value, "");
+    static_assert(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<char*> >::value, "");
+    static_assert(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<float> >::value, "");
 
     return 0;
 }
diff --git a/test/is_readable_iterator.cpp b/test/is_readable_iterator.cpp
index 1d33a64..39c4d75 100644
--- a/test/is_readable_iterator.cpp
+++ b/test/is_readable_iterator.cpp
@@ -4,9 +4,7 @@
 
 #include <deque>
 #include <iterator>
-#include <iostream>
 #include <cstddef> // std::ptrdiff_t
-#include <boost/static_assert.hpp>
 #include <boost/noncopyable.hpp>
 #include <boost/iterator/is_readable_iterator.hpp>
 
@@ -78,19 +76,19 @@ struct proxy_iterator2
 
 int main()
 {
-    BOOST_STATIC_ASSERT(boost::is_readable_iterator<v*>::value);
-    BOOST_STATIC_ASSERT(boost::is_readable_iterator<v const*>::value);
-    BOOST_STATIC_ASSERT(boost::is_readable_iterator<std::deque<v>::iterator>::value);
-    BOOST_STATIC_ASSERT(boost::is_readable_iterator<std::deque<v>::const_iterator>::value);
-    BOOST_STATIC_ASSERT(!boost::is_readable_iterator<std::back_insert_iterator<std::deque<v> > >::value);
-    BOOST_STATIC_ASSERT(!boost::is_readable_iterator<std::ostream_iterator<v> >::value);
-    BOOST_STATIC_ASSERT(boost::is_readable_iterator<proxy_iterator>::value);
-    BOOST_STATIC_ASSERT(!boost::is_readable_iterator<proxy_iterator2>::value);
-    BOOST_STATIC_ASSERT(boost::is_readable_iterator<value_iterator>::value);
+    static_assert(boost::is_readable_iterator<v*>::value, "");
+    static_assert(boost::is_readable_iterator<v const*>::value, "");
+    static_assert(boost::is_readable_iterator<std::deque<v>::iterator>::value, "");
+    static_assert(boost::is_readable_iterator<std::deque<v>::const_iterator>::value, "");
+    static_assert(!boost::is_readable_iterator<std::back_insert_iterator<std::deque<v> > >::value, "");
+    static_assert(!boost::is_readable_iterator<std::ostream_iterator<v> >::value, "");
+    static_assert(boost::is_readable_iterator<proxy_iterator>::value, "");
+    static_assert(!boost::is_readable_iterator<proxy_iterator2>::value, "");
+    static_assert(boost::is_readable_iterator<value_iterator>::value, "");
 
     // Make sure inaccessible copy constructor doesn't prevent
     // readability
-    BOOST_STATIC_ASSERT(boost::is_readable_iterator<noncopyable_iterator>::value);
+    static_assert(boost::is_readable_iterator<noncopyable_iterator>::value, "");
 
     return 0;
 }
diff --git a/test/iterator_adaptor_cc.cpp b/test/iterator_adaptor_cc.cpp
index 2ea7582..6b0b73c 100644
--- a/test/iterator_adaptor_cc.cpp
+++ b/test/iterator_adaptor_cc.cpp
@@ -27,7 +27,7 @@ int main()
 #if defined(__SGI_STL_PORT)                                                             \
     || !BOOST_WORKAROUND(__GNUC__, <= 2)                                                \
     && !(BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, <= 1))    \
-    && !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))                          \
+    && !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))                        \
     && !BOOST_WORKAROUND(__LIBCOMO_VERSION__, BOOST_TESTED_AT(29))                      \
     && !BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, <= 1)
   {
diff --git a/test/iterator_adaptor_test.cpp b/test/iterator_adaptor_test.cpp
index 4b37c14..ef5b9a4 100644
--- a/test/iterator_adaptor_test.cpp
+++ b/test/iterator_adaptor_test.cpp
@@ -209,7 +209,7 @@ main()
     test = static_assert_same<Iter1::pointer, int*>::value;
     test = static_assert_same<Iter1::difference_type, std::ptrdiff_t>::value;
 #if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
-    BOOST_STATIC_ASSERT((boost::is_convertible<Iter1::iterator_category, std::random_access_iterator_tag>::value));
+    static_assert(std::is_convertible<Iter1::iterator_category, std::random_access_iterator_tag>::value, "");
 #endif
   }
 
@@ -220,9 +220,9 @@ main()
     test = static_assert_same<Iter1::reference, const int&>::value;
 
 #if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
-    BOOST_STATIC_ASSERT(boost::is_readable_iterator<Iter1>::value);
+    static_assert(boost::is_readable_iterator<Iter1>::value, "");
 # ifndef BOOST_NO_LVALUE_RETURN_DETECTION
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<Iter1>::value);
+    static_assert(boost::is_lvalue_iterator<Iter1>::value, "");
 # endif
 #endif
 
@@ -243,8 +243,8 @@ main()
 #endif
 
 #ifndef BOOST_NO_LVALUE_RETURN_DETECTION
-    BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<BaseIter>::value);
-    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<Iter>::value);
+    static_assert(boost::is_non_const_lvalue_iterator<BaseIter>::value, "");
+    static_assert(boost::is_lvalue_iterator<Iter>::value, "");
 #endif
 
     typedef modify_traversal<BaseIter, boost::incrementable_traversal_tag> IncrementableIter;
diff --git a/test/iterator_facade.cpp b/test/iterator_facade.cpp
index 7351dd3..09fd88e 100644
--- a/test/iterator_facade.cpp
+++ b/test/iterator_facade.cpp
@@ -8,8 +8,7 @@
 #include <boost/iterator/new_iterator_tests.hpp>
 
 #include <boost/call_traits.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/core/enable_if.hpp>
+#include <type_traits>
 
 // This is a really, really limited test so far.  All we're doing
 // right now is checking that the postfix++ proxy for single-pass
@@ -120,7 +119,7 @@ struct wrapper
     { }
     template <class U>
     wrapper(const wrapper<U>& other,
-        typename boost::enable_if< boost::is_convertible<U,T> >::type* = 0)
+        typename std::enable_if< std::is_convertible<U,T>::value >::type* = 0)
         : m_x(other.m_x)
     { }
 };
@@ -146,7 +145,7 @@ struct iterator_with_proxy_reference
 
 template <class T, class U>
 void same_type(U const&)
-{ BOOST_STATIC_ASSERT((boost::is_same<T,U>::value)); }
+{ static_assert(std::is_same<T,U>::value, ""); }
 
 template <class I, class A>
 struct abstract_iterator
diff --git a/test/iterator_traits_test.cpp b/test/iterator_traits_test.cpp
index 40da049..d2b84c3 100644
--- a/test/iterator_traits_test.cpp
+++ b/test/iterator_traits_test.cpp
@@ -20,15 +20,13 @@
 //              reference type from operator* (David Abrahams)
 //  19 Jan 2001 Initial version with iterator operators (David Abrahams)
 
-#include <boost/type_traits/is_same.hpp>
 #include <boost/operators.hpp>
-#include <boost/static_assert.hpp>
 #include <boost/config.hpp>
 #include <iterator>
 #include <vector>
 #include <list>
 #include <boost/core/lightweight_test.hpp>
-#include <iostream>
+#include <type_traits>
 
 // A UDT for which we can specialize std::iterator_traits<element*> on
 // compilers which don't support partial specialization. There's no
@@ -98,7 +96,7 @@ template <> struct assertion<true>
 
 template <class T, class U>
 struct assert_same
-    : assertion<(::boost::is_same<T,U>::value)>
+    : assertion<(std::is_same<T,U>::value)>
 {
 };
 
diff --git a/test/minimum_category.cpp b/test/minimum_category.cpp
index 3f89d6c..54f7e7a 100644
--- a/test/minimum_category.cpp
+++ b/test/minimum_category.cpp
@@ -6,10 +6,10 @@
 
 #include <boost/iterator/minimum_category.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
-#include <boost/type_traits/is_same.hpp>
 #include <iterator>
+#include <type_traits>
 
-using boost::is_same;
+using std::is_same;
 using boost::iterators::minimum_category;
 
 int main(int, char*[])
diff --git a/test/permutation_iterator_test.cpp b/test/permutation_iterator_test.cpp
index 81cdefe..ac82701 100644
--- a/test/permutation_iterator_test.cpp
+++ b/test/permutation_iterator_test.cpp
@@ -8,7 +8,6 @@
 #include <boost/core/lightweight_test.hpp>
 
 #include <boost/iterator/permutation_iterator.hpp>
-#include <boost/static_assert.hpp>
 #include <boost/iterator/iterator_concepts.hpp>
 #include <boost/concept/assert.hpp>
 
@@ -44,7 +43,7 @@ void permutation_test()
   const int element_range_size = 10;
   const int index_size = 7;
 
-  BOOST_STATIC_ASSERT(index_size <= element_range_size);
+  static_assert(index_size <= element_range_size, "");
   element_range_type elements( element_range_size );
   for( element_range_type::iterator el_it = elements.begin(); el_it != elements.end(); ++el_it )
     { *el_it = std::distance(elements.begin(), el_it); }
diff --git a/test/pointee.cpp b/test/pointee.cpp
index 32e3496..4e54599 100644
--- a/test/pointee.cpp
+++ b/test/pointee.cpp
@@ -3,10 +3,10 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/pointee.hpp>
-#include <boost/type_traits/add_const.hpp>
 #include "static_assert_same.hpp"
 #include <memory>
 #include <list>
+#include <type_traits>
 
 template <class T, class Ref>
 struct proxy_ptr
@@ -27,7 +27,7 @@ struct proxy_ref_ptr : proxy_ptr<T,T&>
 template <class T>
 struct proxy_value_ptr : proxy_ptr<T,T>
 {
-    typedef typename boost::add_const<T>::type element_type;
+    typedef typename std::add_const<T>::type element_type;
 };
 
 struct X {
diff --git a/test/range_distance_compat_test.cpp b/test/range_distance_compat_test.cpp
index ef7e301..5501810 100644
--- a/test/range_distance_compat_test.cpp
+++ b/test/range_distance_compat_test.cpp
@@ -5,6 +5,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/range/distance.hpp>
+#include <boost/type_traits/is_integral.hpp>
 #include <boost/range/iterator_range_core.hpp>
 #include <boost/iterator/distance.hpp>
 
diff --git a/test/reverse_iterator_test.cpp b/test/reverse_iterator_test.cpp
index c2e4a41..4be9734 100644
--- a/test/reverse_iterator_test.cpp
+++ b/test/reverse_iterator_test.cpp
@@ -161,7 +161,7 @@ int main()
 #if defined(__SGI_STL_PORT)                                                             \
     || !BOOST_WORKAROUND(__GNUC__, <= 2)                                                \
     && !(BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, <= 1))    \
-    && !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))                          \
+    && !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))                        \
     && !BOOST_WORKAROUND(__LIBCOMO_VERSION__, BOOST_TESTED_AT(29))                      \
     && !BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, <= 1)
 
diff --git a/test/static_assert_same.hpp b/test/static_assert_same.hpp
index 5d96da9..2911845 100644
--- a/test/static_assert_same.hpp
+++ b/test/static_assert_same.hpp
@@ -5,10 +5,9 @@
 #ifndef STATIC_ASSERT_SAME_DWA2003530_HPP
 # define STATIC_ASSERT_SAME_DWA2003530_HPP
 
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_same.hpp>
+#include <type_traits>
 
-#define STATIC_ASSERT_SAME( T1,T2 ) BOOST_STATIC_ASSERT((::boost::is_same< T1, T2 >::value))
+#define STATIC_ASSERT_SAME( T1,T2 ) static_assert(std::is_same<T1, T2>::value, "")
 
 template <class T1, class T2>
 struct static_assert_same
diff --git a/test/transform_iterator_test.cpp b/test/transform_iterator_test.cpp
index b22cb16..3fd788e 100644
--- a/test/transform_iterator_test.cpp
+++ b/test/transform_iterator_test.cpp
@@ -172,20 +172,20 @@ main()
   {
     {
       typedef boost::transform_iterator<adaptable_mult_functor, int*, float> iter_t;
-      BOOST_STATIC_ASSERT((boost::is_same<iter_t::reference,  float>::value));
-      BOOST_STATIC_ASSERT((boost::is_same<iter_t::value_type, float>::value));
+      static_assert(boost::is_same<iter_t::reference,  float>::value, "");
+      static_assert(boost::is_same<iter_t::value_type, float>::value, "");
     }
 
     {
       typedef boost::transform_iterator<adaptable_mult_functor, int*, boost::use_default, float> iter_t;
-      BOOST_STATIC_ASSERT((boost::is_same<iter_t::reference,  int>::value));
-      BOOST_STATIC_ASSERT((boost::is_same<iter_t::value_type, float>::value));
+      static_assert(boost::is_same<iter_t::reference,  int>::value, "");
+      static_assert(boost::is_same<iter_t::value_type, float>::value, "");
     }
 
     {
       typedef boost::transform_iterator<adaptable_mult_functor, int*, float, double> iter_t;
-      BOOST_STATIC_ASSERT((boost::is_same<iter_t::reference,  float>::value));
-      BOOST_STATIC_ASSERT((boost::is_same<iter_t::value_type, double>::value));
+      static_assert(boost::is_same<iter_t::reference,  float>::value, "");
+      static_assert(boost::is_same<iter_t::value_type, double>::value, "");
     }
   }
 
diff --git a/test/unit_tests.cpp b/test/unit_tests.cpp
index 656e72f..bbb4bb8 100644
--- a/test/unit_tests.cpp
+++ b/test/unit_tests.cpp
@@ -3,10 +3,10 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 #include <boost/iterator/iterator_adaptor.hpp>
-#include <boost/static_assert.hpp>
 
 #include "static_assert_same.hpp"
 
+#include <type_traits>
 #include <boost/iterator/minimum_category.hpp>
 
 struct X { int a; };
@@ -38,32 +38,41 @@ void category_test()
     using namespace boost::iterators;
     using namespace boost::iterators::detail;
 
-    BOOST_STATIC_ASSERT((
-        !boost::is_convertible<
+    static_assert(
+        !std::is_convertible<
             std::input_iterator_tag
-          , input_output_iterator_tag>::value));
+          , input_output_iterator_tag>::value,
+        "");
 
-    BOOST_STATIC_ASSERT((
-        !boost::is_convertible<
+    static_assert(
+        !std::is_convertible<
             std::output_iterator_tag
-          , input_output_iterator_tag>::value));
+          , input_output_iterator_tag
+         >::value,
+        "");
 
-    BOOST_STATIC_ASSERT((
-        boost::is_convertible<
+    static_assert(
+        std::is_convertible<
             input_output_iterator_tag
-          , std::input_iterator_tag>::value));
+          , std::input_iterator_tag
+        >::value,
+        "");
 
-    BOOST_STATIC_ASSERT((
-        boost::is_convertible<
+    static_assert(
+        std::is_convertible<
             input_output_iterator_tag
-          , std::output_iterator_tag>::value));
+          , std::output_iterator_tag
+        >::value,
+        "");
 
 #if 0 // This seems wrong; we're not advertising
       // input_output_iterator_tag are we?
-    BOOST_STATIC_ASSERT((
+    static_assert(
         boost::is_convertible<
             std::forward_iterator_tag
-          , input_output_iterator_tag>::value));
+          , input_output_iterator_tag
+        >::value,
+        "");
 #endif
 
     int test = static_assert_min_cat<