Editing Ru/IO Inside (section)

=== unsafeInterleaveIO ===

But there is an even stranger operation called 'unsafeInterleaveIO' that
gets the "official baton", makes its own pirate copy, and then runs
an "illegal" relay-race in parallel with the main one! I can't talk further
about its behavior without causing grief and indignation, so it's no surprise
that this operation is widely used in countries that are hotbeds of software piracy such as Russia and China! ;)  Don't even ask me - I won't say anything more about this dirty trick I use all the time ;)

One can use unsafePerformIO (not unsafeInterleaveIO) to perform I/O
operations not in predefined order but by demand. For example, the
following code:

<haskell>
do let c = unsafePerformIO getChar
   do_proc c
</haskell>

will perform getChar I/O call only when value of c is really required
by code, i.e. it this call will be performed lazily as any usual
Haskell computation.

Now imagine the following code:

<haskell>
do let s = [unsafePerformIO getChar, unsafePerformIO getChar, unsafePerformIO getChar]
   do_proc s
</haskell>

Three chars inside this list will be computed on demand too, and this
means that their values will depend on the order they are consumed. It
is not that we usually need :)


unsafeInterleaveIO solves this problem - it performs I/O only on
demand but allows to define exact *internal* execution order for parts
of your datastructure. It is why I wrote that unsafeInterleaveIO makes
illegal copy of baton :)

First, unsafeInterleaveIO has (IO a) action as a parameter and returns
value of type 'a':

<haskell>
do str <- unsafeInterleaveIO myGetContents
</haskell>

Second, unsafeInterleaveIO don't perform any action immediately, it
only creates a box of type 'a' which on requesting this value will
perform action specified as a parameter.

Third, this action by itself may compute the whole value immediately
or... use unsafeInterleaveIO again to defer calculation of some
sub-components:

<haskell>
myGetContents = do
   c <- getChar
   s <- unsafeInterleaveIO myGetContents
   return (c:s)
</haskell>

This code will be executed only at the moment when value of str is
really demanded. In this moment, getChar will be performed (with
result assigned to c) and one more lazy IO box will be created - for s.
This box again contains link to the myGetContents call

Then, list cell returned that contains one char read and link to
myGetContents call as a way to compute rest of the list. Only at the
moment when next value in list required, this operation will be
performed again

As a final result, we get inability to read second char in list before
first one, but lazy character of reading in whole. bingo!


PS: of course, actual code should include EOF checking. also note that
you can read many chars/records at each call:

<haskell>
myGetContents = do
   c <- replicateM 512 getChar
   s <- unsafeInterleaveIO myGetContents
   return (c++s)
</haskell>