I start to understand: A (lazy) range is something like a
voucher: byChunk() does not provide the data immediately, but
only a voucher to hand you a chunk (an array of 2 bytes in my
example above) a time. This voucher is passed to joiner(), which
keeps that voucher and hands me out a new voucher for a byte a
time (called "a" in my example above). This voucher is now passed
to take(), whick again keeps that voucher and hands me out yet an
other voucher for a byte a time, but limits itself to 5 items.
Up to now nothing has happend, but the exchange of that vouchers.
Now when writeln() is called, it shows take() that voucher and
says: "Give me the first of your numbers". take() uses his
voucher to do the same with joiner(), which uses its voucher to
get the first chunk of byChunk(), takes the first byte of that
chunk and hands it to take() and take() hands it to writeln().
Now writeln() uses it's voucher once again, to get the next byte.
take() asks joiner() again, but this time joiner() does not ask
byChunk(), because it still has one number left in the chunk it
got when asking the last time. Now joiner() uses this second byte
to hand it back. And so on.
After writeln() finished I'm doing something evil: I use a
private copy of that voucher, that I allready handed to take() to
use it myself. That's sort of stealing back. And hence the
results are more or less unpredictable. Especially, when I use
this copy, before take() finished it's job, as Jonathan M Davis
My misthinking was to assume, that my copy of the voucher is
still the same as the voucher, that take() owns after having
handed out the 5 items, so I can use it to get the other items.
If it where possible to ask take() to hand me back it's voucher,
I could do it with this voucher, but I don't see a possibility to
get that voucher back.
What I actually want to do, when using take(), is not to get a
new voucher, but I want to keep my voucher and just use this
voucher to get the first 5 items - take() doesn't do that, so
I've got to write my own function which cannot be lazy.
Or better: I'd like to hand in my voucher and get back two
vouchers, one for the first 5 bytes and one for the rest. That's
actually, what I thought, take() is doing...