so, A common idiom when using Control.Monad.ST is to do some complicated, state using computation to compute a big array which is then used purely functionally as a read-only array in the rest of the program. to avoid the cost of copying the array at the end, we are forced to use 'unsafeFreeze'. it occurs to me that this particular idiom can actually be done safely, by adding the following... runSTArray :: (forall s . (ST s (STArray s i e))) -> Array i e runSTUArray :: (forall s . (ST s (STUArray s i e))) -> UArray i e now, since these discard 's' and hence the ability to modify the arrays they return, they may safely use the final arrays directly as if they were immutable. the routines are also very easy to implement: runSTArray st = runST $ st >>= unsafeFreeze runSTUArray st = runST $ st >>= unsafeFreeze so, is my logic correct? that runSTArray and runSTUArray need not be considered unsafe? if so, perhaps we should add these (or some better generalization that someone comes up with) to the standard libraries, as it would be nice to be able to use this idiom without resorting to trickery. (well, user visible trickery at least) John -- --------------------------------------------------------------------------- John Meacham - California Institute of Technology, Alum. - john@foo.net ---------------------------------------------------------------------------