Associate MutableArray with the state token rather than the monad
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Mon, 16 Nov 2009 03:46:31 +0000 (03:46 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Mon, 16 Nov 2009 03:46:31 +0000 (03:46 +0000)
Data/Primitive/Array.hs

index f085cf1..8b1d97a 100644 (file)
@@ -26,33 +26,33 @@ import GHC.Prim
 -- | Boxed arrays
 data Array a = Array (Array# a)
 
--- | Mutable boxed arrays associated with a primitive state-transformer monad.
-data MutableArray m a = MutableArray (MutableArray# (PrimState m) a)
+-- | Mutable boxed arrays associated with a primitive state token.
+data MutableArray s a = MutableArray (MutableArray# s a)
 
 -- | Create a new mutable array of the specified size and initialise all
 -- elements with the given value.
-newArray :: PrimMonad m => Int -> a -> m (MutableArray m a)
+newArray :: PrimMonad m => Int -> a -> m (MutableArray (PrimState m) a)
 {-# INLINE newArray #-}
 newArray (I# n#) x = primitive
    (\s# -> case newArray# n# x s# of
              (# s'#, arr# #) -> (# s'#, MutableArray arr# #))
 
 -- | Read a value from the array at the given index.
-readArray :: PrimMonad m => MutableArray m a -> Int -> m a
+readArray :: PrimMonad m => MutableArray (PrimState m) a -> Int -> m a
 {-# INLINE readArray #-}
 readArray (MutableArray arr#) (I# i#) = primitive (readArray# arr# i#)
 
 -- | Write a value to the array at the given index.
-writeArray :: PrimMonad m => MutableArray m a -> Int -> a -> m ()
+writeArray :: PrimMonad m => MutableArray (PrimState m) a -> Int -> a -> m ()
 {-# INLINE writeArray #-}
 writeArray (MutableArray arr#) (I# i#) x = primitive_ (writeArray# arr# i# x)
 
--- | Read a value from the array at the given index.
+-- | Read a value from the immutable array at the given index.
 indexArray :: Array a -> Int -> a
 {-# INLINE indexArray #-}
 indexArray (Array arr#) (I# i#) = case indexArray# arr# i# of (# x #) -> x
 
--- | Monadically read a value from the array at the given index.
+-- | Monadically read a value from the immutable array at the given index.
 -- This allows us to be strict in the array while remaining lazy in the read
 -- element which is very useful for collective operations. Suppose we want to
 -- copy an array. We could do something like this:
@@ -82,7 +82,7 @@ indexArrayM (Array arr#) (I# i#)
 
 -- | Convert a mutable array to an immutable one without copying. The
 -- array should not be modified after the conversion.
-unsafeFreezeArray :: PrimMonad m => MutableArray m a -> m (Array a)
+unsafeFreezeArray :: PrimMonad m => MutableArray (PrimState m) a -> m (Array a)
 {-# INLINE unsafeFreezeArray #-}
 unsafeFreezeArray (MutableArray arr#)
   = primitive (\s# -> case unsafeFreezeArray# arr# s# of
@@ -90,14 +90,14 @@ unsafeFreezeArray (MutableArray arr#)
 
 -- | Convert an immutable array to an mutable one without copying. The
 -- immutable array should not be used after the conversion.
-unsafeThawArray :: PrimMonad m => Array a -> m (MutableArray m a)
+unsafeThawArray :: PrimMonad m => Array a -> m (MutableArray (PrimState m) a)
 {-# INLINE unsafeThawArray #-}
 unsafeThawArray (Array arr#)
   = primitive (\s# -> case unsafeThawArray# arr# s# of
                         (# s'#, arr'# #) -> (# s'#, MutableArray arr'# #))
 
 -- | Check whether the two arrays refer to the same memory block.
-sameMutableArray :: MutableArray m a -> MutableArray m a -> Bool
+sameMutableArray :: MutableArray s a -> MutableArray s a -> Bool
 {-# INLINE sameMutableArray #-}
 sameMutableArray (MutableArray arr#) (MutableArray brr#)
   = sameMutableArray# arr# brr#