Editing Ru/IO Inside (section)

== Mutable data (references, arrays, hash tables...) ==

As you should know, every name in Haskell is bound to one fixed (immutable) value. This greatly simplifies understanding algorithms and code optimization, but it's inappropriate in some cases. As we all know, there are plenty of algorithms that are simpler to implement in terms of updatable
variables, arrays and so on. This means that the value associated with
a variable, for example, can be different at different execution points,
so reading its value can't be considered as a pure function. Imagine,
for example, the following code:

<haskell>
main = do let a0 = readVariable varA
              _  = writeVariable varA 1
              a1 = readVariable varA
          print (a0, a1)
</haskell>

Does this look strange? First, the two calls to 'readVariable' look the same, so the compiler can just reuse the value returned by the first call. Second,
the result of the 'writeVariable' call isn't used so the compiler can (and will!) omit this call completely. To complete the picture, these three calls may be rearranged in any order because they appear to be independent of each
other.   This is obviously not what was intended.  What's the solution? You already know this - use IO actions!  Using IO actions guarantees that:

# the execution order will be retained as written
# each action will have to be executed
# the result of the "same" action (such as "readVariable varA") will not be reused

So, the code above really should be written as:

<haskell>
main = do varA <- newIORef 0  -- Create and initialize a new variable
          a0 <- readIORef varA
          writeIORef varA 1
          a1 <- readIORef varA
          print (a0, a1)
</haskell>

Here, 'varA' has the type "IORef Int" which means "a variable (reference) in
the IO monad holding a value of type Int". newIORef creates a new variable
(reference) and returns it, and then read/write actions use this
reference. The value returned by the "readIORef varA" action depends not
only on the variable involved but also on the moment this operation is performed so it can return different values on each call.

Arrays, hash tables and any other _mutable_ data structures are
defined in the same way - for each of them, there's an operation that creates new "mutable values" and returns a reference to it. Then special read and write
operations in the IO monad are used. The following code shows an example
using mutable arrays:

<haskell>
 import Data.Array.IO
 main = do arr <- newArray (1,10) 37 :: IO (IOArray Int Int)
           a <- readArray arr 1
           writeArray arr 1 64
           b <- readArray arr 1
           print (a, b)
</haskell>

Here, an array of 10 elements with 37 as the initial value at each location is created. After reading the value of the first element (index 1) into 'a' this element's value is changed to 64 and then read again into 'b'. As you can see by executing this code, 'a' will be set to 37 and 'b' to 64.
           


Other state-dependent operations are also often implemented as IO
actions. For example, a random number generator should return a different
value on each call. It looks natural to give it a type involving IO:

<haskell>
rand :: IO Int
</haskell>

Moreover, when you import C routines you should be careful - if this
routine is impure, i.e. its result depends on something in the "real
world" (file system, memory contents...), internal state and so on,
you should give it an IO type. Otherwise, the compiler can
"optimize" repetitive calls of this procedure with the same parameters! :)

For example, we can write a non-IO type for:

<haskell>
foreign import ccall
   sin :: Double -> Double
</haskell>

because the result of 'sin' depends only on its argument, but

<haskell>
foreign import ccall
   tell :: Int -> IO Int
</haskell>

If you will declare 'tell' as a pure function (without IO) then you may
get the same position on each call! :)