[project @ 2001-08-04 06:11:24 by ken]

[ghc-hetmet.git] / ghc / lib / std / PrelEnum.lhs

diff --git a/ghc/lib/std/PrelEnum.lhs b/ghc/lib/std/PrelEnum.lhs
index 2ace283..c0874a3 100644 (file)
--- a/ghc/lib/std/PrelEnum.lhs
+++ b/ghc/lib/std/PrelEnum.lhs
@@ -1,6 +1,9 @@
+% -----------------------------------------------------------------------------
+% $Id: PrelEnum.lhs,v 1.14 2001/07/24 06:31:35 ken Exp $
 %
-% (c) The GRASP/AQUA Project, Glasgow University, 1992-1996
+% (c) The University of Glasgow, 1992-2000
 %
+
 \section[PrelBounded]{Module @PrelBounded@}
 
 Instances of Bounded for various datatypes.
@@ -10,7 +13,7 @@ Instances of Bounded for various datatypes.
 
 module PrelEnum(
        Bounded(..), Enum(..),
-       enumFromBounded, enumFromThenBounded,
+       boundedEnumFrom, boundedEnumFromThen,
 
        -- Instances for Bounded and Eum: (), Char, Int
 
@@ -19,6 +22,8 @@ module PrelEnum(
 import {-# SOURCE #-} PrelErr ( error )
 import PrelBase
 import PrelTup ()      -- To make sure we look for the .hi file
+
+default ()             -- Double isn't available yet
 \end{code}
 
 
@@ -49,11 +54,11 @@ class  Enum a       where
     enumFromThenTo x1 x2 y = map toEnum [fromEnum x1, fromEnum x2 .. fromEnum y]
 
 -- Default methods for bounded enumerations
-enumFromBounded :: (Enum a, Bounded a) => a -> [a]
-enumFromBounded n = map toEnum [fromEnum n .. fromEnum (maxBound `asTypeOf` n)]
+boundedEnumFrom :: (Enum a, Bounded a) => a -> [a]
+boundedEnumFrom n = map toEnum [fromEnum n .. fromEnum (maxBound `asTypeOf` n)]
 
-enumFromThenBounded :: (Enum a, Bounded a) => a -> a -> [a]
-enumFromThenBounded n1 n2 
+boundedEnumFromThen :: (Enum a, Bounded a) => a -> a -> [a]
+boundedEnumFromThen n1 n2 
   | i_n2 >= i_n1  = map toEnum [i_n1, i_n2 .. fromEnum (maxBound `asTypeOf` n1)]
   | otherwise     = map toEnum [i_n1, i_n2 .. fromEnum (minBound `asTypeOf` n1)]
   where
@@ -128,8 +133,8 @@ instance Enum Bool where
   fromEnum True  = oneInt
 
   -- Use defaults for the rest
-  enumFrom     = enumFromBounded
-  enumFromThen = enumFromThenBounded
+  enumFrom     = boundedEnumFrom
+  enumFromThen = boundedEnumFromThen
 \end{code}
 
 %*********************************************************
@@ -162,8 +167,8 @@ instance Enum Ordering where
   fromEnum GT = twoInt
 
   -- Use defaults for the rest
-  enumFrom     = enumFromBounded
-  enumFromThen = enumFromThenBounded
+  enumFrom     = boundedEnumFrom
+  enumFromThen = boundedEnumFromThen
 \end{code}
 
 %*********************************************************
@@ -175,11 +180,11 @@ instance Enum Ordering where
 \begin{code}
 instance  Bounded Char  where
     minBound =  '\0'
-    maxBound =  '\255'
+    maxBound =  '\x10FFFF'
 
 instance  Enum Char  where
     succ (C# c#)
-       | not (ord# c# ==# 255#) = C# (chr# (ord# c# +# 1#))
+       | not (ord# c# ==# 0x10FFFF#) = C# (chr# (ord# c# +# 1#))
        | otherwise             = error ("Prelude.Enum.Char.succ: bad argument")
     pred (C# c#)
        | not (ord# c# ==# 0#)   = C# (chr# (ord# c# -# 1#))
@@ -189,17 +194,32 @@ instance  Enum Char  where
     fromEnum = ord
 
     {-# INLINE enumFrom #-}
-    enumFrom (C# x) = build (\ c n -> eftCharFB c n (ord# x) 255#)
+    enumFrom (C# x) = eftChar (ord# x) 0x10FFFF#
        -- Blarg: technically I guess enumFrom isn't strict!
 
     {-# INLINE enumFromTo #-}
-    enumFromTo (C# x) (C# y) = build (\ c n -> eftCharFB c n (ord# x) (ord# y))
-
+    enumFromTo (C# x) (C# y) = eftChar (ord# x) (ord# y)
+    
     {-# INLINE enumFromThen #-}
-    enumFromThen (C# x1) (C# x2) = build (\ c n -> efdCharFB c n (ord# x1) (ord# x2))
-
+    enumFromThen (C# x1) (C# x2) = efdChar (ord# x1) (ord# x2)
+    
     {-# INLINE enumFromThenTo #-}
-    enumFromThenTo (C# x1) (C# x2) (C# y) = build (\ c n -> efdtCharFB c n (ord# x1) (ord# x2) (ord# y))
+    enumFromThenTo (C# x1) (C# x2) (C# y) = efdtChar (ord# x1) (ord# x2) (ord# y)
+
+eftChar  = eftCharList
+efdChar  = efdCharList
+efdtChar = efdtCharList
+
+
+{-# RULES
+"eftChar"      forall x y.     eftChar x y       = build (\c n -> eftCharFB c n x y)
+"efdChar"      forall x1 x2.   efdChar x1 x2     = build (\ c n -> efdCharFB c n x1 x2)
+"efdtChar"     forall x1 x2 l. efdtChar x1 x2 l  = build (\ c n -> efdtCharFB c n x1 x2 l)
+"eftCharList"  eftCharFB  (:) [] = eftCharList
+"efdCharList"  efdCharFB  (:) [] = efdCharList
+"efdtCharList" efdtCharFB (:) [] = efdtCharList
+ #-}
+
 
 -- We can do better than for Ints because we don't
 -- have hassles about arithmetic overflow at maxBound
@@ -215,13 +235,13 @@ eftCharList x y | x ># y    = []
 
 -- For enumFromThenTo we give up on inlining
 efdCharFB c n x1 x2
-  | delta >=# 0# = go_up_char_fb c n x1 delta 255#
+  | delta >=# 0# = go_up_char_fb c n x1 delta 0x10FFFF#
   | otherwise    = go_dn_char_fb c n x1 delta 0#
   where
     delta = x2 -# x1
 
 efdCharList x1 x2
-  | delta >=# 0# = go_up_char_list x1 delta 255#
+  | delta >=# 0# = go_up_char_list x1 delta 0x10FFFF#
   | otherwise    = go_dn_char_list x1 delta 0#
   where
     delta = x2 -# x1
@@ -261,13 +281,6 @@ go_dn_char_list x delta lim
   where
     go_dn x | x <# lim  = []
            | otherwise = C# (chr# x) : go_dn (x +# delta)
-
-
-{-# RULES
-"eftCharList"  eftCharFB  (:) [] = eftCharList
-"efdCharList"  efdCharFB  (:) [] = efdCharList
-"efdtCharList" efdtCharFB (:) [] = efdtCharList
- #-}
 \end{code}
 
 
@@ -301,17 +314,32 @@ instance  Enum Int  where
     fromEnum x = x
 
     {-# INLINE enumFrom #-}
-    enumFrom (I# x) = build (\ c n -> eftIntFB c n x 2147483647#)
+    enumFrom (I# x) = case maxInt of I# y -> eftInt x y
        -- Blarg: technically I guess enumFrom isn't strict!
 
     {-# INLINE enumFromTo #-}
-    enumFromTo (I# x) (I# y) = build (\ c n -> eftIntFB c n x y)
+    enumFromTo (I# x) (I# y) = eftInt x y
 
     {-# INLINE enumFromThen #-}
-    enumFromThen (I# x1) (I# x2) = build (\ c n -> efdIntFB c n x1 x2)
+    enumFromThen (I# x1) (I# x2) = efdInt x1 x2
 
     {-# INLINE enumFromThenTo #-}
-    enumFromThenTo (I# x1) (I# x2) (I# y) = build (\ c n -> efdtIntFB c n x1 x2 y)
+    enumFromThenTo (I# x1) (I# x2) (I# y) = efdtInt x1 x2 y
+
+eftInt         = eftIntList
+efdInt         = efdIntList
+efdtInt = efdtIntList
+
+{-# RULES
+"eftInt"       forall x y.     eftInt x y       = build (\ c n -> eftIntFB c n x y)
+"efdInt"       forall x1 x2.   efdInt x1 x2     = build (\ c n -> efdIntFB c n x1 x2)
+"efdtInt"      forall x1 x2 l. efdtInt x1 x2 l  = build (\ c n -> efdtIntFB c n x1 x2 l)
+
+"eftIntList"   eftIntFB  (:) [] = eftIntList
+"efdIntList"   efdIntFB  (:) [] = efdIntList
+"efdtIntList"  efdtIntFB (:) [] = efdtIntList
+ #-}
+
 
 {-# INLINE eftIntFB #-}
 eftIntFB c n x y | x ># y    = n       
@@ -346,14 +374,14 @@ efdtIntList x1 x2 y
     lim   = y -# delta
 
 efdIntFB c n x1 x2
-  | delta >=# 0# = go_up_int_fb c n x1 delta (  2147483647#  -# delta)
-  | otherwise    = go_dn_int_fb c n x1 delta ((-2147483648#) -# delta)
+  | delta >=# 0# = case maxInt of I# y -> go_up_int_fb c n x1 delta (y -# delta)
+  | otherwise    = case minInt of I# y -> go_dn_int_fb c n x1 delta (y -# delta)
   where
     delta = x2 -# x1
 
 efdIntList x1 x2
-  | delta >=# 0# = go_up_int_list x1 delta (  2147483647#  -# delta)
-  | otherwise    = go_dn_int_list x1 delta ((-2147483648#) -# delta)
+  | delta >=# 0# = case maxInt of I# y -> go_up_int_list x1 delta (y -# delta)
+  | otherwise    = case minInt of I# y -> go_dn_int_list x1 delta (y -# delta)
   where
     delta = x2 -# x1
 
@@ -382,12 +410,5 @@ go_dn_int_list x delta lim
   where
     go_dn x | x <# lim  = [I# x]
            | otherwise = I# x : go_dn (x +# delta)
-
-
-{-# RULES
-"eftIntList"   eftIntFB  (:) [] = eftIntList
-"efdIntList"   efdIntFB  (:) [] = efdIntList
-"efdtIntList"  efdtIntFB (:) [] = efdtIntList
- #-}
 \end{code}