nhc only: expose Foldable and Traversable instances of Array

[ghc-base.git] / Data / Typeable.hs

diff --git a/Data/Typeable.hs b/Data/Typeable.hs
index aae61fe..ee9e89a 100644 (file)
--- a/Data/Typeable.hs
+++ b/Data/Typeable.hs
@@ -83,7 +83,6 @@ module Data.Typeable
 
 import qualified Data.HashTable as HT
 import Data.Maybe
-import Data.Either
 import Data.Int
 import Data.Word
 import Data.List( foldl, intersperse )
@@ -91,21 +90,20 @@ import Unsafe.Coerce
 
 #ifdef __GLASGOW_HASKELL__
 import GHC.Base
-import GHC.Show
-import GHC.Err
-import GHC.Num
-import GHC.Float
+import GHC.Show         (Show(..), ShowS,
+                         shows, showString, showChar, showParen)
+import GHC.Err          (undefined)
+import GHC.Num          (Integer, fromInteger, (+))
 import GHC.Real         ( rem, Ratio )
 import GHC.IOBase       (IORef,newIORef,unsafePerformIO)
 
 -- These imports are so we can define Typeable instances
 -- It'd be better to give Typeable instances in the modules themselves
 -- but they all have to be compiled before Typeable
-import GHC.IOBase       ( IO, MVar, Handle, block )
+import GHC.IOBase       ( IOArray, IO, MVar, Handle, block )
 import GHC.ST           ( ST )
 import GHC.STRef        ( STRef )
 import GHC.Ptr          ( Ptr, FunPtr )
-import GHC.ForeignPtr   ( ForeignPtr )
 import GHC.Stable       ( StablePtr, newStablePtr, freeStablePtr,
                           deRefStablePtr, castStablePtrToPtr,
                           castPtrToStablePtr )
@@ -115,18 +113,17 @@ import GHC.Arr          ( Array, STArray )
 
 #ifdef __HUGS__
 import Hugs.Prelude     ( Key(..), TypeRep(..), TyCon(..), Ratio,
-                          Exception, ArithException, IOException,
-                          ArrayException, AsyncException, Handle,
-                          Ptr, FunPtr, ForeignPtr, StablePtr )
+                          Handle, Ptr, FunPtr, ForeignPtr, StablePtr )
 import Hugs.IORef       ( IORef, newIORef, readIORef, writeIORef )
 import Hugs.IOExts      ( unsafePerformIO )
         -- For the Typeable instance
 import Hugs.Array       ( Array )
+import Hugs.IOArray
 import Hugs.ConcBase    ( MVar )
 #endif
 
 #ifdef __NHC__
-import NHC.IOExtras (IORef,newIORef,readIORef,writeIORef,unsafePerformIO)
+import NHC.IOExtras (IOArray,IORef,newIORef,readIORef,writeIORef,unsafePerformIO)
 import IO (Handle)
 import Ratio (Ratio)
         -- For the Typeable instance
@@ -487,7 +484,6 @@ INSTANCE_TYPEABLE0((),unitTc,"()")
 INSTANCE_TYPEABLE1([],listTc,"[]")
 INSTANCE_TYPEABLE1(Maybe,maybeTc,"Maybe")
 INSTANCE_TYPEABLE1(Ratio,ratioTc,"Ratio")
-INSTANCE_TYPEABLE2(Either,eitherTc,"Either")
 INSTANCE_TYPEABLE2((->),funTc,"->")
 INSTANCE_TYPEABLE1(IO,ioTc,"IO")
 
@@ -496,8 +492,8 @@ INSTANCE_TYPEABLE1(IO,ioTc,"IO")
 INSTANCE_TYPEABLE1(MVar,mvarTc,"MVar" )
 #endif
 
--- Types defined in GHC.Arr
 INSTANCE_TYPEABLE2(Array,arrayTc,"Array")
+INSTANCE_TYPEABLE2(IOArray,iOArrayTc,"IOArray")
 
 #ifdef __GLASGOW_HASKELL__
 -- Hugs has these too, but their Typeable<n> instances are defined
@@ -540,7 +536,6 @@ instance Typeable7 (,,,,,,) where
 
 INSTANCE_TYPEABLE1(Ptr,ptrTc,"Ptr")
 INSTANCE_TYPEABLE1(FunPtr,funPtrTc,"FunPtr")
-INSTANCE_TYPEABLE1(ForeignPtr,foreignPtrTc,"ForeignPtr")
 INSTANCE_TYPEABLE1(StablePtr,stablePtrTc,"StablePtr")
 INSTANCE_TYPEABLE1(IORef,iORefTc,"IORef")