The Death of Finalizers

[George Russell]

Simon Peyton-Jones wrote:
> 
> | In the meantime, I'm glad we have got a new function
> |    atomicModifyIORef
> | which I for one will use, when it gets into GHC's regular release.
> 
> Just before this gets out of the door... any chance of calling it
> 
>         modifyIORef
> 
> and documenting that it's atomic

My vote goes for

modifyIORef :: IORef a -> (a -> (a,b)) -> IO b
modifyIORef_ :: IORef a -> (a -> a) -> IO a

modifyIORef_ ioRef fn = modifyIORef ioRef (\ a0 -> let a1 = fn a0 in (a1,a1))

The names are similar to those of GHC's modifyMVar and modifyMVar_.
I think there's some sense in providing modifyIORef_ as well as 
modifyIORef, as I think for some implementations it will be even faster,
since it's unnecessary to create thunks for (fst (fn a0)) and 
(snd (fn a0)).  But you lot know a lot more about writing Haskell 
compilers than I do . . .

Thus you can implement a counter returning integers 1,2,3,...
via

   newCounter :: IO (IO Integer)
   newCounter = do
      ioRef <- newIORef 0
      return (modifyIORef_ ioRef (+1))

I don't think it's necessary for the name to include "atomic".
We are unlikely ever to want a non-atomic version of atomicModifyIORef,
especially as such a thing would be quite dangerous, and you can roll
your own from readIORef and writeIORef.