RealWorld

[Ross Paterson]

On Thu, Sep 25, 2003 at 02:30:45PM +0100, Simon Peyton-Jones wrote:
> Ross Paterson writes:
> | The proposal is to expose
> | 
> | 	type IORef = STRef IORegion
> | 	type IOArray = STArray IORegion
> | 	type IOUArray = STUArray IORegion
> | 
> | (modulo the name of IORegion) but to keep IO opaque.  I think that while
> | IO includes state, it is not itself a state monad (because the "state"
> | there can be changed by other agents at the same time).

(where IORegion occurs in stToIO :: ST IORegion a -> IO a to make it safe)

> Aha. I hadn't realised that you want to expose IORef as an STRef, but
> not the IO monad itself. 
> 
> I certainly don't object to that, but I'm not sure of all the
> implications.  For example, at the moment one could have
> 	class MRef m r | m -> r, r -> m where
> 	  new :: a -> m (r a)
> 	  read :: r a -> m a
> 	  write :: r a -> a -> m ()
> 
> 	instance MRef IO IORef where ...
> 	instance MRef (ST s) (STRef s) where ...
> 
> I don't think that'll be legal if IORef = STRef IORegion, because the
> "r->m" dependency becomes ambiguous.  So we'd have to lose the "r->m"
> dependency.

The reason for having an MRef class was that there were two reference
types.  If there's only one, but parameterized by region, you might as
well parameterize on the region instead, describing a class of monads
that contain a heap region:

	class MonadST s m | m -> s where
		liftST :: Control.Monad.ST.ST s a -> m a

Then you can't have the s->m dependency:

	instance MonadST s (Control.Monad.ST.ST s) where
		liftST = id
	instance MonadST s (Control.Monad.ST.Lazy.ST s) where
		liftST = strictToLazyST
	instance MonadST IORegion IO where
		liftST = Control.Monad.ST.stToIO
	instance MonadST s m => MonadST s (ContT r m) where
		liftST = lift . liftST
	...

but you don't want it: you want to manipulate the same references in
different monads (as we already do with the lazy and strict ST monads).
All the operations lift to all such monads, e.g.

	read :: MonadST s m => STRef s a -> m a
	read r = liftST (Data.STRef.readSTRef r)

and that handles arrays as well as refs.