All of these concepts are built on the idea of iterator pairs, representing a range of values. This framework, which while being extremely powerful and flexible, is more complex than is needed in some (many?) scenarios. When studying Scala -- which is arguably the only truly multi-paradigm language -- I realized that a Generic Programming framework can be built for collections from a single concept, which, for lack of a better name, I am currently calling the Iterable concept. An Iterable concept is as follows (written in imaginary-Heron):

concept Iterable {
  types {
    value_type;
  }
  signature {
    for_each[Procedure[value_type] P](P proc);
  }
}

concept Iterable  {
  public {
    typedef value_type;
    template<typename Procedure>
    void for_each(Procedure proc);
  }
}

This is an exceedingly simple concept. In order to model the Iterable concept a class has to only provide one typedef, and one member function. However, don't let the simplicity fool you. By taking lessons from functional techniques (mixed with value mutation), you can achieve very sophisticated code with relatively little work.

Example 1: Outputting all Elements from an Iterable

struct putter {
  putter(std::ostream& o, char delim = ' ') : out(x) { }
  template<typename T> void operator()(T& x) { 
    out << x << delim;  
  }
  std::ostream& out;
};

putter put(std::ostream& o) {
  return putter(o);
}

template<typename Iterable>
void print_iterable(Iterable& i) {
  i.for_each(put(std::cout));
}

Example 2: Concatenation of Iterable Collections

template<typename Iterable1, typename Iterable>
struct cat {
  cat(Iterable1& i1, Iterable2& i2)  
    : iterable1(i1), iterable2(i2) 
  { }
  template<typename Procedure>
  void for_each(Procedure proc) {
    iterable1.for_each(proc);
    iterable2.for_each(proc);
  }  
  typedef typename Iterable1::value_type value_type;
  Iterable1& iterable1;
  Iterable2& iterable2;
};

Example 3: Adapting a Container to an Iterable

template<typename Container>
struct container_to_iterable {
  container_to_iterable(Container& x) : 
    container(x) 
  { }
  template<typename Procedure>
  for_each(Procedure p) {
    typename Container::iterator iter = container.begin();
    typename Container::iterator last = container.end();
    while (iter != last) {
      p(*iter++);
    }
  }
  Container& container;
}

struct int_range {
  typedef int value_type;
  int_range(int x, int y) : first(x), last(y) { }
  template<typename Procedure>
  void for_each(Procedure p) { 
    int n = first;
    while (n != last) {
      p(n++);
    }
  }
  int first;
  int last;
}

concept Indexable {
  types {
    Value value_type;
    Incrementable index_type;
  }
  signature {
    low() : index_type;
    high() : index_type;
    get(index_type i) : value_type;
    set(index_type i, value_type x);
  }
}

struct int_range {
>   typedef int value_type;
>   int_range(int x, int y) : first(x), last(y) { }
>   template<typename Procedure>
>   void for_each(Procedure p) { 
>     int n = first;
>     while (n != last) {
>       p(n++);
>     }
>   }
>   int first;
>   int last;
> }

void print(int n)
{
  std::cout << n << " ";
}
 
int main()
{
  int_range r(1,11);
 
  r.for_each(print);
}

class generator
{
public:
  generator(int initial) : i(initial) {}
 
  int operator()() { return i++; }
 
private:
  int i;
};
 
int main()
{
  typedef std::ostream_iterator<int> out;
 
  std::generate_n(out(std::cout," "),10,generator(1));
}

struct putter {
  putter(std::ostream& o, char d = ' ') : out(o), delim(d) { }
  template<typename T> void operator()(T& x) { 
    out << x << delim;  
  }
  std::ostream& out;
  char delim;
};
 
putter put(std::ostream& o) {
  return putter(o);
}
 
template<typename Iterable>
void print_iterable(Iterable& i) {
  i.for_each(put(std::cout));
}
 
template<typename T,int Size>
class array_wrapper
{
public:
  array_wrapper(T(&array)[Size]) : array(array) {}
 
  template<typename Procedure>
  void for_each(Procedure p)
  {
    std::for_each(array,array+Size,p); // (*)
  }
 
private:
  T (&array)[Size];
};
 
int main()
{
  int array[]={1,2,3,4,5,6,7,8,9,10};
 
  print_iterable(array_wrapper<int,10>(array));
}

int main()
{
  int array[]={1,2,3,4,5,6,7,8,9,10};
 
  typedef std::ostream_iterator<int> out;
 
  std::copy(array,array+10,out(std::cout," "));
}

  std::reverse_copy(array,array+10,out(std::cout," "));

struct MyContainer {
  typedef fu value_type;
  typedef fu iterator;
  typedef fu const_iterator;
  typedef fu reference;
  typedef fu const_reference;
  typedef fu pointer;
  typedef fu difference_type;
  typedef fu size_type;
  MyContainer(const MyContainer& x);
  MyContainer& operator=(const MyContainer&);
  iterator begin();
  const_iterator begin();
  iterator end();
  const_iterator end();
  size_type size();
  size_type max_size();
  bool empty();
  void swap(MyContainer& a);
}

struct MyIterable {
  typedef fu value_type;
  template<typename Procedure>
  void for_each(Procedure p);
}

int main()
> {
>   int array[]={1,2,3,4,5,6,7,8,9,10};
>  
>   typedef std::ostream_iterator<int> out;
>  
>   std::copy(array,array+10,out(std::cout," "));
> }

int main()
{
  int array[]={1,2,3,4,5,6,7,8,9,10};     
  ootl::range_to_iterable(array, array + 10).for_each(ootl::out(std::cout, " ")); 
}

int main()
{
  int array[]={1,2,3,4,5,6,7,8,9,10};     
  ootl::array_to_iterable(array, 10).for_each(ootl::out(std::cout, " ")); 
}

> std::reverse_copy(array,array+10,out(std::cout,"
> " "));

int main()
> > {
> >   int array[]={1,2,3,4,5,6,7,8,9,10};
> >  
> >   typedef std::ostream_iterator<int> out;
> >  
> >   std::copy(array,array+10,out(std::cout," "));
> > }