Contains range-based versions of the std algorithms

namespace boost {
  template<typename Rng, typename Fun> Fun for_each(Rng &, Fun);
  template<typename Rng, typename Fun> Fun for_each(Rng const &, Fun);
  template<typename Rng, typename Val> 
    BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type 
    find(Rng &, Val const &);
  template<typename Rng, typename Val> 
    BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type 
    find(Rng const &, Val const &);
  template<typename Rng, typename Pred> 
    BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type 
    find_if(Rng &, Pred);
  template<typename Rng, typename Pred> 
    BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type 
    find_if(Rng const &, Pred);
  template<typename Rng1, typename Rng2> 
    BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng1 >::type 
    find_end(Rng1 &, Rng2 const &);
  template<typename Rng1, typename Rng2> 
    BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng1 >::type 
    find_end(Rng1 const &, Rng2 const &);
  template<typename Rng1, typename Rng2, typename BinPred> 
    BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng1 >::type 
    find_end(Rng1 &, Rng2 const &, BinPred);
  template<typename Rng1, typename Rng2, typename BinPred> 
    BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng1 >::type 
    find_end(Rng1 const &, Rng2 const &, BinPred);
  template<typename Rng1, typename Rng2> 
    BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng1 >::type 
    find_first_of(Rng1 &, Rng2 const &);
  template<typename Rng1, typename Rng2> 
    BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng1 >::type 
    find_first_of(Rng1 const &, Rng2 const &);
  template<typename Rng1, typename Rng2, typename BinPred> 
    BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng1 >::type 
    find_first_of(Rng1 &, Rng2 const &, BinPred);
  template<typename Rng1, typename Rng2, typename BinPred> 
    BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng1 >::type 
    find_first_of(Rng1 const &, Rng2 const &, BinPred);
  template<typename Rng> 
    BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type 
    adjacent_find(Rng &);
  template<typename Rng> 
    BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type 
    adjacent_find(Rng const &);
  template<typename Rng, typename BinPred> 
    BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type 
    adjacent_find(Rng &, BinPred);
  template<typename Rng, typename BinPred> 
    BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type 
    adjacent_find(Rng const &, BinPred);
  template<typename Rng, typename Val> 
    BOOST_DEDUCED_TYPENAME boost::range_difference< Rng >::type 
    count(Rng &, Val const &);
  template<typename Rng, typename Val> 
    BOOST_DEDUCED_TYPENAME boost::range_difference< Rng const  >::type 
    count(Rng const &, Val const &);
  template<typename Rng, typename Pred> 
    BOOST_DEDUCED_TYPENAME boost::range_difference< Rng >::type 
    count_if(Rng &, Pred);
  template<typename Rng, typename Pred> 
    BOOST_DEDUCED_TYPENAME boost::range_difference< Rng const  >::type 
    count_if(Rng const &, Pred);
  template<typename Rng, typename InIter> 
    std::pair< BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type, InIter > 
    mismatch(Rng &, InIter);
  template<typename Rng, typename InIter> 
    std::pair< BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type, InIter > 
    mismatch(Rng const &, InIter);
  template<typename Rng, typename InIter, typename BinPred> 
    std::pair< BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type, InIter > 
    mismatch(Rng &, InIter, BinPred);
  template<typename Rng, typename InIter, typename BinPred> 
    std::pair< BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type, InIter > 
    mismatch(Rng const &, InIter, BinPred);
  template<typename Rng, typename InIter> bool equal(Rng &, InIter);
  template<typename Rng, typename InIter> bool equal(Rng const &, InIter);
  template<typename Rng, typename InIter, typename BinPred> 
    bool equal(Rng &, InIter, BinPred);
  template<typename Rng, typename InIter, typename BinPred> 
    bool equal(Rng const &, InIter, BinPred);
  template<typename Rng1, typename Rng2> 
    BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng1 >::type 
    search(Rng1 &, Rng2 const &);
  template<typename Rng1, typename Rng2> 
    BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng1 >::type 
    search(Rng1 const &, Rng2 const &);
  template<typename Rng1, typename Rng2, typename BinPred> 
    BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng1 >::type 
    search(Rng1 &, Rng2 const &, BinPred);
  template<typename Rng1, typename Rng2, typename BinPred> 
    BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng1 >::type 
    search(Rng1 const &, Rng2 const &, BinPred);
  template<typename Rng, typename OutIter> OutIter copy(Rng const &, OutIter);
  template<typename Rng, typename BidiIter> 
    BidiIter copy_backward(Rng const &, BidiIter);
  template<typename Rng, typename OutIter, typename UnaryOp> 
    OutIter transform(Rng const &, OutIter, UnaryOp);
  template<typename Rng, typename InIter, typename OutIter, typename BinOp> 
    OutIter transform(Rng const &, InIter, OutIter, BinOp);
  template<typename Rng, typename Val> 
    void replace(Rng &, Val const &, Val const &);
  template<typename Rng, typename Val> 
    void replace(Rng const &, Val const &, Val const &);
  template<typename Rng, typename Pred, typename Val> 
    void replace_if(Rng &, Pred, Val const &);
  template<typename Rng, typename Pred, typename Val> 
    void replace_if(Rng const &, Pred, Val const &);
  template<typename Rng, typename OutIter, typename Val> 
    OutIter replace_copy(Rng const &, OutIter, Val const &, Val const &);
  template<typename Rng, typename OutIter, typename Pred, typename Val> 
    OutIter replace_copy_if(Rng const &, OutIter, Pred, Val const &);
  template<typename Rng, typename Val> void fill(Rng &, Val const &);
  template<typename Rng, typename Val> void fill(Rng const &, Val const &);
  template<typename Rng, typename Int, typename Val> 
    void fill_n(Rng &, Int, Val const &);
  template<typename Rng, typename Int, typename Val> 
    void fill_n(Rng const &, Int, Val const &);
  template<typename Rng, typename Generator> void generate(Rng &, Generator);
  template<typename Rng, typename Generator> 
    void generate(Rng const &, Generator);
  template<typename Rng, typename Int, typename Generator> 
    void generate_n(Rng &, Int, Generator);
  template<typename Rng, typename Int, typename Generator> 
    void generate_n(Rng const &, Int, Generator);
  template<typename Rng, typename Val> 
    BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type 
    remove(Rng &, Val const &);
  template<typename Rng, typename Val> 
    BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type 
    remove(Rng const &, Val const &);
  template<typename Rng, typename Pred> 
    BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type 
    remove_if(Rng &, Pred);
  template<typename Rng, typename Pred> 
    BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type 
    remove_if(Rng const &, Pred);
  template<typename Rng, typename OutIter, typename Val> 
    OutIter remove_copy(Rng const &, OutIter, Val const &);
  template<typename Rng, typename OutIter, typename Pred> 
    OutIter remove_copy_if(Rng const &, OutIter, Pred);
  template<typename Rng> 
    BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type unique(Rng &);
  template<typename Rng> 
    BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type 
    unique(Rng const &);
  template<typename Rng, typename Pred> 
    BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type 
    unique(Rng &, Pred);
  template<typename Rng, typename Pred> 
    BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type 
    unique(Rng const &, Pred);
  template<typename Rng, typename OutIter> 
    OutIter unique_copy(Rng const &, OutIter);
  template<typename Rng, typename OutIter, typename Pred> 
    OutIter unique_copy(Rng const &, OutIter, Pred);
  template<typename Rng> void reverse(Rng &);
  template<typename Rng> void reverse(Rng const &);
  template<typename Rng, typename OutIter> 
    OutIter reverse_copy(Rng const &, OutIter);
  template<typename Rng> 
    void rotate(Rng &, 
                BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type);
  template<typename Rng> 
    void rotate(Rng const &, 
                BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type);
  template<typename Rng, typename OutIter> 
    OutIter rotate_copy(Rng &, 
                        BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type, 
                        OutIter);
  template<typename Rng, typename OutIter> 
    OutIter rotate_copy(Rng const &, 
                        BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type, 
                        OutIter);
  template<typename Rng> void random_shuffle(Rng &);
  template<typename Rng> void random_shuffle(Rng const &);
  template<typename Rng, typename Generator> 
    void random_shuffle(Rng &, Generator);
  template<typename Rng, typename Generator> 
    void random_shuffle(Rng const &, Generator);
  template<typename Rng, typename Pred> 
    BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type 
    partition(Rng &, Pred);
  template<typename Rng, typename Pred> 
    BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type 
    partition(Rng const &, Pred);
  template<typename Rng, typename Pred> 
    BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type 
    stable_partition(Rng &, Pred);
  template<typename Rng, typename Pred> 
    BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type 
    stable_partition(Rng const &, Pred);
  template<typename Rng> void sort(Rng &);
  template<typename Rng> void sort(Rng const &);
  template<typename Rng, typename Cmp> void sort(Rng &, Cmp);
  template<typename Rng, typename Cmp> void sort(Rng const &, Cmp);
  template<typename Rng> void stable_sort(Rng &);
  template<typename Rng> void stable_sort(Rng const &);
  template<typename Rng, typename Cmp> void stable_sort(Rng &, Cmp);
  template<typename Rng, typename Cmp> void stable_sort(Rng const &, Cmp);
  template<typename Rng> 
    void partial_sort(Rng &, 
                      BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type);
  template<typename Rng> 
    void partial_sort(Rng const &, 
                      BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type);
  template<typename Rng, typename Cmp> 
    void partial_sort(Rng &, 
                      BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type, 
                      Cmp);
  template<typename Rng, typename Cmp> 
    void partial_sort(Rng const &, 
                      BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type, 
                      Cmp);
  template<typename Rng1, typename Rng2> 
    BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng2 >::type 
    partial_sort_copy(Rng1 const &, Rng2 &);
  template<typename Rng1, typename Rng2> 
    BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng2 >::type 
    partial_sort_copy(Rng1 const &, Rng2 const &);
  template<typename Rng1, typename Rng2, typename Cmp> 
    BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng2 >::type 
    partial_sort_copy(Rng1 const &, Rng2 &, Cmp);
  template<typename Rng1, typename Rng2, typename Cmp> 
    BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng2 >::type 
    partial_sort_copy(Rng1 const &, Rng2 const &, Cmp);
  template<typename Rng> 
    void nth_element(Rng &, 
                     BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type);
  template<typename Rng> 
    void nth_element(Rng const &, 
                     BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type);
  template<typename Rng, typename Cmp> 
    void nth_element(Rng &, 
                     BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type, 
                     Cmp);
  template<typename Rng, typename Cmp> 
    void nth_element(Rng const &, 
                     BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type, 
                     Cmp);
  template<typename Rng, typename Val> 
    BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type 
    lower_bound(Rng &, Val const &);
  template<typename Rng, typename Val> 
    BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type 
    lower_bound(Rng const &, Val const &);
  template<typename Rng, typename Val, typename Cmp> 
    BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type 
    lower_bound(Rng &, Val const &, Cmp);
  template<typename Rng, typename Val, typename Cmp> 
    BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type 
    lower_bound(Rng const &, Val const &, Cmp);
  template<typename Rng, typename Val> 
    BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type 
    upper_bound(Rng &, Val const &);
  template<typename Rng, typename Val> 
    BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type 
    upper_bound(Rng const &, Val const &);
  template<typename Rng, typename Val, typename Cmp> 
    BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type 
    upper_bound(Rng &, Val const &, Cmp);
  template<typename Rng, typename Val, typename Cmp> 
    BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type 
    upper_bound(Rng const &, Val const &, Cmp);
  template<typename Rng, typename Val> 
    unspecified equal_range(Rng &, Val const &);
  template<typename Rng, typename Val> 
    unspecified equal_range(Rng const &, Val const &);
  template<typename Rng, typename Val, typename Cmp> 
    unspecified equal_range(Rng &, Val const &, Cmp);
  template<typename Rng, typename Val, typename Cmp> 
    unspecified equal_range(Rng const &, Val const &, Cmp);
  template<typename Rng, typename Val> 
    bool binary_search(Rng const &, Val const &);
  template<typename Rng, typename Val, typename Cmp> 
    bool binary_search(Rng const &, Val const &, Cmp);
  template<typename Rng1, typename Rng2, typename OutIter> 
    OutIter merge(Rng1 const &, Rng2 const &, OutIter);
  template<typename Rng1, typename Rng2, typename OutIter, typename Cmp> 
    OutIter merge(Rng1 const &, Rng2 const &, OutIter, Cmp);
  template<typename Rng> 
    void inplace_merge(Rng &, 
                       BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type);
  template<typename Rng> 
    void inplace_merge(Rng const &, 
                       BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type);
  template<typename Rng, typename Cmp> 
    void inplace_merge(Rng &, 
                       BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type, 
                       Cmp);
  template<typename Rng, typename Cmp> 
    void inplace_merge(Rng const &, 
                       BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type, 
                       Cmp);
  template<typename Rng1, typename Rng2> 
    bool includes(Rng1 const &, Rng2 const &);
  template<typename Rng1, typename Rng2, typename Cmp> 
    bool includes(Rng1 const &, Rng2 const &, Cmp);
  template<typename Rng1, typename Rng2, typename OutIter> 
    OutIter set_union(Rng1 const &, Rng2 const &, OutIter);
  template<typename Rng1, typename Rng2, typename OutIter, typename Cmp> 
    OutIter set_union(Rng1 const &, Rng2 const &, OutIter, Cmp);
  template<typename Rng1, typename Rng2, typename OutIter> 
    OutIter set_intersection(Rng1 const &, Rng2 const &, OutIter);
  template<typename Rng1, typename Rng2, typename OutIter, typename Cmp> 
    OutIter set_intersection(Rng1 const &, Rng2 const &, OutIter, Cmp);
  template<typename Rng1, typename Rng2, typename OutIter> 
    OutIter set_difference(Rng1 const &, Rng2 const &, OutIter);
  template<typename Rng1, typename Rng2, typename OutIter, typename Cmp> 
    OutIter set_difference(Rng1 const &, Rng2 const &, OutIter, Cmp);
  template<typename Rng1, typename Rng2, typename OutIter> 
    OutIter set_symmetric_difference(Rng1 const &, Rng2 const &, OutIter);
  template<typename Rng1, typename Rng2, typename OutIter, typename Cmp> 
    OutIter set_symmetric_difference(Rng1 const &, Rng2 const &, OutIter, Cmp);
  template<typename Rng> void push_heap(Rng &);
  template<typename Rng> void push_heap(Rng const &);
  template<typename Rng, typename Cmp> void push_heap(Rng &, Cmp);
  template<typename Rng, typename Cmp> void push_heap(Rng const &, Cmp);
  template<typename Rng> void pop_heap(Rng &);
  template<typename Rng> void pop_heap(Rng const &);
  template<typename Rng, typename Cmp> void pop_heap(Rng &, Cmp);
  template<typename Rng, typename Cmp> void pop_heap(Rng const &, Cmp);
  template<typename Rng> void make_heap(Rng &);
  template<typename Rng> void make_heap(Rng const &);
  template<typename Rng, typename Cmp> void make_heap(Rng &, Cmp);
  template<typename Rng, typename Cmp> void make_heap(Rng const &, Cmp);
  template<typename Rng> void sort_heap(Rng &);
  template<typename Rng> void sort_heap(Rng const &);
  template<typename Rng, typename Cmp> void sort_heap(Rng &, Cmp);
  template<typename Rng, typename Cmp> void sort_heap(Rng const &, Cmp);
  template<typename Rng> 
    BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type 
    min_element(Rng &);
  template<typename Rng> 
    BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type 
    min_element(Rng const &);
  template<typename Rng, typename BinPred> 
    BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type 
    min_element(Rng &, BinPred);
  template<typename Rng, typename BinPred> 
    BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type 
    min_element(Rng const &, BinPred);
  template<typename Rng> 
    BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type 
    max_element(Rng &);
  template<typename Rng> 
    BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type 
    max_element(Rng const &);
  template<typename Rng, typename BinPred> 
    BOOST_DEDUCED_TYPENAME boost::range_iterator< Rng >::type 
    max_element(Rng &, BinPred);
  template<typename Rng, typename BinPred> 
    BOOST_DEDUCED_TYPENAME boost::range_const_iterator< Rng >::type 
    max_element(Rng const &, BinPred);
  template<typename Rng1, typename Rng2> 
    bool lexicographical_compare(Rng1 const &, Rng2 const &);
  template<typename Rng1, typename Rng2, typename BinPred> 
    bool lexicographical_compare(Rng1 const &, Rng2 const &, BinPred);
  template<typename Rng> bool next_permutation(Rng &);
  template<typename Rng> bool next_permutation(Rng const &);
  template<typename Rng, typename Cmp> bool next_permutation(Rng &, Cmp);
  template<typename Rng, typename Cmp> bool next_permutation(Rng const &, Cmp);
  template<typename Rng> bool prev_permutation(Rng &);
  template<typename Rng> bool prev_permutation(Rng const &);
  template<typename Rng, typename Cmp> bool prev_permutation(Rng &, Cmp);
  template<typename Rng, typename Cmp> bool prev_permutation(Rng const &, Cmp);
}

Defines the filter range adaptor, as well as the make_filter_range() helper

namespace boost {
  template<typename FwdRng, typename Pred> struct filter_range;
  template<typename FwdRng, typename Pred> 
    filter_range< FwdRng, Pred > make_filter_range(FwdRng &, Pred);
  template<typename FwdRng, typename Pred> 
    filter_range< FwdRng const, Pred > make_filter_range(FwdRng const &, Pred);
  namespace adaptor {
    namespace @0 {
    }
  }
}

Defines the indirect range adaptor, as well as the make_indirect_range() helper

namespace boost {
  template<typename FwdRng> struct indirect_range;
  template<typename FwdRng> 
    indirect_range< FwdRng > make_indirect_range(FwdRng &);
  template<typename FwdRng> 
    indirect_range< FwdRng const  > make_indirect_range(FwdRng const &);
  namespace adaptor {
    namespace @1 {
    }
  }
}

Defines the iterator_cast() function, as well as the auto_base() helper

namespace boost {
  template<typename Base, typename Iter> Base iterator_cast(Iter);
  template<typename Iter> unspecified auto_base(Iter);
}

Defines the reverse range adaptor, as well as the make_reverse_range() helper

namespace boost {
  template<typename BidiRng> struct reverse_range;
  template<typename BidiRng> 
    boost::reverse_range< BidiRng > make_reverse_range(BidiRng &);
  template<typename BidiRng> 
    boost::reverse_range< BidiRng const  > make_reverse_range(BidiRng const &);
  namespace adaptor {
    namespace @2 {
    }
  }
}

Defines the transform range adaptor, as well as the make_transform_range() helper

namespace boost {
  template<typename FwdRng, typename UnaryFunc> struct transform_range;
  template<typename FwdRng, typename UnaryFunc> 
    transform_range< FwdRng, UnaryFunc > 
    make_transform_range(FwdRng &, UnaryFunc);
  template<typename FwdRng, typename UnaryFunc> 
    transform_range< FwdRng const, UnaryFunc > 
    make_transform_range(FwdRng const &, UnaryFunc);
  namespace adaptor {
    namespace @3 {
    }
  }
}