diff --git a/include/boost/unordered/detail/implementation.hpp b/include/boost/unordered/detail/implementation.hpp
index d45ca246..9914683f 100644
--- a/include/boost/unordered/detail/implementation.hpp
+++ b/include/boost/unordered/detail/implementation.hpp
@@ -35,12 +35,11 @@
 #include <boost/type_traits/integral_constant.hpp>
 #include <boost/type_traits/is_base_of.hpp>
 #include <boost/type_traits/is_class.hpp>
-#include <boost/type_traits/is_const.hpp>
 #include <boost/type_traits/is_empty.hpp>
 #include <boost/type_traits/is_nothrow_move_assignable.hpp>
 #include <boost/type_traits/is_nothrow_move_constructible.hpp>
+#include <boost/type_traits/is_nothrow_swappable.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_scalar.hpp>
 #include <boost/type_traits/remove_const.hpp>
 #include <boost/unordered/detail/fwd.hpp>
 #include <boost/utility/addressof.hpp>
@@ -740,19 +739,6 @@ namespace boost {
 #pragma warning(pop)
 #endif
 
-      ////////////////////////////////////////////////////////////////////////////
-      // is_nothrow_swappable
-      //
-      // TODO: Replace this very basic implementation when the full type_traits
-      // implementation is available.
-
-      template <class T>
-      struct is_nothrow_swappable
-        : boost::integral_constant<bool,
-            boost::is_scalar<T>::value && !boost::is_const<T>::value>
-      {
-      };
-
       //////////////////////////////////////////////////////////////////////////
       // value_base
       //
@@ -1800,7 +1786,7 @@ namespace boost {
           BOOST_FWD_REF(A0), BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
         {
           boost::unordered::detail::func::construct_from_tuple(
-            alloc, boost::addressof (address->first), boost::forward<A1>(a1));
+            alloc, boost::addressof(address->first), boost::forward<A1>(a1));
           BOOST_TRY
           {
             boost::unordered::detail::func::construct_from_tuple(
@@ -1997,7 +1983,7 @@ namespace boost {
       {
         BOOST_ASSERT(!node_);
         node_ = node_allocator_traits::allocate(alloc_, 1);
-        new ((void*) boost::to_address(node_)) node();
+        new ((void*)boost::to_address(node_)) node();
       }
 
       template <typename NodeAlloc> struct node_tmp
@@ -2756,8 +2742,8 @@ namespace boost {
           boost::is_nothrow_move_constructible<H>::value &&
           boost::is_nothrow_move_constructible<P>::value;
         static const bool nothrow_swappable =
-          boost::unordered::detail::is_nothrow_swappable<H>::value &&
-          boost::unordered::detail::is_nothrow_swappable<P>::value;
+          boost::is_nothrow_swappable<H>::value &&
+          boost::is_nothrow_swappable<P>::value;
 
       private:
         functions& operator=(functions const&);
@@ -3220,9 +3206,9 @@ namespace boost {
           bucket_pointer end =
             buckets_ + static_cast<std::ptrdiff_t>(new_count);
           for (bucket_pointer i = buckets_; i != end; ++i) {
-            new ((void*) boost::to_address(i)) bucket();
+            new ((void*)boost::to_address(i)) bucket();
           }
-          new ((void*) boost::to_address(end)) bucket(dummy_node);
+          new ((void*)boost::to_address(end)) bucket(dummy_node);
         }
 
         ////////////////////////////////////////////////////////////////////////
diff --git a/include/boost/unordered/unordered_map.hpp b/include/boost/unordered/unordered_map.hpp
index acaf99c6..1910219c 100644
--- a/include/boost/unordered/unordered_map.hpp
+++ b/include/boost/unordered/unordered_map.hpp
@@ -717,8 +717,8 @@ namespace boost {
 
       void swap(unordered_map&)
         BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
-            boost::unordered::detail::is_nothrow_swappable<H>::value&&
-              boost::unordered::detail::is_nothrow_swappable<P>::value);
+            boost::is_nothrow_swappable<H>::value&&
+              boost::is_nothrow_swappable<P>::value);
       void clear() BOOST_NOEXCEPT { table_.clear_impl(); }
 
       template <typename H2, typename P2>
@@ -1326,8 +1326,8 @@ namespace boost {
 
       void swap(unordered_multimap&)
         BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
-            boost::unordered::detail::is_nothrow_swappable<H>::value&&
-              boost::unordered::detail::is_nothrow_swappable<P>::value);
+            boost::is_nothrow_swappable<H>::value&&
+              boost::is_nothrow_swappable<P>::value);
       void clear() BOOST_NOEXCEPT { table_.clear_impl(); }
 
       template <typename H2, typename P2>
@@ -1737,8 +1737,8 @@ namespace boost {
     template <class K, class T, class H, class P, class A>
     void unordered_map<K, T, H, P, A>::swap(unordered_map& other)
       BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
-          boost::unordered::detail::is_nothrow_swappable<H>::value&&
-            boost::unordered::detail::is_nothrow_swappable<P>::value)
+          boost::is_nothrow_swappable<H>::value&&
+            boost::is_nothrow_swappable<P>::value)
     {
       table_.swap(other.table_);
     }
@@ -2213,8 +2213,8 @@ namespace boost {
     template <class K, class T, class H, class P, class A>
     void unordered_multimap<K, T, H, P, A>::swap(unordered_multimap& other)
       BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
-          boost::unordered::detail::is_nothrow_swappable<H>::value&&
-            boost::unordered::detail::is_nothrow_swappable<P>::value)
+          boost::is_nothrow_swappable<H>::value&&
+            boost::is_nothrow_swappable<P>::value)
     {
       table_.swap(other.table_);
     }
diff --git a/include/boost/unordered/unordered_set.hpp b/include/boost/unordered/unordered_set.hpp
index 92af2c01..dfc24e85 100644
--- a/include/boost/unordered/unordered_set.hpp
+++ b/include/boost/unordered/unordered_set.hpp
@@ -443,8 +443,8 @@ namespace boost {
 
       void swap(unordered_set&)
         BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
-            boost::unordered::detail::is_nothrow_swappable<H>::value&&
-              boost::unordered::detail::is_nothrow_swappable<P>::value);
+            boost::is_nothrow_swappable<H>::value&&
+              boost::is_nothrow_swappable<P>::value);
       void clear() BOOST_NOEXCEPT { table_.clear_impl(); }
 
       template <typename H2, typename P2>
@@ -990,8 +990,8 @@ namespace boost {
 
       void swap(unordered_multiset&)
         BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
-            boost::unordered::detail::is_nothrow_swappable<H>::value&&
-              boost::unordered::detail::is_nothrow_swappable<P>::value);
+            boost::is_nothrow_swappable<H>::value&&
+              boost::is_nothrow_swappable<P>::value);
       void clear() BOOST_NOEXCEPT { table_.clear_impl(); }
 
       template <typename H2, typename P2>
@@ -1362,8 +1362,8 @@ namespace boost {
     template <class T, class H, class P, class A>
     void unordered_set<T, H, P, A>::swap(unordered_set& other)
       BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
-          boost::unordered::detail::is_nothrow_swappable<H>::value&&
-            boost::unordered::detail::is_nothrow_swappable<P>::value)
+          boost::is_nothrow_swappable<H>::value&&
+            boost::is_nothrow_swappable<P>::value)
     {
       table_.swap(other.table_);
     }
@@ -1756,8 +1756,8 @@ namespace boost {
     template <class T, class H, class P, class A>
     void unordered_multiset<T, H, P, A>::swap(unordered_multiset& other)
       BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
-          boost::unordered::detail::is_nothrow_swappable<H>::value&&
-            boost::unordered::detail::is_nothrow_swappable<P>::value)
+          boost::is_nothrow_swappable<H>::value&&
+            boost::is_nothrow_swappable<P>::value)
     {
       table_.swap(other.table_);
     }
diff --git a/test/unordered/compile_tests.hpp b/test/unordered/compile_tests.hpp
index 588414ec..691e4413 100644
--- a/test/unordered/compile_tests.hpp
+++ b/test/unordered/compile_tests.hpp
@@ -17,11 +17,12 @@
 #endif
 
 #include "../helpers/check_return_type.hpp"
-#include <boost/limits.hpp>
 #include <boost/core/pointer_traits.hpp>
+#include <boost/limits.hpp>
 #include <boost/predef.h>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/cv_traits.hpp>
+#include <boost/type_traits/is_const.hpp>
 #include <boost/type_traits/is_convertible.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/swap.hpp>
@@ -286,36 +287,47 @@ template <class X, class Key> void unordered_set_test(X& r, Key const&)
   BOOST_STATIC_ASSERT((boost::is_same<iterator,
     BOOST_DEDUCED_TYPENAME boost::pointer_traits<iterator>::pointer>::value));
   BOOST_STATIC_ASSERT((boost::is_same<value_type const,
-    BOOST_DEDUCED_TYPENAME boost::pointer_traits<iterator>::element_type>::value));
-  BOOST_STATIC_ASSERT((boost::is_same<std::ptrdiff_t,
-    BOOST_DEDUCED_TYPENAME boost::pointer_traits<iterator>::difference_type>::value));
+    BOOST_DEDUCED_TYPENAME
+      boost::pointer_traits<iterator>::element_type>::value));
+  BOOST_STATIC_ASSERT((
+    boost::is_same<std::ptrdiff_t, BOOST_DEDUCED_TYPENAME boost::pointer_traits<
+                                     iterator>::difference_type>::value));
 
   // pointer_traits<const_iterator>
 
-  BOOST_STATIC_ASSERT((boost::is_same<const_iterator,
-    BOOST_DEDUCED_TYPENAME boost::pointer_traits<const_iterator>::pointer>::value));
+  BOOST_STATIC_ASSERT((
+    boost::is_same<const_iterator, BOOST_DEDUCED_TYPENAME boost::pointer_traits<
+                                     const_iterator>::pointer>::value));
   BOOST_STATIC_ASSERT((boost::is_same<value_type const,
-    BOOST_DEDUCED_TYPENAME boost::pointer_traits<const_iterator>::element_type>::value));
-  BOOST_STATIC_ASSERT((boost::is_same<std::ptrdiff_t,
-    BOOST_DEDUCED_TYPENAME boost::pointer_traits<const_iterator>::difference_type>::value));
+    BOOST_DEDUCED_TYPENAME
+      boost::pointer_traits<const_iterator>::element_type>::value));
+  BOOST_STATIC_ASSERT((
+    boost::is_same<std::ptrdiff_t, BOOST_DEDUCED_TYPENAME boost::pointer_traits<
+                                     const_iterator>::difference_type>::value));
 
   // pointer_traits<local_iterator>
 
-  BOOST_STATIC_ASSERT((boost::is_same<local_iterator,
-    BOOST_DEDUCED_TYPENAME boost::pointer_traits<local_iterator>::pointer>::value));
+  BOOST_STATIC_ASSERT((
+    boost::is_same<local_iterator, BOOST_DEDUCED_TYPENAME boost::pointer_traits<
+                                     local_iterator>::pointer>::value));
   BOOST_STATIC_ASSERT((boost::is_same<value_type const,
-    BOOST_DEDUCED_TYPENAME boost::pointer_traits<local_iterator>::element_type>::value));
-  BOOST_STATIC_ASSERT((boost::is_same<std::ptrdiff_t,
-    BOOST_DEDUCED_TYPENAME boost::pointer_traits<local_iterator>::difference_type>::value));
+    BOOST_DEDUCED_TYPENAME
+      boost::pointer_traits<local_iterator>::element_type>::value));
+  BOOST_STATIC_ASSERT((
+    boost::is_same<std::ptrdiff_t, BOOST_DEDUCED_TYPENAME boost::pointer_traits<
+                                     local_iterator>::difference_type>::value));
 
   // pointer_traits<const_local_iterator>
 
   BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator,
-    BOOST_DEDUCED_TYPENAME boost::pointer_traits<const_local_iterator>::pointer>::value));
+    BOOST_DEDUCED_TYPENAME
+      boost::pointer_traits<const_local_iterator>::pointer>::value));
   BOOST_STATIC_ASSERT((boost::is_same<value_type const,
-    BOOST_DEDUCED_TYPENAME boost::pointer_traits<const_local_iterator>::element_type>::value));
+    BOOST_DEDUCED_TYPENAME
+      boost::pointer_traits<const_local_iterator>::element_type>::value));
   BOOST_STATIC_ASSERT((boost::is_same<std::ptrdiff_t,
-    BOOST_DEDUCED_TYPENAME boost::pointer_traits<const_local_iterator>::difference_type>::value));
+    BOOST_DEDUCED_TYPENAME
+      boost::pointer_traits<const_local_iterator>::difference_type>::value));
 
   typedef BOOST_DEDUCED_TYPENAME X::node_type node_type;
   typedef BOOST_DEDUCED_TYPENAME node_type::value_type node_value_type;
@@ -366,37 +378,48 @@ void unordered_map_test(X& r, Key const& k, T const& v)
 
   BOOST_STATIC_ASSERT((boost::is_same<iterator,
     BOOST_DEDUCED_TYPENAME boost::pointer_traits<iterator>::pointer>::value));
-  BOOST_STATIC_ASSERT((boost::is_same<value_type,
-    BOOST_DEDUCED_TYPENAME boost::pointer_traits<iterator>::element_type>::value));
-  BOOST_STATIC_ASSERT((boost::is_same<std::ptrdiff_t,
-    BOOST_DEDUCED_TYPENAME boost::pointer_traits<iterator>::difference_type>::value));
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<value_type, BOOST_DEDUCED_TYPENAME boost::pointer_traits<
+                                  iterator>::element_type>::value));
+  BOOST_STATIC_ASSERT((
+    boost::is_same<std::ptrdiff_t, BOOST_DEDUCED_TYPENAME boost::pointer_traits<
+                                     iterator>::difference_type>::value));
 
   // pointer_traits<const_iterator>
 
-  BOOST_STATIC_ASSERT((boost::is_same<const_iterator,
-    BOOST_DEDUCED_TYPENAME boost::pointer_traits<const_iterator>::pointer>::value));
+  BOOST_STATIC_ASSERT((
+    boost::is_same<const_iterator, BOOST_DEDUCED_TYPENAME boost::pointer_traits<
+                                     const_iterator>::pointer>::value));
   BOOST_STATIC_ASSERT((boost::is_same<value_type const,
-    BOOST_DEDUCED_TYPENAME boost::pointer_traits<const_iterator>::element_type>::value));
-  BOOST_STATIC_ASSERT((boost::is_same<std::ptrdiff_t,
-    BOOST_DEDUCED_TYPENAME boost::pointer_traits<const_iterator>::difference_type>::value));
+    BOOST_DEDUCED_TYPENAME
+      boost::pointer_traits<const_iterator>::element_type>::value));
+  BOOST_STATIC_ASSERT((
+    boost::is_same<std::ptrdiff_t, BOOST_DEDUCED_TYPENAME boost::pointer_traits<
+                                     const_iterator>::difference_type>::value));
 
   // pointer_traits<local_iterator>
 
-  BOOST_STATIC_ASSERT((boost::is_same<local_iterator,
-    BOOST_DEDUCED_TYPENAME boost::pointer_traits<local_iterator>::pointer>::value));
-  BOOST_STATIC_ASSERT((boost::is_same<value_type,
-    BOOST_DEDUCED_TYPENAME boost::pointer_traits<local_iterator>::element_type>::value));
-  BOOST_STATIC_ASSERT((boost::is_same<std::ptrdiff_t,
-    BOOST_DEDUCED_TYPENAME boost::pointer_traits<local_iterator>::difference_type>::value));
+  BOOST_STATIC_ASSERT((
+    boost::is_same<local_iterator, BOOST_DEDUCED_TYPENAME boost::pointer_traits<
+                                     local_iterator>::pointer>::value));
+  BOOST_STATIC_ASSERT(
+    (boost::is_same<value_type, BOOST_DEDUCED_TYPENAME boost::pointer_traits<
+                                  local_iterator>::element_type>::value));
+  BOOST_STATIC_ASSERT((
+    boost::is_same<std::ptrdiff_t, BOOST_DEDUCED_TYPENAME boost::pointer_traits<
+                                     local_iterator>::difference_type>::value));
 
   // pointer_traits<const_local_iterator>
 
   BOOST_STATIC_ASSERT((boost::is_same<const_local_iterator,
-    BOOST_DEDUCED_TYPENAME boost::pointer_traits<const_local_iterator>::pointer>::value));
+    BOOST_DEDUCED_TYPENAME
+      boost::pointer_traits<const_local_iterator>::pointer>::value));
   BOOST_STATIC_ASSERT((boost::is_same<value_type const,
-    BOOST_DEDUCED_TYPENAME boost::pointer_traits<const_local_iterator>::element_type>::value));
+    BOOST_DEDUCED_TYPENAME
+      boost::pointer_traits<const_local_iterator>::element_type>::value));
   BOOST_STATIC_ASSERT((boost::is_same<std::ptrdiff_t,
-    BOOST_DEDUCED_TYPENAME boost::pointer_traits<const_local_iterator>::difference_type>::value));
+    BOOST_DEDUCED_TYPENAME
+      boost::pointer_traits<const_local_iterator>::difference_type>::value));
 
   typedef BOOST_DEDUCED_TYPENAME X::node_type node_type;
   typedef BOOST_DEDUCED_TYPENAME node_type::key_type node_key_type;
diff --git a/test/unordered/noexcept_tests.cpp b/test/unordered/noexcept_tests.cpp
index 4a28ce18..454e7c23 100644
--- a/test/unordered/noexcept_tests.cpp
+++ b/test/unordered/noexcept_tests.cpp
@@ -165,13 +165,12 @@ namespace noexcept_tests {
       !boost::is_nothrow_move_constructible<hash_possible_exception>::value);
     BOOST_TEST(
       !boost::is_nothrow_move_assignable<hash_possible_exception>::value);
-    BOOST_TEST(!boost::unordered::detail::is_nothrow_swappable<
-               hash_possible_exception>::value);
+    BOOST_TEST(!boost::is_nothrow_swappable<hash_possible_exception>::value);
     BOOST_TEST((!boost::is_nothrow_move_constructible<
                 equal_to_nothrow<false, false, false> >::value));
     BOOST_TEST((!boost::is_nothrow_move_assignable<
                 equal_to_nothrow<false, false, false> >::value));
-    BOOST_TEST((!boost::unordered::detail::is_nothrow_swappable<
+    BOOST_TEST((!boost::is_nothrow_swappable<
                 equal_to_nothrow<false, false, false> >::value));
 
     have_is_nothrow_move =
@@ -179,7 +178,7 @@ namespace noexcept_tests {
     have_is_nothrow_move_assign =
       boost::is_nothrow_move_assignable<hash_nothrow_move_assign>::value;
     have_is_nothrow_swap =
-      boost::unordered::detail::is_nothrow_swappable<hash_nothrow_swap>::value;
+      boost::is_nothrow_swappable<hash_nothrow_swap>::value;
 
 // Check that the traits work when expected.
 #if !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_SFINAE_EXPR) &&     \
@@ -191,8 +190,7 @@ namespace noexcept_tests {
 #if !defined(BOOST_NO_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_NOEXCEPT) &&     \
   !defined(BOOST_NO_CXX11_DECLTYPE) &&                                         \
   !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
-// TODO: Turn test on when unordered starts to use is_nothrow_swap
-// BOOST_TEST(have_is_nothrow_swap);
+    BOOST_TEST(have_is_nothrow_swap);
 #endif
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM
@@ -286,8 +284,7 @@ namespace noexcept_tests {
       throwing_set;
 
     if (have_is_nothrow_swap) {
-      BOOST_TEST(
-        boost::unordered::detail::is_nothrow_swappable<throwing_set>::value);
+      BOOST_TEST(boost::is_nothrow_swappable<throwing_set>::value);
     }
 
     throwing_test_exception = false;