Here is an excerpt from the online documentation followed by some sample code from the download.

Iterable Concept

  concept {
    typedef value_type;
    template<typename Procedure>
    void for_each(Procedure f);
  }
  

The Iterable concept is a way of providing a minimalist functional interface to a collection. In the way that the STL collections start from the Container concept, the Iterable concept provides a foundation for the OOTL collections.

A model of the Iterable concept applies a Procedure to values it contains in a sequential manner. A simple example of an Iterable model in action is below:

  void array_adaptor_test() {
    writeln("This is a test of the array adapter");
    writeln("Expect the numbers 1 to 3 in sequence separated by spaces");
    int a[] = { 1, 2, 3 };
    output(array_to_iterable(a, 3));
    writeln();
  }
  

The Iterable concept is more flexible than a Container since it can easily model purely functional notions such as infinite series, or input streams, but it lacks the computational power which comes with positional information. This is similar to the trade off inherent in the usage of Input Iterators versus Random Access Iterators.

A model of the Iterable concept is expected to have shallow assignment semantics. Whether or not an iterable is single pass, is not specified at this time.

Demonstration of the Iterable Concept

void array_adaptor_test() {
  writeln("This is a test of the array adapter");
  writeln("Expect the numbers 1 to 3 in sequence separated by spaces");
  int a[] = { 1, 2, 3 };
  output(array_to_iterable(a, 3));
  writeln();
}

void generator_test() {
  writeln("This is a test of the iterable generator.");
  writeln("Expect 5 even numbers starting from 2.");
  output(iterable_gen(2, next_even(), 5));
  writeln();
}

void filter_test() {
  writeln("This is a test of the filter and adapter.");
  writeln("Expect the primes between 10-20");
  output(filter(int_range(10, 20), is_prime()));
  writeln();
}

template<typename Iterable, typename F, typename G>
void output_composition(Iterable i, F f, G g) {
  output(compose(i, compose_fxn(f, g)));
}

void composition_test() {
  writeln("This is a test of double composition.");
  writeln("Expect the squares of the values from 1 to 10, minus 1");
  output_composition(int_range(1, 11), square(), dec());
  writeln();
}

void alternating_test() {
  writeln("This is a test of conditional function composition.");
  writeln("Expect numbers from 1 to 10 with odd numbers as negatives.");
  output(
    compose(
      int_range(1, 11),
      cond_fxn(
        is_even(),
        identity(),
        negative()
      )
    )
  );
  writeln();
}