[project @ 2001-03-28 22:14:02 by qrczak]

Fix Enum instances for types larger than Int.

diff --git a/ghc/lib/std/PrelInt.lhs b/ghc/lib/std/PrelInt.lhs
index d6412b4..728f262 100644 (file)
--- a/ghc/lib/std/PrelInt.lhs
+++ b/ghc/lib/std/PrelInt.lhs
@@ -393,6 +393,8 @@ instance Enum Int64 where
         | otherwise     = fromEnumError "Int64" x
     enumFrom            = integralEnumFrom
     enumFromThen        = integralEnumFromThen
+    enumFromTo          = integralEnumFromTo
+    enumFromThenTo      = integralEnumFromThenTo
 
 instance Integral Int64 where
     quot    x@(I64# x#) y@(I64# y#)

diff --git a/ghc/lib/std/PrelReal.lhs b/ghc/lib/std/PrelReal.lhs
index 5452cc5..a8e5651 100644 (file)
--- a/ghc/lib/std/PrelReal.lhs
+++ b/ghc/lib/std/PrelReal.lhs
@@ -1,5 +1,5 @@
 % ------------------------------------------------------------------------------
-% $Id: PrelReal.lhs,v 1.11 2001/03/01 19:10:16 qrczak Exp $
+% $Id: PrelReal.lhs,v 1.12 2001/03/28 22:14:02 qrczak Exp $
 %
 % (c) The University of Glasgow, 1994-2000
 %
@@ -353,10 +353,17 @@ integralEnumFrom :: (Integral a, Bounded a) => a -> [a]
 integralEnumFrom n = map fromInteger [toInteger n .. toInteger (maxBound `asTypeOf` n)]
 
 integralEnumFromThen :: (Integral a, Bounded a) => a -> a -> [a]
-integralEnumFromThen n1 n2 
+integralEnumFromThen n1 n2
   | i_n2 >= i_n1  = map fromInteger [i_n1, i_n2 .. toInteger (maxBound `asTypeOf` n1)]
   | otherwise     = map fromInteger [i_n1, i_n2 .. toInteger (minBound `asTypeOf` n1)]
   where
     i_n1 = toInteger n1
     i_n2 = toInteger n2
+
+integralEnumFromTo :: (Integral a, Bounded a) => a -> a -> [a]
+integralEnumFromTo n m = map fromInteger [toInteger n .. toInteger m]
+
+integralEnumFromThenTo :: (Integral a, Bounded a) => a -> a -> a -> [a]
+integralEnumFromThenTo n1 n2 m
+  = map fromInteger [toInteger n1, toInteger n2 .. toInteger m]
 \end{code}

diff --git a/ghc/lib/std/PrelWord.lhs b/ghc/lib/std/PrelWord.lhs
index 4cac193..f5f0d99 100644 (file)
--- a/ghc/lib/std/PrelWord.lhs
+++ b/ghc/lib/std/PrelWord.lhs
@@ -98,6 +98,8 @@ instance Enum Word where
         | otherwise     = fromEnumError "Word" x
     enumFrom            = integralEnumFrom
     enumFromThen        = integralEnumFromThen
+    enumFromTo          = integralEnumFromTo
+    enumFromThenTo      = integralEnumFromThenTo
 
 instance Integral Word where
     quot    x@(W# x#) y@(W# y#)
@@ -421,14 +423,16 @@ instance Enum Word32 where
                         = W32# (int2Word# i#)
         | otherwise     = toEnumError "Word32" i (minBound::Word32, maxBound::Word32)
 #if WORD_SIZE_IN_BYTES == 4
-    fromEnum (W32# x#)  = I# (word2Int# x#)
-    enumFrom            = integralEnumFrom
-    enumFromThen        = integralEnumFromThen
-#else
     fromEnum x@(W32# x#)
         | x <= fromIntegral (maxBound::Int)
                         = I# (word2Int# x#)
         | otherwise     = fromEnumError "Word32" x
+    enumFrom            = integralEnumFrom
+    enumFromThen        = integralEnumFromThen
+    enumFromTo          = integralEnumFromTo
+    enumFromThenTo      = integralEnumFromThenTo
+#else
+    fromEnum (W32# x#)  = I# (word2Int# x#)
     enumFrom            = boundedEnumFrom
     enumFromThen        = boundedEnumFromThen
 #endif
@@ -545,6 +549,8 @@ instance Enum Word64 where
         | otherwise     = fromEnumError "Word64" x
     enumFrom            = integralEnumFrom
     enumFromThen        = integralEnumFromThen
+    enumFromTo          = integralEnumFromTo
+    enumFromThenTo      = integralEnumFromThenTo
 
 instance Integral Word64 where
     quot    x@(W64# x#) y@(W64# y#)
@@ -647,6 +653,8 @@ instance Enum Word64 where
         | otherwise     = fromEnumError "Word64" x
     enumFrom            = integralEnumFrom
     enumFromThen        = integralEnumFromThen
+    enumFromTo          = integralEnumFromTo
+    enumFromThenTo      = integralEnumFromThenTo
 
 instance Integral Word64 where
     quot    x@(W64# x#) y@(W64# y#)