    {-# LANGUAGE DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses,
                 CPP #-}
    #if __GLASGOW_HASKELL__ >= 708
    {-# LANGUAGE RoleAnnotations #-}
    #endif

    {-# OPTIONS_HADDOCK hide #-}
    -----------------------------------------------------------------------------
    -- |
    -- Module      :  Data.Array.IO.Internal
    -- Copyright   :  (c) The University of Glasgow 2001-2012
    -- License     :  BSD-style (see the file libraries/base/LICENSE)
    --
    -- Maintainer  :  libraries@haskell.org
    -- Stability   :  experimental
    -- Portability :  non-portable (uses Data.Array.Base)
    --
    -- Mutable boxed and unboxed arrays in the IO monad.
    --
    -----------------------------------------------------------------------------

    module Data.Array.IO.Internals (
        IOArray(..),         -- instance of: Eq, Typeable
        IOUArray(..),        -- instance of: Eq, Typeable
        castIOUArray,        -- :: IOUArray ix a -> IO (IOUArray ix b)
        unsafeThawIOUArray,
      ) where

    import Data.Int
    import Data.Word
    import Data.Typeable

    import Control.Monad.ST         ( RealWorld, stToIO )
    import Foreign.Ptr              ( Ptr, FunPtr )
    import Foreign.StablePtr        ( StablePtr )

    #if __GLASGOW_HASKELL__ < 711
    import Data.Ix
    #endif
    import Data.Array.Base

    import GHC.IOArray (IOArray(..))

    -----------------------------------------------------------------------------
    -- 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 "Data.Array.MArray" for a list of instances.
    --
    newtype IOUArray i e = IOUArray (STUArray RealWorld i e)
                           deriving Typeable
    #if __GLASGOW_HASKELL__ >= 708
    -- Both parameters have class-based invariants. See also #9220.
    type role IOUArray nominal nominal
    #endif

    instance Eq (IOUArray i e) where
        IOUArray s1 == IOUArray s2  =  s1 == s2

    instance MArray IOUArray Bool IO where
        {-# INLINE getBounds #-}
        getBounds (IOUArray arr) = stToIO $ getBounds arr
        {-# INLINE getNumElements #-}
        getNumElements (IOUArray arr) = stToIO $ getNumElements arr
        {-# INLINE newArray #-}
        newArray lu initialValue = stToIO $ do
            marr <- newArray lu initialValue; return (IOUArray marr)
        {-# INLINE unsafeNewArray_ #-}
        unsafeNewArray_ lu = stToIO $ do
            marr <- unsafeNewArray_ lu; return (IOUArray marr)
        {-# INLINE newArray_ #-}
        newArray_ = unsafeNewArray_
        {-# 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 getBounds #-}
        getBounds (IOUArray arr) = stToIO $ getBounds arr
        {-# INLINE getNumElements #-}
        getNumElements (IOUArray arr) = stToIO $ getNumElements arr
        {-# INLINE newArray #-}
        newArray lu initialValue = stToIO $ do
            marr <- newArray lu initialValue; return (IOUArray marr)
        {-# INLINE unsafeNewArray_ #-}
        unsafeNewArray_ lu = stToIO $ do
            marr <- unsafeNewArray_ lu; return (IOUArray marr)
        {-# INLINE newArray_ #-}
        newArray_ = unsafeNewArray_
        {-# 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 getBounds #-}
        getBounds (IOUArray arr) = stToIO $ getBounds arr
        {-# INLINE getNumElements #-}
        getNumElements (IOUArray arr) = stToIO $ getNumElements arr
        {-# INLINE newArray #-}
        newArray lu initialValue = stToIO $ do
            marr <- newArray lu initialValue; return (IOUArray marr)
        {-# INLINE unsafeNewArray_ #-}
        unsafeNewArray_ lu = stToIO $ do
            marr <- unsafeNewArray_ lu; return (IOUArray marr)
        {-# INLINE newArray_ #-}
        newArray_ = unsafeNewArray_
        {-# 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 getBounds #-}
        getBounds (IOUArray arr) = stToIO $ getBounds arr
        {-# INLINE getNumElements #-}
        getNumElements (IOUArray arr) = stToIO $ getNumElements arr
        {-# INLINE newArray #-}
        newArray lu initialValue = stToIO $ do
            marr <- newArray lu initialValue; return (IOUArray marr)
        {-# INLINE unsafeNewArray_ #-}
        unsafeNewArray_ lu = stToIO $ do
            marr <- unsafeNewArray_ lu; return (IOUArray marr)
        {-# INLINE newArray_ #-}
        newArray_ = unsafeNewArray_
        {-# 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 getBounds #-}
        getBounds (IOUArray arr) = stToIO $ getBounds arr
        {-# INLINE getNumElements #-}
        getNumElements (IOUArray arr) = stToIO $ getNumElements arr
        {-# INLINE newArray #-}
        newArray lu initialValue = stToIO $ do
            marr <- newArray lu initialValue; return (IOUArray marr)
        {-# INLINE unsafeNewArray_ #-}
        unsafeNewArray_ lu = stToIO $ do
            marr <- unsafeNewArray_ lu; return (IOUArray marr)
        {-# INLINE newArray_ #-}
        newArray_ = unsafeNewArray_
        {-# 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 getBounds #-}
        getBounds (IOUArray arr) = stToIO $ getBounds arr
        {-# INLINE getNumElements #-}
        getNumElements (IOUArray arr) = stToIO $ getNumElements arr
        {-# INLINE newArray #-}
        newArray lu initialValue = stToIO $ do
            marr <- newArray lu initialValue; return (IOUArray marr)
        {-# INLINE unsafeNewArray_ #-}
        unsafeNewArray_ lu = stToIO $ do
            marr <- unsafeNewArray_ lu; return (IOUArray marr)
        {-# INLINE newArray_ #-}
        newArray_ = unsafeNewArray_
        {-# 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 getBounds #-}
        getBounds (IOUArray arr) = stToIO $ getBounds arr
        {-# INLINE getNumElements #-}
        getNumElements (IOUArray arr) = stToIO $ getNumElements arr
        {-# INLINE newArray #-}
        newArray lu initialValue = stToIO $ do
            marr <- newArray lu initialValue; return (IOUArray marr)
        {-# INLINE unsafeNewArray_ #-}
        unsafeNewArray_ lu = stToIO $ do
            marr <- unsafeNewArray_ lu; return (IOUArray marr)
        {-# INLINE newArray_ #-}
        newArray_ = unsafeNewArray_
        {-# 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 getBounds #-}
        getBounds (IOUArray arr) = stToIO $ getBounds arr
        {-# INLINE getNumElements #-}
        getNumElements (IOUArray arr) = stToIO $ getNumElements arr
        {-# INLINE newArray #-}
        newArray lu initialValue = stToIO $ do
            marr <- newArray lu initialValue; return (IOUArray marr)
        {-# INLINE unsafeNewArray_ #-}
        unsafeNewArray_ lu = stToIO $ do
            marr <- unsafeNewArray_ lu; return (IOUArray marr)
        {-# INLINE newArray_ #-}
        newArray_ = unsafeNewArray_
        {-# 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 getBounds #-}
        getBounds (IOUArray arr) = stToIO $ getBounds arr
        {-# INLINE getNumElements #-}
        getNumElements (IOUArray arr) = stToIO $ getNumElements arr
        {-# INLINE newArray #-}
        newArray lu initialValue = stToIO $ do
            marr <- newArray lu initialValue; return (IOUArray marr)
        {-# INLINE unsafeNewArray_ #-}
        unsafeNewArray_ lu = stToIO $ do
            marr <- unsafeNewArray_ lu; return (IOUArray marr)
        {-# INLINE newArray_ #-}
        newArray_ = unsafeNewArray_
        {-# 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 getBounds #-}
        getBounds (IOUArray arr) = stToIO $ getBounds arr
        {-# INLINE getNumElements #-}
        getNumElements (IOUArray arr) = stToIO $ getNumElements arr
        {-# INLINE newArray #-}
        newArray lu initialValue = stToIO $ do
            marr <- newArray lu initialValue; return (IOUArray marr)
        {-# INLINE unsafeNewArray_ #-}
        unsafeNewArray_ lu = stToIO $ do
            marr <- unsafeNewArray_ lu; return (IOUArray marr)
        {-# INLINE newArray_ #-}
        newArray_ = unsafeNewArray_
        {-# 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 getBounds #-}
        getBounds (IOUArray arr) = stToIO $ getBounds arr
        {-# INLINE getNumElements #-}
        getNumElements (IOUArray arr) = stToIO $ getNumElements arr
        {-# INLINE newArray #-}
        newArray lu initialValue = stToIO $ do
            marr <- newArray lu initialValue; return (IOUArray marr)
        {-# INLINE unsafeNewArray_ #-}
        unsafeNewArray_ lu = stToIO $ do
            marr <- unsafeNewArray_ lu; return (IOUArray marr)
        {-# INLINE newArray_ #-}
        newArray_ = unsafeNewArray_
        {-# 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 getBounds #-}
        getBounds (IOUArray arr) = stToIO $ getBounds arr
        {-# INLINE getNumElements #-}
        getNumElements (IOUArray arr) = stToIO $ getNumElements arr
        {-# INLINE newArray #-}
        newArray lu initialValue = stToIO $ do
            marr <- newArray lu initialValue; return (IOUArray marr)
        {-# INLINE unsafeNewArray_ #-}
        unsafeNewArray_ lu = stToIO $ do
            marr <- unsafeNewArray_ lu; return (IOUArray marr)
        {-# INLINE newArray_ #-}
        newArray_ = unsafeNewArray_
        {-# 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 getBounds #-}
        getBounds (IOUArray arr) = stToIO $ getBounds arr
        {-# INLINE getNumElements #-}
        getNumElements (IOUArray arr) = stToIO $ getNumElements arr
        {-# INLINE newArray #-}
        newArray lu initialValue = stToIO $ do
            marr <- newArray lu initialValue; return (IOUArray marr)
        {-# INLINE unsafeNewArray_ #-}
        unsafeNewArray_ lu = stToIO $ do
            marr <- unsafeNewArray_ lu; return (IOUArray marr)
        {-# INLINE newArray_ #-}
        newArray_ = unsafeNewArray_
        {-# 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 getBounds #-}
        getBounds (IOUArray arr) = stToIO $ getBounds arr
        {-# INLINE getNumElements #-}
        getNumElements (IOUArray arr) = stToIO $ getNumElements arr
        {-# INLINE newArray #-}
        newArray lu initialValue = stToIO $ do
            marr <- newArray lu initialValue; return (IOUArray marr)
        {-# INLINE unsafeNewArray_ #-}
        unsafeNewArray_ lu = stToIO $ do
            marr <- unsafeNewArray_ lu; return (IOUArray marr)
        {-# INLINE newArray_ #-}
        newArray_ = unsafeNewArray_
        {-# 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 getBounds #-}
        getBounds (IOUArray arr) = stToIO $ getBounds arr
        {-# INLINE getNumElements #-}
        getNumElements (IOUArray arr) = stToIO $ getNumElements arr
        {-# INLINE newArray #-}
        newArray lu initialValue = stToIO $ do
            marr <- newArray lu initialValue; return (IOUArray marr)
        {-# INLINE unsafeNewArray_ #-}
        unsafeNewArray_ lu = stToIO $ do
            marr <- unsafeNewArray_ lu; return (IOUArray marr)
        {-# INLINE newArray_ #-}
        newArray_ = unsafeNewArray_
        {-# 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 getBounds #-}
        getBounds (IOUArray arr) = stToIO $ getBounds arr
        {-# INLINE getNumElements #-}
        getNumElements (IOUArray arr) = stToIO $ getNumElements arr
        {-# INLINE newArray #-}
        newArray lu initialValue = stToIO $ do
            marr <- newArray lu initialValue; return (IOUArray marr)
        {-# INLINE unsafeNewArray_ #-}
        unsafeNewArray_ lu = stToIO $ do
            marr <- unsafeNewArray_ lu; return (IOUArray marr)
        {-# INLINE newArray_ #-}
        newArray_ = unsafeNewArray_
        {-# 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 getBounds #-}
        getBounds (IOUArray arr) = stToIO $ getBounds arr
        {-# INLINE getNumElements #-}
        getNumElements (IOUArray arr) = stToIO $ getNumElements arr
        {-# INLINE newArray #-}
        newArray lu initialValue = stToIO $ do
            marr <- newArray lu initialValue; return (IOUArray marr)
        {-# INLINE unsafeNewArray_ #-}
        unsafeNewArray_ lu = stToIO $ do
            marr <- unsafeNewArray_ lu; return (IOUArray marr)
        {-# INLINE newArray_ #-}
        newArray_ = unsafeNewArray_
        {-# INLINE unsafeRead #-}
        unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
        {-# INLINE unsafeWrite #-}
        unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)

    -- | Casts an 'IOUArray' with one element type into one with a
    -- different element type.  All the elements of the resulting array
    -- are undefined (unless you know what you\'re doing...).
    castIOUArray :: IOUArray ix a -> IO (IOUArray ix b)
    castIOUArray (IOUArray marr) = stToIO $ do
        marr' <- castSTUArray marr
        return (IOUArray marr')

    {-# INLINE unsafeThawIOUArray #-}
    #if __GLASGOW_HASKELL__ >= 711
    unsafeThawIOUArray :: UArray ix e -> IO (IOUArray ix e)
    #else
    unsafeThawIOUArray :: Ix ix => UArray ix e -> IO (IOUArray ix e)
    #endif
    unsafeThawIOUArray arr = stToIO $ do
        marr <- unsafeThawSTUArray arr
        return (IOUArray marr)

    {-# RULES
    "unsafeThaw/IOUArray" unsafeThaw = unsafeThawIOUArray
        #-}

    #if __GLASGOW_HASKELL__ >= 711
    thawIOUArray :: UArray ix e -> IO (IOUArray ix e)
    #else
    thawIOUArray :: Ix ix => UArray ix e -> IO (IOUArray ix e)
    #endif
    thawIOUArray arr = stToIO $ do
        marr <- thawSTUArray arr
        return (IOUArray marr)

    {-# RULES
    "thaw/IOUArray" thaw = thawIOUArray
        #-}

    {-# INLINE unsafeFreezeIOUArray #-}
    #if __GLASGOW_HASKELL__ >= 711
    unsafeFreezeIOUArray :: IOUArray ix e -> IO (UArray ix e)
    #else
    unsafeFreezeIOUArray :: Ix ix => IOUArray ix e -> IO (UArray ix e)
    #endif
    unsafeFreezeIOUArray (IOUArray marr) = stToIO (unsafeFreezeSTUArray marr)

    {-# RULES
    "unsafeFreeze/IOUArray" unsafeFreeze = unsafeFreezeIOUArray
        #-}

    #if __GLASGOW_HASKELL__ >= 711
    freezeIOUArray :: IOUArray ix e -> IO (UArray ix e)
    #else
    freezeIOUArray :: Ix ix => IOUArray ix e -> IO (UArray ix e)
    #endif
    freezeIOUArray (IOUArray marr) = stToIO (freezeSTUArray marr)

    {-# RULES
    "freeze/IOUArray" freeze = freezeIOUArray
        #-}