[/==============================================================================
    Copyright (C) 2001-2007 Joel de Guzman, Dan Marsden, Tobias Schwinger

    Use, modification and distribution is subject to 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)
===============================================================================/]
[section Iterator]

Like __mpl__ and __stl__, iterators are a fundamental concept in Fusion.
As with __mpl__ and __stl__ iterators describe positions, and
provide access to data within an underlying __sequence__.

[heading Header]
    #include <boost/fusion/iterator.hpp>
    #include <boost/fusion/include/iterator.hpp>

[section Concepts]

Fusion iterators are divided into different traversal categories.
__forward_iterator__ is the most basic concept. __bidirectional_iterator__
is a refinement of __forward_iterator__. __random_access_iterator__ is a
refinement of __bidirectional_iterator__.

[section Forward Iterator]

[heading Description]
A Forward Iterator traverses a __sequence__ allowing movement in only one direction through
it's elements, one element at a time.

[variablelist Notation
    [[`i`, `j`]         [Forward Iterators]]
    [[`I`, `J`]         [Forward Iterator types]]
    [[`M`]              [An __mpl__ integral constant]]
    [[`N`]              [An integral constant]]
]

[heading Expression requirements]
A type models Forward Iterator if, in addition to being CopyConstructable,
the following expressions are valid:

[table
    [[Expression]        [Return type]                [Runtime Complexity]]
    [[`__next__(i)`]         [__forward_iterator__]       [Constant]]
    [[`i == j`]          [Convertible to bool]        [Constant]]
    [[`i != j`]          [Convertible to bool]        [Constant]]
    [[`__advance_c__<N>(i)`] [__forward_iterator__]       [Constant]]
    [[`__advance__<M>(i)`] [__forward_iterator__]       [Constant]]
    [[`__distance__(i, j)`]  [`__result_of_distance__<I, J>::type`][Constant]]
    [[`__deref__(i)`]        [`__result_of_deref__<I>::type`] [Constant]]
    [[`*i`]              [`__result_of_deref__<I>::type`] [Constant]]
]

[heading Meta Expressions]
[table
    [[Expression]                       [Compile Time Complexity]]
    [[`__result_of_next__<I>::type`]            [Amortized constant time]]
    [[`__result_of_equal_to__<I, J>::type`]      [Amortized constant time]]
    [[`__result_of_advance_c__<I, N>::type`]     [Linear]]
    [[`__result_of_advance__<I ,M>::type`]       [Linear]]
    [[`__result_of_distance__<I ,J>::type`]      [Linear]]
    [[`__result_of_deref__<I>::type`]       [Amortized constant time]]
    [[`__result_of_value_of__<I>::type`]    [Amortized constant time]]
]

[heading Expression Semantics]
[
table
    [[Expression]              [Semantics]]
    [[`__next__(i)`]               [An iterator to the element following `i`]]
    [[`i == j`]                [Iterator equality comparison]]
    [[`i != j`]                [Iterator inequality comparison]]
    [[`__advance_c__<N>(i)`]       [An iterator n elements after `i` in the sequence]]
    [[`__advance__<M>(i)`]         [Equivalent to `advance_c<M::value>(i)`]]
    [[`__distance__(i, j)`]        [The number of elements between `i` and `j`]]
    [[`__deref__(i)`]    [The element at position`i`]]
    [[`*i`]          [Equivalent to `deref(i)`]]
]

[heading Invariants]
The following invariants always hold:

* `!(i == j) == (i != j)`
* `__next__(i) == __advance_c__<1>(i)`
* `__distance__(i, __advance_c__<N>(i)) == N`
* Using `__next__` to traverse the sequence will never return to a previously seen position
* `__deref__(i)` is equivalent to `*i`
* If `i == j` then `*i` is equivalent to `*j`

[heading Models]
* __std_pair__ iterator
* __boost_array__ iterator
* __vector__ iterator
* __cons__ iterator
* __list__ iterator
* __set__ iterator
* __map__ iterator
* __single_view__ iterator
* __filter_view__ iterator
* __iterator_range__ iterator
* __joint_view__ iterator
* __transform_view__ iterator
* __reverse_view__ iterator

[endsect]

[section Bidirectional Iterator]
[heading Description]
A Bidirectional Iterator traverses a __sequence__ allowing movement in either direction one
element at a time.

[variablelist Notation
    [[`i`]         [A Bidirectional Iterator]]
    [[`I`]         [A Bidirectional Iterator type]]
    [[`M`]         [An __mpl__ integral constant]]
    [[`N`]         [An integral constant]]
]

[heading Refinement of]
__forward_iterator__

[heading Expression requirements]
In addition to the requirements defined in __forward_iterator__,
the following expressions must be valid:

[table
    [[Expression]        [Return type]                [Runtime Complexity]]
    [[`__next__(i)`]         [__bidirectional_iterator__] [Constant]]
    [[`__prior__(i)`]        [__bidirectional_iterator__] [Constant]]
    [[`__advance_c__<N>(i)`] [__bidirectional_iterator__] [Constant]]
    [[`__advance__<M>(i)`]   [__bidirectional_iterator__] [Constant]]
]

[heading Meta Expressions]
[table
    [[Expression]              [Compile Time Complexity]]
    [[`__result_of_prior__<I>::type`]  [Amortized constant time]]
]

[heading Expression Semantics]
The semantics of an expression are defined only where they differ from, or are not defined
in __forward_iterator__

[table
    [[Expression]    [Semantics]]
    [[`__prior__(i)`]     [An iterator to the element preceding `i`]]
]

[heading Invariants]
In addition to the invariants of __forward_iterator__,
the following invariants always hold:

* `__prior__(__next__(i)) == i && __prior__(__next__(i)) == __next__(__prior__(i))`
* `__prior__(i) == __advance_c__<-1>(i)`
* Using `__prior__` to traverse a sequence will never return a previously seen position

[heading Models]
* __std_pair__ iterator
* __boost_array__ iterator
* __vector__ iterator
* __iterator_range__ (where adapted sequence is a __bidirectional_sequence__)
* __transform_view__ (where adapted sequence is a __bidirectional_sequence__)
* __reverse_view__

[endsect]

[section Random Access Iterator]
[heading Description]
A Random Access Iterator traverses a __sequence__ moving in either direction,
permitting efficient arbitrary distance movements back and forward through the
sequence.

[variablelist Notation
    [[`i`, `j`]         [Random Access Iterators]]
    [[`I`, `J`]         [Random Access Iterator types]]
    [[`M`]              [An __mpl__ integral constant]]
    [[`N`]              [An integral constant]]
]

[heading Refinement of]
__bidirectional_iterator__

[heading Expression requirements]
In addition to the requirements defined in __bidirectional_iterator__,
the following expressions must be valid:

[table
    [[Expression]        [Return type]                [Runtime Complexity]]
    [[`__next__(i)`]         [__random_access_iterator__]       [Constant]]
    [[`__prior__(i)`]        [__random_access_iterator__]       [Constant]]
    [[`__advance_c__<N>(i)`] [__random_access_iterator__]       [Constant]]
    [[`__advance__<M>(i)`]   [__random_access_iterator__]       [Constant]]
]

[heading Meta Expressions]
[table
    [[Expression]                       [Compile Time Complexity]]
    [[`__result_of_advance_c__<I, N>::type`]  [Amortized constant time]]
    [[`__result_of_advance__<I, M>::type`]    [Amortized constant time]]
    [[`__result_of_distance__<I ,J>::type`]   [Amortized constant time]]
]

[heading Models]
* __vector__ iterator
* __std_pair__ iterator
* __boost_array__ iterator
* __iterator_range__ iterator (where adapted sequence is a __random_access_sequence__)
* __transform_view__ iterator (where adapted sequence is a __random_access_sequence__)
* __reverse_view__ iterator (where adapted sequence is a __random_access_sequence__)

[endsect]

[endsect]

[section Functions]
Fusion provides functions for manipulating iterators, analogous to the similar functions
from the __mpl__ library.

[section deref]

[heading Description]
Deferences an iterator.

[heading Synopsis]
    template<
        typename I
        >
    typename __result_of_deref__<I>::type deref(I const& i);

[table Parameters
    [[Parameter]      [Requirement]    [Description]]
    [[`i`]            [Model of __forward_iterator__] [Operation's argument]]
]

[heading Expression Semantics]
    __deref__(i);

[*Return type]: `__result_of_deref__<I>::type`

[*Semantics]: Dereferences the iterator `i`.

[heading Header]
    #include <boost/fusion/iterator/deref.hpp>
    #include <boost/fusion/include/deref.hpp>

[heading Example]
    typedef __vector__<int,int&> vec;

    int i(0);
    vec v(1,i);
    assert(__deref__(__begin__(v)) == 1);
    assert(__deref__(__next__(__begin__(v))) == 0);
    assert(&(__deref__(__next__(__begin__(v)))) == &i);

[endsect]

[section next]

[heading Description]
Moves an iterator 1 position forwards.

[heading Synopsis]
    template<
        typename I
        >
    typename __result_of_next__<I>::type next(I const& i);

[table Parameters
    [[Parameter]    [Requirement]   [Description]]
    [[`i`]          [Model of __forward_iterator__] [Operation's argument]]
]

[heading Expression Semantics]
    next(i);

[*Return type]: A model of the same iterator concept as `i`.

[*Semantics]: Returns an iterator to the next element after `i`.

[heading Header]
    #include <boost/fusion/iterator/next.hpp>
    #include <boost/fusion/include/next.hpp>

[heading Example]
    typedef __vector__<int,int,int> vec;

    vec v(1,2,3);
    assert(__deref__(__begin__(v)) == 1);
    assert(__deref__(__next__(__begin__(v))) == 2);
    assert(__deref__(__next__(__next__(__begin__(v)))) == 3);

[endsect]

[section prior]

[heading Description]
Moves an iterator 1 position backwards.

[heading Synopsis]
    template<
        typename I
        >
    typename __result_of_prior__<I>::type prior(I const& i);

[table Parameters
    [[Parameter]    [Requirement]   [Description]]
    [[`i`]          [Model of __bidirectional_iterator__] [Operation's argument]]
]

[heading Expression Semantics]
    __prior__(i);

[*Return type]: A model of the same iterator concept as `i`.

[*Semantics]: Returns an iterator to the element prior to `i`.

[heading Header]
    #include <boost/fusion/iterator/prior.hpp>
    #include <boost/fusion/include/prior.hpp>

[heading Example]
    typedef __vector__<int,int> vec;

    vec v(1,2);
    assert(__deref__(__next__(__begin__(v))) == 2);
    assert(__deref__(__prior__(__next__(__begin__(v)))) == 1);

[endsect]

[section distance]

[heading Description]
Returns the distance between 2 iterators.

[heading Synopsis]
    template<
        typename I,
        typename J
        >
    typename __result_of_distance__<I, J>::type distance(I const& i, J const& j);

[table Parameters
    [[Parameter]    [Requirement]   [Description]]
    [[`i`, `j`]          [Models of __forward_iterator__ into the same sequence] [The start and end points of the distance to be measured]]
]

[heading Expression Semantics]
    __distance__(i,j);

[*Return type]: `int`

[*Semantics]: Returns the distance between iterators `i` and `j`.

[heading Header]
    #include <boost/fusion/iterator/distance.hpp>
    #include <boost/fusion/include/distance.hpp>

[heading Example]
    typedef __vector__<int,int,int> vec;

    vec v(1,2,3);
    assert(__distance__(__begin__(v), __next__(__next__(__begin__(v)))) == 2);

[endsect]

[section advance]

[heading Description]
Moves an iterator by a specified distance.

[heading Synopsis]
    template<
        typename I,
        typename M
        >
    typename __result_of_advance__<I, M>::type advance(I const& i);

[table Parameters
    [[Parameter]    [Requirement]   [Description]]
    [[`i`]          [Model of __forward_iterator__] [Iterator to move relative to]]
    [[`N`]          [An __mpl_integral_constant__] [Number of positions to move]]
]

[heading Expression Semantics]
    __advance__<M>(i);

[*Return type]: A model of the same iterator concept as `i`.

[*Semantics]: Returns an iterator to the element `M` positions from `i`. If `i` is a __bidirectional_iterator__ then `M` may be negative.

[heading Header]
    #include <boost/fusion/iterator/advance.hpp>
    #include <boost/fusion/include/advance.hpp>

[heading Example]
    typedef __vector__<int,int,int> vec;

    vec v(1,2,3);
    assert(__deref__(__advance__<mpl::int_<2> >(__begin__(v))) == 3);

[endsect]

[section advance_c]

[heading Description]
Moves an iterator by a specified distance.

[heading Synopsis]
    template<
        typename I,
        int N
        >
    typename __result_of_advance_c__<I, N>::type advance_c(I const& i);

[table Parameters
    [[Parameter]    [Requirement]   [Description]]
    [[`i`]          [Model of __forward_iterator__] [Iterator to move relative to]]
    [[`N`]          [Integer constant] [Number of positions to move]]
]

[heading Expression Semantics]
    __advance_c__<N>(i);

[*Return type]: A model of the same iterator concept as `i`.

[*Semantics]: Returns an iterator to the element `N` positions from `i`. If `i` is a __bidirectional_iterator__ then `N` may be negative.

[heading Header]
    #include <boost/fusion/iterator/advance.hpp>
    #include <boost/fusion/include/advance.hpp>

[heading Example]
    typedef __vector__<int,int,int> vec;

    vec v(1,2,3);
    assert(__deref__(__advance_c__<2>(__begin__(v))) == 3);

[endsect]

[endsect]

[section Operator]

Overloaded operators are provided to provide a more natural syntax for dereferencing iterators, and comparing them for equality.

[section:operator_unary_star Operator *]

[heading Description]
Dereferences an iterator.

[heading Synopsis]
    template<
        typename I
        >
    typename __result_of_deref__<I>::type operator*(__unspecified__<I> const& i);

[table Parameters
    [[Parameter]      [Requirement]    [Description]]
    [[`i`]            [Model of __forward_iterator__] [Operation's argument]]
]

[heading Expression Semantics]
    *i

[*Return type]: Equivalent to the return type of `__deref__(i)`.

[*Semantics]: Equivalent to `__deref__(i)`.

[heading Header]
    #include <boost/fusion/iterator/deref.hpp>
    #include <boost/fusion/include/deref.hpp>

[heading Example]
    typedef __vector__<int,int&> vec;

    int i(0);
    vec v(1,i);
    assert(*__begin__(v) == 1);
    assert(*__next__(__begin__(v)) == 0);
    assert(&(*__next__(__begin__(v))) == &i);

[endsect]

[section:operator_equality Operator ==]

[heading Description]
Compares 2 iterators for equality.

[heading Synopsis]
    template<
        typename I,
        typename J
        >
    __unspecified__ operator==(I const& i, J const& i);

[table Parameters
    [[Parameter]    [Requirement]   [Description]]
    [[`i`, `j`]     [Any fusion iterators] [Operation's arguments]]
]

[heading Expression Semantics]
    i == j

[*Return type]: Convertible to `bool`.

[*Semantics]: Equivalent to `__result_of_equal_to__<I,J>::value` where `I` and `J` are the types of `i` and `j` respectively.

[heading Header]
    #include <boost/fusion/iterator/equal_to.hpp>
    #include <boost/fusion/include/equal_to.hpp>

[endsect]

[section:operator_inequality Operator !=]

[heading Description]
Compares 2 iterators for inequality.

[heading Synopsis]
    template<
        typename I,
        typename J
        >
    __unspecified__ operator==(I const& i, J const& i);

[table Parameters
    [[Parameter]    [Requirement]   [Description]]
    [[`i`, `j`]     [Any fusion iterators] [Operation's arguments]]
]

[heading Expression Semantics]

[*Return type]: Convertible to `bool`.

[*Semantics]: Equivalent to `!__result_of_equal_to__<I,J>::value` where `I` and `J` are the types of `i` and `j` respectively.

[heading Header]
    #include <boost/fusion/iterator/equal_to.hpp>
    #include <boost/fusion/include/equal_to.hpp>

[endsect]

[endsect]

[section Metafunctions]

[section value_of]

[heading Description]

Returns the type stored at the position of an iterator.

[heading Synopsis]
    template<
        typename I
        >
    struct value_of
    {
        typedef __unspecified__ type;
    };

[table Parameters
    [[Parameter]    [Requirement]   [Description]]
    [[`I`]          [Model of __forward_iterator__] [Operation's argument]]
]

[heading Expression Semantics]
    __result_of_value_of__<I>::type

[*Return type]: Any type

[*Semantics]: Returns the type stored in a sequence at iterator position `I`.

[heading Header]
    #include <boost/fusion/iterator/value_of.hpp>
    #include <boost/fusion/include/value_of.hpp>

[heading Example]
    typedef __vector__<int,int&,const int&> vec;
    typedef __result_of_begin__<vec>::type first;
    typedef __result_of_next__<first>::type second;
    typedef __result_of_next__<second>::type third;

    BOOST_MPL_ASSERT((boost::is_same<__result_of_value_of__<first>::type, int>));
    BOOST_MPL_ASSERT((boost::is_same<__result_of_value_of__<second>::type, int&>));
    BOOST_MPL_ASSERT((boost::is_same<__result_of_value_of__<third>::type, const int&>));

[endsect]

[section deref]

[heading Description]
Returns the type that will be returned by dereferencing an iterator.

[heading Synposis]
    template<
        typename I
        >
    struct deref
    {
        typedef __unspecified__ type;
    };

[table Parameters
    [[Parameter] [Requirement]                   [Description]]
    [[`I`]       [Model of __forward_iterator__] [Operation's argument]]
]

[heading Expression Semantics]
    __result_of_deref__<I>::type

[*Return type]: Any type

[*Semantics]: Returns the result of dereferencing an iterator of type `I`.

[heading Header]
    #include <boost/fusion/iterator/deref.hpp>
    #include <boost/fusion/include/deref.hpp>

[heading Example]
    typedef __vector__<int,int&> vec;
    typedef const vec const_vec;
    typedef __result_of_begin__<vec>::type first;
    typedef __result_of_next__<first>::type second;

    typedef __result_of_begin__<const_vec>::type const_first;
    typedef __result_of_next__<const_first>::type const_second;

    BOOST_MPL_ASSERT((boost::is_same<__result_of_deref__<first>::type, int&>));
    BOOST_MPL_ASSERT((boost::is_same<__result_of_deref__<second>::type, int&>));

[endsect]

[section next]

[heading Description]
Returns the type of the next iterator in a sequence.

[heading Synposis]
    template<
        typename I
        >
    struct next
    {
        typedef __unspecified__ type;
    };

[table Parameters
    [[Parameter]    [Requirement]   [Description]]
    [[`I`]          [Model of __forward_iterator__] [Operation's argument]]
]

[heading Expression Semantics]
    __result_of_next__<I>::type

[*Return type]: A model of the same iterator concept as `I`.

[*Semantics]: Returns an iterator to the next element in the sequence after `I`.

[heading Header]
    #include <boost/fusion/iterator/next.hpp>
    #include <boost/fusion/include/next.hpp>

[heading Example]
    typedef __vector__<int,double> vec;
    typedef __result_of_next__<__result_of_begin__<vec>::type>::type second;

    BOOST_MPL_ASSERT((boost::is_same<__result_of_value_of__<second>::type, double>));

[endsect]

[section prior]

[heading Description]
Returns the type of the previous iterator in a sequence.

[heading Synopsis]
    template<
        typename I
        >
    struct prior
    {
        typedef __unspecified__ type;
    };

[table Parameters
    [[Parameter]    [Requirement]   [Description]]
    [[`I`]          [Model of __bidirectional_iterator__] [Operation's argument]]
]

[heading Expression Semantics]
    __result_of_prior__<I>::type

[*Return type]: A model of the same iterator concept as `I`.

[*Semantics]: Returns an iterator to the previous element in the sequence before `I`.

[heading Header]
    #include <boost/fusion/iterator/prior.hpp>
    #include <boost/fusion/include/prior.hpp>

[heading Example]
    typedef __vector__<int,double> vec;
    typedef __result_of_next__<__result_of_begin__<vec>::type>::type second;

    BOOST_MPL_ASSERT((boost::is_same<__result_of_value_of__<second>::type, double>));

    typedef __result_of_prior__<second>::type first;
    BOOST_MPL_ASSERT((boost::is_same<__result_of_value_of__<first>::type, int>));

[endsect]

[section equal_to]

[heading Description]
Returns a true-valued __mpl_integral_constant__ if `I` and `J` are equal.

[heading Synopsis]
    template<
        typename I,
        typename J
        >
    struct equal_to
    {
        typedef __unspecified__ type;
    };

[table Parameters
    [[Parameter]    [Requirement]   [Description]]
    [[`I`, `J`]     [Any fusion iterators] [Operation's arguments]]
]

[heading Expression Semantics]
    __result_of_equal_to__<I, J>::type

[*Return type]: A model of __mpl_integral_constant__.

[*Semantics]: Returns `boost::mpl::true_` if `I` and `J` are iterators to the same position. Returns `boost::mpl::false_` otherwise.

[heading Header]
    #include <boost/fusion/iterator/equal_to.hpp>
    #include <boost/fusion/include/equal_to.hpp>

[heading Example]
    typedef __vector__<int,double> vec;
    typedef __result_of_begin__<vec>::type first;
    typedef __result_of_end__<vec>::type last;
    BOOST_MPL_ASSERT((__result_of_equal_to__<first, first>));
    BOOST_MPL_ASSERT_NOT((__result_of_equal_to__<first,last>));

[endsect]

[section distance]

[heading Description]
Returns the distance between two iterators.

[heading Synopsis]
    template<
        typename I,
        typename J
        >
    struct distance
    {
        typedef __unspecified__ type;
    };

[table Parameters
    [[Parameter]    [Requirement]   [Description]]
    [[`I`, `J`]          [Models of __forward_iterator__ into the same sequence] [The start and end points of the distance to be measured]]
]

[heading Expression Semantics]
    __result_of_distance__<I, J>::type

[*Return type]: A model of __mpl_integral_constant__.

[*Semantics]: Returns the distance between iterators of types `I` and `J`.

[heading Header]
    #include <boost/fusion/iterator/distance.hpp>
    #include <boost/fusion/include/distance.hpp>

[heading Example]
    typedef __vector__<int,double,char> vec;
    typedef __result_of_begin__<vec>::type first;
    typedef __result_of_next__<first>::type second;
    typedef __result_of_next__<second>::type third;
    typedef __result_of_distance__<first,third>::type dist;

    BOOST_MPL_ASSERT_RELATION(dist::value, ==, 2);

[endsect]

[section advance]

[heading Description]
Moves an iterator a specified distance.

[heading Synopsis]
    template<
        typename I,
        typename M
        >
    struct advance
    {
        typedef __unspecified__ type;
    };

[table Parameters
    [[Parameter]    [Requirement]   [Description]]
    [[`I`]          [Model of __forward_iterator__] [Iterator to move relative to]]
    [[`M`]          [Model of __mpl_integral_constant__] [Number of positions to move]]
]

[heading Expression Semantics]
    __result_of_advance__<I,M>::type

[*Return type]: A model of the same iterator concept as `I`.

[*Semantics]: Returns an iterator a distance `M` from `I`. If `I` is a __bidirectional_iterator__ then `M` may be negative.

[heading Header]
    #include <boost/fusion/iterator/advance.hpp>
    #include <boost/fusion/include/advance.hpp>

[heading Example]
    typedef __vector__<int,double,char> vec;
    typedef __result_of_begin__<vec>::type first;
    typedef __result_of_next__<first>::type second;
    typedef __result_of_next__<second>::type third;

    BOOST_MPL_ASSERT((__result_of_equal_to__<__result_of_advance__<first, boost::mpl::int_<2> >::type, third>));

[endsect]

[section advance_c]

[heading Description]
Moves an iterator by a specified distance.

[heading Synopsis]
    template<
        typename I,
        int N
        >
    struct advance_c
    {
        typedef __unspecified__ type;
    };

[table Parameters
    [[Parameter]    [Requirement]   [Description]]
    [[`I`]          [Model of __forward_iterator__] [Iterator to move relative to]]
    [[`N`]          [Integer constant] [Number of positions to move]]
]

[heading Expression Semantics]
    __result_of_advance_c__<I, N>::type

[*Return type]: A model of the same iterator concept as `I`.

[*Semantics]: Returns an iterator a distance `N` from `I`. If `I` is a __bidirectional_iterator__ then `N` may be negative. Equivalent to `__result_of_advance__<I, boost::mpl::int_<N> >::type`.

[heading Header]
    #include <boost/fusion/iterator/advance.hpp>
    #include <boost/fusion/include/advance.hpp>

[heading Example]
    typedef __vector__<int,double,char> vec;
    typedef __result_of_begin__<vec>::type first;
    typedef __result_of_next__<first>::type second;
    typedef __result_of_next__<second>::type third;

    BOOST_MPL_ASSERT((__result_of_equal_to__<__result_of_advance_c__<first, 2>::type, third>));

[endsect]

[endsect]

[endsect]