//The following copied from:
/*
From: "Robert Ramey" <ramey@rrsd.com>
Newsgroups: gmane.comp.lib.boost.user
Subject: challange to MPL gurus
Date: Mon, 12 Dec 2011 11:41:09 -0800
 */
#include <boost/mpl/list.hpp>
#include <boost/mpl/deref.hpp>
#include <boost/mpl/next.hpp>
#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/if_recur.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/arg.hpp>
#include <boost/mpl/assert.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/concept/assert.hpp>

namespace boost{namespace mpl{

template<typename IterBeg, typename IterEnd>
struct ForwardIterator
{
        template
        < typename StateIter
        >
      struct next_deref
      : next<StateIter>
      {
              typedef typename 
            deref<StateIter>::type 
          t1
            //What's this used for?
            //Is there supposed to be some
            //concept check on this type also?
            ;
          BOOST_MPL_ASSERT
          (( is_convertible
             < typename StateIter::category
             , forward_iterator_tag
             >
          ))
            //Is this not redundant?  Why not
            //just check this once in ForwardSequence?
            //If StateIter is forarward iter, 
            //then isn't next<StateIter>::type also
            //forward iter?
            ;
      };
        typedef typename
      if_recur
      < identity<IterBeg>
      , not_
        < boost::is_same
          < arg<1>
          , IterEnd
          >
        >
      , next_deref<arg<1> >
      >::type
    type;
};

template<typename S>
struct ForwardSequence {
    typedef typename begin<S>::type iter_beg;
    typedef typename end<S>::type iter_end;
    BOOST_CONCEPT_ASSERT(( ForwardIterator<iter_beg,iter_end> ));
};

void test_list_sequence(){
    BOOST_CONCEPT_ASSERT(( ForwardSequence<
            list<int, char>
        >
    ));
} 

}}