"Given one or more argument [[streams|iterables]], return a
 stream containing elements of the given streams. The 
 elements are ordered first according to their position in 
 the argument stream, and then according to the stream in 
 which they occur. The resulting stream contains exactly the 
 same number of elements from each stream.
 
 For example, the expression
 
     interleave(1..5, \"-+\".cycled)
 
 results in the stream 
 `{ 1, '-', 2, '+', 3, '-', 4, '+', 5, '-' }`."
see (`function Iterable.interpose`)
shared Iterable<Element,Absent>
        interleave<Element,Absent>
        (Iterable<Element,Absent>+ iterables) 
        given Absent satisfies Null {
    object interleaved satisfies Iterable<Element,Absent> {
        size => min { for (it in iterables) it.size } * iterables.size;
        empty => package.any { for (it in iterables) it.empty };
        shared actual Iterator<Element> iterator() {
            object iterator satisfies Iterator<Element> {
                value iterators 
                        = iterables.collect((Iterable<Element> it) 
                    => it.iterator());
                variable value which = 0;
                shared actual Element|Finished next() {
                    assert (exists iter = iterators[which]);
                    if (!is Finished next = iter.next()) {
                        if (++which>=iterators.size) {
                            which = 0;
                        }
                        return next;
                    }
                    else {
                        return finished;
                    }
                }
            }
            return iterator;
        }
    }
    return interleaved;
}