void test()
{
   std::list<int> x;
   x.push_back(1);
   std::list<int>::iterator it = x.begin();
   std::list<int>::reverse_iterator itr(it);
   std::cout << *itr;  // <--- в этом месте выскакивает assert: 'list iterator not decrementable'
}

*ReverseIterator(begin(l)) == *begin(l)

*ReverseIterator(M) == *M

The fundamental relation between a reverse iterator and its corresponding iterator i is established by the identity: &*(reverse_iterator(i)) == &*(i — 1)

[3] Note the implications of this remark. The variable rfirst is initialized as reverse_iterator<...> rfirst(V.end());. The value obtained when it is dereferenced, however, is *(V.end() — 1). This is a general property: the fundamental identity of reverse iterators is &*(reverse_iterator(i)) == &*(i — 1). This code sample shows why this identity is important: if [f, l) is a valid range, then it allows reverse_iterator(l), reverse_iterator(f)) to be a valid range as well. Note that the iterator l is not part of the range, but it is required to be dereferenceable or past-the-end. There is no requirement that any such iterator precedes f.

Most of the library’s algorithmic templates that operate on data structures have interfaces that use ranges.
A range is a pair of iterators that designate the beginning and end of the computation. A range
[i, i) is an empty range; in general, a range [i, j) refers to the elements in the data structure starting with the one pointed to by i and up to but not including the one pointed to by j. Range [i, j) is valid if and only if j is reachable from i. The result of the application of the algorithms in the library to invalid ranges is undefined.

auto result = r;
for (;;)
{
    for (;;)
    {
        if (r.empty) return result;
        if (!pred(r.front)) break;
        r.popFront();
        result.popFront();
    }
    // found the left bound
    assert(!r.empty);
    for (;;)
    {
        if (pred(r.back)) break;
        r.popBack();
        if (r.empty) return result;
    }
    swap(r.front, r.back);
    r.popFront();
    result.popFront();
    r.popBack();
}

boost::copy(input | reversed, output);

std::list<T>::range r = someList.all(), rbest = someList.none();
for(;r;++r.begin)
{
   if(!rbest || *r < *rbest) rbest = r;
}
someList.erase(rbest);

EP>boost::copy(input | reversed, output);
EP>

                       rbegin+1
        rend              | rbegin
          |               |   |
          v               v   v
за-началом [0] [1] [2] [3] [4] за-концом
          ^   ^               ^
          |   |               |
        begin |              end
            begin+1

reverse_iterator::operator*() const
{
  iterator it = this->it_;
  return *(--it);
}

Notice however that when an iterator is reversed, the reversed version does not point to the same element in the range, but to the one preceding it. This is so, in order to arrange for the past-the-end element of a range: An iterator pointing to a past-the-end element in a range, when reversed, is pointing to the last element (not past it) of the range (this would be the first element of the reversed range). And if an iterator to the first element in a range is reversed, the reversed iterator points to the element before the first element (this would be the past-the-end element of the reversed range).

std::list<T>::range r = someList.all(), rbest = someList.none();
LG>for(;r;++r.begin)
LG>{
LG>   if(!rbest || *r < *rbest) rbest = r;
LG>}
LG>someList.erase(rbest);

LG>Сколько предлагаешь за строчку кода?

std::reverse_iterator is an iterator adaptor that reverses the direction of a given iterator. In other words, when provided with a bidirectional iterator, std::reverse_iterator produces a new iterator that moves from the end to the beginning of the sequence defined by the underlying bidirectional iterator.
For a reverse iterator r constructed from an iterator i, the relationship &*r == &*(i-1) is always true; thus a reverse iterator constructed from a one-past-the-end iterator dereferences to the last element in a sequence.
This is the iterator returned by member functions rbegin() and rend() of the standard library containers.