Data/Array/IO/Internals.hs

   1 {-# OPTIONS_GHC -#include "HsBase.h" #-}
   2 -----------------------------------------------------------------------------
   3 -- |
   4 -- Module      :  Data.Array.IO.Internal
   5 -- Copyright   :  (c) The University of Glasgow 2001
   6 -- License     :  BSD-style (see the file libraries/base/LICENSE)
   7 --
   8 -- Maintainer  :  libraries@haskell.org
   9 -- Stability   :  experimental
  10 -- Portability :  non-portable (uses Data.Array.Base)
  11 --
  12 -- Mutable boxed and unboxed arrays in the IO monad.
  13 --
  14 -----------------------------------------------------------------------------
  15
  16 -- #hide
  17 module Data.Array.IO.Internals (
  18    IOArray(..),         -- instance of: Eq, Typeable
  19    IOUArray(..),        -- instance of: Eq, Typeable
  20    castIOUArray,        -- :: IOUArray ix a -> IO (IOUArray ix b)
  21  ) where
  22
  23 import Prelude
  24
  25 import Data.Array.MArray
  26 import Data.Int
  27 import Data.Word
  28 import Data.Typeable
  29
  30 #ifdef __HUGS__
  31 import Hugs.IOArray
  32 #endif
  33
  34 import Control.Monad.ST         ( RealWorld, stToIO )
  35 import Foreign.Ptr              ( Ptr, FunPtr )
  36 import Foreign.StablePtr        ( StablePtr )
  37 import Data.Array.Base
  38
  39 #ifdef __GLASGOW_HASKELL__
  40 import GHC.IOBase
  41 import GHC.Base
  42 #endif /* __GLASGOW_HASKELL__ */
  43
  44 #include "Typeable.h"
  45
  46 INSTANCE_TYPEABLE2(IOArray,iOArrayTc,"IOArray")
  47
  48 -----------------------------------------------------------------------------
  49 -- | Instance declarations for 'IOArray's
  50
  51 #ifdef __GLASGOW_HASKELL__
  52 instance HasBounds IOArray where
  53     {-# INLINE bounds #-}
  54     bounds (IOArray marr) = bounds marr
  55 #endif
  56
  57 #ifdef __HUGS__
  58 instance HasBounds IOArray where
  59     bounds      = boundsIOArray
  60 #endif
  61
  62 instance MArray IOArray e IO where
  63     newArray    = newIOArray
  64     unsafeRead  = unsafeReadIOArray
  65     unsafeWrite = unsafeWriteIOArray
  66
  67 -----------------------------------------------------------------------------
  68 -- Flat unboxed mutable arrays (IO monad)
  69
  70 -- | Mutable, unboxed, strict arrays in the 'IO' monad.  The type
  71 -- arguments are as follows:
  72 --
  73 --  * @i@: the index type of the array (should be an instance of 'Ix')
  74 --
  75 --  * @e@: the element type of the array.  Only certain element types
  76 --    are supported: see "Data.Array.MArray" for a list of instances.
  77 --
  78 newtype IOUArray i e = IOUArray (STUArray RealWorld i e)
  79
  80 INSTANCE_TYPEABLE2(IOUArray,iOUArrayTc,"IOUArray")
  81
  82 instance HasBounds IOUArray where
  83     {-# INLINE bounds #-}
  84     bounds (IOUArray marr) = bounds marr
  85
  86 instance MArray IOUArray Bool IO where
  87     {-# INLINE newArray #-}
  88     newArray lu init = stToIO $ do
  89         marr <- newArray lu init; return (IOUArray marr)
  90     {-# INLINE newArray_ #-}
  91     newArray_ lu = stToIO $ do
  92         marr <- newArray_ lu; return (IOUArray marr)
  93     {-# INLINE unsafeRead #-}
  94     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
  95     {-# INLINE unsafeWrite #-}
  96     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
  97
  98 instance MArray IOUArray Char IO where
  99     {-# INLINE newArray #-}
 100     newArray lu init = stToIO $ do
 101         marr <- newArray lu init; return (IOUArray marr)
 102     {-# INLINE newArray_ #-}
 103     newArray_ lu = stToIO $ do
 104         marr <- newArray_ lu; return (IOUArray marr)
 105     {-# INLINE unsafeRead #-}
 106     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 107     {-# INLINE unsafeWrite #-}
 108     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 109
 110 instance MArray IOUArray Int IO where
 111     {-# INLINE newArray #-}
 112     newArray lu init = stToIO $ do
 113         marr <- newArray lu init; return (IOUArray marr)
 114     {-# INLINE newArray_ #-}
 115     newArray_ lu = stToIO $ do
 116         marr <- newArray_ lu; return (IOUArray marr)
 117     {-# INLINE unsafeRead #-}
 118     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 119     {-# INLINE unsafeWrite #-}
 120     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 121
 122 instance MArray IOUArray Word IO where
 123     {-# INLINE newArray #-}
 124     newArray lu init = stToIO $ do
 125         marr <- newArray lu init; return (IOUArray marr)
 126     {-# INLINE newArray_ #-}
 127     newArray_ lu = stToIO $ do
 128         marr <- newArray_ lu; return (IOUArray marr)
 129     {-# INLINE unsafeRead #-}
 130     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 131     {-# INLINE unsafeWrite #-}
 132     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 133
 134 instance MArray IOUArray (Ptr a) IO where
 135     {-# INLINE newArray #-}
 136     newArray lu init = stToIO $ do
 137         marr <- newArray lu init; return (IOUArray marr)
 138     {-# INLINE newArray_ #-}
 139     newArray_ lu = stToIO $ do
 140         marr <- newArray_ lu; return (IOUArray marr)
 141     {-# INLINE unsafeRead #-}
 142     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 143     {-# INLINE unsafeWrite #-}
 144     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 145
 146 instance MArray IOUArray (FunPtr a) IO where
 147     {-# INLINE newArray #-}
 148     newArray lu init = stToIO $ do
 149         marr <- newArray lu init; return (IOUArray marr)
 150     {-# INLINE newArray_ #-}
 151     newArray_ lu = stToIO $ do
 152         marr <- newArray_ lu; return (IOUArray marr)
 153     {-# INLINE unsafeRead #-}
 154     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 155     {-# INLINE unsafeWrite #-}
 156     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 157
 158 instance MArray IOUArray Float IO where
 159     {-# INLINE newArray #-}
 160     newArray lu init = stToIO $ do
 161         marr <- newArray lu init; return (IOUArray marr)
 162     {-# INLINE newArray_ #-}
 163     newArray_ lu = stToIO $ do
 164         marr <- newArray_ lu; return (IOUArray marr)
 165     {-# INLINE unsafeRead #-}
 166     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 167     {-# INLINE unsafeWrite #-}
 168     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 169
 170 instance MArray IOUArray Double IO where
 171     {-# INLINE newArray #-}
 172     newArray lu init = stToIO $ do
 173         marr <- newArray lu init; return (IOUArray marr)
 174     {-# INLINE newArray_ #-}
 175     newArray_ lu = stToIO $ do
 176         marr <- newArray_ lu; return (IOUArray marr)
 177     {-# INLINE unsafeRead #-}
 178     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 179     {-# INLINE unsafeWrite #-}
 180     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 181
 182 instance MArray IOUArray (StablePtr a) IO where
 183     {-# INLINE newArray #-}
 184     newArray lu init = stToIO $ do
 185         marr <- newArray lu init; return (IOUArray marr)
 186     {-# INLINE newArray_ #-}
 187     newArray_ lu = stToIO $ do
 188         marr <- newArray_ lu; return (IOUArray marr)
 189     {-# INLINE unsafeRead #-}
 190     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 191     {-# INLINE unsafeWrite #-}
 192     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 193
 194 instance MArray IOUArray Int8 IO where
 195     {-# INLINE newArray #-}
 196     newArray lu init = stToIO $ do
 197         marr <- newArray lu init; return (IOUArray marr)
 198     {-# INLINE newArray_ #-}
 199     newArray_ lu = stToIO $ do
 200         marr <- newArray_ lu; return (IOUArray marr)
 201     {-# INLINE unsafeRead #-}
 202     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 203     {-# INLINE unsafeWrite #-}
 204     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 205
 206 instance MArray IOUArray Int16 IO where
 207     {-# INLINE newArray #-}
 208     newArray lu init = stToIO $ do
 209         marr <- newArray lu init; return (IOUArray marr)
 210     {-# INLINE newArray_ #-}
 211     newArray_ lu = stToIO $ do
 212         marr <- newArray_ lu; return (IOUArray marr)
 213     {-# INLINE unsafeRead #-}
 214     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 215     {-# INLINE unsafeWrite #-}
 216     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 217
 218 instance MArray IOUArray Int32 IO where
 219     {-# INLINE newArray #-}
 220     newArray lu init = stToIO $ do
 221         marr <- newArray lu init; return (IOUArray marr)
 222     {-# INLINE newArray_ #-}
 223     newArray_ lu = stToIO $ do
 224         marr <- newArray_ lu; return (IOUArray marr)
 225     {-# INLINE unsafeRead #-}
 226     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 227     {-# INLINE unsafeWrite #-}
 228     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 229
 230 instance MArray IOUArray Int64 IO where
 231     {-# INLINE newArray #-}
 232     newArray lu init = stToIO $ do
 233         marr <- newArray lu init; return (IOUArray marr)
 234     {-# INLINE newArray_ #-}
 235     newArray_ lu = stToIO $ do
 236         marr <- newArray_ lu; return (IOUArray marr)
 237     {-# INLINE unsafeRead #-}
 238     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 239     {-# INLINE unsafeWrite #-}
 240     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 241
 242 instance MArray IOUArray Word8 IO where
 243     {-# INLINE newArray #-}
 244     newArray lu init = stToIO $ do
 245         marr <- newArray lu init; return (IOUArray marr)
 246     {-# INLINE newArray_ #-}
 247     newArray_ lu = stToIO $ do
 248         marr <- newArray_ lu; return (IOUArray marr)
 249     {-# INLINE unsafeRead #-}
 250     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 251     {-# INLINE unsafeWrite #-}
 252     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 253
 254 instance MArray IOUArray Word16 IO where
 255     {-# INLINE newArray #-}
 256     newArray lu init = stToIO $ do
 257         marr <- newArray lu init; return (IOUArray marr)
 258     {-# INLINE newArray_ #-}
 259     newArray_ lu = stToIO $ do
 260         marr <- newArray_ lu; return (IOUArray marr)
 261     {-# INLINE unsafeRead #-}
 262     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 263     {-# INLINE unsafeWrite #-}
 264     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 265
 266 instance MArray IOUArray Word32 IO where
 267     {-# INLINE newArray #-}
 268     newArray lu init = stToIO $ do
 269         marr <- newArray lu init; return (IOUArray marr)
 270     {-# INLINE newArray_ #-}
 271     newArray_ lu = stToIO $ do
 272         marr <- newArray_ lu; return (IOUArray marr)
 273     {-# INLINE unsafeRead #-}
 274     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 275     {-# INLINE unsafeWrite #-}
 276     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 277
 278 instance MArray IOUArray Word64 IO where
 279     {-# INLINE newArray #-}
 280     newArray lu init = stToIO $ do
 281         marr <- newArray lu init; return (IOUArray marr)
 282     {-# INLINE newArray_ #-}
 283     newArray_ lu = stToIO $ do
 284         marr <- newArray_ lu; return (IOUArray marr)
 285     {-# INLINE unsafeRead #-}
 286     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 287     {-# INLINE unsafeWrite #-}
 288     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 289
 290 -- | Casts an 'IOUArray' with one element type into one with a
 291 -- different element type.  All the elements of the resulting array
 292 -- are undefined (unless you know what you\'re doing...).
 293 castIOUArray :: IOUArray ix a -> IO (IOUArray ix b)
 294 castIOUArray (IOUArray marr) = stToIO $ do
 295     marr' <- castSTUArray marr
 296     return (IOUArray marr')
 297