Removed MPL usage from iterator_facade.hpp.

include/boost/iterator/iterator_facade.hpp

@@ -7,7 +7,12 @@
 #ifndef BOOST_ITERATOR_FACADE_23022003THW_HPP
 #define BOOST_ITERATOR_FACADE_23022003THW_HPP
 
+#include <cstddef>
+#include <memory>
+#include <type_traits>
+
 #include <boost/config.hpp>
+#include <boost/mp11/utility.hpp>
 
 #include <boost/iterator/interoperable.hpp>
 #include <boost/iterator/iterator_traits.hpp>
@@ -16,37 +21,21 @@
 #include <boost/iterator/detail/type_traits/conjunction.hpp>
 #include <boost/iterator/detail/type_traits/negation.hpp>
 
-#include <boost/mpl/eval_if.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>
-
 namespace boost {
 namespace iterators {
 
 // This forward declaration is required for the friend declaration
 // in iterator_core_access
-  template <class I, class V, class TC, class R, class D> class iterator_facade;
+template<
+    typename Derived,
+    typename Value,
+    typename CategoryOrTraversal,
+    typename Reference   = Value&,
+    typename Difference  = std::ptrdiff_t
+>
+class iterator_facade;
 
-  namespace detail
-  {
-    // A binary metafunction class that always returns bool.  VC6
-    // ICEs on mpl::always<bool>, probably because of the default
-    // parameters.
-    struct always_bool2
-    {
-        template <class T, class U>
-        struct apply
-        {
-            typedef bool type;
-        };
-    };
+namespace detail {
 
 // The type trait checks if the category or traversal is at least as advanced as the specified required traversal
 template< typename CategoryOrTraversal, typename Required >
@@ -58,14 +47,14 @@ namespace iterators {
 // enable if for use in operator implementation.
 //
 template<
-        class Facade1
-      , class Facade2
-      , class Return
+    typename Facade1,
+    typename Facade2,
+    typename Return
 >
 struct enable_if_interoperable :
     public std::enable_if<
-            is_interoperable<Facade1, Facade2>::value
-          , Return
+        is_interoperable< Facade1, Facade2 >::value,
+        Return
     >
 {};
 
@@ -73,18 +62,18 @@ namespace iterators {
 // enable if for use in implementation of operators specific for random access traversal.
 //
 template<
-        class Facade1
-      , class Facade2
-      , class Return
+    typename Facade1,
+    typename Facade2,
+    typename Return
 >
 struct enable_if_interoperable_and_random_access_traversal :
     public std::enable_if<
         detail::conjunction<
-                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
+            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
     >
 {};
 
@@ -93,25 +82,27 @@ namespace iterators {
 // given parameters.
 //
 template<
-        class ValueParam
-      , class CategoryOrTraversal
-      , class Reference
-      , class Difference
+    typename ValueParam,
+    typename CategoryOrTraversal,
+    typename Reference,
+    typename Difference
 >
 struct iterator_facade_types
 {
-        typedef typename facade_iterator_category<
+    using iterator_category = typename facade_iterator_category<
         CategoryOrTraversal, ValueParam, Reference
-        >::type iterator_category;
+    >::type;
 
-        typedef typename std::remove_const<ValueParam>::type value_type;
+    using value_type = typename std::remove_const< ValueParam >::type;
 
     // Not the real associated pointer type
-        typedef typename mpl::eval_if<
-            boost::iterators::detail::iterator_writability_disabled<ValueParam,Reference>
-          , std::add_pointer<const value_type>
-          , std::add_pointer<value_type>
-        >::type pointer;
+    using pointer = typename std::add_pointer<
+        typename std::conditional<
+            boost::iterators::detail::iterator_writability_disabled< ValueParam, Reference >::value,
+            const value_type,
+            value_type
+        >::type
+    >::type;
 };
 
 // iterators whose dereference operators reference the same value
@@ -120,15 +111,15 @@ namespace iterators {
 // value must be read and stored away before the increment occurs
 // so that *a++ yields the originally referenced element and not
 // the next one.
-    template <class Iterator>
+template< typename Iterator >
 class postfix_increment_proxy
 {
-        typedef typename iterator_value<Iterator>::type value_type;
+    using value_type = typename iterator_value< Iterator >::type;
 
 public:
-        explicit postfix_increment_proxy(Iterator const& x)
-          : stored_iterator(x)
-          , stored_value(*x)
+    explicit postfix_increment_proxy(Iterator const& x) :
+        stored_iterator(x),
+        stored_value(*x)
     {}
 
     // Returning a mutable reference allows nonsense like
@@ -159,39 +150,39 @@ namespace iterators {
 };
 
 
-    template <class Iterator>
+template< typename Iterator >
 class writable_postfix_increment_dereference_proxy;
 
-    template <class T>
+template< typename T >
 struct is_not_writable_postfix_increment_dereference_proxy :
     public std::true_type
 {};
 
-    template <class Iterator>
+template< typename Iterator >
 struct is_not_writable_postfix_increment_dereference_proxy<
     writable_postfix_increment_dereference_proxy< Iterator >
 > :
     public std::false_type
 {};
 
-    template <class Iterator>
+template< typename Iterator >
 class writable_postfix_increment_proxy;
 
 //
 // In general, we can't determine that such an iterator isn't
 // writable -- we also need to store a copy of the old iterator so
 // that it can be written into.
-    template <class Iterator>
+template< typename Iterator >
 class writable_postfix_increment_dereference_proxy
 {
     friend class writable_postfix_increment_proxy< Iterator >;
 
-        typedef typename iterator_value<Iterator>::type value_type;
+    using value_type = typename iterator_value< Iterator >::type;
 
 public:
-        explicit writable_postfix_increment_dereference_proxy(Iterator const& x)
-          : stored_iterator(x)
-          , stored_value(*x)
+    explicit writable_postfix_increment_dereference_proxy(Iterator const& x) :
+        stored_iterator(x),
+        stored_value(*x)
     {}
 
     // Provides readability of *r++
@@ -200,7 +191,7 @@ namespace iterators {
         return this->stored_value;
     }
 
-        template <class OtherIterator>
+    template< typename OtherIterator >
     writable_postfix_increment_dereference_proxy const&
     operator=(writable_postfix_increment_dereference_proxy< OtherIterator > const& x) const
     {
@@ -210,7 +201,7 @@ namespace iterators {
     }
 
     // Provides writability of *r++
-        template <class T>
+    template< typename T >
     typename std::enable_if<
         is_not_writable_postfix_increment_dereference_proxy< T >::value,
         writable_postfix_increment_dereference_proxy const&
@@ -225,14 +216,14 @@ namespace iterators {
     mutable value_type stored_value;
 };
 
-    template <class Iterator>
+template< typename Iterator >
 class writable_postfix_increment_proxy
 {
-        typedef typename iterator_value<Iterator>::type value_type;
+    using value_type = typename iterator_value< Iterator >::type;
 
 public:
-        explicit writable_postfix_increment_proxy(Iterator const& x)
-          : dereference_proxy(x)
+    explicit writable_postfix_increment_proxy(Iterator const& x) :
+        dereference_proxy(x)
     {}
 
     writable_postfix_increment_dereference_proxy< Iterator > const&
@@ -257,12 +248,11 @@ namespace iterators {
     writable_postfix_increment_dereference_proxy< Iterator > dereference_proxy;
 };
 
-    template <class Reference, class Value>
-    struct is_non_proxy_reference
-      : std::is_convertible<
-            typename std::remove_reference<Reference>::type
-            const volatile*
-          , Value const volatile*
+template< typename Reference, typename Value >
+struct is_non_proxy_reference :
+    public std::is_convertible<
+        typename std::remove_reference< Reference >::type const volatile*,
+        Value const volatile*
     >
 {};
 
@@ -281,44 +271,41 @@ namespace iterators {
 // operations, we're not going to try to support them.  Therefore,
 // even if r++ returns a proxy, *r++ will only return a proxy if
 // *r also returns a proxy.
-    template <class Iterator, class Value, class Reference, class CategoryOrTraversal>
+template< typename Iterator, typename Value, typename Reference, typename CategoryOrTraversal >
 struct postfix_increment_result
-      : mpl::eval_if<
+{
+    using type = mp11::mp_eval_if_not<
         detail::conjunction<
             // A proxy is only needed for readable iterators
             std::is_convertible<
-                    Reference
+                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 std::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
-              , detail::negation<
-                    std::is_convertible<
-                        typename iterator_category_to_traversal<CategoryOrTraversal>::type
-                      , forward_traversal_tag
+            detail::negation<
+                detail::is_traversal_at_least< CategoryOrTraversal, forward_traversal_tag >
             >
-                >
-            >
-          , mpl::if_<
-                is_non_proxy_reference<Reference,Value>
-              , postfix_increment_proxy<Iterator>
-              , writable_postfix_increment_proxy<Iterator>
-            >
-          , mpl::identity<Iterator>
-        >
-    {};
+        >,
+        Iterator,
+        mp11::mp_if,
+            is_non_proxy_reference< Reference, Value >,
+            postfix_increment_proxy< Iterator >,
+            writable_postfix_increment_proxy< Iterator >
+    >;
+};
 
 // operator->() needs special support for input iterators to strictly meet the
 // standard's requirements. If *i is not a reference type, we must still
 // produce an lvalue to which a pointer can be formed.  We do that by
 // returning a proxy object containing an instance of the reference object.
-    template <class Reference, class Pointer>
+template< typename Reference, typename Pointer >
 struct operator_arrow_dispatch // proxy references
 {
     struct proxy
@@ -330,17 +317,20 @@ namespace iterators {
         operator Reference*() { return std::addressof(m_ref); }
         Reference m_ref;
     };
-        typedef proxy result_type;
+
+    using result_type = proxy;
+
     static result_type apply(Reference const& x)
     {
         return result_type(x);
     }
 };
 
-    template <class T, class Pointer>
+template< typename T, typename Pointer >
 struct operator_arrow_dispatch< T&, Pointer > // "real" references
 {
-        typedef Pointer result_type;
+    using result_type = Pointer;
+
     static result_type apply(T& x)
     {
         return std::addressof(x);
@@ -350,17 +340,17 @@ namespace iterators {
 // A proxy return type for operator[], needed to deal with
 // iterators that may invalidate referents upon destruction.
 // Consider the temporary iterator in *(a + n)
-    template <class Iterator>
+template< typename Iterator >
 class operator_brackets_proxy
 {
     // Iterator is actually an iterator_facade, so we do not have to
     // go through iterator_traits to access the traits.
-        typedef typename Iterator::reference  reference;
-        typedef typename Iterator::value_type value_type;
+    using reference = typename Iterator::reference;
+    using value_type = typename Iterator::value_type;
 
 public:
-        operator_brackets_proxy(Iterator const& iter)
-          : m_iter(iter)
+    operator_brackets_proxy(Iterator const& iter) :
+        m_iter(iter)
     {}
 
     operator reference() const
@@ -380,58 +370,58 @@ namespace iterators {
 
 // A metafunction that determines whether operator[] must return a
 // proxy, or whether it can simply return a copy of the value_type.
-    template <class ValueType, class Reference>
-    struct use_operator_brackets_proxy
-      : detail::negation<
+template< typename ValueType, typename Reference >
+struct use_operator_brackets_proxy :
+    public detail::negation<
         detail::conjunction<
-                std::is_copy_constructible<ValueType>
-              , std::is_trivial<ValueType>
-              , iterator_writability_disabled<ValueType,Reference>
+            std::is_copy_constructible< ValueType >,
+            std::is_trivial< ValueType >,
+            iterator_writability_disabled< ValueType, Reference >
         >
     >
 {};
 
-    template <class Iterator, class Value, class Reference>
+template< typename Iterator, typename Value, typename Reference >
 struct operator_brackets_result
 {
-        typedef typename std::conditional<
-            use_operator_brackets_proxy<Value,Reference>::value
-          , operator_brackets_proxy<Iterator>
-          , Value
-        >::type type;
+    using type = typename std::conditional<
+        use_operator_brackets_proxy<Value, Reference>::value,
+        operator_brackets_proxy<Iterator>,
+        Value
+    >::type;
 };
 
-    template <class Iterator>
-    operator_brackets_proxy<Iterator> make_operator_brackets_result(Iterator const& iter, std::true_type)
+template< typename Iterator >
+inline operator_brackets_proxy<Iterator> make_operator_brackets_result(Iterator const& iter, std::true_type)
 {
     return operator_brackets_proxy< Iterator >(iter);
 }
 
-    template <class Iterator>
-    typename Iterator::value_type make_operator_brackets_result(Iterator const& iter, std::false_type)
+template< typename Iterator >
+inline typename Iterator::value_type make_operator_brackets_result(Iterator const& iter, std::false_type)
 {
     return *iter;
 }
 
-    struct choose_difference_type
-    {
-        template <class I1, class I2>
-        struct apply : mpl::eval_if<
-                           std::is_convertible<I2,I1>
-                         , iterator_difference<I1>
-                         , iterator_difference<I2>
-                       >
-        {};
-    };
+// A binary metafunction class that always returns bool.
+template< typename Iterator1, typename Iterator2 >
+using always_bool_t = bool;
+
+template< typename Iterator1, typename Iterator2 >
+using choose_difference_type_t = typename std::conditional<
+    std::is_convertible< Iterator2, Iterator1 >::value,
+    iterator_difference< Iterator1 >,
+    iterator_difference< Iterator2 >
+>::type::type;
 
 template<
-        class Derived
-      , class Value
-      , class CategoryOrTraversal
-      , class Reference
-      , class Difference
-      , bool IsBidirectionalTraversal
-      , bool IsRandomAccessTraversal
+    typename Derived,
+    typename Value,
+    typename CategoryOrTraversal,
+    typename Reference,
+    typename Difference,
+    bool IsBidirectionalTraversal,
+    bool IsRandomAccessTraversal
 >
 class iterator_facade_base;
 
@@ -441,16 +431,16 @@ namespace iterators {
 // Macros which describe the declarations of binary operators
 #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 \
+        typename Derived1, typename V1, typename TC1, typename Reference1, typename Difference1, \
+        typename Derived2, typename V2, typename TC2, typename Reference2, typename Difference2  \
     >                                                                   \
     prefix typename enabler<                                            \
-        Derived1, Derived2                                              \
-      , typename mpl::apply2<result_type,Derived1,Derived2>::type       \
+        Derived1, Derived2,                                             \
+        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)
+        iterator_facade< Derived1, V1, TC1, Reference1, Difference1 > const& lhs,   \
+        iterator_facade< Derived2, V2, TC2, Reference2, Difference2 > const& rhs)
 
 #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)
@@ -459,13 +449,13 @@ namespace iterators {
     BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, boost::iterators::detail::enable_if_interoperable_and_random_access_traversal)
 
 #define BOOST_ITERATOR_FACADE_PLUS_HEAD(prefix,args)                \
-    template <class Derived, class V, class TC, class R, class D>   \
+    template< typename Derived, typename V, typename TC, typename R, typename D >   \
     prefix typename std::enable_if<                                 \
         boost::iterators::detail::is_traversal_at_least<            \
-            TC                                                      \
-          , boost::iterators::random_access_traversal_tag           \
-        >::value                                                    \
-      , Derived                                                     \
+            TC,                                                     \
+            boost::iterators::random_access_traversal_tag           \
+        >::value,                                                   \
+        Derived                                                     \
     >::type operator+ args
 
 //
@@ -479,12 +469,13 @@ namespace iterators {
 //
 class iterator_core_access
 {
-      template <class I, class V, class TC, class R, class D> friend class iterator_facade;
-      template <class I, class V, class TC, class R, class D, bool IsBidirectionalTraversal, bool IsRandomAccessTraversal>
+    template< typename I, typename V, typename TC, typename R, typename D >
+    friend class iterator_facade;
+    template< typename I, typename V, typename TC, typename R, typename D, bool IsBidirectionalTraversal, bool IsRandomAccessTraversal >
     friend class detail::iterator_facade_base;
 
 #define BOOST_ITERATOR_FACADE_RELATION(op)                                \
-      BOOST_ITERATOR_FACADE_INTEROP_HEAD(friend,op, boost::iterators::detail::always_bool2);
+    BOOST_ITERATOR_FACADE_INTEROP_HEAD(friend, op, boost::iterators::detail::always_bool_t);
 
     BOOST_ITERATOR_FACADE_RELATION(==)
     BOOST_ITERATOR_FACADE_RELATION(!=)
@@ -492,7 +483,7 @@ namespace iterators {
 #undef BOOST_ITERATOR_FACADE_RELATION
 
 #define BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(op)                                \
-      BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(friend,op, boost::iterators::detail::always_bool2);
+    BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(friend, op, boost::iterators::detail::always_bool_t);
 
     BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<)
     BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>)
@@ -501,70 +492,62 @@ namespace iterators {
 
 #undef BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION
 
-      BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(
-          friend, -, boost::iterators::detail::choose_difference_type)
-      ;
+    BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(friend, -, boost::iterators::detail::choose_difference_type_t);
 
     BOOST_ITERATOR_FACADE_PLUS_HEAD(
-          friend inline
-        , (iterator_facade<Derived, V, TC, R, D> const&
-        , typename Derived::difference_type)
-      )
-      ;
+        friend inline,
+        (iterator_facade< Derived, V, TC, R, D > const&, typename Derived::difference_type)
+    );
 
     BOOST_ITERATOR_FACADE_PLUS_HEAD(
-          friend inline
-        , (typename Derived::difference_type
-        , iterator_facade<Derived, V, TC, R, D> const&)
-      )
-      ;
+        friend inline,
+        (typename Derived::difference_type, iterator_facade< Derived, V, TC, R, D > const&)
+    );
 
-      template <class Facade>
+    template< typename Facade >
     static typename Facade::reference dereference(Facade const& f)
     {
         return f.dereference();
     }
 
-      template <class Facade>
+    template< typename Facade >
     static void increment(Facade& f)
     {
         f.increment();
     }
 
-      template <class Facade>
+    template< typename Facade >
     static void decrement(Facade& f)
     {
         f.decrement();
     }
 
-      template <class Facade1, class Facade2>
+    template< typename Facade1, typename Facade2 >
     static bool equal(Facade1 const& f1, Facade2 const& f2, std::true_type)
     {
         return f1.equal(f2);
     }
 
-      template <class Facade1, class Facade2>
+    template< typename Facade1, typename Facade2 >
     static bool equal(Facade1 const& f1, Facade2 const& f2, std::false_type)
     {
         return f2.equal(f1);
     }
 
-      template <class Facade>
+    template< typename Facade >
     static void advance(Facade& f, typename Facade::difference_type n)
     {
         f.advance(n);
     }
 
-      template <class Facade1, class Facade2>
-      static typename Facade1::difference_type distance_from(
-          Facade1 const& f1, Facade2 const& f2, std::true_type)
+    template< typename Facade1, typename Facade2 >
+    static typename Facade1::difference_type distance_from(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, std::false_type)
+    template< typename Facade1, typename Facade2 >
+    static typename Facade2::difference_type distance_from(Facade1 const& f1, Facade2 const& f2, std::false_type)
     {
         return f2.distance_to(f1);
     }
@@ -572,52 +555,52 @@ namespace iterators {
     //
     // Curiously Recurring Template interface.
     //
-      template <class I, class V, class TC, class R, class D>
+    template< typename I, typename V, typename TC, typename R, typename D >
     static I& derived(iterator_facade< I, V, TC, R, D >& facade)
     {
         return *static_cast< I* >(&facade);
     }
 
-      template <class I, class V, class TC, class R, class D>
+    template< typename I, typename V, typename TC, typename R, typename D >
     static I const& derived(iterator_facade< I, V, TC, R, D > const& facade)
     {
         return *static_cast< I const* >(&facade);
     }
 
     // objects of this class are useless
-      BOOST_DELETED_FUNCTION(iterator_core_access())
+    iterator_core_access() = delete;
 };
 
 namespace detail {
 
 // Implementation for forward traversal iterators
 template<
-        class Derived
-      , class Value
-      , class CategoryOrTraversal
-      , class Reference
-      , class Difference
+    typename Derived,
+    typename Value,
+    typename CategoryOrTraversal,
+    typename Reference,
+    typename Difference
 >
 class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, false, false >
 {
 private:
-        typedef boost::iterators::detail::iterator_facade_types<
+    using associated_types = boost::iterators::detail::iterator_facade_types<
         Value, CategoryOrTraversal, Reference, Difference
-        > associated_types;
+    >;
 
-        typedef boost::iterators::detail::operator_arrow_dispatch<
-            Reference
-          , typename associated_types::pointer
-        > operator_arrow_dispatch_;
+    using operator_arrow_dispatch_ = boost::iterators::detail::operator_arrow_dispatch<
+        Reference,
+        typename associated_types::pointer
+    >;
 
 public:
-        typedef typename associated_types::value_type value_type;
-        typedef Reference reference;
-        typedef Difference difference_type;
+    using value_type = typename associated_types::value_type;
+    using reference = Reference;
+    using difference_type = Difference;
 
-        typedef typename operator_arrow_dispatch_::result_type pointer;
+    using pointer = typename operator_arrow_dispatch_::result_type;
 
-        typedef typename associated_types::iterator_category iterator_category;
+    using iterator_category = typename associated_types::iterator_category;
 
 public:
     reference operator*() const
@@ -653,11 +636,11 @@ namespace iterators {
 
 // Implementation for bidirectional traversal iterators
 template<
-        class Derived
-      , class Value
-      , class CategoryOrTraversal
-      , class Reference
-      , class Difference
+    typename Derived,
+    typename Value,
+    typename CategoryOrTraversal,
+    typename Reference,
+    typename Difference
 >
 class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false > :
     public iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, false, false >
@@ -679,31 +662,29 @@ namespace iterators {
 
 // Implementation for random access traversal iterators
 template<
-        class Derived
-      , class Value
-      , class CategoryOrTraversal
-      , class Reference
-      , class Difference
+    typename Derived,
+    typename Value,
+    typename CategoryOrTraversal,
+    typename Reference,
+    typename Difference
 >
 class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, true > :
     public iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false >
 {
 private:
-        typedef iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false > base_type;
+    using base_type = iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false >;
 
 public:
-        typedef typename base_type::reference reference;
-        typedef typename base_type::difference_type difference_type;
+    using reference = typename base_type::reference;
+    using difference_type = typename base_type::difference_type;
 
 public:
     typename boost::iterators::detail::operator_brackets_result< Derived, Value, reference >::type
     operator[](difference_type n) const
     {
-            using use_proxy = boost::iterators::detail::use_operator_brackets_proxy<Value, Reference>;
-
         return boost::iterators::detail::make_operator_brackets_result< Derived >(
-                this->derived() + n
-              , std::integral_constant<bool, use_proxy::value>{}
+            this->derived() + n,
+            std::integral_constant< bool, boost::iterators::detail::use_operator_brackets_proxy< Value, Reference >::value >{}
         );
     }
 
@@ -733,11 +714,11 @@ namespace iterators {
 // standard-conforming iterators.
 //
 template<
-      class Derived             // The derived iterator type being constructed
-    , class Value
-    , class CategoryOrTraversal
-    , class Reference   = Value&
-    , class Difference  = std::ptrdiff_t
+    typename Derived,             // The derived iterator type being constructed
+    typename Value,
+    typename CategoryOrTraversal,
+    typename Reference,
+    typename Difference
 >
 class iterator_facade :
     public detail::iterator_facade_base<
@@ -752,15 +733,12 @@ namespace iterators {
 {
 protected:
     // For use by derived classes
-      typedef iterator_facade<Derived,Value,CategoryOrTraversal,Reference,Difference> iterator_facade_;
+    using iterator_facade_ = iterator_facade< Derived, Value, CategoryOrTraversal, Reference, Difference >;
 };
 
-  template <class I, class V, class TC, class R, class D>
+template< typename I, typename V, typename TC, typename R, typename D >
 inline typename boost::iterators::detail::postfix_increment_result< I, V, R, TC >::type
-  operator++(
-      iterator_facade<I,V,TC,R,D>& i
-    , int
-  )
+operator++(iterator_facade< I, V, TC, R, D >& i, int)
 {
     typename boost::iterators::detail::postfix_increment_result< I, V, R, TC >::type
         tmp(*static_cast< I* >(&i));
@@ -842,18 +820,18 @@ namespace iterators {
     BOOST_ITERATOR_FACADE_INTEROP_HEAD(inline, op, result_type)                                \
     {                                                                                          \
         return_prefix iterator_core_access::base_op(                                           \
-          *static_cast<Derived1 const*>(&lhs)                                            \
-        , *static_cast<Derived2 const*>(&rhs)                                            \
-        , std::integral_constant<bool, std::is_convertible<Derived2, Derived1>::value>() \
+            *static_cast< Derived1 const* >(&lhs),                                             \
+            *static_cast< Derived2 const* >(&rhs),                                             \
+            std::integral_constant< bool, std::is_convertible< Derived2, Derived1 >::value >() \
         );                                                                                     \
     }
 
 #define BOOST_ITERATOR_FACADE_RELATION(op, return_prefix, base_op) \
     BOOST_ITERATOR_FACADE_INTEROP(                                 \
-      op                                                            \
-    , boost::iterators::detail::always_bool2                        \
-    , return_prefix                                                 \
-    , base_op                                                       \
+        op,                                                        \
+        boost::iterators::detail::always_bool_t,                   \
+        return_prefix,                                             \
+        base_op                                                    \
     )
 
 BOOST_ITERATOR_FACADE_RELATION(==, return, equal)
@@ -865,20 +843,19 @@ namespace iterators {
 #define BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS(op, result_type, return_prefix, base_op)   \
     BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(inline, op, result_type)                  \
     {                                                                                          \
-      using boost::iterators::detail::is_traversal_at_least;                                  \
         return_prefix iterator_core_access::base_op(                                           \
-          *static_cast<Derived1 const*>(&lhs)                                                 \
-        , *static_cast<Derived2 const*>(&rhs)                                                 \
-        , std::integral_constant<bool, std::is_convertible<Derived2, Derived1>::value>()      \
+            *static_cast< Derived1 const* >(&lhs),                                             \
+            *static_cast< Derived2 const* >(&rhs),                                             \
+            std::integral_constant< bool, std::is_convertible< Derived2, Derived1 >::value >() \
         );                                                                                     \
     }
 
 #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_bool_t,                                 \
+        return_prefix,                                                           \
+        base_op                                                                  \
     )
 
 BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<, return 0 >, distance_from)
@@ -890,10 +867,10 @@ namespace iterators {
 
 // operator- requires an additional part in the static assertion
 BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS(
-      -
-    , boost::iterators::detail::choose_difference_type
-    , return
-    , distance_from
+    -,
+    boost::iterators::detail::choose_difference_type_t,
+    return,
+    distance_from
 )
 
 #undef BOOST_ITERATOR_FACADE_INTEROP
@@ -906,15 +883,8 @@ namespace iterators {
         return tmp += n;                               \
     }
 
-  BOOST_ITERATOR_FACADE_PLUS((
-      iterator_facade<Derived, V, TC, R, D> const& i
-    , typename Derived::difference_type n
-  ))
-
-  BOOST_ITERATOR_FACADE_PLUS((
-      typename Derived::difference_type n
-    , iterator_facade<Derived, V, TC, R, D> const& i
-  ))
+BOOST_ITERATOR_FACADE_PLUS((iterator_facade< Derived, V, TC, R, D > const& i, typename Derived::difference_type n))
+BOOST_ITERATOR_FACADE_PLUS((typename Derived::difference_type n, iterator_facade< Derived, V, TC, R, D > const& i))
 
 #undef BOOST_ITERATOR_FACADE_PLUS
 #undef BOOST_ITERATOR_FACADE_PLUS_HEAD