4th International Conference on Principles and Practices ... - MADOC

The first implementation follows the idea of linked lists,
where the evaluation of the remainder is delayed until it is
accessed. For that purpose we define an interface LazyTail
whose method eval returns another (lazily evaluated) infinite
stream when evaluated. This implementation corresponds
to the implementations presented in [4, 5]. To keep
the code simple we only show the necessary methods and
discuss further methods below.
public class LinkedStream implements Stream {
}
public interface LazyTail {
LinkedStream eval();
}
private E head;
private LinkedStream tail; //assigned on demand
private LazyTail lazyTail; //delayed tail rule
public LinkedStream(E head, LazyTail tail) {
this.head = head;
this.lazyTail = tail;
}
public E getHead(){ return head; }
public LinkedStream getTail(){
if(tail == null) {
tail = lazyTail.eval(); lazyTail = null;
}
return tail;
}
...
Method getHead returns the head element of the stream,
and getTail computes and returns the tail of the stream.
Since the remainder of a stream should only be evaluated
once, we store the result in the field tail and free the reference
to the computation procedure so that the garbage
collector can reclaim it.
As an example we define the infinite stream of integers:
public class StreamTest {
static LinkedStream integersFrom(
final int start) {
return new LinkedStream(start,
new LinkedStream.LazyTail(){
public LinkedStream eval(){
return integersFrom(start+1);
}
}
);
}
}
public static void main(String[] args) {
Stream integers = integersFrom(0);
}
Stream s = integers;
for(int i=0; i 0) stream = stream.getTail();
return stream.getHead();
}
For the map method a new stream is generated where the
given function is mapped on each element. The implementation
defines an inner class for the lazy tail. Fields accessed
in the outer scope are copied and have to be declared final.
The zip and select functions are defined similarly.
public LinkedStream map(
final UnaryFunctor< super E, R> f) {
return new LinkedStream(
f.eval(getHead()),
new LazyTail(){
public LinkedStream eval(){
return getTail().map(f);
}
}
);
}
The prepend method adds a new head element. This
method is problematic as it is strict on the stream it is
called. In particular, the head element of the stream to
which a new element is prepended is evaluated as only the
tail of the series is lazily defined.
public Stream prepend(E head){
return new LinkedStream(
head,
new LazyTail(){
public LinkedStream eval(){
return LinkedStream.this;
}
}
);
}
The evaluation of a stream s to which a new head element
e is added could be avoided, if the construct
new LinkedStream(e, new LazyTail(){
public LinkedStream eval(){ return s; }
})
were used.
We close this section with the definition of the streams
of integers, squares and fibonacci numbers. Both methods
integersFrom and fibonacci are recursive and contain calls
to itself in the eval method defined in the anonymous class.
public class StreamTest2 {
public static LinkedStream integersFrom(
final int start) {
return new LinkedStream(
start,
new LinkedStream.LazyTail(){
public LinkedStream eval(){
return integersFrom(start+1);
}
}
);
}
183