import Prelude
+import Data.Array.IO.Internals
import Data.Array ( Array )
import Data.Array.MArray
import Data.Int
import Data.Word
-import Data.Dynamic
-
-#ifdef __HUGS__
-import Hugs.IOArray
-import Hugs.IOExts ( unsafeCoerce )
-import Data.Array.Storable
-#endif
#ifdef __GLASGOW_HASKELL__
+import Foreign
import Foreign.C
-import Foreign.Ptr ( Ptr, FunPtr )
-import Foreign.StablePtr ( StablePtr )
-
import Data.Array.Base
-import GHC.Arr ( STArray, freezeSTArray, unsafeFreezeSTArray,
- thawSTArray, unsafeThawSTArray )
+import GHC.Arr
import GHC.ST ( ST(..) )
-
import GHC.IOBase
import GHC.Handle
-import GHC.Conc
-
-import GHC.Base
-#endif /* __GLASGOW_HASKELL__ */
-
-#ifdef __HUGS__
-instance HasBounds IOArray where
- bounds = boundsIOArray
-
-instance MArray IOArray e IO where
- newArray = newIOArray
- unsafeRead = unsafeReadIOArray
- unsafeWrite = unsafeWriteIOArray
-
-type IOUArray = StorableArray
-
-castIOUArray :: IOUArray i a -> IO (IOUArray i b)
-castIOUArray marr = return (unsafeCoerce marr)
-#endif /* __HUGS__ */
-
-iOArrayTc :: TyCon
-iOArrayTc = mkTyCon "IOArray"
-
-instance (Typeable a, Typeable b) => Typeable (IOArray a b) where
- typeOf a = mkAppTy iOArrayTc [typeOf ((undefined :: IOArray a b -> a) a),
- typeOf ((undefined :: IOArray a b -> b) a)]
+#endif
#ifdef __GLASGOW_HASKELL__
--- GHC only to the end of file
-
------------------------------------------------------------------------------
--- | Mutable, boxed, non-strict arrays in the 'IO' monad. The type
--- arguments are as follows:
---
--- * @i@: the index type of the array (should be an instance of @Ix@)
---
--- * @e@: the element type of the array.
---
-newtype IOArray i e = IOArray (STArray RealWorld i e) deriving Eq
-
-instance HasBounds IOArray where
- {-# INLINE bounds #-}
- bounds (IOArray marr) = bounds marr
-
-instance MArray IOArray e IO where
- {-# INLINE newArray #-}
- newArray lu init = stToIO $ do
- marr <- newArray lu init; return (IOArray marr)
- {-# INLINE newArray_ #-}
- newArray_ lu = stToIO $ do
- marr <- newArray_ lu; return (IOArray marr)
- {-# INLINE unsafeRead #-}
- unsafeRead (IOArray marr) i = stToIO (unsafeRead marr i)
- {-# INLINE unsafeWrite #-}
- unsafeWrite (IOArray marr) i e = stToIO (unsafeWrite marr i e)
-
------------------------------------------------------------------------------
--- Flat unboxed mutable arrays (IO monad)
-
--- | Mutable, unboxed, strict arrays in the 'IO' monad. The type
--- arguments are as follows:
---
--- * @i@: the index type of the array (should be an instance of @Ix@)
---
--- * @e@: the element type of the array. Only certain element types
--- are supported: see 'MArray' for a list of instances.
---
-newtype IOUArray i e = IOUArray (STUArray RealWorld i e) deriving Eq
-
-iOUArrayTc :: TyCon
-iOUArrayTc = mkTyCon "IOUArray"
-
-instance (Typeable a, Typeable b) => Typeable (IOUArray a b) where
- typeOf a = mkAppTy iOUArrayTc [typeOf ((undefined :: IOUArray a b -> a) a),
- typeOf ((undefined :: IOUArray a b -> b) a)]
-
-instance HasBounds IOUArray where
- {-# INLINE bounds #-}
- bounds (IOUArray marr) = bounds marr
-
-instance MArray IOUArray Bool IO where
- {-# INLINE newArray #-}
- newArray lu init = stToIO $ do
- marr <- newArray lu init; return (IOUArray marr)
- {-# INLINE newArray_ #-}
- newArray_ lu = stToIO $ do
- marr <- newArray_ lu; return (IOUArray marr)
- {-# INLINE unsafeRead #-}
- unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
- {-# INLINE unsafeWrite #-}
- unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
-
-instance MArray IOUArray Char IO where
- {-# INLINE newArray #-}
- newArray lu init = stToIO $ do
- marr <- newArray lu init; return (IOUArray marr)
- {-# INLINE newArray_ #-}
- newArray_ lu = stToIO $ do
- marr <- newArray_ lu; return (IOUArray marr)
- {-# INLINE unsafeRead #-}
- unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
- {-# INLINE unsafeWrite #-}
- unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
-
-instance MArray IOUArray Int IO where
- {-# INLINE newArray #-}
- newArray lu init = stToIO $ do
- marr <- newArray lu init; return (IOUArray marr)
- {-# INLINE newArray_ #-}
- newArray_ lu = stToIO $ do
- marr <- newArray_ lu; return (IOUArray marr)
- {-# INLINE unsafeRead #-}
- unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
- {-# INLINE unsafeWrite #-}
- unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
-
-instance MArray IOUArray Word IO where
- {-# INLINE newArray #-}
- newArray lu init = stToIO $ do
- marr <- newArray lu init; return (IOUArray marr)
- {-# INLINE newArray_ #-}
- newArray_ lu = stToIO $ do
- marr <- newArray_ lu; return (IOUArray marr)
- {-# INLINE unsafeRead #-}
- unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
- {-# INLINE unsafeWrite #-}
- unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
-
-instance MArray IOUArray (Ptr a) IO where
- {-# INLINE newArray #-}
- newArray lu init = stToIO $ do
- marr <- newArray lu init; return (IOUArray marr)
- {-# INLINE newArray_ #-}
- newArray_ lu = stToIO $ do
- marr <- newArray_ lu; return (IOUArray marr)
- {-# INLINE unsafeRead #-}
- unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
- {-# INLINE unsafeWrite #-}
- unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
-
-instance MArray IOUArray (FunPtr a) IO where
- {-# INLINE newArray #-}
- newArray lu init = stToIO $ do
- marr <- newArray lu init; return (IOUArray marr)
- {-# INLINE newArray_ #-}
- newArray_ lu = stToIO $ do
- marr <- newArray_ lu; return (IOUArray marr)
- {-# INLINE unsafeRead #-}
- unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
- {-# INLINE unsafeWrite #-}
- unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
-
-instance MArray IOUArray Float IO where
- {-# INLINE newArray #-}
- newArray lu init = stToIO $ do
- marr <- newArray lu init; return (IOUArray marr)
- {-# INLINE newArray_ #-}
- newArray_ lu = stToIO $ do
- marr <- newArray_ lu; return (IOUArray marr)
- {-# INLINE unsafeRead #-}
- unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
- {-# INLINE unsafeWrite #-}
- unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
-
-instance MArray IOUArray Double IO where
- {-# INLINE newArray #-}
- newArray lu init = stToIO $ do
- marr <- newArray lu init; return (IOUArray marr)
- {-# INLINE newArray_ #-}
- newArray_ lu = stToIO $ do
- marr <- newArray_ lu; return (IOUArray marr)
- {-# INLINE unsafeRead #-}
- unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
- {-# INLINE unsafeWrite #-}
- unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
-
-instance MArray IOUArray (StablePtr a) IO where
- {-# INLINE newArray #-}
- newArray lu init = stToIO $ do
- marr <- newArray lu init; return (IOUArray marr)
- {-# INLINE newArray_ #-}
- newArray_ lu = stToIO $ do
- marr <- newArray_ lu; return (IOUArray marr)
- {-# INLINE unsafeRead #-}
- unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
- {-# INLINE unsafeWrite #-}
- unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
-
-instance MArray IOUArray Int8 IO where
- {-# INLINE newArray #-}
- newArray lu init = stToIO $ do
- marr <- newArray lu init; return (IOUArray marr)
- {-# INLINE newArray_ #-}
- newArray_ lu = stToIO $ do
- marr <- newArray_ lu; return (IOUArray marr)
- {-# INLINE unsafeRead #-}
- unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
- {-# INLINE unsafeWrite #-}
- unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
-
-instance MArray IOUArray Int16 IO where
- {-# INLINE newArray #-}
- newArray lu init = stToIO $ do
- marr <- newArray lu init; return (IOUArray marr)
- {-# INLINE newArray_ #-}
- newArray_ lu = stToIO $ do
- marr <- newArray_ lu; return (IOUArray marr)
- {-# INLINE unsafeRead #-}
- unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
- {-# INLINE unsafeWrite #-}
- unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
-
-instance MArray IOUArray Int32 IO where
- {-# INLINE newArray #-}
- newArray lu init = stToIO $ do
- marr <- newArray lu init; return (IOUArray marr)
- {-# INLINE newArray_ #-}
- newArray_ lu = stToIO $ do
- marr <- newArray_ lu; return (IOUArray marr)
- {-# INLINE unsafeRead #-}
- unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
- {-# INLINE unsafeWrite #-}
- unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
-
-instance MArray IOUArray Int64 IO where
- {-# INLINE newArray #-}
- newArray lu init = stToIO $ do
- marr <- newArray lu init; return (IOUArray marr)
- {-# INLINE newArray_ #-}
- newArray_ lu = stToIO $ do
- marr <- newArray_ lu; return (IOUArray marr)
- {-# INLINE unsafeRead #-}
- unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
- {-# INLINE unsafeWrite #-}
- unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
-
-instance MArray IOUArray Word8 IO where
- {-# INLINE newArray #-}
- newArray lu init = stToIO $ do
- marr <- newArray lu init; return (IOUArray marr)
- {-# INLINE newArray_ #-}
- newArray_ lu = stToIO $ do
- marr <- newArray_ lu; return (IOUArray marr)
- {-# INLINE unsafeRead #-}
- unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
- {-# INLINE unsafeWrite #-}
- unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
-
-instance MArray IOUArray Word16 IO where
- {-# INLINE newArray #-}
- newArray lu init = stToIO $ do
- marr <- newArray lu init; return (IOUArray marr)
- {-# INLINE newArray_ #-}
- newArray_ lu = stToIO $ do
- marr <- newArray_ lu; return (IOUArray marr)
- {-# INLINE unsafeRead #-}
- unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
- {-# INLINE unsafeWrite #-}
- unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
-
-instance MArray IOUArray Word32 IO where
- {-# INLINE newArray #-}
- newArray lu init = stToIO $ do
- marr <- newArray lu init; return (IOUArray marr)
- {-# INLINE newArray_ #-}
- newArray_ lu = stToIO $ do
- marr <- newArray_ lu; return (IOUArray marr)
- {-# INLINE unsafeRead #-}
- unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
- {-# INLINE unsafeWrite #-}
- unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
-
-instance MArray IOUArray Word64 IO where
- {-# INLINE newArray #-}
- newArray lu init = stToIO $ do
- marr <- newArray lu init; return (IOUArray marr)
- {-# INLINE newArray_ #-}
- newArray_ lu = stToIO $ do
- marr <- newArray_ lu; return (IOUArray marr)
- {-# INLINE unsafeRead #-}
- unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
- {-# INLINE unsafeWrite #-}
- unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
-
-----------------------------------------------------------------------------
-- Freezing
--- /dev/null
+{-# OPTIONS -#include "HsBase.h" #-}
+-----------------------------------------------------------------------------
+-- |
+-- Module : Data.Array.IO.Internal
+-- Copyright : (c) The University of Glasgow 2001
+-- License : BSD-style (see the file libraries/base/LICENSE)
+--
+-- Maintainer : libraries@haskell.org
+-- Stability : experimental
+-- Portability : non-portable
+--
+-- Mutable boxed and unboxed arrays in the IO monad.
+--
+-----------------------------------------------------------------------------
+
+module Data.Array.IO.Internals (
+ IOArray(..), -- instance of: Eq, Typeable
+ IOUArray(..), -- instance of: Eq, Typeable
+ ) where
+
+import Prelude
+
+import Data.Array.MArray
+import Data.Int
+import Data.Word
+import Data.Dynamic
+
+#ifdef __HUGS__
+import Hugs.IOArray
+import Hugs.IOExts ( unsafeCoerce )
+import Data.Array.Storable
+#endif
+
+#ifdef __GLASGOW_HASKELL__
+import Foreign.Ptr ( Ptr, FunPtr )
+import Foreign.StablePtr ( StablePtr )
+import Data.Array.Base
+
+import GHC.Arr ( STArray )
+import GHC.IOBase
+import GHC.Base
+#endif /* __GLASGOW_HASKELL__ */
+
+#ifdef __HUGS__
+instance HasBounds IOArray where
+ bounds = boundsIOArray
+
+instance MArray IOArray e IO where
+ newArray = newIOArray
+ unsafeRead = unsafeReadIOArray
+ unsafeWrite = unsafeWriteIOArray
+
+type IOUArray = StorableArray
+#endif /* __HUGS__ */
+
+iOArrayTc :: TyCon
+iOArrayTc = mkTyCon "IOArray"
+
+instance (Typeable a, Typeable b) => Typeable (IOArray a b) where
+ typeOf a = mkAppTy iOArrayTc [typeOf ((undefined :: IOArray a b -> a) a),
+ typeOf ((undefined :: IOArray a b -> b) a)]
+
+#ifdef __GLASGOW_HASKELL__
+-- GHC only to the end of file
+
+-----------------------------------------------------------------------------
+-- | Mutable, boxed, non-strict arrays in the 'IO' monad. The type
+-- arguments are as follows:
+--
+-- * @i@: the index type of the array (should be an instance of @Ix@)
+--
+-- * @e@: the element type of the array.
+--
+newtype IOArray i e = IOArray (STArray RealWorld i e) deriving Eq
+
+instance HasBounds IOArray where
+ {-# INLINE bounds #-}
+ bounds (IOArray marr) = bounds marr
+
+instance MArray IOArray e IO where
+ {-# INLINE newArray #-}
+ newArray lu init = stToIO $ do
+ marr <- newArray lu init; return (IOArray marr)
+ {-# INLINE newArray_ #-}
+ newArray_ lu = stToIO $ do
+ marr <- newArray_ lu; return (IOArray marr)
+ {-# INLINE unsafeRead #-}
+ unsafeRead (IOArray marr) i = stToIO (unsafeRead marr i)
+ {-# INLINE unsafeWrite #-}
+ unsafeWrite (IOArray marr) i e = stToIO (unsafeWrite marr i e)
+
+-----------------------------------------------------------------------------
+-- Flat unboxed mutable arrays (IO monad)
+
+-- | Mutable, unboxed, strict arrays in the 'IO' monad. The type
+-- arguments are as follows:
+--
+-- * @i@: the index type of the array (should be an instance of @Ix@)
+--
+-- * @e@: the element type of the array. Only certain element types
+-- are supported: see 'MArray' for a list of instances.
+--
+newtype IOUArray i e = IOUArray (STUArray RealWorld i e) deriving Eq
+
+iOUArrayTc :: TyCon
+iOUArrayTc = mkTyCon "IOUArray"
+
+instance (Typeable a, Typeable b) => Typeable (IOUArray a b) where
+ typeOf a = mkAppTy iOUArrayTc [typeOf ((undefined :: IOUArray a b -> a) a),
+ typeOf ((undefined :: IOUArray a b -> b) a)]
+
+instance HasBounds IOUArray where
+ {-# INLINE bounds #-}
+ bounds (IOUArray marr) = bounds marr
+
+instance MArray IOUArray Bool IO where
+ {-# INLINE newArray #-}
+ newArray lu init = stToIO $ do
+ marr <- newArray lu init; return (IOUArray marr)
+ {-# INLINE newArray_ #-}
+ newArray_ lu = stToIO $ do
+ marr <- newArray_ lu; return (IOUArray marr)
+ {-# INLINE unsafeRead #-}
+ unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
+ {-# INLINE unsafeWrite #-}
+ unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
+
+instance MArray IOUArray Char IO where
+ {-# INLINE newArray #-}
+ newArray lu init = stToIO $ do
+ marr <- newArray lu init; return (IOUArray marr)
+ {-# INLINE newArray_ #-}
+ newArray_ lu = stToIO $ do
+ marr <- newArray_ lu; return (IOUArray marr)
+ {-# INLINE unsafeRead #-}
+ unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
+ {-# INLINE unsafeWrite #-}
+ unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
+
+instance MArray IOUArray Int IO where
+ {-# INLINE newArray #-}
+ newArray lu init = stToIO $ do
+ marr <- newArray lu init; return (IOUArray marr)
+ {-# INLINE newArray_ #-}
+ newArray_ lu = stToIO $ do
+ marr <- newArray_ lu; return (IOUArray marr)
+ {-# INLINE unsafeRead #-}
+ unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
+ {-# INLINE unsafeWrite #-}
+ unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
+
+instance MArray IOUArray Word IO where
+ {-# INLINE newArray #-}
+ newArray lu init = stToIO $ do
+ marr <- newArray lu init; return (IOUArray marr)
+ {-# INLINE newArray_ #-}
+ newArray_ lu = stToIO $ do
+ marr <- newArray_ lu; return (IOUArray marr)
+ {-# INLINE unsafeRead #-}
+ unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
+ {-# INLINE unsafeWrite #-}
+ unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
+
+instance MArray IOUArray (Ptr a) IO where
+ {-# INLINE newArray #-}
+ newArray lu init = stToIO $ do
+ marr <- newArray lu init; return (IOUArray marr)
+ {-# INLINE newArray_ #-}
+ newArray_ lu = stToIO $ do
+ marr <- newArray_ lu; return (IOUArray marr)
+ {-# INLINE unsafeRead #-}
+ unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
+ {-# INLINE unsafeWrite #-}
+ unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
+
+instance MArray IOUArray (FunPtr a) IO where
+ {-# INLINE newArray #-}
+ newArray lu init = stToIO $ do
+ marr <- newArray lu init; return (IOUArray marr)
+ {-# INLINE newArray_ #-}
+ newArray_ lu = stToIO $ do
+ marr <- newArray_ lu; return (IOUArray marr)
+ {-# INLINE unsafeRead #-}
+ unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
+ {-# INLINE unsafeWrite #-}
+ unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
+
+instance MArray IOUArray Float IO where
+ {-# INLINE newArray #-}
+ newArray lu init = stToIO $ do
+ marr <- newArray lu init; return (IOUArray marr)
+ {-# INLINE newArray_ #-}
+ newArray_ lu = stToIO $ do
+ marr <- newArray_ lu; return (IOUArray marr)
+ {-# INLINE unsafeRead #-}
+ unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
+ {-# INLINE unsafeWrite #-}
+ unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
+
+instance MArray IOUArray Double IO where
+ {-# INLINE newArray #-}
+ newArray lu init = stToIO $ do
+ marr <- newArray lu init; return (IOUArray marr)
+ {-# INLINE newArray_ #-}
+ newArray_ lu = stToIO $ do
+ marr <- newArray_ lu; return (IOUArray marr)
+ {-# INLINE unsafeRead #-}
+ unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
+ {-# INLINE unsafeWrite #-}
+ unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
+
+instance MArray IOUArray (StablePtr a) IO where
+ {-# INLINE newArray #-}
+ newArray lu init = stToIO $ do
+ marr <- newArray lu init; return (IOUArray marr)
+ {-# INLINE newArray_ #-}
+ newArray_ lu = stToIO $ do
+ marr <- newArray_ lu; return (IOUArray marr)
+ {-# INLINE unsafeRead #-}
+ unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
+ {-# INLINE unsafeWrite #-}
+ unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
+
+instance MArray IOUArray Int8 IO where
+ {-# INLINE newArray #-}
+ newArray lu init = stToIO $ do
+ marr <- newArray lu init; return (IOUArray marr)
+ {-# INLINE newArray_ #-}
+ newArray_ lu = stToIO $ do
+ marr <- newArray_ lu; return (IOUArray marr)
+ {-# INLINE unsafeRead #-}
+ unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
+ {-# INLINE unsafeWrite #-}
+ unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
+
+instance MArray IOUArray Int16 IO where
+ {-# INLINE newArray #-}
+ newArray lu init = stToIO $ do
+ marr <- newArray lu init; return (IOUArray marr)
+ {-# INLINE newArray_ #-}
+ newArray_ lu = stToIO $ do
+ marr <- newArray_ lu; return (IOUArray marr)
+ {-# INLINE unsafeRead #-}
+ unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
+ {-# INLINE unsafeWrite #-}
+ unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
+
+instance MArray IOUArray Int32 IO where
+ {-# INLINE newArray #-}
+ newArray lu init = stToIO $ do
+ marr <- newArray lu init; return (IOUArray marr)
+ {-# INLINE newArray_ #-}
+ newArray_ lu = stToIO $ do
+ marr <- newArray_ lu; return (IOUArray marr)
+ {-# INLINE unsafeRead #-}
+ unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
+ {-# INLINE unsafeWrite #-}
+ unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
+
+instance MArray IOUArray Int64 IO where
+ {-# INLINE newArray #-}
+ newArray lu init = stToIO $ do
+ marr <- newArray lu init; return (IOUArray marr)
+ {-# INLINE newArray_ #-}
+ newArray_ lu = stToIO $ do
+ marr <- newArray_ lu; return (IOUArray marr)
+ {-# INLINE unsafeRead #-}
+ unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
+ {-# INLINE unsafeWrite #-}
+ unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
+
+instance MArray IOUArray Word8 IO where
+ {-# INLINE newArray #-}
+ newArray lu init = stToIO $ do
+ marr <- newArray lu init; return (IOUArray marr)
+ {-# INLINE newArray_ #-}
+ newArray_ lu = stToIO $ do
+ marr <- newArray_ lu; return (IOUArray marr)
+ {-# INLINE unsafeRead #-}
+ unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
+ {-# INLINE unsafeWrite #-}
+ unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
+
+instance MArray IOUArray Word16 IO where
+ {-# INLINE newArray #-}
+ newArray lu init = stToIO $ do
+ marr <- newArray lu init; return (IOUArray marr)
+ {-# INLINE newArray_ #-}
+ newArray_ lu = stToIO $ do
+ marr <- newArray_ lu; return (IOUArray marr)
+ {-# INLINE unsafeRead #-}
+ unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
+ {-# INLINE unsafeWrite #-}
+ unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
+
+instance MArray IOUArray Word32 IO where
+ {-# INLINE newArray #-}
+ newArray lu init = stToIO $ do
+ marr <- newArray lu init; return (IOUArray marr)
+ {-# INLINE newArray_ #-}
+ newArray_ lu = stToIO $ do
+ marr <- newArray_ lu; return (IOUArray marr)
+ {-# INLINE unsafeRead #-}
+ unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
+ {-# INLINE unsafeWrite #-}
+ unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
+
+instance MArray IOUArray Word64 IO where
+ {-# INLINE newArray #-}
+ newArray lu init = stToIO $ do
+ marr <- newArray lu init; return (IOUArray marr)
+ {-# INLINE newArray_ #-}
+ newArray_ lu = stToIO $ do
+ marr <- newArray_ lu; return (IOUArray marr)
+ {-# INLINE unsafeRead #-}
+ unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
+ {-# INLINE unsafeWrite #-}
+ unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
+
+#endif /* __GLASGOW_HASKELL__ */