Revert to keying mutable arrays on the monad instead of the state token
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Mon, 16 Nov 2009 04:56:58 +0000 (04:56 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Mon, 16 Nov 2009 04:56:58 +0000 (04:56 +0000)
Data/Primitive/Array.hs
Data/Primitive/ByteArray.hs

index 8b1d97a..4b26aa6 100644 (file)
@@ -27,23 +27,23 @@ import GHC.Prim
 data Array a = Array (Array# a)
 
 -- | Mutable boxed arrays associated with a primitive state token.
-data MutableArray s a = MutableArray (MutableArray# s a)
+data MutableArray m a = MutableArray (MutableArray# (PrimState m) 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 (PrimState m) a)
+newArray :: PrimMonad m => Int -> a -> m (MutableArray 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 (PrimState m) a -> Int -> m a
+readArray :: PrimMonad m => MutableArray 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 (PrimState m) a -> Int -> a -> m ()
+writeArray :: PrimMonad m => MutableArray m a -> Int -> a -> m ()
 {-# INLINE writeArray #-}
 writeArray (MutableArray arr#) (I# i#) x = primitive_ (writeArray# arr# i# x)
 
@@ -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 (PrimState m) a -> m (Array a)
+unsafeFreezeArray :: PrimMonad m => MutableArray m a -> m (Array a)
 {-# INLINE unsafeFreezeArray #-}
 unsafeFreezeArray (MutableArray arr#)
   = primitive (\s# -> case unsafeFreezeArray# arr# s# of
@@ -90,7 +90,7 @@ 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 (PrimState m) a)
+unsafeThawArray :: PrimMonad m => Array a -> m (MutableArray m a)
 {-# INLINE unsafeThawArray #-}
 unsafeThawArray (Array arr#)
   = primitive (\s# -> case unsafeThawArray# arr# s# of
index a08a01f..b0a1391 100644 (file)
@@ -31,10 +31,10 @@ import GHC.Prim
 data ByteArray = ByteArray ByteArray#
 
 -- | Mutable byte arrays associated with a primitive state token
-data MutableByteArray s = MutableByteArray (MutableByteArray# s)
+data MutableByteArray m = MutableByteArray (MutableByteArray# (PrimState m))
 
 -- | Create a new mutable byte array of the specified size.
-newByteArray :: PrimMonad m => Int -> m (MutableByteArray (PrimState m))
+newByteArray :: PrimMonad m => Int -> m (MutableByteArray m)
 {-# INLINE newByteArray #-}
 newByteArray (I# n#)
   = primitive (\s# -> case newByteArray# n# s# of
@@ -42,7 +42,7 @@ newByteArray (I# n#)
 
 -- | Create a /pinned/ byte array of the specified size. The garbage collector
 -- is guaranteed not to move it.
-newPinnedByteArray :: PrimMonad m => Int -> m (MutableByteArray (PrimState m))
+newPinnedByteArray :: PrimMonad m => Int -> m (MutableByteArray m)
 {-# INLINE newPinnedByteArray #-}
 newPinnedByteArray (I# n#)
   = primitive (\s# -> case newPinnedByteArray# n# s# of
@@ -50,8 +50,7 @@ newPinnedByteArray (I# n#)
 
 -- | Create a /pinned/ byte array of the specified size and with the give
 -- alignment. The garbage collector is guaranteed not to move it.
-newAlignedPinnedByteArray
-  :: PrimMonad m => Int -> Int -> m (MutableByteArray (PrimState m))
+newAlignedPinnedByteArray :: PrimMonad m => Int -> Int -> m (MutableByteArray m)
 {-# INLINE newAlignedPinnedByteArray #-}
 newAlignedPinnedByteArray (I# n#) (I# k#)
   = primitive (\s# -> case newAlignedPinnedByteArray# n# k# s# of
@@ -72,8 +71,7 @@ sameMutableByteArray (MutableByteArray arr#) (MutableByteArray brr#)
 
 -- | Convert a mutable byte array to an immutable one without copying. The
 -- array should not be modified after the conversion.
-unsafeFreezeByteArray
-  :: PrimMonad m => MutableByteArray (PrimState m) -> m ByteArray
+unsafeFreezeByteArray :: PrimMonad m => MutableByteArray m -> m ByteArray
 {-# INLINE unsafeFreezeByteArray #-}
 unsafeFreezeByteArray (MutableByteArray arr#)
   = primitive (\s# -> case unsafeFreezeByteArray# arr# s# of
@@ -97,8 +95,7 @@ indexByteArray (ByteArray arr#) (I# i#) = indexByteArray# arr# i#
 
 -- | Read a primitive value from the byte array. The offset is given in
 -- elements of type @a@ rather than in bytes.
-readByteArray
-  :: (Prim a, PrimMonad m) => MutableByteArray (PrimState m) -> Int -> m a
+readByteArray :: (Prim a, PrimMonad m) => MutableByteArray m -> Int -> m a
 {-# INLINE readByteArray #-}
 readByteArray (MutableByteArray arr#) (I# i#)
   = primitive (readByteArray# arr# i#)
@@ -106,7 +103,7 @@ readByteArray (MutableByteArray arr#) (I# i#)
 -- | Write a primitive value to the byte array. The offset is given in
 -- elements of type @a@ rather than in bytes.
 writeByteArray
-  :: (Prim a, PrimMonad m) => MutableByteArray (PrimState m) -> Int -> a -> m ()
+  :: (Prim a, PrimMonad m) => MutableByteArray m -> Int -> a -> m ()
 {-# INLINE writeByteArray #-}
 writeByteArray (MutableByteArray arr#) (I# i#) x
   = primitive_ (writeByteArray# arr# i# x)