E>А почему именно "начинающийся", а не "заканчивающийся"? Как-то нелогично несколько...

template<class R, class T>
R find(R r, T value);

“Reduces the range r from left until its front isо
equal with value or r is exhausted.”

template<class Iterator>
for_each(Iterator begin, Iterator end);

template<class BeginIterator, class EndIterator>
for_each(BeginIterator begin, EndIterator end);

return the range starting with the found element (if any), empty if not found

for(range r = ...; ! find(r,'A').empty() ; r.pop_front())
{
  do something with r.front();
}

CS>for(range r = ...; ! find(r,'A').empty() ; r.pop_front())
CS>{
CS>  do something with r.front();
CS>}
CS>

for( auto r= find( where, 'A' ); !r.empty(); r.popFront(), r= find( r, 'A' ) )
{
  do something with r.front();
}

DS>for( auto r= find( where, 'A' ); !r.empty(); r.popFront(), r= find( r, 'A' ) )
DS>{
DS>  do something with r.front();
DS>}
DS>

for(range r = ...; !(r = find(r,'A')).empty() ; r.pop_front())
{
  do something with r.front();
}

for(range r = ...; (r = find(r,'A')) ; r.pop_front() )
{
  do something with r.front();
}

contaier_t c;
auto r= find(c, 'A');
auto exr= c.create_range_at( r, 5 ); //create range [r-5,r+5]

DS>contaier_t c;
DS>auto r= find(c, 'A');
DS>auto exr= c.create_range_at( r, 5 ); //create range [r-5,r+5]
DS>

concat( take(find(с, 'A'), 5), take_last(before(с, x), 5) );

auto r_pair = split(с, 'A');
concat( take(r_pair[0], 5), take_last(r_pair[0], 5) );

int[] a = [ 1, 2, 3 ];
string[] b = [ "a", "b", "c" ];
// prints 1:a 2:b 3:c
foreach (e; zip(a, b))
{
    write(e.at!(0), ':', e.at!(1), ' ');
}

Можно ли то же самое элегантно сделать с итераторами?
Что принципиально нельзя сделать из того, что позволяли итераторы?
Что нового привносит данная концепция?
Каковы взаимоотношения контейнера и Ranges в плане валидности Ranges при изменение контейнеров? Необходимо ли вводить observers или можно жить по старым соглашениям от итераторов?

DS>>contaier_t c;
DS>>auto r= find(c, 'A');
DS>>auto exr= c.create_range_at( r, 5 ); //create range [r-5,r+5]
DS>>

J>concat( take(find(с, 'A'), 5), take_last(before(с, x), 5) );
J>

int[][] x = new int[][2];
x[0] = [1, 2];
x[1] = [3, 4];
auto ror = transversal(x, 1);
assert(equals(ror, [ 2, 4 ][]));

More composition opportunities
• Stride: span a range several steps at once
Iterators can’t implement it!

istream_iterator<...> b( str );
istream_iterator<...> b1= b;
++b;
*b1; // Oops

vector vec;
// fill vec ...
sort( stride(vec,13) );

vector vec;
// fill vec ...
sort( chain(stride(vec,13),stride(vec,19)) );

template <class BaseIterator>
class ForwardRangeIterator
{
public:

    typedef typename BaseIterator::Item Item;

    ForwardRangeIterator(BaseIterator begin, BaseIterator end) 
    {
        this->current = begin;
        this->end = end;
    }

    bool IsValid() const
    {
        return current.IsValid() and current != end; 
    }     

    void MoveNext() 
    {
        current.MoveNext();
    }

    Item& GetCurrent() 
    {
        return *current;
    }  

private:

    BaseIterator current;
    BaseIterator end;
};

vector<double> v1, v2;
deque<double> d;
partial_sort(v1, chain(v2, d));
sort(chain(v1, v2, d));

vector<double> vd;
vector<string> vs;
deque<int>     vi;
// sort the three in lockstep
sort(zip(vs, vd, vi));

E>А зачем это всё нужно?

Range-based design offers much more than a port of iterator-based functions to ranges

sort(chain(v1, chain( v2, v1 )));

#include <...>
using namespace std;

void MoveBests( vector<player>& liga1, 
                deque<player>& liga2, 
                deque<player>& liga3,
                boost::finction< bool ( const player& , const player& ) > crit )
{ 
     partial_sort( liga1, chain( liga2, liga3 ), crit );
}

E>Да нет, вполне хорошо работает и такой подход, что достаем самое плохое из лучших, а их худших самое хорошее, и меняем..

E>Не совсем понятно зачем нужны динамически созданные структуры. Код-то пишется ещё ДО КОМПИЛЯЦИИ?

E>Ну это к тому, что легко граблей напрогать, а как проверить напрогали ли граблей -- не ясно

пока( худший из ещё не поменяных лучших хуже лучшего их ещё непоменяных худших ) 
    поменять (худшего из ещё непоменяных лучших и лучшего из ещё непоменяных худших )

DS>Я как бы хотел узнать, можно ли исходную конструкцию назвать итератором, и чем она отличается от range. В возможности добавления туда игр и девушек я не сомневался

vector<double> vd;
vector<string> vs;
deque<int>     vi;
// sort the three in lockstep
sort(
  make_zip_iterator( make_tuple(vs.begin(), vd.begin(), vi.begin()) ),
  make_zip_iterator( make_tuple(vs.end(),   vd.end(),   vi.end()  ) )
);

DS>>Что нового привносит данная концепция?
J>Имхо — ничего, если принимать во внимание существование Boost.Range.

J>vector<double> vd;
J>vector<string> vs;
J>deque<int>     vi;
J>// sort the three in lockstep
J>sort(
J>  make_zip_iterator( make_tuple(vs.begin(), vd.begin(), vi.begin()) ),
J>  make_zip_iterator( make_tuple(vs.end(),   vd.end(),   vi.end()  ) )
J>);
J>

DS>Не то чтобы против, но вот это заставило напрячь извилины

DS>А вот про это он промолчал

J>>vector<double> vd;
J>>vector<string> vs;
J>>deque<int>     vi;
J>>// sort the three in lockstep
J>>sort(
J>>  make_zip_iterator( make_tuple(vs.begin(), vd.begin(), vi.begin()) ),
J>>  make_zip_iterator( make_tuple(vs.end(),   vd.end(),   vi.end()  ) )
J>>);
J>>

struct less_by_first_element
{
  template <class T>
  bool operator()(const T& lhs, const T& rhs) const {
    return std::less( lhs.get<0>(), rhs.get<0>() );
  }
};

DS>PS. Для ясности повторюсь. Мне просто понравилась идея и подход Александреску . Она (идея) пока что не кажется жизнеспособной, но от этого красивой быть не перестает.

container | boost::adaptors::filtered(_1==0) | | boost::adaptors::reversed

Rearranges the elements in the range [first,last), in such a way that the subrange [first,middle) contains the smallest elements of the entire range sorted in ascending order, and the subrange [middle,end) contains the remaining elements without any specific order.

E>>Как видишь, твой подход только запутывает...

E>>Самописный алгоритм нифига не самописный. Да и не сложный, к тому же..

пока( худший из ещё не поменяных лучших хуже лучшего их ещё непоменяных худших ) 
E>>    поменять (худшего из ещё непоменяных лучших и лучшего из ещё непоменяных худших )

E>>а в лигах путём итерации первой лиги от худших к лучшим, а второй и третьей от лучших к худшим, методом двухпутевого слияния...

E>>Ветвиться будет не там, в внутри объединённого диапазона...

E>>Нереальная задача. И как это ёксель-то написать смогли?

E>>Глупый пример. Давным-давно придуманы эффективные реализации 2-хмерных массивов для С++, которые, в том числе, позволяют легко переставлять как строки, так и столбцы. Вот их и надо использовать...

E>>Кстати, как планируется решать эту задачу на диапазонах?

E>>Ну ты же рекламируешь не то, что мимо "end не промахнёшься", с этим как раз более или менее всё понятно. А то, что есть всякие рульные новые фичи, которых у итераторов просто нет?

E>>Я же спросил "зачем надо писать partial_sort( chain( v1, v2 ) )?"...

Зачем нужно уметь писать: partial_sort(d, chain(v1, v2))?

DS>Предлагаю прекратить болтать.

Вот у меня есть динамически определяемое число последовательностей. Ну, например std::vector<std::vector<double> >.
И как мне при помощи диапазонов отсортировать эту таблицу по третьей колонке, например?..

template <class BaseIterator>
class TwoWayIteratorOnRange
{
public:

    typedef typename BaseIterator::Item Item;

    TwoWayIteratorOnRange(BaseIterator current, Range<BaseIterator> range)
    {
        this->current = current;
        this->range = range;
    }

    bool IsValid() const
    {
        return current.IsValid() and range.Contains(current);
    }     

    void MovePrevious() 
    {
        current.MovePrevious();
    }

    void MoveNext() 
    {
        current.MoveNext();
    }

    Item& GetCurrent() 
    {
        return current.GetCurrent();
    }  

private:

    BaseIterator current;
    Range<BaseIterator> range;
};

A range is a pair of begin/end iterators packed together