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