Imperative Object Destruction

C++ provides a convenient mechanism for cleaning up stuff, the 
destructor, which is guaranteed to get called when an object passes out 
of scope (or something).

I'm wondering how to make a Haskell equivalent for imperative code. For 
instance, consider a simple file API, with these operations:

  open: given a string (the filename), open an existing file with that 
name, return a file-handle (or fail)

  count: given a file-handle, get the length of the file

  read: given a file-handle, offset into the file and a number of bytes, 
read the file returning a list of bytes (or fail)

  write: given a file-handle, offset into the file and a list of bytes, 
write the bytes to the file at the offset

  close: given a file-handle, close the handle

In C++ I could simply create an OpenFile class, with the close operation 
in the destructor. The actual operations would be hidden from OpenFile's 
clients.

I'd like to represent this API in Haskell so that the type-rules 
guarantee that in any imperative action of type 'IO a',

1. every opened file gets closed exactly once

2. no read or write operations are performed on file-handles that have 
not yet been opened, or that have already been closed.

My first guess was to create a function that encapsulated the entire 
life-cycle of the file, passing in a function that would represent 
whatever one wished to do on the file:

  count :: Handle -> IO Integer
  read :: (Integer,Integer) -> Handle -> IO [Byte]
  write :: (Integer,[Byte]) -> Handle -> IO ()
  withFile :: (Handle -> IO a) -> String -> IO a

'withFile operation name' would open the file called 'name', perform the 
operation 'operation', and then close the file. So for instance, to get 
the length of a file named "/home/ashley/foo":

  withFile count "/home/ashley/foo"

Trouble is, one can easily pass a return function to withFile to get 
ahold of the handle after it's been closed.

My second guess was to use a special type to represent an imperative 
operation that needed a handle:

  read :: (Integer,Integer) -> HandleOperation [Byte]
  write :: (Integer,[Byte]) -> HandleOperation ()
  withFile :: HandleOperation a -> String -> IO a

Of course, I'd then need to provide functions to compose/concatenate 
HandleOperation values. But I can't help thinking this problem is already 
well-known and there's a straightforward solution...

-- 
Ashley Yakeley, Seattle WA