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 ff81405..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
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Word

@@ -14,18 +15,16 @@
 -----------------------------------------------------------------------------
 
 module Data.Word
 -----------------------------------------------------------------------------
 
 module Data.Word

-  ( 
-       -- * Unsigned integral types
+  (
+        -- * Unsigned integral types

 
 

-#ifndef __HUGS__
-       Word,
-#endif
-       Word8, Word16, Word32, Word64,
-       
-       -- * Notes
-       
-       -- $notes
-       ) where
+        Word,
+        Word8, Word16, Word32, Word64,
+
+        -- * Notes
+
+        -- $notes
+        ) where

 
 #ifdef __GLASGOW_HASKELL__
 import GHC.Word
 
 #ifdef __GLASGOW_HASKELL__
 import GHC.Word

@@ -35,25 +34,31 @@ import GHC.Word
 import Hugs.Word
 #endif
 
 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
 {- $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
   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.
 
   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.
 
   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
   over the various 'Word' types defined here.
 
 * Right and left shifts by amounts greater than or equal to the width