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 module Data.Array.IO.Internals (
  17    IOArray(..),         -- instance of: Eq, Typeable
  18    IOUArray(..),        -- instance of: Eq, Typeable
  19  ) where
  20
  21 import Prelude
  22
  23 import Data.Array.MArray
  24 import Data.Int
  25 import Data.Word
  26 import Data.Dynamic
  27
  28 #ifdef __HUGS__
  29 import Hugs.IOArray
  30 import Hugs.IOExts              ( unsafeCoerce )
  31 import Data.Array.Storable
  32 #endif
  33
  34 #ifdef __GLASGOW_HASKELL__
  35 import Foreign.Ptr              ( Ptr, FunPtr )
  36 import Foreign.StablePtr        ( StablePtr )
  37 import Data.Array.Base
  38
  39 import GHC.Arr                  ( STArray )
  40 import GHC.IOBase
  41 import GHC.Base
  42 #endif /* __GLASGOW_HASKELL__ */
  43
  44 #ifdef __HUGS__
  45 instance HasBounds IOArray where
  46     bounds = boundsIOArray
  47
  48 instance MArray IOArray e IO where
  49     newArray    = newIOArray
  50     unsafeRead  = unsafeReadIOArray
  51     unsafeWrite = unsafeWriteIOArray
  52
  53 type IOUArray = StorableArray
  54 #endif /* __HUGS__ */
  55
  56 iOArrayTc :: TyCon
  57 iOArrayTc = mkTyCon "IOArray"
  58
  59 instance (Typeable a, Typeable b) => Typeable (IOArray a b) where
  60   typeOf a = mkAppTy iOArrayTc [typeOf ((undefined :: IOArray a b -> a) a),
  61                                 typeOf ((undefined :: IOArray a b -> b) a)]
  62
  63 #ifdef __GLASGOW_HASKELL__
  64 -- GHC only to the end of file
  65
  66 -----------------------------------------------------------------------------
  67 -- | Mutable, boxed, non-strict arrays in the 'IO' monad.  The type
  68 -- arguments are as follows:
  69 --
  70 --  * @i@: the index type of the array (should be an instance of @Ix@)
  71 --
  72 --  * @e@: the element type of the array.
  73 --
  74 newtype IOArray i e = IOArray (STArray RealWorld i e) deriving Eq
  75
  76 instance HasBounds IOArray where
  77     {-# INLINE bounds #-}
  78     bounds (IOArray marr) = bounds marr
  79
  80 instance MArray IOArray e IO where
  81     {-# INLINE newArray #-}
  82     newArray lu init = stToIO $ do
  83         marr <- newArray lu init; return (IOArray marr)
  84     {-# INLINE newArray_ #-}
  85     newArray_ lu = stToIO $ do
  86         marr <- newArray_ lu; return (IOArray marr)
  87     {-# INLINE unsafeRead #-}
  88     unsafeRead (IOArray marr) i = stToIO (unsafeRead marr i)
  89     {-# INLINE unsafeWrite #-}
  90     unsafeWrite (IOArray marr) i e = stToIO (unsafeWrite marr i e)
  91
  92 -----------------------------------------------------------------------------
  93 -- Flat unboxed mutable arrays (IO monad)
  94
  95 -- | Mutable, unboxed, strict arrays in the 'IO' monad.  The type
  96 -- arguments are as follows:
  97 --
  98 --  * @i@: the index type of the array (should be an instance of @Ix@)
  99 --
 100 --  * @e@: the element type of the array.  Only certain element types
 101 --    are supported: see 'MArray' for a list of instances.
 102 --
 103 newtype IOUArray i e = IOUArray (STUArray RealWorld i e) deriving Eq
 104
 105 iOUArrayTc :: TyCon
 106 iOUArrayTc = mkTyCon "IOUArray"
 107
 108 instance (Typeable a, Typeable b) => Typeable (IOUArray a b) where
 109   typeOf a = mkAppTy iOUArrayTc [typeOf ((undefined :: IOUArray a b -> a) a),
 110                                  typeOf ((undefined :: IOUArray a b -> b) a)]
 111
 112 instance HasBounds IOUArray where
 113     {-# INLINE bounds #-}
 114     bounds (IOUArray marr) = bounds marr
 115
 116 instance MArray IOUArray Bool IO where
 117     {-# INLINE newArray #-}
 118     newArray lu init = stToIO $ do
 119         marr <- newArray lu init; return (IOUArray marr)
 120     {-# INLINE newArray_ #-}
 121     newArray_ lu = stToIO $ do
 122         marr <- newArray_ lu; return (IOUArray marr)
 123     {-# INLINE unsafeRead #-}
 124     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 125     {-# INLINE unsafeWrite #-}
 126     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 127
 128 instance MArray IOUArray Char IO where
 129     {-# INLINE newArray #-}
 130     newArray lu init = stToIO $ do
 131         marr <- newArray lu init; return (IOUArray marr)
 132     {-# INLINE newArray_ #-}
 133     newArray_ lu = stToIO $ do
 134         marr <- newArray_ lu; return (IOUArray marr)
 135     {-# INLINE unsafeRead #-}
 136     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 137     {-# INLINE unsafeWrite #-}
 138     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 139
 140 instance MArray IOUArray Int IO where
 141     {-# INLINE newArray #-}
 142     newArray lu init = stToIO $ do
 143         marr <- newArray lu init; return (IOUArray marr)
 144     {-# INLINE newArray_ #-}
 145     newArray_ lu = stToIO $ do
 146         marr <- newArray_ lu; return (IOUArray marr)
 147     {-# INLINE unsafeRead #-}
 148     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 149     {-# INLINE unsafeWrite #-}
 150     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 151
 152 instance MArray IOUArray Word IO where
 153     {-# INLINE newArray #-}
 154     newArray lu init = stToIO $ do
 155         marr <- newArray lu init; return (IOUArray marr)
 156     {-# INLINE newArray_ #-}
 157     newArray_ lu = stToIO $ do
 158         marr <- newArray_ lu; return (IOUArray marr)
 159     {-# INLINE unsafeRead #-}
 160     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 161     {-# INLINE unsafeWrite #-}
 162     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 163
 164 instance MArray IOUArray (Ptr a) IO where
 165     {-# INLINE newArray #-}
 166     newArray lu init = stToIO $ do
 167         marr <- newArray lu init; return (IOUArray marr)
 168     {-# INLINE newArray_ #-}
 169     newArray_ lu = stToIO $ do
 170         marr <- newArray_ lu; return (IOUArray marr)
 171     {-# INLINE unsafeRead #-}
 172     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 173     {-# INLINE unsafeWrite #-}
 174     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 175
 176 instance MArray IOUArray (FunPtr a) IO where
 177     {-# INLINE newArray #-}
 178     newArray lu init = stToIO $ do
 179         marr <- newArray lu init; return (IOUArray marr)
 180     {-# INLINE newArray_ #-}
 181     newArray_ lu = stToIO $ do
 182         marr <- newArray_ lu; return (IOUArray marr)
 183     {-# INLINE unsafeRead #-}
 184     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 185     {-# INLINE unsafeWrite #-}
 186     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 187
 188 instance MArray IOUArray Float IO where
 189     {-# INLINE newArray #-}
 190     newArray lu init = stToIO $ do
 191         marr <- newArray lu init; return (IOUArray marr)
 192     {-# INLINE newArray_ #-}
 193     newArray_ lu = stToIO $ do
 194         marr <- newArray_ lu; return (IOUArray marr)
 195     {-# INLINE unsafeRead #-}
 196     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 197     {-# INLINE unsafeWrite #-}
 198     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 199
 200 instance MArray IOUArray Double IO where
 201     {-# INLINE newArray #-}
 202     newArray lu init = stToIO $ do
 203         marr <- newArray lu init; return (IOUArray marr)
 204     {-# INLINE newArray_ #-}
 205     newArray_ lu = stToIO $ do
 206         marr <- newArray_ lu; return (IOUArray marr)
 207     {-# INLINE unsafeRead #-}
 208     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 209     {-# INLINE unsafeWrite #-}
 210     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 211
 212 instance MArray IOUArray (StablePtr a) IO where
 213     {-# INLINE newArray #-}
 214     newArray lu init = stToIO $ do
 215         marr <- newArray lu init; return (IOUArray marr)
 216     {-# INLINE newArray_ #-}
 217     newArray_ lu = stToIO $ do
 218         marr <- newArray_ lu; return (IOUArray marr)
 219     {-# INLINE unsafeRead #-}
 220     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 221     {-# INLINE unsafeWrite #-}
 222     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 223
 224 instance MArray IOUArray Int8 IO where
 225     {-# INLINE newArray #-}
 226     newArray lu init = stToIO $ do
 227         marr <- newArray lu init; return (IOUArray marr)
 228     {-# INLINE newArray_ #-}
 229     newArray_ lu = stToIO $ do
 230         marr <- newArray_ lu; return (IOUArray marr)
 231     {-# INLINE unsafeRead #-}
 232     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 233     {-# INLINE unsafeWrite #-}
 234     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 235
 236 instance MArray IOUArray Int16 IO where
 237     {-# INLINE newArray #-}
 238     newArray lu init = stToIO $ do
 239         marr <- newArray lu init; return (IOUArray marr)
 240     {-# INLINE newArray_ #-}
 241     newArray_ lu = stToIO $ do
 242         marr <- newArray_ lu; return (IOUArray marr)
 243     {-# INLINE unsafeRead #-}
 244     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 245     {-# INLINE unsafeWrite #-}
 246     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 247
 248 instance MArray IOUArray Int32 IO where
 249     {-# INLINE newArray #-}
 250     newArray lu init = stToIO $ do
 251         marr <- newArray lu init; return (IOUArray marr)
 252     {-# INLINE newArray_ #-}
 253     newArray_ lu = stToIO $ do
 254         marr <- newArray_ lu; return (IOUArray marr)
 255     {-# INLINE unsafeRead #-}
 256     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 257     {-# INLINE unsafeWrite #-}
 258     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 259
 260 instance MArray IOUArray Int64 IO where
 261     {-# INLINE newArray #-}
 262     newArray lu init = stToIO $ do
 263         marr <- newArray lu init; return (IOUArray marr)
 264     {-# INLINE newArray_ #-}
 265     newArray_ lu = stToIO $ do
 266         marr <- newArray_ lu; return (IOUArray marr)
 267     {-# INLINE unsafeRead #-}
 268     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 269     {-# INLINE unsafeWrite #-}
 270     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 271
 272 instance MArray IOUArray Word8 IO where
 273     {-# INLINE newArray #-}
 274     newArray lu init = stToIO $ do
 275         marr <- newArray lu init; return (IOUArray marr)
 276     {-# INLINE newArray_ #-}
 277     newArray_ lu = stToIO $ do
 278         marr <- newArray_ lu; return (IOUArray marr)
 279     {-# INLINE unsafeRead #-}
 280     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 281     {-# INLINE unsafeWrite #-}
 282     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 283
 284 instance MArray IOUArray Word16 IO where
 285     {-# INLINE newArray #-}
 286     newArray lu init = stToIO $ do
 287         marr <- newArray lu init; return (IOUArray marr)
 288     {-# INLINE newArray_ #-}
 289     newArray_ lu = stToIO $ do
 290         marr <- newArray_ lu; return (IOUArray marr)
 291     {-# INLINE unsafeRead #-}
 292     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 293     {-# INLINE unsafeWrite #-}
 294     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 295
 296 instance MArray IOUArray Word32 IO where
 297     {-# INLINE newArray #-}
 298     newArray lu init = stToIO $ do
 299         marr <- newArray lu init; return (IOUArray marr)
 300     {-# INLINE newArray_ #-}
 301     newArray_ lu = stToIO $ do
 302         marr <- newArray_ lu; return (IOUArray marr)
 303     {-# INLINE unsafeRead #-}
 304     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 305     {-# INLINE unsafeWrite #-}
 306     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 307
 308 instance MArray IOUArray Word64 IO where
 309     {-# INLINE newArray #-}
 310     newArray lu init = stToIO $ do
 311         marr <- newArray lu init; return (IOUArray marr)
 312     {-# INLINE newArray_ #-}
 313     newArray_ lu = stToIO $ do
 314         marr <- newArray_ lu; return (IOUArray marr)
 315     {-# INLINE unsafeRead #-}
 316     unsafeRead (IOUArray marr) i = stToIO (unsafeRead marr i)
 317     {-# INLINE unsafeWrite #-}
 318     unsafeWrite (IOUArray marr) i e = stToIO (unsafeWrite marr i e)
 319
 320 #endif /* __GLASGOW_HASKELL__ */