Editing Ru/IO Inside (section)

=== Example: a memory allocator generator ===

As an example, one of my programs has a module which is a memory suballocator. It receives the address and size of a large memory block and returns two
procedures - one to allocate a subblock of a given size and the other to
free the allocated subblock:

<haskell>
memoryAllocator :: Ptr a -> Int -> IO (Int -> IO (Ptr b),
                                       Ptr c -> IO ())

memoryAllocator buf size = do ......
                              let alloc size = do ...
                                                  ...
                                  free ptr = do ...
                                                ...
                              return (alloc, free)
</haskell>

How this is implemented? 'alloc' and 'free' work with references
created inside the memoryAllocator procedure. Because the creation of these references is a part of the memoryAllocator IO actions chain, a new independent set of references will be created for each memory block for which
memoryAllocator is called:

<haskell>
memoryAllocator buf size = do start <- newIORef buf
                              end <- newIORef (buf `plusPtr` size)
                              ...
</haskell>

These two references are read and written in the 'alloc' and 'free' definitions (we'll implement a very simple memory allocator for this example):

<haskell>
      ...
      let alloc size = do addr <- readIORef start
                          writeIORef start (addr `plusPtr` size)
                          return addr
                          
      let free ptr = do writeIORef start ptr
</haskell>

What we've defined here is just a pair of closures that use state
available at the moment of their definition. As you can see, it's as
easy as in any other functional language, despite Haskell's lack
of direct support for impure functions.
      
The following example uses procedures, returned by memoryAllocator, to
simultaneously allocate/free blocks in two independent memory buffers:

<haskell>
main = do buf1 <- mallocBytes (2^16)
          buf2 <- mallocBytes (2^20)
          (alloc1, free1) <- memoryAllocator buf1 (2^16)
          (alloc2, free2) <- memoryAllocator buf2 (2^20)
          ptr11 <- alloc1 100
          ptr21 <- alloc2 1000
          free1 ptr11
          free2 ptr21
          ptr12 <- alloc1 100
          ptr22 <- alloc2 1000
</haskell>