1 % -----------------------------------------------------------------------------
2 % $Id: Base.lhs,v 1.8 2002/04/24 16:10:21 simonmar Exp $
4 % (c) The University of Glasgow, 1992-2002
6 \section[GHC.Base]{Module @GHC.Base@}
9 The overall structure of the GHC Prelude is a bit tricky.
11 a) We want to avoid "orphan modules", i.e. ones with instance
12 decls that don't belong either to a tycon or a class
13 defined in the same module
15 b) We want to avoid giant modules
17 So the rough structure is as follows, in (linearised) dependency order
20 GHC.Prim Has no implementation. It defines built-in things, and
21 by importing it you bring them into scope.
22 The source file is GHC.Prim.hi-boot, which is just
23 copied to make GHC.Prim.hi
25 Classes: CCallable, CReturnable
27 GHC.Base Classes: Eq, Ord, Functor, Monad
28 Types: list, (), Int, Bool, Ordering, Char, String
30 Data.Tup Types: tuples, plus instances for GHC.Base classes
32 GHC.Show Class: Show, plus instances for GHC.Base/GHC.Tup types
34 GHC.Enum Class: Enum, plus instances for GHC.Base/GHC.Tup types
36 Data.Maybe Type: Maybe, plus instances for GHC.Base classes
38 GHC.Num Class: Num, plus instances for Int
39 Type: Integer, plus instances for all classes so far (Eq, Ord, Num, Show)
41 Integer is needed here because it is mentioned in the signature
42 of 'fromInteger' in class Num
44 GHC.Real Classes: Real, Integral, Fractional, RealFrac
45 plus instances for Int, Integer
46 Types: Ratio, Rational
47 plus intances for classes so far
49 Rational is needed here because it is mentioned in the signature
50 of 'toRational' in class Real
52 Ix Classes: Ix, plus instances for Int, Bool, Char, Integer, Ordering, tuples
54 GHC.Arr Types: Array, MutableArray, MutableVar
56 Does *not* contain any ByteArray stuff (see GHC.ByteArr)
57 Arrays are used by a function in GHC.Float
59 GHC.Float Classes: Floating, RealFloat
60 Types: Float, Double, plus instances of all classes so far
62 This module contains everything to do with floating point.
63 It is a big module (900 lines)
64 With a bit of luck, many modules can be compiled without ever reading GHC.Float.hi
66 GHC.ByteArr Types: ByteArray, MutableByteArray
68 We want this one to be after GHC.Float, because it defines arrays
72 Other Prelude modules are much easier with fewer complex dependencies.
76 {-# OPTIONS -fno-implicit-prelude #-}
83 module GHC.Prim, -- Re-export GHC.Prim and GHC.Err, to avoid lots
84 module GHC.Err -- of people having to import it explicitly
89 import {-# SOURCE #-} GHC.Err
93 infix 4 ==, /=, <, <=, >=, >
99 default () -- Double isn't available yet
103 %*********************************************************
105 \subsection{DEBUGGING STUFF}
106 %* (for use when compiling GHC.Base itself doesn't work)
108 %*********************************************************
112 data Bool = False | True
113 data Ordering = LT | EQ | GT
121 (&&) True True = True
127 unpackCString# :: Addr# -> [Char]
128 unpackFoldrCString# :: Addr# -> (Char -> a -> a) -> a -> a
129 unpackAppendCString# :: Addr# -> [Char] -> [Char]
130 unpackCStringUtf8# :: Addr# -> [Char]
131 unpackCString# a = error "urk"
132 unpackFoldrCString# a = error "urk"
133 unpackAppendCString# a = error "urk"
134 unpackCStringUtf8# a = error "urk"
139 %*********************************************************
141 \subsection{Standard classes @Eq@, @Ord@}
143 %*********************************************************
147 (==), (/=) :: a -> a -> Bool
149 x /= y = not (x == y)
150 x == y = not (x /= y)
152 class (Eq a) => Ord a where
153 compare :: a -> a -> Ordering
154 (<), (<=), (>), (>=) :: a -> a -> Bool
155 max, min :: a -> a -> a
157 -- An instance of Ord should define either 'compare' or '<='.
158 -- Using 'compare' can be more efficient for complex types.
162 | x <= y = LT -- NB: must be '<=' not '<' to validate the
163 -- above claim about the minimal things that
164 -- can be defined for an instance of Ord
167 x < y = case compare x y of { LT -> True; _other -> False }
168 x <= y = case compare x y of { GT -> False; _other -> True }
169 x > y = case compare x y of { GT -> True; _other -> False }
170 x >= y = case compare x y of { LT -> False; _other -> True }
172 -- These two default methods use '<=' rather than 'compare'
173 -- because the latter is often more expensive
174 max x y = if x <= y then y else x
175 min x y = if x <= y then x else y
178 %*********************************************************
180 \subsection{Monadic classes @Functor@, @Monad@ }
182 %*********************************************************
185 class Functor f where
186 fmap :: (a -> b) -> f a -> f b
189 (>>=) :: m a -> (a -> m b) -> m b
190 (>>) :: m a -> m b -> m b
192 fail :: String -> m a
194 m >> k = m >>= \_ -> k
199 %*********************************************************
201 \subsection{The list type}
203 %*********************************************************
206 data [] a = [] | a : [a] -- do explicitly: deriving (Eq, Ord)
207 -- to avoid weird names like con2tag_[]#
210 instance (Eq a) => Eq [a] where
211 {-# SPECIALISE instance Eq [Char] #-}
213 (x:xs) == (y:ys) = x == y && xs == ys
216 instance (Ord a) => Ord [a] where
217 {-# SPECIALISE instance Ord [Char] #-}
219 compare [] (_:_) = LT
220 compare (_:_) [] = GT
221 compare (x:xs) (y:ys) = case compare x y of
225 instance Functor [] where
228 instance Monad [] where
229 m >>= k = foldr ((++) . k) [] m
230 m >> k = foldr ((++) . (\ _ -> k)) [] m
235 A few list functions that appear here because they are used here.
236 The rest of the prelude list functions are in GHC.List.
238 ----------------------------------------------
239 -- foldr/build/augment
240 ----------------------------------------------
243 foldr :: (a -> b -> b) -> b -> [a] -> b
245 -- foldr f z (x:xs) = f x (foldr f z xs)
246 {-# INLINE [0] foldr #-}
247 -- Inline only in the final stage, after the foldr/cons rule has had a chance
251 go (y:ys) = y `k` go ys
253 build :: forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
254 {-# INLINE [1] build #-}
255 -- The INLINE is important, even though build is tiny,
256 -- because it prevents [] getting inlined in the version that
257 -- appears in the interface file. If [] *is* inlined, it
258 -- won't match with [] appearing in rules in an importing module.
260 -- The "1" says to inline in phase 1
264 augment :: forall a. (forall b. (a->b->b) -> b -> b) -> [a] -> [a]
265 {-# INLINE [1] augment #-}
266 augment g xs = g (:) xs
269 "fold/build" forall k z (g::forall b. (a->b->b) -> b -> b) .
270 foldr k z (build g) = g k z
272 "foldr/augment" forall k z xs (g::forall b. (a->b->b) -> b -> b) .
273 foldr k z (augment g xs) = g k (foldr k z xs)
275 "foldr/id" foldr (:) [] = \x->x
276 "foldr/app" [1] forall xs ys. foldr (:) ys xs = xs ++ ys
277 -- Only activate this from phase 1, because that's
278 -- when we disable the rule that expands (++) into foldr
280 -- The foldr/cons rule looks nice, but it can give disastrously
281 -- bloated code when commpiling
282 -- array (a,b) [(1,2), (2,2), (3,2), ...very long list... ]
283 -- i.e. when there are very very long literal lists
284 -- So I've disabled it for now. We could have special cases
285 -- for short lists, I suppose.
286 -- "foldr/cons" forall k z x xs. foldr k z (x:xs) = k x (foldr k z xs)
288 "foldr/single" forall k z x. foldr k z [x] = k x z
289 "foldr/nil" forall k z. foldr k z [] = z
291 "augment/build" forall (g::forall b. (a->b->b) -> b -> b)
292 (h::forall b. (a->b->b) -> b -> b) .
293 augment g (build h) = build (\c n -> g c (h c n))
294 "augment/nil" forall (g::forall b. (a->b->b) -> b -> b) .
295 augment g [] = build g
298 -- This rule is true, but not (I think) useful:
299 -- augment g (augment h t) = augment (\cn -> g c (h c n)) t
303 ----------------------------------------------
305 ----------------------------------------------
308 map :: (a -> b) -> [a] -> [b]
310 map f (x:xs) = f x : map f xs
313 mapFB :: (elt -> lst -> lst) -> (a -> elt) -> a -> lst -> lst
314 {-# INLINE [0] mapFB #-}
315 mapFB c f x ys = c (f x) ys
317 -- The rules for map work like this.
319 -- Up to (but not including) phase 1, we use the "map" rule to
320 -- rewrite all saturated applications of map with its build/fold
321 -- form, hoping for fusion to happen.
322 -- In phase 1 and 0, we switch off that rule, inline build, and
323 -- switch on the "mapList" rule, which rewrites the foldr/mapFB
324 -- thing back into plain map.
326 -- It's important that these two rules aren't both active at once
327 -- (along with build's unfolding) else we'd get an infinite loop
328 -- in the rules. Hence the activation control below.
330 -- The "mapFB" rule optimises compositions of map.
332 -- This same pattern is followed by many other functions:
333 -- e.g. append, filter, iterate, repeat, etc.
336 "map" [~1] forall f xs. map f xs = build (\c n -> foldr (mapFB c f) n xs)
337 "mapList" [1] forall f. foldr (mapFB (:) f) [] = map f
338 "mapFB" forall c f g. mapFB (mapFB c f) g = mapFB c (f.g)
343 ----------------------------------------------
345 ----------------------------------------------
347 (++) :: [a] -> [a] -> [a]
349 (++) (x:xs) ys = x : xs ++ ys
352 "++" [~1] forall xs ys. xs ++ ys = augment (\c n -> foldr c n xs) ys
358 %*********************************************************
360 \subsection{Type @Bool@}
362 %*********************************************************
365 data Bool = False | True deriving (Eq, Ord)
366 -- Read in GHC.Read, Show in GHC.Show
370 (&&), (||) :: Bool -> Bool -> Bool
385 %*********************************************************
387 \subsection{The @()@ type}
389 %*********************************************************
391 The Unit type is here because virtually any program needs it (whereas
392 some programs may get away without consulting GHC.Tup). Furthermore,
393 the renamer currently *always* asks for () to be in scope, so that
394 ccalls can use () as their default type; so when compiling GHC.Base we
395 need (). (We could arrange suck in () only if -fglasgow-exts, but putting
396 it here seems more direct.)
405 instance Ord () where
416 %*********************************************************
418 \subsection{Type @Ordering@}
420 %*********************************************************
423 data Ordering = LT | EQ | GT deriving (Eq, Ord)
424 -- Read in GHC.Read, Show in GHC.Show
428 %*********************************************************
430 \subsection{Type @Char@ and @String@}
432 %*********************************************************
439 -- We don't use deriving for Eq and Ord, because for Ord the derived
440 -- instance defines only compare, which takes two primops. Then
441 -- '>' uses compare, and therefore takes two primops instead of one.
443 instance Eq Char where
444 (C# c1) == (C# c2) = c1 `eqChar#` c2
445 (C# c1) /= (C# c2) = c1 `neChar#` c2
447 instance Ord Char where
448 (C# c1) > (C# c2) = c1 `gtChar#` c2
449 (C# c1) >= (C# c2) = c1 `geChar#` c2
450 (C# c1) <= (C# c2) = c1 `leChar#` c2
451 (C# c1) < (C# c2) = c1 `ltChar#` c2
454 "x# `eqChar#` x#" forall x#. x# `eqChar#` x# = True
455 "x# `neChar#` x#" forall x#. x# `neChar#` x# = False
456 "x# `gtChar#` x#" forall x#. x# `gtChar#` x# = False
457 "x# `geChar#` x#" forall x#. x# `geChar#` x# = True
458 "x# `leChar#` x#" forall x#. x# `leChar#` x# = True
459 "x# `ltChar#` x#" forall x#. x# `ltChar#` x# = False
463 chr (I# i#) | int2Word# i# `leWord#` int2Word# 0x10FFFF# = C# (chr# i#)
464 | otherwise = error "Prelude.chr: bad argument"
466 unsafeChr :: Int -> Char
467 unsafeChr (I# i#) = C# (chr# i#)
470 ord (C# c#) = I# (ord# c#)
473 String equality is used when desugaring pattern-matches against strings.
476 eqString :: String -> String -> Bool
477 eqString [] [] = True
478 eqString (c1:cs1) (c2:cs2) = c1 == c2 && cs1 `eqString` cs2
479 eqString cs1 cs2 = False
481 {-# RULES "eqString" (==) = eqString #-}
485 %*********************************************************
487 \subsection{Type @Int@}
489 %*********************************************************
494 zeroInt, oneInt, twoInt, maxInt, minInt :: Int
499 {- Seems clumsy. Should perhaps put minInt and MaxInt directly into MachDeps.h -}
500 #if WORD_SIZE_IN_BITS == 31
501 minInt = I# (-0x40000000#)
502 maxInt = I# 0x3FFFFFFF#
503 #elif WORD_SIZE_IN_BITS == 32
504 minInt = I# (-0x80000000#)
505 maxInt = I# 0x7FFFFFFF#
507 minInt = I# (-0x8000000000000000#)
508 maxInt = I# 0x7FFFFFFFFFFFFFFF#
511 instance Eq Int where
515 instance Ord Int where
522 compareInt :: Int -> Int -> Ordering
523 (I# x#) `compareInt` (I# y#) = compareInt# x# y#
525 compareInt# :: Int# -> Int# -> Ordering
533 %*********************************************************
535 \subsection{The function type}
537 %*********************************************************
548 -- function composition
550 (.) :: (b -> c) -> (a -> b) -> a -> c
553 -- flip f takes its (first) two arguments in the reverse order of f.
554 flip :: (a -> b -> c) -> b -> a -> c
557 -- right-associating infix application operator (useful in continuation-
560 ($) :: (a -> b) -> a -> b
563 -- until p f yields the result of applying f until p holds.
564 until :: (a -> Bool) -> (a -> a) -> a -> a
565 until p f x | p x = x
566 | otherwise = until p f (f x)
568 -- asTypeOf is a type-restricted version of const. It is usually used
569 -- as an infix operator, and its typing forces its first argument
570 -- (which is usually overloaded) to have the same type as the second.
571 asTypeOf :: a -> a -> a
575 %*********************************************************
577 \subsection{CCallable instances}
579 %*********************************************************
581 Defined here to avoid orphans
584 instance CCallable Char
585 instance CReturnable Char
587 instance CCallable Int
588 instance CReturnable Int
590 instance CReturnable () -- Why, exactly?
594 %*********************************************************
596 \subsection{Generics}
598 %*********************************************************
603 data (:+:) a b = Inl a | Inr b
604 data (:*:) a b = a :*: b
609 %*********************************************************
611 \subsection{Numeric primops}
613 %*********************************************************
616 divInt#, modInt# :: Int# -> Int# -> Int#
618 | (x# ># 0#) && (y# <# 0#) = ((x# -# y#) -# 1#) `quotInt#` y#
619 | (x# <# 0#) && (y# ># 0#) = ((x# -# y#) +# 1#) `quotInt#` y#
620 | otherwise = x# `quotInt#` y#
622 | (x# ># 0#) && (y# <# 0#) ||
623 (x# <# 0#) && (y# ># 0#) = if r# /=# 0# then r# +# y# else 0#
629 Definitions of the boxed PrimOps; these will be
630 used in the case of partial applications, etc.
639 {-# INLINE plusInt #-}
640 {-# INLINE minusInt #-}
641 {-# INLINE timesInt #-}
642 {-# INLINE quotInt #-}
643 {-# INLINE remInt #-}
644 {-# INLINE negateInt #-}
646 plusInt, minusInt, timesInt, quotInt, remInt, divInt, modInt, gcdInt :: Int -> Int -> Int
647 (I# x) `plusInt` (I# y) = I# (x +# y)
648 (I# x) `minusInt` (I# y) = I# (x -# y)
649 (I# x) `timesInt` (I# y) = I# (x *# y)
650 (I# x) `quotInt` (I# y) = I# (x `quotInt#` y)
651 (I# x) `remInt` (I# y) = I# (x `remInt#` y)
652 (I# x) `divInt` (I# y) = I# (x `divInt#` y)
653 (I# x) `modInt` (I# y) = I# (x `modInt#` y)
656 "x# +# 0#" forall x#. x# +# 0# = x#
657 "0# +# x#" forall x#. 0# +# x# = x#
658 "x# -# 0#" forall x#. x# -# 0# = x#
659 "x# -# x#" forall x#. x# -# x# = 0#
660 "x# *# 0#" forall x#. x# *# 0# = 0#
661 "0# *# x#" forall x#. 0# *# x# = 0#
662 "x# *# 1#" forall x#. x# *# 1# = x#
663 "1# *# x#" forall x#. 1# *# x# = x#
666 gcdInt (I# a) (I# b) = g a b
667 where g 0# 0# = error "GHC.Base.gcdInt: gcd 0 0 is undefined"
670 g _ _ = I# (gcdInt# absA absB)
672 absInt x = if x <# 0# then negateInt# x else x
677 negateInt :: Int -> Int
678 negateInt (I# x) = I# (negateInt# x)
680 gtInt, geInt, eqInt, neInt, ltInt, leInt :: Int -> Int -> Bool
681 (I# x) `gtInt` (I# y) = x ># y
682 (I# x) `geInt` (I# y) = x >=# y
683 (I# x) `eqInt` (I# y) = x ==# y
684 (I# x) `neInt` (I# y) = x /=# y
685 (I# x) `ltInt` (I# y) = x <# y
686 (I# x) `leInt` (I# y) = x <=# y
689 "x# ># x#" forall x#. x# ># x# = False
690 "x# >=# x#" forall x#. x# >=# x# = True
691 "x# ==# x#" forall x#. x# ==# x# = True
692 "x# /=# x#" forall x#. x# /=# x# = False
693 "x# <# x#" forall x#. x# <# x# = False
694 "x# <=# x#" forall x#. x# <=# x# = True
698 "plusFloat x 0.0" forall x#. plusFloat# x# 0.0# = x#
699 "plusFloat 0.0 x" forall x#. plusFloat# 0.0# x# = x#
700 "minusFloat x 0.0" forall x#. minusFloat# x# 0.0# = x#
701 "minusFloat x x" forall x#. minusFloat# x# x# = 0.0#
702 "timesFloat x 0.0" forall x#. timesFloat# x# 0.0# = 0.0#
703 "timesFloat0.0 x" forall x#. timesFloat# 0.0# x# = 0.0#
704 "timesFloat x 1.0" forall x#. timesFloat# x# 1.0# = x#
705 "timesFloat 1.0 x" forall x#. timesFloat# 1.0# x# = x#
706 "divideFloat x 1.0" forall x#. divideFloat# x# 1.0# = x#
710 "plusDouble x 0.0" forall x#. (+##) x# 0.0## = x#
711 "plusDouble 0.0 x" forall x#. (+##) 0.0## x# = x#
712 "minusDouble x 0.0" forall x#. (-##) x# 0.0## = x#
713 "minusDouble x x" forall x#. (-##) x# x# = 0.0##
714 "timesDouble x 0.0" forall x#. (*##) x# 0.0## = 0.0##
715 "timesDouble 0.0 x" forall x#. (*##) 0.0## x# = 0.0##
716 "timesDouble x 1.0" forall x#. (*##) x# 1.0## = x#
717 "timesDouble 1.0 x" forall x#. (*##) 1.0## x# = x#
718 "divideDouble x 1.0" forall x#. (/##) x# 1.0## = x#
721 -- Wrappers for the shift operations. The uncheckedShift# family are
722 -- undefined when the amount being shifted by is greater than the size
723 -- in bits of Int#, so these wrappers perform a check and return
724 -- either zero or -1 appropriately.
726 -- Note that these wrappers still produce undefined results when the
727 -- second argument (the shift amount) is negative.
729 shiftL#, shiftRL# :: Word# -> Int# -> Word#
731 a `shiftL#` b | b >=# WORD_SIZE_IN_BITS# = int2Word# 0#
732 | otherwise = a `uncheckedShiftL#` b
734 a `shiftRL#` b | b >=# WORD_SIZE_IN_BITS# = int2Word# 0#
735 | otherwise = a `uncheckedShiftRL#` b
737 iShiftL#, iShiftRA#, iShiftRL# :: Int# -> Int# -> Int#
739 a `iShiftL#` b | b >=# WORD_SIZE_IN_BITS# = 0#
740 | otherwise = a `uncheckedIShiftL#` b
742 a `iShiftRA#` b | b >=# WORD_SIZE_IN_BITS# = if a <# 0# then (-1#) else 0#
743 | otherwise = a `uncheckedIShiftRA#` b
745 a `iShiftRL#` b | b >=# WORD_SIZE_IN_BITS# = 0#
746 | otherwise = a `uncheckedIShiftRL#` b
748 #if WORD_SIZE_IN_BITS == 32
750 "narrow32Int#" forall x#. narrow32Int# x# = x#
751 "narrow32Word#" forall x#. narrow32Word# x# = x#
756 "int2Word2Int" forall x#. int2Word# (word2Int# x#) = x#
757 "word2Int2Word" forall x#. word2Int# (int2Word# x#) = x#
762 %********************************************************
764 \subsection{Unpacking C strings}
766 %********************************************************
768 This code is needed for virtually all programs, since it's used for
769 unpacking the strings of error messages.
772 unpackCString# :: Addr# -> [Char]
773 {-# NOINLINE [1] unpackCString# #-}
774 unpackCString# a = unpackCStringList# a
776 unpackCStringList# :: Addr# -> [Char]
777 unpackCStringList# addr
781 | ch `eqChar#` '\0'# = []
782 | otherwise = C# ch : unpack (nh +# 1#)
784 ch = indexCharOffAddr# addr nh
786 unpackAppendCString# :: Addr# -> [Char] -> [Char]
787 unpackAppendCString# addr rest
791 | ch `eqChar#` '\0'# = rest
792 | otherwise = C# ch : unpack (nh +# 1#)
794 ch = indexCharOffAddr# addr nh
796 unpackFoldrCString# :: Addr# -> (Char -> a -> a) -> a -> a
797 {-# NOINLINE [0] unpackFoldrCString# #-}
798 -- Don't inline till right at the end;
799 -- usually the unpack-list rule turns it into unpackCStringList
800 unpackFoldrCString# addr f z
804 | ch `eqChar#` '\0'# = z
805 | otherwise = C# ch `f` unpack (nh +# 1#)
807 ch = indexCharOffAddr# addr nh
809 unpackCStringUtf8# :: Addr# -> [Char]
810 unpackCStringUtf8# addr
814 | ch `eqChar#` '\0'# = []
815 | ch `leChar#` '\x7F'# = C# ch : unpack (nh +# 1#)
816 | ch `leChar#` '\xDF'# =
817 C# (chr# ((ord# ch -# 0xC0#) `uncheckedIShiftL#` 6# +#
818 (ord# (indexCharOffAddr# addr (nh +# 1#)) -# 0x80#))) :
820 | ch `leChar#` '\xEF'# =
821 C# (chr# ((ord# ch -# 0xE0#) `uncheckedIShiftL#` 12# +#
822 (ord# (indexCharOffAddr# addr (nh +# 1#)) -# 0x80#) `uncheckedIShiftL#` 6# +#
823 (ord# (indexCharOffAddr# addr (nh +# 2#)) -# 0x80#))) :
826 C# (chr# ((ord# ch -# 0xF0#) `uncheckedIShiftL#` 18# +#
827 (ord# (indexCharOffAddr# addr (nh +# 1#)) -# 0x80#) `uncheckedIShiftL#` 12# +#
828 (ord# (indexCharOffAddr# addr (nh +# 2#)) -# 0x80#) `uncheckedIShiftL#` 6# +#
829 (ord# (indexCharOffAddr# addr (nh +# 3#)) -# 0x80#))) :
832 ch = indexCharOffAddr# addr nh
834 unpackNBytes# :: Addr# -> Int# -> [Char]
835 unpackNBytes# _addr 0# = []
836 unpackNBytes# addr len# = unpack [] (len# -# 1#)
841 case indexCharOffAddr# addr i# of
842 ch -> unpack (C# ch : acc) (i# -# 1#)
845 "unpack" [~1] forall a . unpackCString# a = build (unpackFoldrCString# a)
846 "unpack-list" [1] forall a . unpackFoldrCString# a (:) [] = unpackCStringList# a
847 "unpack-append" forall a n . unpackFoldrCString# a (:) n = unpackAppendCString# a n
849 -- There's a built-in rule (in GHC.Rules.lhs) for
850 -- unpackFoldr "foo" c (unpackFoldr "baz" c n) = unpackFoldr "foobaz" c n