One more GHC.Err import eliminated
[packages/base.git] / GHC / Enum.lhs
1 \begin{code}
2 {-# LANGUAGE Trustworthy #-}
3 {-# LANGUAGE NoImplicitPrelude, BangPatterns, MagicHash #-}
4 {-# OPTIONS_HADDOCK hide #-}
5
6 -----------------------------------------------------------------------------
7 -- |
8 -- Module      :  GHC.Enum
9 -- Copyright   :  (c) The University of Glasgow, 1992-2002
10 -- License     :  see libraries/base/LICENSE
11 -- 
12 -- Maintainer  :  cvs-ghc@haskell.org
13 -- Stability   :  internal
14 -- Portability :  non-portable (GHC extensions)
15 --
16 -- The 'Enum' and 'Bounded' classes.
17 -- 
18 -----------------------------------------------------------------------------
19
20 -- #hide
21 module GHC.Enum(
22         Bounded(..), Enum(..),
23         boundedEnumFrom, boundedEnumFromThen,
24         toEnumError, fromEnumError, succError, predError,
25
26         -- Instances for Bounded and Enum: (), Char, Int
27
28    ) where
29
30 import GHC.Base
31 import GHC.Char
32 import GHC.Integer
33 import GHC.Num
34 import GHC.Show
35 default ()              -- Double isn't available yet
36 \end{code}
37
38
39 %*********************************************************
40 %*                                                      *
41 \subsection{Class declarations}
42 %*                                                      *
43 %*********************************************************
44
45 \begin{code}
46 -- | The 'Bounded' class is used to name the upper and lower limits of a
47 -- type.  'Ord' is not a superclass of 'Bounded' since types that are not
48 -- totally ordered may also have upper and lower bounds.
49 --
50 -- The 'Bounded' class may be derived for any enumeration type;
51 -- 'minBound' is the first constructor listed in the @data@ declaration
52 -- and 'maxBound' is the last.
53 -- 'Bounded' may also be derived for single-constructor datatypes whose
54 -- constituent types are in 'Bounded'.
55
56 class  Bounded a  where
57     minBound, maxBound :: a
58
59 -- | Class 'Enum' defines operations on sequentially ordered types.
60 --
61 -- The @enumFrom@... methods are used in Haskell's translation of
62 -- arithmetic sequences.
63 --
64 -- Instances of 'Enum' may be derived for any enumeration type (types
65 -- whose constructors have no fields).  The nullary constructors are
66 -- assumed to be numbered left-to-right by 'fromEnum' from @0@ through @n-1@.
67 -- See Chapter 10 of the /Haskell Report/ for more details.
68 --  
69 -- For any type that is an instance of class 'Bounded' as well as 'Enum',
70 -- the following should hold:
71 --
72 -- * The calls @'succ' 'maxBound'@ and @'pred' 'minBound'@ should result in
73 --   a runtime error.
74 -- 
75 -- * 'fromEnum' and 'toEnum' should give a runtime error if the 
76 --   result value is not representable in the result type.
77 --   For example, @'toEnum' 7 :: 'Bool'@ is an error.
78 --
79 -- * 'enumFrom' and 'enumFromThen' should be defined with an implicit bound,
80 --   thus:
81 --
82 -- >    enumFrom     x   = enumFromTo     x maxBound
83 -- >    enumFromThen x y = enumFromThenTo x y bound
84 -- >      where
85 -- >        bound | fromEnum y >= fromEnum x = maxBound
86 -- >              | otherwise                = minBound
87 --
88 class  Enum a   where
89     -- | the successor of a value.  For numeric types, 'succ' adds 1.
90     succ                :: a -> a
91     -- | the predecessor of a value.  For numeric types, 'pred' subtracts 1.
92     pred                :: a -> a
93     -- | Convert from an 'Int'.
94     toEnum              :: Int -> a
95     -- | Convert to an 'Int'.
96     -- It is implementation-dependent what 'fromEnum' returns when
97     -- applied to a value that is too large to fit in an 'Int'.
98     fromEnum            :: a -> Int
99
100     -- | Used in Haskell's translation of @[n..]@.
101     enumFrom            :: a -> [a]
102     -- | Used in Haskell's translation of @[n,n'..]@.
103     enumFromThen        :: a -> a -> [a]
104     -- | Used in Haskell's translation of @[n..m]@.
105     enumFromTo          :: a -> a -> [a]
106     -- | Used in Haskell's translation of @[n,n'..m]@.
107     enumFromThenTo      :: a -> a -> a -> [a]
108
109     succ                   = toEnum . (+ 1)  . fromEnum
110     pred                   = toEnum . (subtract 1) . fromEnum
111     enumFrom x             = map toEnum [fromEnum x ..]
112     enumFromThen x y       = map toEnum [fromEnum x, fromEnum y ..]
113     enumFromTo x y         = map toEnum [fromEnum x .. fromEnum y]
114     enumFromThenTo x1 x2 y = map toEnum [fromEnum x1, fromEnum x2 .. fromEnum y]
115
116 -- Default methods for bounded enumerations
117 boundedEnumFrom :: (Enum a, Bounded a) => a -> [a]
118 boundedEnumFrom n = map toEnum [fromEnum n .. fromEnum (maxBound `asTypeOf` n)]
119
120 boundedEnumFromThen :: (Enum a, Bounded a) => a -> a -> [a]
121 boundedEnumFromThen n1 n2 
122   | i_n2 >= i_n1  = map toEnum [i_n1, i_n2 .. fromEnum (maxBound `asTypeOf` n1)]
123   | otherwise     = map toEnum [i_n1, i_n2 .. fromEnum (minBound `asTypeOf` n1)]
124   where
125     i_n1 = fromEnum n1
126     i_n2 = fromEnum n2
127 \end{code}
128
129 \begin{code}
130 ------------------------------------------------------------------------
131 -- Helper functions
132 ------------------------------------------------------------------------
133
134 {-# NOINLINE toEnumError #-}
135 toEnumError :: (Show a) => String -> Int -> (a,a) -> b
136 toEnumError inst_ty i bnds =
137     error $ "Enum.toEnum{" ++ inst_ty ++ "}: tag (" ++
138             show i ++
139             ") is outside of bounds " ++
140             show bnds
141
142 {-# NOINLINE fromEnumError #-}
143 fromEnumError :: (Show a) => String -> a -> b
144 fromEnumError inst_ty x =
145     error $ "Enum.fromEnum{" ++ inst_ty ++ "}: value (" ++
146             show x ++
147             ") is outside of Int's bounds " ++
148             show (minBound::Int, maxBound::Int)
149
150 {-# NOINLINE succError #-}
151 succError :: String -> a
152 succError inst_ty =
153     error $ "Enum.succ{" ++ inst_ty ++ "}: tried to take `succ' of maxBound"
154
155 {-# NOINLINE predError #-}
156 predError :: String -> a
157 predError inst_ty =
158     error $ "Enum.pred{" ++ inst_ty ++ "}: tried to take `pred' of minBound"
159 \end{code}
160
161
162 %*********************************************************
163 %*                                                      *
164 \subsection{Tuples}
165 %*                                                      *
166 %*********************************************************
167
168 \begin{code}
169 instance Bounded () where
170     minBound = ()
171     maxBound = ()
172
173 instance Enum () where
174     succ _      = error "Prelude.Enum.().succ: bad argument"
175     pred _      = error "Prelude.Enum.().pred: bad argument"
176
177     toEnum x | x == 0    = ()
178              | otherwise = error "Prelude.Enum.().toEnum: bad argument"
179
180     fromEnum () = 0
181     enumFrom ()         = [()]
182     enumFromThen () ()  = let many = ():many in many
183     enumFromTo () ()    = [()]
184     enumFromThenTo () () () = let many = ():many in many
185 \end{code}
186
187 \begin{code}
188 -- Report requires instances up to 15
189 instance (Bounded a, Bounded b) => Bounded (a,b) where
190    minBound = (minBound, minBound)
191    maxBound = (maxBound, maxBound)
192
193 instance (Bounded a, Bounded b, Bounded c) => Bounded (a,b,c) where
194    minBound = (minBound, minBound, minBound)
195    maxBound = (maxBound, maxBound, maxBound)
196
197 instance (Bounded a, Bounded b, Bounded c, Bounded d) => Bounded (a,b,c,d) where
198    minBound = (minBound, minBound, minBound, minBound)
199    maxBound = (maxBound, maxBound, maxBound, maxBound)
200
201 instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e) => Bounded (a,b,c,d,e) where
202    minBound = (minBound, minBound, minBound, minBound, minBound)
203    maxBound = (maxBound, maxBound, maxBound, maxBound, maxBound)
204
205 instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f)
206         => Bounded (a,b,c,d,e,f) where
207    minBound = (minBound, minBound, minBound, minBound, minBound, minBound)
208    maxBound = (maxBound, maxBound, maxBound, maxBound, maxBound, maxBound)
209
210 instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g)
211         => Bounded (a,b,c,d,e,f,g) where
212    minBound = (minBound, minBound, minBound, minBound, minBound, minBound, minBound)
213    maxBound = (maxBound, maxBound, maxBound, maxBound, maxBound, maxBound, maxBound)
214
215 instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g,
216           Bounded h)
217         => Bounded (a,b,c,d,e,f,g,h) where
218    minBound = (minBound, minBound, minBound, minBound, minBound, minBound, minBound, minBound)
219    maxBound = (maxBound, maxBound, maxBound, maxBound, maxBound, maxBound, maxBound, maxBound)
220
221 instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g,
222           Bounded h, Bounded i)
223         => Bounded (a,b,c,d,e,f,g,h,i) where
224    minBound = (minBound, minBound, minBound, minBound, minBound, minBound, minBound, minBound,
225                minBound)
226    maxBound = (maxBound, maxBound, maxBound, maxBound, maxBound, maxBound, maxBound, maxBound,
227                maxBound)
228
229 instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g,
230           Bounded h, Bounded i, Bounded j)
231         => Bounded (a,b,c,d,e,f,g,h,i,j) where
232    minBound = (minBound, minBound, minBound, minBound, minBound, minBound, minBound, minBound,
233                minBound, minBound)
234    maxBound = (maxBound, maxBound, maxBound, maxBound, maxBound, maxBound, maxBound, maxBound,
235                maxBound, maxBound)
236
237 instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g,
238           Bounded h, Bounded i, Bounded j, Bounded k)
239         => Bounded (a,b,c,d,e,f,g,h,i,j,k) where
240    minBound = (minBound, minBound, minBound, minBound, minBound, minBound, minBound, minBound,
241                minBound, minBound, minBound)
242    maxBound = (maxBound, maxBound, maxBound, maxBound, maxBound, maxBound, maxBound, maxBound,
243                maxBound, maxBound, maxBound)
244
245 instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g,
246           Bounded h, Bounded i, Bounded j, Bounded k, Bounded l)
247         => Bounded (a,b,c,d,e,f,g,h,i,j,k,l) where
248    minBound = (minBound, minBound, minBound, minBound, minBound, minBound, minBound, minBound,
249                minBound, minBound, minBound, minBound)
250    maxBound = (maxBound, maxBound, maxBound, maxBound, maxBound, maxBound, maxBound, maxBound,
251                maxBound, maxBound, maxBound, maxBound)
252
253 instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g,
254           Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m)
255         => Bounded (a,b,c,d,e,f,g,h,i,j,k,l,m) where
256    minBound = (minBound, minBound, minBound, minBound, minBound, minBound, minBound, minBound,
257                minBound, minBound, minBound, minBound, minBound)
258    maxBound = (maxBound, maxBound, maxBound, maxBound, maxBound, maxBound, maxBound, maxBound,
259                maxBound, maxBound, maxBound, maxBound, maxBound)
260
261 instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g,
262           Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n)
263         => Bounded (a,b,c,d,e,f,g,h,i,j,k,l,m,n) where
264    minBound = (minBound, minBound, minBound, minBound, minBound, minBound, minBound, minBound,
265                minBound, minBound, minBound, minBound, minBound, minBound)
266    maxBound = (maxBound, maxBound, maxBound, maxBound, maxBound, maxBound, maxBound, maxBound,
267                maxBound, maxBound, maxBound, maxBound, maxBound, maxBound)
268
269 instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g,
270           Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n, Bounded o)
271         => Bounded (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) where
272    minBound = (minBound, minBound, minBound, minBound, minBound, minBound, minBound, minBound,
273                minBound, minBound, minBound, minBound, minBound, minBound, minBound)
274    maxBound = (maxBound, maxBound, maxBound, maxBound, maxBound, maxBound, maxBound, maxBound,
275                maxBound, maxBound, maxBound, maxBound, maxBound, maxBound, maxBound)
276 \end{code}
277
278
279 %*********************************************************
280 %*                                                      *
281 \subsection{Type @Bool@}
282 %*                                                      *
283 %*********************************************************
284
285 \begin{code}
286 instance Bounded Bool where
287   minBound = False
288   maxBound = True
289
290 instance Enum Bool where
291   succ False = True
292   succ True  = error "Prelude.Enum.Bool.succ: bad argument"
293
294   pred True  = False
295   pred False  = error "Prelude.Enum.Bool.pred: bad argument"
296
297   toEnum n | n == 0    = False
298            | n == 1    = True
299            | otherwise = error "Prelude.Enum.Bool.toEnum: bad argument"
300
301   fromEnum False = 0
302   fromEnum True  = 1
303
304   -- Use defaults for the rest
305   enumFrom     = boundedEnumFrom
306   enumFromThen = boundedEnumFromThen
307 \end{code}
308
309 %*********************************************************
310 %*                                                      *
311 \subsection{Type @Ordering@}
312 %*                                                      *
313 %*********************************************************
314
315 \begin{code}
316 instance Bounded Ordering where
317   minBound = LT
318   maxBound = GT
319
320 instance Enum Ordering where
321   succ LT = EQ
322   succ EQ = GT
323   succ GT = error "Prelude.Enum.Ordering.succ: bad argument"
324
325   pred GT = EQ
326   pred EQ = LT
327   pred LT = error "Prelude.Enum.Ordering.pred: bad argument"
328
329   toEnum n | n == 0 = LT
330            | n == 1 = EQ
331            | n == 2 = GT
332   toEnum _ = error "Prelude.Enum.Ordering.toEnum: bad argument"
333
334   fromEnum LT = 0
335   fromEnum EQ = 1
336   fromEnum GT = 2
337
338   -- Use defaults for the rest
339   enumFrom     = boundedEnumFrom
340   enumFromThen = boundedEnumFromThen
341 \end{code}
342
343 %*********************************************************
344 %*                                                      *
345 \subsection{Type @Char@}
346 %*                                                      *
347 %*********************************************************
348
349 \begin{code}
350 instance  Bounded Char  where
351     minBound =  '\0'
352     maxBound =  '\x10FFFF'
353
354 instance  Enum Char  where
355     succ (C# c#)
356        | not (ord# c# ==# 0x10FFFF#) = C# (chr# (ord# c# +# 1#))
357        | otherwise              = error ("Prelude.Enum.Char.succ: bad argument")
358     pred (C# c#)
359        | not (ord# c# ==# 0#)   = C# (chr# (ord# c# -# 1#))
360        | otherwise              = error ("Prelude.Enum.Char.pred: bad argument")
361
362     toEnum   = chr
363     fromEnum = ord
364
365     {-# INLINE enumFrom #-}
366     enumFrom (C# x) = eftChar (ord# x) 0x10FFFF#
367         -- Blarg: technically I guess enumFrom isn't strict!
368
369     {-# INLINE enumFromTo #-}
370     enumFromTo (C# x) (C# y) = eftChar (ord# x) (ord# y)
371     
372     {-# INLINE enumFromThen #-}
373     enumFromThen (C# x1) (C# x2) = efdChar (ord# x1) (ord# x2)
374     
375     {-# INLINE enumFromThenTo #-}
376     enumFromThenTo (C# x1) (C# x2) (C# y) = efdtChar (ord# x1) (ord# x2) (ord# y)
377
378 {-# RULES
379 "eftChar"       [~1] forall x y.        eftChar x y       = build (\c n -> eftCharFB c n x y)
380 "efdChar"       [~1] forall x1 x2.      efdChar x1 x2     = build (\ c n -> efdCharFB c n x1 x2)
381 "efdtChar"      [~1] forall x1 x2 l.    efdtChar x1 x2 l  = build (\ c n -> efdtCharFB c n x1 x2 l)
382 "eftCharList"   [1]  eftCharFB  (:) [] = eftChar
383 "efdCharList"   [1]  efdCharFB  (:) [] = efdChar
384 "efdtCharList"  [1]  efdtCharFB (:) [] = efdtChar
385  #-}
386
387
388 -- We can do better than for Ints because we don't
389 -- have hassles about arithmetic overflow at maxBound
390 {-# INLINE [0] eftCharFB #-}
391 eftCharFB :: (Char -> a -> a) -> a -> Int# -> Int# -> a
392 eftCharFB c n x0 y = go x0
393                  where
394                     go x | x ># y    = n
395                          | otherwise = C# (chr# x) `c` go (x +# 1#)
396
397 {-# NOINLINE [1] eftChar #-}
398 eftChar :: Int# -> Int# -> String
399 eftChar x y | x ># y    = []
400             | otherwise = C# (chr# x) : eftChar (x +# 1#) y
401
402
403 -- For enumFromThenTo we give up on inlining
404 {-# NOINLINE [0] efdCharFB #-}
405 efdCharFB :: (Char -> a -> a) -> a -> Int# -> Int# -> a
406 efdCharFB c n x1 x2
407   | delta >=# 0# = go_up_char_fb c n x1 delta 0x10FFFF#
408   | otherwise    = go_dn_char_fb c n x1 delta 0#
409   where
410     !delta = x2 -# x1
411
412 {-# NOINLINE [1] efdChar #-}
413 efdChar :: Int# -> Int# -> String
414 efdChar x1 x2
415   | delta >=# 0# = go_up_char_list x1 delta 0x10FFFF#
416   | otherwise    = go_dn_char_list x1 delta 0#
417   where
418     !delta = x2 -# x1
419
420 {-# NOINLINE [0] efdtCharFB #-}
421 efdtCharFB :: (Char -> a -> a) -> a -> Int# -> Int# -> Int# -> a
422 efdtCharFB c n x1 x2 lim
423   | delta >=# 0# = go_up_char_fb c n x1 delta lim
424   | otherwise    = go_dn_char_fb c n x1 delta lim
425   where
426     !delta = x2 -# x1
427
428 {-# NOINLINE [1] efdtChar #-}
429 efdtChar :: Int# -> Int# -> Int# -> String
430 efdtChar x1 x2 lim
431   | delta >=# 0# = go_up_char_list x1 delta lim
432   | otherwise    = go_dn_char_list x1 delta lim
433   where
434     !delta = x2 -# x1
435
436 go_up_char_fb :: (Char -> a -> a) -> a -> Int# -> Int# -> Int# -> a
437 go_up_char_fb c n x0 delta lim
438   = go_up x0
439   where
440     go_up x | x ># lim  = n
441             | otherwise = C# (chr# x) `c` go_up (x +# delta)
442
443 go_dn_char_fb :: (Char -> a -> a) -> a -> Int# -> Int# -> Int# -> a
444 go_dn_char_fb c n x0 delta lim
445   = go_dn x0
446   where
447     go_dn x | x <# lim  = n
448             | otherwise = C# (chr# x) `c` go_dn (x +# delta)
449
450 go_up_char_list :: Int# -> Int# -> Int# -> String
451 go_up_char_list x0 delta lim
452   = go_up x0
453   where
454     go_up x | x ># lim  = []
455             | otherwise = C# (chr# x) : go_up (x +# delta)
456
457 go_dn_char_list :: Int# -> Int# -> Int# -> String
458 go_dn_char_list x0 delta lim
459   = go_dn x0
460   where
461     go_dn x | x <# lim  = []
462             | otherwise = C# (chr# x) : go_dn (x +# delta)
463 \end{code}
464
465
466 %*********************************************************
467 %*                                                      *
468 \subsection{Type @Int@}
469 %*                                                      *
470 %*********************************************************
471
472 Be careful about these instances.  
473         (a) remember that you have to count down as well as up e.g. [13,12..0]
474         (b) be careful of Int overflow
475         (c) remember that Int is bounded, so [1..] terminates at maxInt
476
477 \begin{code}
478 instance  Bounded Int where
479     minBound =  minInt
480     maxBound =  maxInt
481
482 instance  Enum Int  where
483     succ x  
484        | x == maxBound  = error "Prelude.Enum.succ{Int}: tried to take `succ' of maxBound"
485        | otherwise      = x + 1
486     pred x
487        | x == minBound  = error "Prelude.Enum.pred{Int}: tried to take `pred' of minBound"
488        | otherwise      = x - 1
489
490     toEnum   x = x
491     fromEnum x = x
492
493     {-# INLINE enumFrom #-}
494     enumFrom (I# x) = eftInt x maxInt#
495         where !(I# maxInt#) = maxInt
496         -- Blarg: technically I guess enumFrom isn't strict!
497
498     {-# INLINE enumFromTo #-}
499     enumFromTo (I# x) (I# y) = eftInt x y
500
501     {-# INLINE enumFromThen #-}
502     enumFromThen (I# x1) (I# x2) = efdInt x1 x2
503
504     {-# INLINE enumFromThenTo #-}
505     enumFromThenTo (I# x1) (I# x2) (I# y) = efdtInt x1 x2 y
506
507
508 -----------------------------------------------------
509 -- eftInt and eftIntFB deal with [a..b], which is the 
510 -- most common form, so we take a lot of care
511 -- In particular, we have rules for deforestation
512
513 {-# RULES
514 "eftInt"        [~1] forall x y. eftInt x y = build (\ c n -> eftIntFB c n x y)
515 "eftIntList"    [1] eftIntFB  (:) [] = eftInt
516  #-}
517
518 {-# NOINLINE [1] eftInt #-}
519 eftInt :: Int# -> Int# -> [Int]
520 -- [x1..x2]
521 eftInt x0 y | x0 ># y    = []
522             | otherwise = go x0
523                where
524                  go x = I# x : if x ==# y then [] else go (x +# 1#)
525
526 {-# INLINE [0] eftIntFB #-}
527 eftIntFB :: (Int -> r -> r) -> r -> Int# -> Int# -> r
528 eftIntFB c n x0 y | x0 ># y    = n        
529                   | otherwise = go x0
530                  where
531                    go x = I# x `c` if x ==# y then n else go (x +# 1#)
532                         -- Watch out for y=maxBound; hence ==, not >
533         -- Be very careful not to have more than one "c"
534         -- so that when eftInfFB is inlined we can inline
535         -- whatever is bound to "c"
536
537
538 -----------------------------------------------------
539 -- efdInt and efdtInt deal with [a,b..] and [a,b..c].
540 -- The code is more complicated because of worries about Int overflow.
541
542 {-# RULES
543 "efdtInt"       [~1] forall x1 x2 y.
544                      efdtInt x1 x2 y = build (\ c n -> efdtIntFB c n x1 x2 y)
545 "efdtIntUpList" [1]  efdtIntFB (:) [] = efdtInt
546  #-}
547
548 efdInt :: Int# -> Int# -> [Int]
549 -- [x1,x2..maxInt]
550 efdInt x1 x2 
551  | x2 >=# x1 = case maxInt of I# y -> efdtIntUp x1 x2 y
552  | otherwise = case minInt of I# y -> efdtIntDn x1 x2 y
553
554 {-# NOINLINE [1] efdtInt #-}
555 efdtInt :: Int# -> Int# -> Int# -> [Int]
556 -- [x1,x2..y]
557 efdtInt x1 x2 y
558  | x2 >=# x1 = efdtIntUp x1 x2 y
559  | otherwise = efdtIntDn x1 x2 y
560
561 {-# INLINE [0] efdtIntFB #-}
562 efdtIntFB :: (Int -> r -> r) -> r -> Int# -> Int# -> Int# -> r
563 efdtIntFB c n x1 x2 y
564  | x2 >=# x1  = efdtIntUpFB c n x1 x2 y
565  | otherwise  = efdtIntDnFB c n x1 x2 y
566
567 -- Requires x2 >= x1
568 efdtIntUp :: Int# -> Int# -> Int# -> [Int]
569 efdtIntUp x1 x2 y    -- Be careful about overflow!
570  | y <# x2   = if y <# x1 then [] else [I# x1]
571  | otherwise = -- Common case: x1 <= x2 <= y
572                let !delta = x2 -# x1 -- >= 0
573                    !y' = y -# delta  -- x1 <= y' <= y; hence y' is representable
574
575                    -- Invariant: x <= y
576                    -- Note that: z <= y' => z + delta won't overflow
577                    -- so we are guaranteed not to overflow if/when we recurse
578                    go_up x | x ># y'  = [I# x]
579                            | otherwise = I# x : go_up (x +# delta)
580                in I# x1 : go_up x2
581
582 -- Requires x2 >= x1
583 efdtIntUpFB :: (Int -> r -> r) -> r -> Int# -> Int# -> Int# -> r
584 efdtIntUpFB c n x1 x2 y    -- Be careful about overflow!
585  | y <# x2   = if y <# x1 then n else I# x1 `c` n
586  | otherwise = -- Common case: x1 <= x2 <= y
587                let !delta = x2 -# x1 -- >= 0
588                    !y' = y -# delta  -- x1 <= y' <= y; hence y' is representable
589
590                    -- Invariant: x <= y
591                    -- Note that: z <= y' => z + delta won't overflow
592                    -- so we are guaranteed not to overflow if/when we recurse
593                    go_up x | x ># y'   = I# x `c` n
594                            | otherwise = I# x `c` go_up (x +# delta)
595                in I# x1 `c` go_up x2
596
597 -- Requires x2 <= x1
598 efdtIntDn :: Int# -> Int# -> Int# -> [Int]
599 efdtIntDn x1 x2 y    -- Be careful about underflow!
600  | y ># x2   = if y ># x1 then [] else [I# x1]
601  | otherwise = -- Common case: x1 >= x2 >= y
602                let !delta = x2 -# x1 -- <= 0
603                    !y' = y -# delta  -- y <= y' <= x1; hence y' is representable
604
605                    -- Invariant: x >= y
606                    -- Note that: z >= y' => z + delta won't underflow
607                    -- so we are guaranteed not to underflow if/when we recurse
608                    go_dn x | x <# y'  = [I# x]
609                            | otherwise = I# x : go_dn (x +# delta)
610    in I# x1 : go_dn x2
611
612 -- Requires x2 <= x1
613 efdtIntDnFB :: (Int -> r -> r) -> r -> Int# -> Int# -> Int# -> r
614 efdtIntDnFB c n x1 x2 y    -- Be careful about underflow!
615  | y ># x2 = if y ># x1 then n else I# x1 `c` n
616  | otherwise = -- Common case: x1 >= x2 >= y
617                let !delta = x2 -# x1 -- <= 0
618                    !y' = y -# delta  -- y <= y' <= x1; hence y' is representable
619
620                    -- Invariant: x >= y
621                    -- Note that: z >= y' => z + delta won't underflow
622                    -- so we are guaranteed not to underflow if/when we recurse
623                    go_dn x | x <# y'   = I# x `c` n
624                            | otherwise = I# x `c` go_dn (x +# delta)
625                in I# x1 `c` go_dn x2
626 \end{code}
627
628
629 %*********************************************************
630 %*                                                      *
631 \subsection{Type @Word@}
632 %*                                                      *
633 %*********************************************************
634
635 \begin{code}
636 instance Bounded Word where
637     minBound = 0
638
639     -- use unboxed literals for maxBound, because GHC doesn't optimise
640     -- (fromInteger 0xffffffff :: Word).
641 #if WORD_SIZE_IN_BITS == 32
642     maxBound = W# (int2Word# 0xFFFFFFFF#)
643 #else
644     maxBound = W# (int2Word# 0xFFFFFFFFFFFFFFFF#)
645 #endif
646 \end{code}
647
648
649 %*********************************************************
650 %*                                                      *
651 \subsection{The @Integer@ instance for @Enum@}
652 %*                                                      *
653 %*********************************************************
654
655 \begin{code}
656 instance  Enum Integer  where
657     succ x               = x + 1
658     pred x               = x - 1
659     toEnum (I# n)        = smallInteger n
660     fromEnum n           = I# (integerToInt n)
661
662     {-# INLINE enumFrom #-}
663     {-# INLINE enumFromThen #-}
664     {-# INLINE enumFromTo #-}
665     {-# INLINE enumFromThenTo #-}
666     enumFrom x             = enumDeltaInteger  x 1
667     enumFromThen x y       = enumDeltaInteger  x (y-x)
668     enumFromTo x lim       = enumDeltaToInteger x 1     lim
669     enumFromThenTo x y lim = enumDeltaToInteger x (y-x) lim
670
671 {-# RULES
672 "enumDeltaInteger"      [~1] forall x y.  enumDeltaInteger x y     = build (\c _ -> enumDeltaIntegerFB c x y)
673 "efdtInteger"           [~1] forall x y l.enumDeltaToInteger x y l = build (\c n -> enumDeltaToIntegerFB c n x y l)
674 "enumDeltaInteger"      [1] enumDeltaIntegerFB   (:)    = enumDeltaInteger
675 "enumDeltaToInteger"    [1] enumDeltaToIntegerFB (:) [] = enumDeltaToInteger
676  #-}
677
678 {-# NOINLINE [0] enumDeltaIntegerFB #-}
679 enumDeltaIntegerFB :: (Integer -> b -> b) -> Integer -> Integer -> b
680 enumDeltaIntegerFB c x d = x `seq` (x `c` enumDeltaIntegerFB c (x+d) d)
681
682 {-# NOINLINE [1] enumDeltaInteger #-}
683 enumDeltaInteger :: Integer -> Integer -> [Integer]
684 enumDeltaInteger x d = x `seq` (x : enumDeltaInteger (x+d) d)
685 -- strict accumulator, so
686 --     head (drop 1000000 [1 .. ]
687 -- works
688
689 {-# NOINLINE [0] enumDeltaToIntegerFB #-}
690 -- Don't inline this until RULE "enumDeltaToInteger" has had a chance to fire
691 enumDeltaToIntegerFB :: (Integer -> a -> a) -> a
692                      -> Integer -> Integer -> Integer -> a
693 enumDeltaToIntegerFB c n x delta lim
694   | delta >= 0 = up_fb c n x delta lim
695   | otherwise  = dn_fb c n x delta lim
696
697 {-# NOINLINE [1] enumDeltaToInteger #-}
698 enumDeltaToInteger :: Integer -> Integer -> Integer -> [Integer]
699 enumDeltaToInteger x delta lim
700   | delta >= 0 = up_list x delta lim
701   | otherwise  = dn_list x delta lim
702
703 up_fb :: (Integer -> a -> a) -> a -> Integer -> Integer -> Integer -> a
704 up_fb c n x0 delta lim = go (x0 :: Integer)
705                       where
706                         go x | x > lim   = n
707                              | otherwise = x `c` go (x+delta)
708 dn_fb :: (Integer -> a -> a) -> a -> Integer -> Integer -> Integer -> a
709 dn_fb c n x0 delta lim = go (x0 :: Integer)
710                       where
711                         go x | x < lim   = n
712                              | otherwise = x `c` go (x+delta)
713
714 up_list :: Integer -> Integer -> Integer -> [Integer]
715 up_list x0 delta lim = go (x0 :: Integer)
716                     where
717                         go x | x > lim   = []
718                              | otherwise = x : go (x+delta)
719 dn_list :: Integer -> Integer -> Integer -> [Integer]
720 dn_list x0 delta lim = go (x0 :: Integer)
721                     where
722                         go x | x < lim   = []
723                              | otherwise = x : go (x+delta)
724 \end{code}
725