Without getting into a general debate about the new stream classes,
a stream class meant for writing to a file SHOULDN'T have #contents
in its interface.
(1) For example, if you open a channel for *output* in Unix, you have
no reason to expect that you have been granted a right to read it.
For example, suppose user=fred group=whizzy owns a file foo.grace
with permission bits rw--w---- and you are running a program as
user=mary group=whizzy.�� You can open foo.grace for writing, but
you cannot read it.
(2) The thing you open might not be a file.�� It might be, for
example, a symbolic link to /dev/null, a symbolic link to /dev/tty,
a named pipe, or even (in principle, I don't know if anyone has
done it, but with something like FUSE it *could* be done) a socket
to a remote machine.�� In all these cases, *nobody* is storing the
contents.
(3) If the thing you open *is* a disc file, and you *do* have
permission to read it back, what should happen if you have written
more to the file than your memory can hold?
If you know that the output written to the stream is going to be
small enough that holding it in memory won't be a problem, could
you use a WriteStream and then write it to the output file in one
burst when it's finished?
Now, what about #ensureASpace?�� It can *almost* be done on a
buffered stream by looking at the last character in the buffer
and adding a space if it isn't one.�� But what if you called
#flush and the buffer is empty?�� Well, in that case, if you have
a "monolithic" design where the stream records the last character
at every flush, it's still doable.�� If you don't have a monolithic
design, you have to be able to read the last block before the
present one, and we've just seen why that is not in general
possible.�� The one thing you can safely do is to say that if the
buffer is empty you will add a space just to be sure, so that the
contract for #ensureASpace becomes
�� ��Ensures that the past contents of the receiver ends with a
�� ��space.�� Tries to avoid adding a space when there is already
�� ��one, but may or may not succeed.