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

4. FIXED POINT DEFINITIONS
A stream often depends on itself as e.g. the stream of
integers or fibonacci numbers shown above. This self recursion
is revealed in the lazily evaluated recursive calls of
the methods integersFrom or fibonacci. This recursion
property can also be made more visible and be used to define
a stream as a fixed point of a map on the domain of
streams [6].
Such maps are defined with method map of the interface
StreamMap (defined in the interface Stream)
interface StreamMap {
Stream map(Stream stream);
}
and new streams are constructed with the static generic
method fixedpoint
static Stream fixedPoint(StreamMap map){..}
which constructs a stream which is a fixed point of the given
map.
In particular, we think of maps which do not perform
operations on their argument but rather simply include it
in a new stream which is returned as result. In particular,
the head element of the defined stream must not depend on
the argument. This way bootstrapping of the construction
of the stream is possible.
As an example we show the definition of the stream of
ones with a fixed point. This stream is the fixed point of a
map which prepends the element one to its argument.
Stream ones = fixedPoint(
new StreamMap(){
public Stream map(Stream s){
return s.prepend(1);
}
}
);
We now discuss how the fixedPoint method is implemented
for LinkedStreams and ArrayStreams. In both cases
a new stream is constructed and passed to the given map.
The result is another stream of the same type. The fields
of this stream are copied to the initially generated stream.
This way the fixed point of the map is constructed. The
resulting code looks similar for both classes.
public class LinkedStream implements Stream {
private LinkedStream(){}
public static Stream fixedPoint(
StreamMap map){
LinkedStream s1 = new LinkedStream();
LinkedStream s2 = (LinkedStream)map.map(s1);
s1.head = s2.head;
s1.lazyTail = s2.lazyTail;
return s2;
} ...
}
public class ArrayStream implements Stream {
private ArrayStream(){}
public static Stream fixedPoint(
StreamMap map){
ArrayStream s1 = new ArrayStream();
ArrayStream s2 = (ArrayStream)map.map(s1);
s1.lazyCoeff = s2.lazyCoeff;
return s2;
} ...
}
Let us now define some streams as fixed points of stream
maps. The first example is the periodic sequence [A, B, C,
A, B, C, A, B, C, . . .]. This stream is simply the fixed point
of a map which pretends the strings “A”, “B” and “C” to
its argument. The statement
System.out.println(
fixedPoint(
new StreamMap(){
public Stream map(Stream s){
return s.prepend("C").prepend("B").
prepend("A");
}
}
)
);
generates the output
A B C A B C A B C A B C A B C ...
Next we define the stream of integers as fixed point of a
map which takes a stream, adds one to each element and
prepends zero.
integers = fixedPoint(
new StreamMap(){
public Stream map(Stream s){
return s.map(
new UnaryFunctor(){
public Integer eval(Integer x){
return x+1;
}
}
).prepend(0);
}
}
);
This example only works if the prepend method does not
evaluate the stream to which a new head element is prepended.
Otherwise the call s.map is evaluated which results in
a NullPointerException as the head element of the stream
to be constructed by this fixed point definition is not yet
defined. As a consequence, this definition only works with
the fixed point method of class ArrayStream.
Fibonacci numbers can be expressed as the fixed point of
the map
f ibs → 0 : (+ f ibs (1 : f ibs))
which leads to the following definition:
class Add implements
Stream.BinaryFunctor {
public Integer eval(Integer x, Integer y){
return x+y;
}
};
Stream fibonacci = fixedPoint(
new StreamMap() {
public Stream map(Stream f){
return f.zip(new Add(),
f.prepend(1)).prepend(0);
}
}
);
Again, this definition only works with class ArrayStream.
In this example the zip function accesses the head element
185