ghc/lib/std/PrelBase.lhs

   1 % -----------------------------------------------------------------------------
   2 % $Id: PrelBase.lhs,v 1.39 2000/10/03 08:43:05 simonpj Exp $
   3 %
   4 % (c) The University of Glasgow, 1992-2000
   5 %
   6 \section[PrelBase]{Module @PrelBase@}
   7
   8
   9 The overall structure of the GHC Prelude is a bit tricky.
  10
  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
  14
  15   b) We want to avoid giant modules
  16
  17 So the rough structure is as follows, in (linearised) dependency order
  18
  19
  20 PrelGHC         Has no implementation.  It defines built-in things, and
  21                 by importing it you bring them into scope.
  22                 The source file is PrelGHC.hi-boot, which is just
  23                 copied to make PrelGHC.hi
  24
  25                 Classes: CCallable, CReturnable
  26
  27 PrelBase        Classes: Eq, Ord, Functor, Monad
  28                 Types:   list, (), Int, Bool, Ordering, Char, String
  29
  30 PrelTup         Types: tuples, plus instances for PrelBase classes
  31
  32 PrelShow        Class: Show, plus instances for PrelBase/PrelTup types
  33
  34 PrelEnum        Class: Enum,  plus instances for PrelBase/PrelTup types
  35
  36 PrelMaybe       Type: Maybe, plus instances for PrelBase classes
  37
  38 PrelNum         Class: Num, plus instances for Int
  39                 Type:  Integer, plus instances for all classes so far (Eq, Ord, Num, Show)
  40
  41                 Integer is needed here because it is mentioned in the signature
  42                 of 'fromInteger' in class Num
  43
  44 PrelReal        Classes: Real, Integral, Fractional, RealFrac
  45                          plus instances for Int, Integer
  46                 Types:  Ratio, Rational
  47                         plus intances for classes so far
  48
  49                 Rational is needed here because it is mentioned in the signature
  50                 of 'toRational' in class Real
  51
  52 Ix              Classes: Ix, plus instances for Int, Bool, Char, Integer, Ordering, tuples
  53
  54 PrelArr         Types: Array, MutableArray, MutableVar
  55
  56                 Does *not* contain any ByteArray stuff (see PrelByteArr)
  57                 Arrays are used by a function in PrelFloat
  58
  59 PrelFloat       Classes: Floating, RealFloat
  60                 Types:   Float, Double, plus instances of all classes so far
  61
  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 PrelFloat.hi
  65
  66 PrelByteArr     Types: ByteArray, MutableByteArray
  67
  68                 We want this one to be after PrelFloat, because it defines arrays
  69                 of unboxed floats.
  70
  71
  72 Other Prelude modules are much easier with fewer complex dependencies.
  73
  74
  75 \begin{code}
  76 {-# OPTIONS -fno-implicit-prelude #-}
  77
  78 module PrelBase
  79         (
  80         module PrelBase,
  81         module PrelGHC,         -- Re-export PrelGHC, PrelErr & PrelNum, to avoid lots
  82         module PrelErr          -- of people having to import it explicitly
  83   )
  84         where
  85
  86 import PrelGHC
  87 import {-# SOURCE #-} PrelErr
  88
  89 infixr 9  .
  90 infixr 5  ++, :
  91 infix  4  ==, /=, <, <=, >=, >
  92 infixr 3  &&
  93 infixr 2  ||
  94 infixl 1  >>, >>=
  95 infixr 0  $
  96
  97 default ()              -- Double isn't available yet
  98 \end{code}
  99
 100
 101 %*********************************************************
 102 %*                                                      *
 103 \subsection{DEBUGGING STUFF}
 104 %*  (for use when compiling PrelBase itself doesn't work)
 105 %*                                                      *
 106 %*********************************************************
 107
 108 \begin{code}
 109 {-
 110 data  Bool  =  False | True
 111 data Ordering = LT | EQ | GT
 112 data Char = C# Char#
 113 type  String = [Char]
 114 data Int = I# Int#
 115 data  ()  =  ()
 116 data [] a = MkNil
 117
 118 not True = False
 119 (&&) True True = True
 120 otherwise = True
 121
 122 build = error "urk"
 123 foldr = error "urk"
 124
 125 unpackCString# :: Addr# -> [Char]
 126 unpackFoldrCString# :: Addr# -> (Char  -> a -> a) -> a -> a
 127 unpackAppendCString# :: Addr# -> [Char] -> [Char]
 128 unpackCStringUtf8# :: Addr# -> [Char]
 129 unpackCString# a = error "urk"
 130 unpackFoldrCString# a = error "urk"
 131 unpackAppendCString# a = error "urk"
 132 unpackCStringUtf8# a = error "urk"
 133 -}
 134 \end{code}
 135
 136
 137 %*********************************************************
 138 %*                                                      *
 139 \subsection{Standard classes @Eq@, @Ord@}
 140 %*                                                      *
 141 %*********************************************************
 142
 143 \begin{code}
 144 class  Eq a  where
 145     (==), (/=)          :: a -> a -> Bool
 146
 147     (/=) x y            = not ((==) x y)
 148     (==) x y            = not ((/=) x y)
 149
 150 class  (Eq a) => Ord a  where
 151     compare             :: a -> a -> Ordering
 152     (<), (<=), (>=), (>):: a -> a -> Bool
 153     max, min            :: a -> a -> a
 154
 155 -- An instance of Ord should define either compare or <=
 156 -- Using compare can be more efficient for complex types.
 157     compare x y
 158             | x == y    = EQ
 159             | x <= y    = LT    -- NB: must be '<=' not '<' to validate the
 160                                 -- above claim about the minimal things that can
 161                                 -- be defined for an instance of Ord
 162             | otherwise = GT
 163
 164     x <= y  = case compare x y of { GT -> False; _other -> True }
 165     x <  y  = case compare x y of { LT -> True;  _other -> False }
 166     x >= y  = case compare x y of { LT -> False; _other -> True }
 167     x >  y  = case compare x y of { GT -> True;  _other -> False }
 168
 169         -- These two default methods use '>' rather than compare
 170         -- because the latter is often more expensive
 171     max x y = if x > y then x else y
 172     min x y = if x > y then y else x
 173 \end{code}
 174
 175 %*********************************************************
 176 %*                                                      *
 177 \subsection{Monadic classes @Functor@, @Monad@ }
 178 %*                                                      *
 179 %*********************************************************
 180
 181 \begin{code}
 182 class  Functor f  where
 183     fmap        :: (a -> b) -> f a -> f b
 184
 185 class  Monad m  where
 186     (>>=)       :: m a -> (a -> m b) -> m b
 187     (>>)        :: m a -> m b -> m b
 188     return      :: a -> m a
 189     fail        :: String -> m a
 190
 191     m >> k      =  m >>= \_ -> k
 192     fail s      = error s
 193 \end{code}
 194
 195
 196 %*********************************************************
 197 %*                                                      *
 198 \subsection{The list type}
 199 %*                                                      *
 200 %*********************************************************
 201
 202 \begin{code}
 203 data [] a = [] | a : [a]  -- do explicitly: deriving (Eq, Ord)
 204                           -- to avoid weird names like con2tag_[]#
 205
 206
 207 instance (Eq a) => Eq [a]  where
 208 {-
 209     {-# SPECIALISE instance Eq [Char] #-}
 210 -}
 211     []     == []     = True
 212     (x:xs) == (y:ys) = x == y && xs == ys
 213     _xs    == _ys    = False
 214
 215     xs     /= ys     = if (xs == ys) then False else True
 216
 217 instance (Ord a) => Ord [a] where
 218 {-
 219     {-# SPECIALISE instance Ord [Char] #-}
 220 -}
 221     a <  b  = case compare a b of { LT -> True;  EQ -> False; GT -> False }
 222     a <= b  = case compare a b of { LT -> True;  EQ -> True;  GT -> False }
 223     a >= b  = case compare a b of { LT -> False; EQ -> True;  GT -> True  }
 224     a >  b  = case compare a b of { LT -> False; EQ -> False; GT -> True  }
 225
 226     compare []     []     = EQ
 227     compare (_:_)  []     = GT
 228     compare []     (_:_)  = LT
 229     compare (x:xs) (y:ys) = case compare x y of
 230                                  LT -> LT
 231                                  GT -> GT
 232                                  EQ -> compare xs ys
 233
 234 instance Functor [] where
 235     fmap = map
 236
 237 instance  Monad []  where
 238     m >>= k             = foldr ((++) . k) [] m
 239     m >> k              = foldr ((++) . (\ _ -> k)) [] m
 240     return x            = [x]
 241     fail _              = []
 242 \end{code}
 243
 244 A few list functions that appear here because they are used here.
 245 The rest of the prelude list functions are in PrelList.
 246
 247 ----------------------------------------------
 248 --      foldr/build/augment
 249 ----------------------------------------------
 250
 251 \begin{code}
 252 foldr            :: (a -> b -> b) -> b -> [a] -> b
 253 -- foldr _ z []     =  z
 254 -- foldr f z (x:xs) =  f x (foldr f z xs)
 255 {-# INLINE foldr #-}
 256 foldr k z xs = go xs
 257              where
 258                go []     = z
 259                go (y:ys) = y `k` go ys
 260
 261 build   :: forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
 262 {-# INLINE 2 build #-}
 263         -- The INLINE is important, even though build is tiny,
 264         -- because it prevents [] getting inlined in the version that
 265         -- appears in the interface file.  If [] *is* inlined, it
 266         -- won't match with [] appearing in rules in an importing module.
 267         --
 268         -- The "2" says to inline in phase 2
 269
 270 build g = g (:) []
 271
 272 augment :: forall a. (forall b. (a->b->b) -> b -> b) -> [a] -> [a]
 273 {-# INLINE 2 augment #-}
 274 augment g xs = g (:) xs
 275
 276 {-# RULES
 277 "fold/build"    forall k z (g::forall b. (a->b->b) -> b -> b) .
 278                 foldr k z (build g) = g k z
 279
 280 "foldr/augment" forall k z xs (g::forall b. (a->b->b) -> b -> b) .
 281                 foldr k z (augment g xs) = g k (foldr k z xs)
 282
 283 "foldr/id"      foldr (:) [] = \x->x
 284 "foldr/app"     forall xs ys. foldr (:) ys xs = append xs ys
 285
 286 "foldr/cons"    forall k z x xs. foldr k z (x:xs) = k x (foldr k z xs)
 287 "foldr/nil"     forall k z.      foldr k z []     = z
 288
 289 "augment/build" forall (g::forall b. (a->b->b) -> b -> b)
 290                        (h::forall b. (a->b->b) -> b -> b) .
 291                        augment g (build h) = build (\c n -> g c (h c n))
 292 "augment/nil"   forall (g::forall b. (a->b->b) -> b -> b) .
 293                         augment g [] = build g
 294  #-}
 295
 296 -- This rule is true, but not (I think) useful:
 297 --      augment g (augment h t) = augment (\cn -> g c (h c n)) t
 298 \end{code}
 299
 300
 301 ----------------------------------------------
 302 --              map
 303 ----------------------------------------------
 304
 305 \begin{code}
 306 map :: (a -> b) -> [a] -> [b]
 307 map = mapList
 308
 309 -- Note eta expanded
 310 mapFB ::  (elt -> lst -> lst) -> (a -> elt) -> a -> lst -> lst
 311 mapFB c f x ys = c (f x) ys
 312
 313 mapList :: (a -> b) -> [a] -> [b]
 314 mapList _ []     = []
 315 mapList f (x:xs) = f x : mapList f xs
 316
 317 {-# RULES
 318 "map"       forall f xs.        map f xs                = build (\c n -> foldr (mapFB c f) n xs)
 319 "mapFB"     forall c f g.       mapFB (mapFB c f) g     = mapFB c (f.g)
 320 "mapList"   forall f.           foldr (mapFB (:) f) []  = mapList f
 321  #-}
 322 \end{code}
 323
 324
 325 ----------------------------------------------
 326 --              append
 327 ----------------------------------------------
 328 \begin{code}
 329 (++) :: [a] -> [a] -> [a]
 330 (++) = append
 331
 332 {-# RULES
 333   "++"  forall xs ys. (++) xs ys = augment (\c n -> foldr c n xs) ys
 334  #-}
 335
 336 append :: [a] -> [a] -> [a]
 337 append []     ys = ys
 338 append (x:xs) ys = x : append xs ys
 339 \end{code}
 340
 341
 342 %*********************************************************
 343 %*                                                      *
 344 \subsection{Type @Bool@}
 345 %*                                                      *
 346 %*********************************************************
 347
 348 \begin{code}
 349 data  Bool  =  False | True  deriving (Eq, Ord)
 350         -- Read in PrelRead, Show in PrelShow
 351
 352 -- Boolean functions
 353
 354 (&&), (||)              :: Bool -> Bool -> Bool
 355 True  && x              =  x
 356 False && _              =  False
 357 True  || _              =  True
 358 False || x              =  x
 359
 360 not                     :: Bool -> Bool
 361 not True                =  False
 362 not False               =  True
 363
 364 otherwise               :: Bool
 365 otherwise               =  True
 366 \end{code}
 367
 368
 369 %*********************************************************
 370 %*                                                      *
 371 \subsection{The @()@ type}
 372 %*                                                      *
 373 %*********************************************************
 374
 375 The Unit type is here because virtually any program needs it (whereas
 376 some programs may get away without consulting PrelTup).  Furthermore,
 377 the renamer currently *always* asks for () to be in scope, so that
 378 ccalls can use () as their default type; so when compiling PrelBase we
 379 need ().  (We could arrange suck in () only if -fglasgow-exts, but putting
 380 it here seems more direct.)
 381
 382 \begin{code}
 383 data  ()  =  ()
 384
 385 instance Eq () where
 386     () == () = True
 387     () /= () = False
 388
 389 instance Ord () where
 390     () <= () = True
 391     () <  () = False
 392     () >= () = True
 393     () >  () = False
 394     max () () = ()
 395     min () () = ()
 396     compare () () = EQ
 397 \end{code}
 398
 399
 400 %*********************************************************
 401 %*                                                      *
 402 \subsection{Type @Ordering@}
 403 %*                                                      *
 404 %*********************************************************
 405
 406 \begin{code}
 407 data Ordering = LT | EQ | GT deriving (Eq, Ord)
 408         -- Read in PrelRead, Show in PrelShow
 409 \end{code}
 410
 411
 412 %*********************************************************
 413 %*                                                      *
 414 \subsection{Type @Char@ and @String@}
 415 %*                                                      *
 416 %*********************************************************
 417
 418 \begin{code}
 419 type  String = [Char]
 420
 421 data Char = C# Char#
 422
 423 -- We don't use deriving for Eq and Ord, because for Ord the derived
 424 -- instance defines only compare, which takes two primops.  Then
 425 -- '>' uses compare, and therefore takes two primops instead of one.
 426
 427 instance Eq Char where
 428   (C# c1) == (C# c2) = c1 `eqChar#` c2
 429   (C# c1) /= (C# c2) = c1 `neChar#` c2
 430
 431 instance Ord Char where
 432   (C# c1) >  (C# c2) = c1 `gtChar#` c2
 433   (C# c1) >= (C# c2) = c1 `geChar#` c2
 434   (C# c1) <= (C# c2) = c1 `leChar#` c2
 435   (C# c1) <  (C# c2) = c1 `ltChar#` c2
 436
 437 chr :: Int -> Char
 438 chr (I# i) | i >=# 0#
 439 #if INT_SIZE_IN_BYTES > 4
 440              && i <=# 0x7FFFFFFF#
 441 #endif
 442              = C# (chr# i)
 443            | otherwise = error ("Prelude.chr: bad argument")
 444
 445 unsafeChr :: Int -> Char
 446 unsafeChr (I# i) =  C# (chr# i)
 447
 448 ord :: Char -> Int
 449 ord (C# c) =  I# (ord# c)
 450 \end{code}
 451
 452 String equality is used when desugaring pattern-matches against strings.
 453 It's worth making it fast, and providing a rule to use the fast version
 454 where possible.
 455
 456 \begin{code}
 457 eqString :: String -> String -> Bool
 458 eqString []            []            = True
 459 eqString (C# c1 : cs1) (C# c2 : cs2) = c1 `eqChar#` c2 && cs1 `eqString` cs2
 460 eqString _             _             = False
 461
 462 {-# RULES
 463 "eqString"  (==) = eqString
 464   #-}
 465 \end{code}
 466
 467 %*********************************************************
 468 %*                                                      *
 469 \subsection{Type @Int@}
 470 %*                                                      *
 471 %*********************************************************
 472
 473 \begin{code}
 474 data Int = I# Int#
 475
 476 zeroInt, oneInt, twoInt, maxInt, minInt :: Int
 477 zeroInt = I# 0#
 478 oneInt  = I# 1#
 479 twoInt  = I# 2#
 480 minInt  = I# (-2147483648#)     -- GHC <= 2.09 had this at -2147483647
 481 maxInt  = I# 2147483647#
 482
 483 instance Eq Int where
 484     (==) x y = x `eqInt` y
 485     (/=) x y = x `neInt` y
 486
 487 instance Ord Int where
 488     compare x y = compareInt x y
 489
 490     (<)  x y = ltInt x y
 491     (<=) x y = leInt x y
 492     (>=) x y = geInt x y
 493     (>)  x y = gtInt x y
 494
 495 compareInt :: Int -> Int -> Ordering
 496 (I# x) `compareInt` (I# y) | x <# y    = LT
 497                            | x ==# y   = EQ
 498                            | otherwise = GT
 499 \end{code}
 500
 501
 502 %*********************************************************
 503 %*                                                      *
 504 \subsection{The function type}
 505 %*                                                      *
 506 %*********************************************************
 507
 508 \begin{code}
 509 -- identity function
 510 id                      :: a -> a
 511 id x                    =  x
 512
 513 -- constant function
 514 const                   :: a -> b -> a
 515 const x _               =  x
 516
 517 -- function composition
 518 {-# INLINE (.) #-}
 519 (.)       :: (b -> c) -> (a -> b) -> a -> c
 520 (.) f g x = f (g x)
 521
 522 -- flip f  takes its (first) two arguments in the reverse order of f.
 523 flip                    :: (a -> b -> c) -> b -> a -> c
 524 flip f x y              =  f y x
 525
 526 -- right-associating infix application operator (useful in continuation-
 527 -- passing style)
 528 ($)                     :: (a -> b) -> a -> b
 529 f $ x                   =  f x
 530
 531 -- until p f  yields the result of applying f until p holds.
 532 until                   :: (a -> Bool) -> (a -> a) -> a -> a
 533 until p f x | p x       =  x
 534             | otherwise =  until p f (f x)
 535
 536 -- asTypeOf is a type-restricted version of const.  It is usually used
 537 -- as an infix operator, and its typing forces its first argument
 538 -- (which is usually overloaded) to have the same type as the second.
 539 asTypeOf                :: a -> a -> a
 540 asTypeOf                =  const
 541 \end{code}
 542
 543 %*********************************************************
 544 %*                                                      *
 545 \subsection{CCallable instances}
 546 %*                                                      *
 547 %*********************************************************
 548
 549 Defined here to avoid orphans
 550
 551 \begin{code}
 552 instance CCallable Char
 553 instance CReturnable Char
 554
 555 instance CCallable   Int
 556 instance CReturnable Int
 557
 558 instance CReturnable () -- Why, exactly?
 559 \end{code}
 560
 561
 562 %*********************************************************
 563 %*                                                      *
 564 \subsection{Generics}
 565 %*                                                      *
 566 %*********************************************************
 567
 568 \begin{code}
 569 data Unit = Unit
 570 data a :+: b = Inl a | Inr b
 571 data a :*: b = a :*: b
 572 \end{code}
 573
 574
 575 %*********************************************************
 576 %*                                                      *
 577 \subsection{Numeric primops}
 578 %*                                                      *
 579 %*********************************************************
 580
 581 Definitions of the boxed PrimOps; these will be
 582 used in the case of partial applications, etc.
 583
 584 \begin{code}
 585 {-# INLINE eqInt #-}
 586 {-# INLINE neInt #-}
 587 {-# INLINE gtInt #-}
 588 {-# INLINE geInt #-}
 589 {-# INLINE ltInt #-}
 590 {-# INLINE leInt #-}
 591 {-# INLINE plusInt #-}
 592 {-# INLINE minusInt #-}
 593 {-# INLINE timesInt #-}
 594 {-# INLINE quotInt #-}
 595 {-# INLINE remInt #-}
 596 {-# INLINE negateInt #-}
 597
 598 plusInt, minusInt, timesInt, quotInt, remInt, gcdInt :: Int -> Int -> Int
 599 plusInt (I# x) (I# y) = I# (x +# y)
 600 minusInt(I# x) (I# y) = I# (x -# y)
 601 timesInt(I# x) (I# y) = I# (x *# y)
 602 quotInt (I# x) (I# y) = I# (quotInt# x y)
 603 remInt  (I# x) (I# y) = I# (remInt#  x y)
 604
 605 gcdInt (I# a) (I# b) = g a b
 606    where g 0# 0# = error "PrelBase.gcdInt: gcd 0 0 is undefined"
 607          g 0# _  = I# absB
 608          g _  0# = I# absA
 609          g _  _  = I# (gcdInt# absA absB)
 610
 611          absInt x = if x <# 0# then negateInt# x else x
 612
 613          absA     = absInt a
 614          absB     = absInt b
 615
 616 negateInt :: Int -> Int
 617 negateInt (I# x) = I# (negateInt# x)
 618
 619 divInt, modInt :: Int -> Int -> Int
 620 x `divInt` y
 621   | x > zeroInt && y < zeroInt = quotInt ((x `minusInt` y) `minusInt` oneInt) y
 622   | x < zeroInt && y > zeroInt = quotInt ((x `minusInt` y) `plusInt`  oneInt) y
 623   | otherwise      = quotInt x y
 624
 625 x `modInt` y
 626   | x > zeroInt && y < zeroInt ||
 627     x < zeroInt && y > zeroInt  = if r/=zeroInt then r `plusInt` y else zeroInt
 628   | otherwise                   = r
 629   where
 630     r = remInt x y
 631
 632 gtInt, geInt, eqInt, neInt, ltInt, leInt :: Int -> Int -> Bool
 633 gtInt   (I# x) (I# y) = x ># y
 634 geInt   (I# x) (I# y) = x >=# y
 635 eqInt   (I# x) (I# y) = x ==# y
 636 neInt   (I# x) (I# y) = x /=# y
 637 ltInt   (I# x) (I# y) = x <# y
 638 leInt   (I# x) (I# y) = x <=# y
 639 \end{code}
 640
 641
 642 %********************************************************
 643 %*                                                      *
 644 \subsection{Unpacking C strings}
 645 %*                                                      *
 646 %********************************************************
 647
 648 This code is needed for virtually all programs, since it's used for
 649 unpacking the strings of error messages.
 650
 651 \begin{code}
 652 unpackCString# :: Addr# -> [Char]
 653 unpackCString# a = unpackCStringList# a
 654
 655 unpackCStringList# :: Addr# -> [Char]
 656 unpackCStringList# addr
 657   = unpack 0#
 658   where
 659     unpack nh
 660       | ch `eqChar#` '\0'# = []
 661       | otherwise          = C# ch : unpack (nh +# 1#)
 662       where
 663         ch = indexCharOffAddr# addr nh
 664
 665 unpackAppendCString# :: Addr# -> [Char] -> [Char]
 666 unpackAppendCString# addr rest
 667   = unpack 0#
 668   where
 669     unpack nh
 670       | ch `eqChar#` '\0'# = rest
 671       | otherwise          = C# ch : unpack (nh +# 1#)
 672       where
 673         ch = indexCharOffAddr# addr nh
 674
 675 unpackFoldrCString# :: Addr# -> (Char  -> a -> a) -> a -> a
 676 unpackFoldrCString# addr f z
 677   = unpack 0#
 678   where
 679     unpack nh
 680       | ch `eqChar#` '\0'# = z
 681       | otherwise          = C# ch `f` unpack (nh +# 1#)
 682       where
 683         ch = indexCharOffAddr# addr nh
 684
 685 unpackCStringUtf8# :: Addr# -> [Char]
 686 unpackCStringUtf8# addr
 687   = unpack 0#
 688   where
 689     unpack nh
 690       | ch `eqChar#` '\0'# = []
 691       | ch `leChar#` '\x7F'# = C# ch : unpack (nh +# 1#)
 692       | ch `leChar#` '\xDF'# = C# (chr# ((ord# ch                                  `iShiftL#`  6#) +#
 693                                          (ord# (indexCharOffAddr# addr (nh +# 1#))) -# 0x3080#))
 694                                : unpack (nh +# 2#)
 695       | ch `leChar#` '\xEF'# = C# (chr# ((ord# ch                                  `iShiftL#` 12#) +#
 696                                          (ord# (indexCharOffAddr# addr (nh +# 1#)) `iShiftL#`  6#) +#
 697                                          (ord# (indexCharOffAddr# addr (nh +# 2#))) -# 0xE2080#))
 698                                : unpack (nh +# 3#)
 699       | ch `leChar#` '\xF7'# = C# (chr# ((ord# ch                                  `iShiftL#` 18#) +#
 700                                          (ord# (indexCharOffAddr# addr (nh +# 1#)) `iShiftL#` 12#) +#
 701                                          (ord# (indexCharOffAddr# addr (nh +# 2#)) `iShiftL#`  6#) +#
 702                                          (ord# (indexCharOffAddr# addr (nh +# 3#))) -# 0x3C82080#))
 703                                : unpack (nh +# 4#)
 704       | ch `leChar#` '\xFB'# = C# (chr# ((ord# ch -# 0xF8#                         `iShiftL#` 24#) +#
 705                                          (ord# (indexCharOffAddr# addr (nh +# 1#)) `iShiftL#` 18#) +#
 706                                          (ord# (indexCharOffAddr# addr (nh +# 2#)) `iShiftL#` 12#) +#
 707                                          (ord# (indexCharOffAddr# addr (nh +# 3#)) `iShiftL#`  6#) +#
 708                                          (ord# (indexCharOffAddr# addr (nh +# 4#))) -# 0x2082080#))
 709                                : unpack (nh +# 5#)
 710       | otherwise           = C# (chr# (((ord# ch -# 0xFC#)                        `iShiftL#` 30#) +#
 711                                         ((ord# (indexCharOffAddr# addr (nh +# 1#)) -# 0x80#)
 712                                                                                    `iShiftL#` 24#) +#
 713                                          (ord# (indexCharOffAddr# addr (nh +# 2#)) `iShiftL#` 18#) +#
 714                                          (ord# (indexCharOffAddr# addr (nh +# 3#)) `iShiftL#` 12#) +#
 715                                          (ord# (indexCharOffAddr# addr (nh +# 4#)) `iShiftL#`  6#) +#
 716                                          (ord# (indexCharOffAddr# addr (nh +# 5#))) -# 0x2082080#))
 717                                : unpack (nh +# 6#)
 718       where
 719         ch = indexCharOffAddr# addr nh
 720
 721 unpackNBytes# :: Addr# -> Int# -> [Char]
 722 unpackNBytes# _addr 0#   = []
 723 unpackNBytes#  addr len# = unpack [] (len# -# 1#)
 724     where
 725      unpack acc i#
 726       | i# <# 0#  = acc
 727       | otherwise =
 728          case indexCharOffAddr# addr i# of
 729             ch -> unpack (C# ch : acc) (i# -# 1#)
 730
 731 {-# RULES
 732 "unpack"         forall a   . unpackCString# a             = build (unpackFoldrCString# a)
 733 "unpack-list"    forall a   . unpackFoldrCString# a (:) [] = unpackCStringList# a
 734 "unpack-append"  forall a n . unpackFoldrCString# a (:) n  = unpackAppendCString# a n
 735
 736 -- There's a built-in rule (in PrelRules.lhs) for
 737 --      unpackFoldr "foo" c (unpackFoldr "baz" c n)  =  unpackFoldr "foobaz" c n
 738
 739   #-}
 740 \end{code}