diff --git a/include/boost/core/pointer_traits.hpp b/include/boost/core/pointer_traits.hpp
index ff1a532..4ebd332 100644
--- a/include/boost/core/pointer_traits.hpp
+++ b/include/boost/core/pointer_traits.hpp
@@ -1,5 +1,5 @@
 /*
-Copyright 2017 Glen Joseph Fernandes
+Copyright 2017-2018 Glen Joseph Fernandes
 (glenjofe@gmail.com)
 
 Distributed under the Boost Software License, Version 1.0.
@@ -24,7 +24,7 @@ namespace detail {
 
 template<class U>
 inline typename boost::pointer_traits<U>::element_type*
-ptr_traits_address(const U& v) BOOST_NOEXCEPT
+ptr_to_address(const U& v) BOOST_NOEXCEPT
 {
     return boost::pointer_traits<U>::to_address(v);
 }
@@ -41,7 +41,7 @@ struct pointer_traits
     };
     static typename std::pointer_traits<T>::element_type*
     to_address(const T& v) BOOST_NOEXCEPT {
-        return detail::ptr_traits_address(v.operator->());
+        return detail::ptr_to_address(v.operator->());
     }
 };
 
@@ -59,136 +59,103 @@ struct pointer_traits<T*>
 #else
 namespace detail {
 
-struct ptr_traits_none { char first, second; };
-
-template<class T>
-struct ptr_traits_has_element {
-private:
-    template<class U>
-    static ptr_traits_none call(...);
-    template<class U>
-    static char call(typename U::element_type* = 0);
-public:
-    static const bool value = sizeof(call<T>(0)) == 1;
+template<class>
+struct ptr_void {
+    typedef void type;
 };
 
 template<class T>
-struct ptr_traits_first;
+struct ptr_first;
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 template<template<class, class...> class T, class U, class... Args>
-struct ptr_traits_first<T<U, Args...> > {
+struct ptr_first<T<U, Args...> > {
     typedef U type;
 };
 #else
 template<template<class> class T, class U>
-struct ptr_traits_first<T<U> > {
+struct ptr_first<T<U> > {
     typedef U type;
 };
 
 template<template<class, class> class T, class U1, class U2>
-struct ptr_traits_first<T<U1, U2> > {
+struct ptr_first<T<U1, U2> > {
     typedef U1 type;
 };
 
 template<template<class, class, class> class T, class U1, class U2, class U3>
-struct ptr_traits_first<T<U1, U2, U3> > {
+struct ptr_first<T<U1, U2, U3> > {
     typedef U1 type;
 };
 #endif
 
-template<class T, bool = ptr_traits_has_element<T>::value>
-struct ptr_traits_element {
+template<class T, class = void>
+struct ptr_element {
+    typedef typename ptr_first<T>::type type;
+};
+
+template<class T>
+struct ptr_element<T, typename ptr_void<typename T::element_type>::type> {
     typedef typename T::element_type type;
 };
 
-template<class T>
-struct ptr_traits_element<T, false> {
-    typedef typename ptr_traits_first<T>::type type;
-};
-
-template<class T>
-struct ptr_traits_has_difference {
-private:
-    template<class U>
-    static ptr_traits_none call(...);
-    template<class U>
-    static char call(typename U::difference_type* = 0);
-public:
-    static const bool value = sizeof(call<T>(0)) == 1;
-};
-
-template<class T, bool = ptr_traits_has_difference<T>::value>
-struct ptr_traits_difference {
-    typedef typename T::difference_type type;
-};
-
-template<class T>
-struct ptr_traits_difference<T, false> {
+template<class, class = void>
+struct ptr_difference {
     typedef std::ptrdiff_t type;
 };
 
-template<class T, class V>
-struct ptr_traits_has_rebind {
-private:
-    template<class U>
-    static ptr_traits_none call(...);
-    template<class U>
-    static char call(typename U::template rebind<V>* = 0);
-public:
-    static const bool value = sizeof(call<T>(0)) == 1;
+template<class T>
+struct ptr_difference<T,
+    typename ptr_void<typename T::difference_type>::type> {
+    typedef typename T::difference_type type;
 };
 
 template<class T, class V>
-struct ptr_traits_rebind_to;
+struct ptr_rebind_to;
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 template<template<class, class...> class T, class U, class... Args, class V>
-struct ptr_traits_rebind_to<T<U, Args...>, V> {
+struct ptr_rebind_to<T<U, Args...>, V> {
     typedef T<V, Args...> type;
 };
 #else
 template<template<class> class T, class U, class V>
-struct ptr_traits_rebind_to<T<U>, V> {
+struct ptr_rebind_to<T<U>, V> {
     typedef T<V> type;
 };
 
 template<template<class, class> class T, class U1, class U2, class V>
-struct ptr_traits_rebind_to<T<U1, U2>, V> {
+struct ptr_rebind_to<T<U1, U2>, V> {
     typedef T<V, U2> type;
 };
 
 template<template<class, class, class> class T,
     class U1, class U2, class U3, class V>
-struct ptr_traits_rebind_to<T<U1, U2, U3>, V> {
+struct ptr_rebind_to<T<U1, U2, U3>, V> {
     typedef T<V, U2, U3> type;
 };
 #endif
 
-#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
-template<class T, class U, bool = ptr_traits_has_rebind<T, U>::value>
-struct ptr_traits_rebind {
-    typedef typename T::template rebind<U> type;
+template<class T, class U, class = void>
+struct ptr_rebind {
+    typedef typename ptr_rebind_to<T, U>::type type;
 };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 template<class T, class U>
-struct ptr_traits_rebind<T, U, false> {
-    typedef typename ptr_traits_rebind_to<T, U>::type type;
-};
-#else
-template<class T, class U>
-struct ptr_traits_rebind {
-    typedef typename ptr_traits_rebind_to<T, U>::type type;
+struct ptr_rebind<T, U,
+    typename ptr_void<typename T::template rebind<U> >::type> {
+    typedef typename T::template rebind<U> type;
 };
 #endif
 
 template<class T>
-struct ptr_traits_value {
+struct ptr_value {
     typedef T type;
 };
 
 template<>
-struct ptr_traits_value<void> {
+struct ptr_value<void> {
     typedef struct { } type;
 };
 
@@ -197,22 +164,22 @@ struct ptr_traits_value<void> {
 template<class T>
 struct pointer_traits {
     typedef T pointer;
-    typedef typename detail::ptr_traits_element<T>::type element_type;
-    typedef typename detail::ptr_traits_difference<T>::type difference_type;
+    typedef typename detail::ptr_element<T>::type element_type;
+    typedef typename detail::ptr_difference<T>::type difference_type;
     template<class U>
     struct rebind_to {
-        typedef typename detail::ptr_traits_rebind<T, U>::type type;
+        typedef typename detail::ptr_rebind<T, U>::type type;
     };
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
     template<class U>
-    using rebind = typename detail::ptr_traits_rebind<T, U>::type;
+    using rebind = typename detail::ptr_rebind<T, U>::type;
 #endif
     static pointer
-    pointer_to(typename detail::ptr_traits_value<element_type>::type& v) {
+    pointer_to(typename detail::ptr_value<element_type>::type& v) {
         return pointer::pointer_to(v);
     }
     static element_type* to_address(const pointer& v) BOOST_NOEXCEPT {
-        return detail::ptr_traits_address(v.operator->());
+        return detail::ptr_to_address(v.operator->());
     }
 };
 
@@ -230,8 +197,8 @@ struct pointer_traits<T*> {
     using rebind = U*;
 #endif
     static T*
-    pointer_to(typename detail::ptr_traits_value<T>::type& v) BOOST_NOEXCEPT {
-        return addressof(v);
+    pointer_to(typename detail::ptr_value<T>::type& v) BOOST_NOEXCEPT {
+        return boost::addressof(v);
     }
     static T* to_address(T* v) BOOST_NOEXCEPT {
         return v;