Data/Array/IO/Internals.hs

   1 {-# OPTIONS -#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
  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 #ifdef __GLASGOW_HASKELL__
 123 instance MArray IOUArray Word IO where
 124     {-# INLINE newArray #-}
 125     newArray lu init = stToIO $ do
 126         marr <- newArray lu init; return (IOUArray marr)
 127     {-# INLINE newArray_ #-}
 128     newArray_ lu = stToIO $ do
 129         marr <- newArray_ lu; return (IOUArray marr)
 130     {-# INLINE unsafeRead #-}
 131     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 132     {-# INLINE unsafeWrite #-}
 133     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 134 #endif
 135
 136 instance MArray IOUArray (Ptr a) IO where
 137     {-# INLINE newArray #-}
 138     newArray lu init = stToIO $ do
 139         marr <- newArray lu init; return (IOUArray marr)
 140     {-# INLINE newArray_ #-}
 141     newArray_ lu = stToIO $ do
 142         marr <- newArray_ lu; return (IOUArray marr)
 143     {-# INLINE unsafeRead #-}
 144     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 145     {-# INLINE unsafeWrite #-}
 146     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 147
 148 instance MArray IOUArray (FunPtr a) IO where
 149     {-# INLINE newArray #-}
 150     newArray lu init = stToIO $ do
 151         marr <- newArray lu init; return (IOUArray marr)
 152     {-# INLINE newArray_ #-}
 153     newArray_ lu = stToIO $ do
 154         marr <- newArray_ lu; return (IOUArray marr)
 155     {-# INLINE unsafeRead #-}
 156     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 157     {-# INLINE unsafeWrite #-}
 158     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 159
 160 instance MArray IOUArray Float IO where
 161     {-# INLINE newArray #-}
 162     newArray lu init = stToIO $ do
 163         marr <- newArray lu init; return (IOUArray marr)
 164     {-# INLINE newArray_ #-}
 165     newArray_ lu = stToIO $ do
 166         marr <- newArray_ lu; return (IOUArray marr)
 167     {-# INLINE unsafeRead #-}
 168     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 169     {-# INLINE unsafeWrite #-}
 170     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 171
 172 instance MArray IOUArray Double IO where
 173     {-# INLINE newArray #-}
 174     newArray lu init = stToIO $ do
 175         marr <- newArray lu init; return (IOUArray marr)
 176     {-# INLINE newArray_ #-}
 177     newArray_ lu = stToIO $ do
 178         marr <- newArray_ lu; return (IOUArray marr)
 179     {-# INLINE unsafeRead #-}
 180     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 181     {-# INLINE unsafeWrite #-}
 182     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 183
 184 instance MArray IOUArray (StablePtr a) IO where
 185     {-# INLINE newArray #-}
 186     newArray lu init = stToIO $ do
 187         marr <- newArray lu init; return (IOUArray marr)
 188     {-# INLINE newArray_ #-}
 189     newArray_ lu = stToIO $ do
 190         marr <- newArray_ lu; return (IOUArray marr)
 191     {-# INLINE unsafeRead #-}
 192     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 193     {-# INLINE unsafeWrite #-}
 194     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 195
 196 instance MArray IOUArray Int8 IO where
 197     {-# INLINE newArray #-}
 198     newArray lu init = stToIO $ do
 199         marr <- newArray lu init; return (IOUArray marr)
 200     {-# INLINE newArray_ #-}
 201     newArray_ lu = stToIO $ do
 202         marr <- newArray_ lu; return (IOUArray marr)
 203     {-# INLINE unsafeRead #-}
 204     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 205     {-# INLINE unsafeWrite #-}
 206     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 207
 208 instance MArray IOUArray Int16 IO where
 209     {-# INLINE newArray #-}
 210     newArray lu init = stToIO $ do
 211         marr <- newArray lu init; return (IOUArray marr)
 212     {-# INLINE newArray_ #-}
 213     newArray_ lu = stToIO $ do
 214         marr <- newArray_ lu; return (IOUArray marr)
 215     {-# INLINE unsafeRead #-}
 216     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 217     {-# INLINE unsafeWrite #-}
 218     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 219
 220 instance MArray IOUArray Int32 IO where
 221     {-# INLINE newArray #-}
 222     newArray lu init = stToIO $ do
 223         marr <- newArray lu init; return (IOUArray marr)
 224     {-# INLINE newArray_ #-}
 225     newArray_ lu = stToIO $ do
 226         marr <- newArray_ lu; return (IOUArray marr)
 227     {-# INLINE unsafeRead #-}
 228     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 229     {-# INLINE unsafeWrite #-}
 230     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 231
 232 instance MArray IOUArray Int64 IO where
 233     {-# INLINE newArray #-}
 234     newArray lu init = stToIO $ do
 235         marr <- newArray lu init; return (IOUArray marr)
 236     {-# INLINE newArray_ #-}
 237     newArray_ lu = stToIO $ do
 238         marr <- newArray_ lu; return (IOUArray marr)
 239     {-# INLINE unsafeRead #-}
 240     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 241     {-# INLINE unsafeWrite #-}
 242     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 243
 244 instance MArray IOUArray Word8 IO where
 245     {-# INLINE newArray #-}
 246     newArray lu init = stToIO $ do
 247         marr <- newArray lu init; return (IOUArray marr)
 248     {-# INLINE newArray_ #-}
 249     newArray_ lu = stToIO $ do
 250         marr <- newArray_ lu; return (IOUArray marr)
 251     {-# INLINE unsafeRead #-}
 252     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 253     {-# INLINE unsafeWrite #-}
 254     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 255
 256 instance MArray IOUArray Word16 IO where
 257     {-# INLINE newArray #-}
 258     newArray lu init = stToIO $ do
 259         marr <- newArray lu init; return (IOUArray marr)
 260     {-# INLINE newArray_ #-}
 261     newArray_ lu = stToIO $ do
 262         marr <- newArray_ lu; return (IOUArray marr)
 263     {-# INLINE unsafeRead #-}
 264     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 265     {-# INLINE unsafeWrite #-}
 266     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 267
 268 instance MArray IOUArray Word32 IO where
 269     {-# INLINE newArray #-}
 270     newArray lu init = stToIO $ do
 271         marr <- newArray lu init; return (IOUArray marr)
 272     {-# INLINE newArray_ #-}
 273     newArray_ lu = stToIO $ do
 274         marr <- newArray_ lu; return (IOUArray marr)
 275     {-# INLINE unsafeRead #-}
 276     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 277     {-# INLINE unsafeWrite #-}
 278     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 279
 280 instance MArray IOUArray Word64 IO where
 281     {-# INLINE newArray #-}
 282     newArray lu init = stToIO $ do
 283         marr <- newArray lu init; return (IOUArray marr)
 284     {-# INLINE newArray_ #-}
 285     newArray_ lu = stToIO $ do
 286         marr <- newArray_ lu; return (IOUArray marr)
 287     {-# INLINE unsafeRead #-}
 288     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 289     {-# INLINE unsafeWrite #-}
 290     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 291
 292 -- | Casts an 'IOUArray' with one element type into one with a
 293 -- different element type.  All the elements of the resulting array
 294 -- are undefined (unless you know what you\'re doing...).
 295 castIOUArray :: IOUArray ix a -> IO (IOUArray ix b)
 296 castIOUArray (IOUArray marr) = stToIO $ do
 297     marr' <- castSTUArray marr
 298     return (IOUArray marr')
 299