add GHC.HetMet.{hetmet_kappa,hetmet_kappa_app}

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

diff --git a/Data/Word.hs b/Data/Word.hs
index 3bcc8a7..18300d2 100644 (file)
--- a/Data/Word.hs
+++ b/Data/Word.hs
@@ -1,4 +1,5 @@
-{-# OPTIONS -fno-implicit-prelude #-}
+{-# LANGUAGE CPP, NoImplicitPrelude #-}
+
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Word
@@ -14,16 +15,16 @@
 -----------------------------------------------------------------------------
 
 module Data.Word
-  ( 
-       -- * Unsigned integral types
+  (
+        -- * Unsigned integral types
+
+        Word,
+        Word8, Word16, Word32, Word64,
+
+        -- * Notes
 
-       Word,
-       Word8, Word16, Word32, Word64,
-       
-       -- * Notes
-       
-       -- $notes
-       ) where
+        -- $notes
+        ) where
 
 #ifdef __GLASGOW_HASKELL__
 import GHC.Word
@@ -33,25 +34,31 @@ import GHC.Word
 import Hugs.Word
 #endif
 
+#ifdef __NHC__
+import NHC.FFI (Word8, Word16, Word32, Word64)
+import NHC.SizedTypes (Word8, Word16, Word32, Word64)   -- instances of Bits
+type Word = Word32
+#endif
+
 {- $notes
 
 * All arithmetic is performed modulo 2^n, where n is the number of
-  bits in the type.  One non-obvious consequence of this is that 'negate'
+  bits in the type.  One non-obvious consequence of this is that 'Prelude.negate'
   should /not/ raise an error on negative arguments.
 
 * For coercing between any two integer types, use
-  'fromIntegral', which is specialized for all the
+  'Prelude.fromIntegral', which is specialized for all the
   common cases so should be fast enough.  Coercing word types to and
   from integer types preserves representation, not sign.
 
-* It would be very natural to add a type 'Natural' providing an unbounded 
-  size unsigned integer, just as 'Integer' provides unbounded
+* It would be very natural to add a type @Natural@ providing an unbounded 
+  size unsigned integer, just as 'Prelude.Integer' provides unbounded
   size signed integers.  We do not do that yet since there is no demand
   for it.
 
-* The rules that hold for 'Enum' instances over a bounded type
-  such as 'Int' (see the section of the Haskell report dealing
-  with arithmetic sequences) also hold for the 'Enum' instances
+* The rules that hold for 'Prelude.Enum' instances over a bounded type
+  such as 'Prelude.Int' (see the section of the Haskell report dealing
+  with arithmetic sequences) also hold for the 'Prelude.Enum' instances
   over the various 'Word' types defined here.
 
 * Right and left shifts by amounts greater than or equal to the width