[project @ 2003-06-19 10:42:26 by simonmar]
[packages/random.git] / GHC / Enum.lhs
1 \begin{code}
2 {-# OPTIONS -fno-implicit-prelude #-}
3 -----------------------------------------------------------------------------
4 -- |
5 -- Module      :  GHC.Enum
6 -- Copyright   :  (c) The University of Glasgow, 1992-2002
7 -- License     :  see libraries/base/LICENSE
8 -- 
9 -- Maintainer  :  cvs-ghc@haskell.org
10 -- Stability   :  internal
11 -- Portability :  non-portable (GHC extensions)
12 --
13 -- The 'Enum' and 'Bounded' classes.
14 -- 
15 -----------------------------------------------------------------------------
16
17 module GHC.Enum(
18         Bounded(..), Enum(..),
19         boundedEnumFrom, boundedEnumFromThen,
20
21         -- Instances for Bounded and Enum: (), Char, Int
22
23    ) where
24
25 import {-# SOURCE #-} GHC.Err ( error )
26 import GHC.Base
27 import Data.Tuple       ()              -- for dependencies
28 default ()              -- Double isn't available yet
29 \end{code}
30
31
32 %*********************************************************
33 %*                                                      *
34 \subsection{Class declarations}
35 %*                                                      *
36 %*********************************************************
37
38 \begin{code}
39 class  Bounded a  where
40     minBound, maxBound :: a
41
42 class  Enum a   where
43     succ, pred          :: a -> a
44     toEnum              :: Int -> a
45     fromEnum            :: a -> Int
46     enumFrom            :: a -> [a]             -- [n..]
47     enumFromThen        :: a -> a -> [a]        -- [n,n'..]
48     enumFromTo          :: a -> a -> [a]        -- [n..m]
49     enumFromThenTo      :: a -> a -> a -> [a]   -- [n,n'..m]
50
51     succ                   = toEnum . (`plusInt` oneInt)  . fromEnum
52     pred                   = toEnum . (`minusInt` oneInt) . fromEnum
53     enumFrom x             = map toEnum [fromEnum x ..]
54     enumFromThen x y       = map toEnum [fromEnum x, fromEnum y ..]
55     enumFromTo x y         = map toEnum [fromEnum x .. fromEnum y]
56     enumFromThenTo x1 x2 y = map toEnum [fromEnum x1, fromEnum x2 .. fromEnum y]
57
58 -- Default methods for bounded enumerations
59 boundedEnumFrom :: (Enum a, Bounded a) => a -> [a]
60 boundedEnumFrom n = map toEnum [fromEnum n .. fromEnum (maxBound `asTypeOf` n)]
61
62 boundedEnumFromThen :: (Enum a, Bounded a) => a -> a -> [a]
63 boundedEnumFromThen n1 n2 
64   | i_n2 >= i_n1  = map toEnum [i_n1, i_n2 .. fromEnum (maxBound `asTypeOf` n1)]
65   | otherwise     = map toEnum [i_n1, i_n2 .. fromEnum (minBound `asTypeOf` n1)]
66   where
67     i_n1 = fromEnum n1
68     i_n2 = fromEnum n2
69 \end{code}
70
71
72 %*********************************************************
73 %*                                                      *
74 \subsection{Tuples}
75 %*                                                      *
76 %*********************************************************
77
78 \begin{code}
79 instance Bounded () where
80     minBound = ()
81     maxBound = ()
82
83 instance Enum () where
84     succ _      = error "Prelude.Enum.().succ: bad argment"
85     pred _      = error "Prelude.Enum.().pred: bad argument"
86
87     toEnum x | x == zeroInt = ()
88              | otherwise    = error "Prelude.Enum.().toEnum: bad argument"
89
90     fromEnum () = zeroInt
91     enumFrom ()         = [()]
92     enumFromThen () ()  = [()]
93     enumFromTo () ()    = [()]
94     enumFromThenTo () () () = [()]
95 \end{code}
96
97 \begin{code}
98 instance (Bounded a, Bounded b) => Bounded (a,b) where
99    minBound = (minBound, minBound)
100    maxBound = (maxBound, maxBound)
101
102 instance (Bounded a, Bounded b, Bounded c) => Bounded (a,b,c) where
103    minBound = (minBound, minBound, minBound)
104    maxBound = (maxBound, maxBound, maxBound)
105
106 instance (Bounded a, Bounded b, Bounded c, Bounded d) => Bounded (a,b,c,d) where
107    minBound = (minBound, minBound, minBound, minBound)
108    maxBound = (maxBound, maxBound, maxBound, maxBound)
109 \end{code}
110
111
112 %*********************************************************
113 %*                                                      *
114 \subsection{Type @Bool@}
115 %*                                                      *
116 %*********************************************************
117
118 \begin{code}
119 instance Bounded Bool where
120   minBound = False
121   maxBound = True
122
123 instance Enum Bool where
124   succ False = True
125   succ True  = error "Prelude.Enum.Bool.succ: bad argment"
126
127   pred True  = False
128   pred False  = error "Prelude.Enum.Bool.pred: bad argment"
129
130   toEnum n | n == zeroInt = False
131            | n == oneInt  = True
132            | otherwise    = error "Prelude.Enum.Bool.toEnum: bad argment"
133
134   fromEnum False = zeroInt
135   fromEnum True  = oneInt
136
137   -- Use defaults for the rest
138   enumFrom     = boundedEnumFrom
139   enumFromThen = boundedEnumFromThen
140 \end{code}
141
142 %*********************************************************
143 %*                                                      *
144 \subsection{Type @Ordering@}
145 %*                                                      *
146 %*********************************************************
147
148 \begin{code}
149 instance Bounded Ordering where
150   minBound = LT
151   maxBound = GT
152
153 instance Enum Ordering where
154   succ LT = EQ
155   succ EQ = GT
156   succ GT = error "Prelude.Enum.Ordering.succ: bad argment"
157
158   pred GT = EQ
159   pred EQ = LT
160   pred LT = error "Prelude.Enum.Ordering.pred: bad argment"
161
162   toEnum n | n == zeroInt = LT
163            | n == oneInt  = EQ
164            | n == twoInt  = GT
165   toEnum _ = error "Prelude.Enum.Ordering.toEnum: bad argment"
166
167   fromEnum LT = zeroInt
168   fromEnum EQ = oneInt
169   fromEnum GT = twoInt
170
171   -- Use defaults for the rest
172   enumFrom     = boundedEnumFrom
173   enumFromThen = boundedEnumFromThen
174 \end{code}
175
176 %*********************************************************
177 %*                                                      *
178 \subsection{Type @Char@}
179 %*                                                      *
180 %*********************************************************
181
182 \begin{code}
183 instance  Bounded Char  where
184     minBound =  '\0'
185     maxBound =  '\x10FFFF'
186
187 instance  Enum Char  where
188     succ (C# c#)
189        | not (ord# c# ==# 0x10FFFF#) = C# (chr# (ord# c# +# 1#))
190        | otherwise              = error ("Prelude.Enum.Char.succ: bad argument")
191     pred (C# c#)
192        | not (ord# c# ==# 0#)   = C# (chr# (ord# c# -# 1#))
193        | otherwise              = error ("Prelude.Enum.Char.pred: bad argument")
194
195     toEnum   = chr
196     fromEnum = ord
197
198     {-# INLINE enumFrom #-}
199     enumFrom (C# x) = eftChar (ord# x) 0x10FFFF#
200         -- Blarg: technically I guess enumFrom isn't strict!
201
202     {-# INLINE enumFromTo #-}
203     enumFromTo (C# x) (C# y) = eftChar (ord# x) (ord# y)
204     
205     {-# INLINE enumFromThen #-}
206     enumFromThen (C# x1) (C# x2) = efdChar (ord# x1) (ord# x2)
207     
208     {-# INLINE enumFromThenTo #-}
209     enumFromThenTo (C# x1) (C# x2) (C# y) = efdtChar (ord# x1) (ord# x2) (ord# y)
210
211 {-# RULES
212 "eftChar"       [~1] forall x y.        eftChar x y       = build (\c n -> eftCharFB c n x y)
213 "efdChar"       [~1] forall x1 x2.      efdChar x1 x2     = build (\ c n -> efdCharFB c n x1 x2)
214 "efdtChar"      [~1] forall x1 x2 l.    efdtChar x1 x2 l  = build (\ c n -> efdtCharFB c n x1 x2 l)
215 "eftCharList"   [1]  eftCharFB  (:) [] = eftChar
216 "efdCharList"   [1]  efdCharFB  (:) [] = efdChar
217 "efdtCharList"  [1]  efdtCharFB (:) [] = efdtChar
218  #-}
219
220
221 -- We can do better than for Ints because we don't
222 -- have hassles about arithmetic overflow at maxBound
223 {-# INLINE [0] eftCharFB #-}
224 eftCharFB c n x y = go x
225                  where
226                     go x | x ># y    = n
227                          | otherwise = C# (chr# x) `c` go (x +# 1#)
228
229 eftChar x y | x ># y    = [] 
230                 | otherwise = C# (chr# x) : eftChar (x +# 1#) y
231
232
233 -- For enumFromThenTo we give up on inlining
234 {-# NOINLINE [0] efdCharFB #-}
235 efdCharFB c n x1 x2
236   | delta >=# 0# = go_up_char_fb c n x1 delta 0x10FFFF#
237   | otherwise    = go_dn_char_fb c n x1 delta 0#
238   where
239     delta = x2 -# x1
240
241 efdChar x1 x2
242   | delta >=# 0# = go_up_char_list x1 delta 0x10FFFF#
243   | otherwise    = go_dn_char_list x1 delta 0#
244   where
245     delta = x2 -# x1
246
247 {-# NOINLINE [0] efdtCharFB #-}
248 efdtCharFB c n x1 x2 lim
249   | delta >=# 0# = go_up_char_fb c n x1 delta lim
250   | otherwise    = go_dn_char_fb c n x1 delta lim
251   where
252     delta = x2 -# x1
253
254 efdtChar x1 x2 lim
255   | delta >=# 0# = go_up_char_list x1 delta lim
256   | otherwise    = go_dn_char_list x1 delta lim
257   where
258     delta = x2 -# x1
259
260 go_up_char_fb c n x delta lim
261   = go_up x
262   where
263     go_up x | x ># lim  = n
264             | otherwise = C# (chr# x) `c` go_up (x +# delta)
265
266 go_dn_char_fb c n x delta lim
267   = go_dn x
268   where
269     go_dn x | x <# lim  = n
270             | otherwise = C# (chr# x) `c` go_dn (x +# delta)
271
272 go_up_char_list x delta lim
273   = go_up x
274   where
275     go_up x | x ># lim  = []
276             | otherwise = C# (chr# x) : go_up (x +# delta)
277
278 go_dn_char_list x delta lim
279   = go_dn x
280   where
281     go_dn x | x <# lim  = []
282             | otherwise = C# (chr# x) : go_dn (x +# delta)
283 \end{code}
284
285
286 %*********************************************************
287 %*                                                      *
288 \subsection{Type @Int@}
289 %*                                                      *
290 %*********************************************************
291
292 Be careful about these instances.  
293         (a) remember that you have to count down as well as up e.g. [13,12..0]
294         (b) be careful of Int overflow
295         (c) remember that Int is bounded, so [1..] terminates at maxInt
296
297 Also NB that the Num class isn't available in this module.
298         
299 \begin{code}
300 instance  Bounded Int where
301     minBound =  minInt
302     maxBound =  maxInt
303
304 instance  Enum Int  where
305     succ x  
306        | x == maxBound  = error "Prelude.Enum.succ{Int}: tried to take `succ' of maxBound"
307        | otherwise      = x `plusInt` oneInt
308     pred x
309        | x == minBound  = error "Prelude.Enum.pred{Int}: tried to take `pred' of minBound"
310        | otherwise      = x `minusInt` oneInt
311
312     toEnum   x = x
313     fromEnum x = x
314
315     {-# INLINE enumFrom #-}
316     enumFrom (I# x) = eftInt x maxInt#
317         where I# maxInt# = maxInt
318         -- Blarg: technically I guess enumFrom isn't strict!
319
320     {-# INLINE enumFromTo #-}
321     enumFromTo (I# x) (I# y) = eftInt x y
322
323     {-# INLINE enumFromThen #-}
324     enumFromThen (I# x1) (I# x2) = efdInt x1 x2
325
326     {-# INLINE enumFromThenTo #-}
327     enumFromThenTo (I# x1) (I# x2) (I# y) = efdtInt x1 x2 y
328
329 {-# RULES
330 "eftInt"        [~1] forall x y.        eftInt x y       = build (\ c n -> eftIntFB c n x y)
331 "efdInt"        [~1] forall x1 x2.      efdInt x1 x2     = build (\ c n -> efdIntFB c n x1 x2)
332 "efdtInt"       [~1] forall x1 x2 l.    efdtInt x1 x2 l  = build (\ c n -> efdtIntFB c n x1 x2 l)
333
334 "eftIntList"    [1] eftIntFB  (:) [] = eftInt
335 "efdIntList"    [1] efdIntFB  (:) [] = efdInt
336 "efdtIntList"   [1] efdtIntFB (:) [] = efdtInt
337  #-}
338
339
340 {-# INLINE [0] eftIntFB #-}
341 eftIntFB c n x y | x ># y    = n        
342                  | otherwise = go x
343                  where
344                    go x = I# x `c` if x ==# y then n else go (x +# 1#)
345                         -- Watch out for y=maxBound; hence ==, not >
346         -- Be very careful not to have more than one "c"
347         -- so that when eftInfFB is inlined we can inline
348         -- whatver is bound to "c"
349
350 eftInt x y | x ># y    = []
351                | otherwise = go x
352                where
353                  go x = I# x : if x ==# y then [] else go (x +# 1#)
354
355
356 -- For enumFromThenTo we give up on inlining; so we don't worry
357 -- about duplicating occurrences of "c"
358 {-# NOINLINE [0] efdtIntFB #-}
359 efdtIntFB c n x1 x2 y
360   | delta >=# 0# = if x1 ># y then n else go_up_int_fb c n x1 delta lim
361   | otherwise    = if x1 <# y then n else go_dn_int_fb c n x1 delta lim 
362   where
363     delta = x2 -# x1
364     lim   = y -# delta
365
366 efdtInt x1 x2 y
367   | delta >=# 0# = if x1 ># y then [] else go_up_int_list x1 delta lim
368   | otherwise    = if x1 <# y then [] else go_dn_int_list x1 delta lim
369   where
370     delta = x2 -# x1
371     lim   = y -# delta
372
373 {-# NOINLINE [0] efdIntFB #-}
374 efdIntFB c n x1 x2
375   | delta >=# 0# = case maxInt of I# y -> go_up_int_fb c n x1 delta (y -# delta)
376   | otherwise    = case minInt of I# y -> go_dn_int_fb c n x1 delta (y -# delta)
377   where
378     delta = x2 -# x1
379
380 efdInt x1 x2
381   | delta >=# 0# = case maxInt of I# y -> go_up_int_list x1 delta (y -# delta)
382   | otherwise    = case minInt of I# y -> go_dn_int_list x1 delta (y -# delta)
383   where
384     delta = x2 -# x1
385
386 -- In all of these, the (x +# delta) is guaranteed not to overflow
387
388 go_up_int_fb c n x delta lim
389   = go_up x
390   where
391     go_up x | x ># lim  = I# x `c` n
392             | otherwise = I# x `c` go_up (x +# delta)
393
394 go_dn_int_fb c n x delta lim 
395   = go_dn x
396   where
397     go_dn x | x <# lim  = I# x `c` n
398             | otherwise = I# x `c` go_dn (x +# delta)
399
400 go_up_int_list x delta lim
401   = go_up x
402   where
403     go_up x | x ># lim  = [I# x]
404             | otherwise = I# x : go_up (x +# delta)
405
406 go_dn_int_list x delta lim 
407   = go_dn x
408   where
409     go_dn x | x <# lim  = [I# x]
410             | otherwise = I# x : go_dn (x +# delta)
411 \end{code}
412