Editing Ru/IO Inside (section)

=== Example: returning an IO action as a result ===

How about returning an IO action as the result of a function?  Well, we've done
this each time we've defined an IO procedure - they all return IO actions
that need a RealWorld value to be performed. While we usually just
execute them as part of a higher-level IO procedure, it's also
possible to just collect them without actual execution:

<haskell>
main = do let a = sequence ioActions
              b = when True getChar
              c = getChar >> getChar
          putStr "These 'let' statements are not executed!"
</haskell>

These assigned IO procedures can be used as parameters to other
procedures, or written to global variables, or processed in some other
way, or just executed later, as we did in the example with 'get2chars'.

But how about returning a parameterized IO action from an IO procedure?  Let's define a procedure that returns the i'th byte from a file represented as a Handle:

<haskell>
readi h i = do hSeek h AbsoluteSeek i 
               hGetChar h
</haskell>

So far so good. But how about a procedure that returns the i'th byte of a file
with a given name without reopening it each time?

<haskell>
readfilei :: String -> IO (Integer -> IO Char)
readfilei name = do h <- openFile name ReadMode
                    return (readi h)
</haskell>

As you can see, it's an IO procedure that opens a file and returns...
another IO procedure that will read the specified byte. But we can go
further and include the 'readi' body in 'readfilei':

<haskell>
readfilei name = do h <- openFile name ReadMode
                    let readi h i = do hSeek h AbsoluteSeek i 
                                       hGetChar h
                    return (readi h)
</haskell>

That's a little better.  But why do we add 'h' as a parameter to 'readi' if it can be obtained from the environment where 'readi' is now defined?  An even shorter version is this:

<haskell>
readfilei name = do h <- openFile name ReadMode
                    let readi i = do hSeek h AbsoluteSeek i
                                     hGetChar h
                    return readi
</haskell>

What have we done here? We've build a parameterized IO action involving local
names inside 'readfilei' and returned it as the result. Now it can be
used in the following way:

<haskell>
main = do myfile <- readfilei "test"
          a <- myfile 0
          b <- myfile 1
          print (a,b)
</haskell>


This way of using IO actions is very typical for Haskell programs - you
just construct one or more IO actions that you need,
with or without parameters, possibly involving the parameters that your
"constructor" received, and return them to the caller. Then these IO actions
can be used in the rest of the program without any knowledge about your
internal implementation strategy. One thing this can be used for is to
partially emulate the OOP (or more precisely, the ADT) programming paradigm.