GHC/Base.lhs

   1 \section[GHC.Base]{Module @GHC.Base@}
   2
   3 The overall structure of the GHC Prelude is a bit tricky.
   4
   5   a) We want to avoid "orphan modules", i.e. ones with instance
   6         decls that don't belong either to a tycon or a class
   7         defined in the same module
   8
   9   b) We want to avoid giant modules
  10
  11 So the rough structure is as follows, in (linearised) dependency order
  12
  13
  14 GHC.Prim                Has no implementation.  It defines built-in things, and
  15                 by importing it you bring them into scope.
  16                 The source file is GHC.Prim.hi-boot, which is just
  17                 copied to make GHC.Prim.hi
  18
  19                 Classes: CCallable, CReturnable
  20
  21 GHC.Base        Classes: Eq, Ord, Functor, Monad
  22                 Types:   list, (), Int, Bool, Ordering, Char, String
  23
  24 Data.Tup        Types: tuples, plus instances for GHC.Base classes
  25
  26 GHC.Show        Class: Show, plus instances for GHC.Base/GHC.Tup types
  27
  28 GHC.Enum        Class: Enum,  plus instances for GHC.Base/GHC.Tup types
  29
  30 Data.Maybe      Type: Maybe, plus instances for GHC.Base classes
  31
  32 GHC.Num         Class: Num, plus instances for Int
  33                 Type:  Integer, plus instances for all classes so far (Eq, Ord, Num, Show)
  34
  35                 Integer is needed here because it is mentioned in the signature
  36                 of 'fromInteger' in class Num
  37
  38 GHC.Real        Classes: Real, Integral, Fractional, RealFrac
  39                          plus instances for Int, Integer
  40                 Types:  Ratio, Rational
  41                         plus intances for classes so far
  42
  43                 Rational is needed here because it is mentioned in the signature
  44                 of 'toRational' in class Real
  45
  46 Ix              Classes: Ix, plus instances for Int, Bool, Char, Integer, Ordering, tuples
  47
  48 GHC.Arr         Types: Array, MutableArray, MutableVar
  49
  50                 Does *not* contain any ByteArray stuff (see GHC.ByteArr)
  51                 Arrays are used by a function in GHC.Float
  52
  53 GHC.Float       Classes: Floating, RealFloat
  54                 Types:   Float, Double, plus instances of all classes so far
  55
  56                 This module contains everything to do with floating point.
  57                 It is a big module (900 lines)
  58                 With a bit of luck, many modules can be compiled without ever reading GHC.Float.hi
  59
  60 GHC.ByteArr     Types: ByteArray, MutableByteArray
  61
  62                 We want this one to be after GHC.Float, because it defines arrays
  63                 of unboxed floats.
  64
  65
  66 Other Prelude modules are much easier with fewer complex dependencies.
  67
  68 \begin{code}
  69 {-# OPTIONS -fno-implicit-prelude #-}
  70 -----------------------------------------------------------------------------
  71 -- |
  72 -- Module      :  GHC.Base
  73 -- Copyright   :  (c) The University of Glasgow, 1992-2002
  74 -- License     :  see libraries/base/LICENSE
  75 --
  76 -- Maintainer  :  cvs-ghc@haskell.org
  77 -- Stability   :  internal
  78 -- Portability :  non-portable (GHC extensions)
  79 --
  80 -- Basic data types and classes.
  81 --
  82 -----------------------------------------------------------------------------
  83
  84 #include "MachDeps.h"
  85
  86 module GHC.Base
  87         (
  88         module GHC.Base,
  89         module GHC.Prim,                -- Re-export GHC.Prim and GHC.Err, to avoid lots
  90         module GHC.Err          -- of people having to import it explicitly
  91   )
  92         where
  93
  94 import GHC.Prim
  95 import {-# SOURCE #-} GHC.Err
  96
  97 infixr 9  .
  98 infixr 5  ++, :
  99 infix  4  ==, /=, <, <=, >=, >
 100 infixr 3  &&
 101 infixr 2  ||
 102 infixl 1  >>, >>=
 103 infixr 0  $
 104
 105 default ()              -- Double isn't available yet
 106 \end{code}
 107
 108
 109 %*********************************************************
 110 %*                                                      *
 111 \subsection{DEBUGGING STUFF}
 112 %*  (for use when compiling GHC.Base itself doesn't work)
 113 %*                                                      *
 114 %*********************************************************
 115
 116 \begin{code}
 117 {-
 118 data  Bool  =  False | True
 119 data Ordering = LT | EQ | GT
 120 data Char = C# Char#
 121 type  String = [Char]
 122 data Int = I# Int#
 123 data  ()  =  ()
 124 data [] a = MkNil
 125
 126 not True = False
 127 (&&) True True = True
 128 otherwise = True
 129
 130 build = error "urk"
 131 foldr = error "urk"
 132
 133 unpackCString# :: Addr# -> [Char]
 134 unpackFoldrCString# :: Addr# -> (Char  -> a -> a) -> a -> a
 135 unpackAppendCString# :: Addr# -> [Char] -> [Char]
 136 unpackCStringUtf8# :: Addr# -> [Char]
 137 unpackCString# a = error "urk"
 138 unpackFoldrCString# a = error "urk"
 139 unpackAppendCString# a = error "urk"
 140 unpackCStringUtf8# a = error "urk"
 141 -}
 142 \end{code}
 143
 144
 145 %*********************************************************
 146 %*                                                      *
 147 \subsection{Standard classes @Eq@, @Ord@}
 148 %*                                                      *
 149 %*********************************************************
 150
 151 \begin{code}
 152 class  Eq a  where
 153     (==), (/=)           :: a -> a -> Bool
 154
 155     x /= y               = not (x == y)
 156     x == y               = not (x /= y)
 157
 158 class  (Eq a) => Ord a  where
 159     compare              :: a -> a -> Ordering
 160     (<), (<=), (>), (>=) :: a -> a -> Bool
 161     max, min             :: a -> a -> a
 162
 163     -- An instance of Ord should define either 'compare' or '<='.
 164     -- Using 'compare' can be more efficient for complex types.
 165
 166     compare x y
 167         | x == y    = EQ
 168         | x <= y    = LT        -- NB: must be '<=' not '<' to validate the
 169                                 -- above claim about the minimal things that
 170                                 -- can be defined for an instance of Ord
 171         | otherwise = GT
 172
 173     x <  y = case compare x y of { LT -> True;  _other -> False }
 174     x <= y = case compare x y of { GT -> False; _other -> True }
 175     x >  y = case compare x y of { GT -> True;  _other -> False }
 176     x >= y = case compare x y of { LT -> False; _other -> True }
 177
 178         -- These two default methods use '<=' rather than 'compare'
 179         -- because the latter is often more expensive
 180     max x y = if x <= y then y else x
 181     min x y = if x <= y then x else y
 182 \end{code}
 183
 184 %*********************************************************
 185 %*                                                      *
 186 \subsection{Monadic classes @Functor@, @Monad@ }
 187 %*                                                      *
 188 %*********************************************************
 189
 190 \begin{code}
 191 class  Functor f  where
 192     fmap        :: (a -> b) -> f a -> f b
 193
 194 class  Monad m  where
 195     (>>=)       :: m a -> (a -> m b) -> m b
 196     (>>)        :: m a -> m b -> m b
 197     return      :: a -> m a
 198     fail        :: String -> m a
 199
 200     m >> k      = m >>= \_ -> k
 201     fail s      = error s
 202 \end{code}
 203
 204
 205 %*********************************************************
 206 %*                                                      *
 207 \subsection{The list type}
 208 %*                                                      *
 209 %*********************************************************
 210
 211 \begin{code}
 212 data [] a = [] | a : [a]  -- do explicitly: deriving (Eq, Ord)
 213                           -- to avoid weird names like con2tag_[]#
 214
 215
 216 instance (Eq a) => Eq [a] where
 217     {-# SPECIALISE instance Eq [Char] #-}
 218     []     == []     = True
 219     (x:xs) == (y:ys) = x == y && xs == ys
 220     _xs    == _ys    = False
 221
 222 instance (Ord a) => Ord [a] where
 223     {-# SPECIALISE instance Ord [Char] #-}
 224     compare []     []     = EQ
 225     compare []     (_:_)  = LT
 226     compare (_:_)  []     = GT
 227     compare (x:xs) (y:ys) = case compare x y of
 228                                 EQ    -> compare xs ys
 229                                 other -> other
 230
 231 instance Functor [] where
 232     fmap = map
 233
 234 instance  Monad []  where
 235     m >>= k             = foldr ((++) . k) [] m
 236     m >> k              = foldr ((++) . (\ _ -> k)) [] m
 237     return x            = [x]
 238     fail _              = []
 239 \end{code}
 240
 241 A few list functions that appear here because they are used here.
 242 The rest of the prelude list functions are in GHC.List.
 243
 244 ----------------------------------------------
 245 --      foldr/build/augment
 246 ----------------------------------------------
 247
 248 \begin{code}
 249 foldr            :: (a -> b -> b) -> b -> [a] -> b
 250 -- foldr _ z []     =  z
 251 -- foldr f z (x:xs) =  f x (foldr f z xs)
 252 {-# INLINE [0] foldr #-}
 253 -- Inline only in the final stage, after the foldr/cons rule has had a chance
 254 foldr k z xs = go xs
 255              where
 256                go []     = z
 257                go (y:ys) = y `k` go ys
 258
 259 build   :: forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
 260 {-# INLINE [1] build #-}
 261         -- The INLINE is important, even though build is tiny,
 262         -- because it prevents [] getting inlined in the version that
 263         -- appears in the interface file.  If [] *is* inlined, it
 264         -- won't match with [] appearing in rules in an importing module.
 265         --
 266         -- The "1" says to inline in phase 1
 267
 268 build g = g (:) []
 269
 270 augment :: forall a. (forall b. (a->b->b) -> b -> b) -> [a] -> [a]
 271 {-# INLINE [1] augment #-}
 272 augment g xs = g (:) xs
 273
 274 {-# RULES
 275 "fold/build"    forall k z (g::forall b. (a->b->b) -> b -> b) .
 276                 foldr k z (build g) = g k z
 277
 278 "foldr/augment" forall k z xs (g::forall b. (a->b->b) -> b -> b) .
 279                 foldr k z (augment g xs) = g k (foldr k z xs)
 280
 281 "foldr/id"                        foldr (:) [] = \x->x
 282 "foldr/app"     [1] forall xs ys. foldr (:) ys xs = xs ++ ys
 283         -- Only activate this from phase 1, because that's
 284         -- when we disable the rule that expands (++) into foldr
 285
 286 -- The foldr/cons rule looks nice, but it can give disastrously
 287 -- bloated code when commpiling
 288 --      array (a,b) [(1,2), (2,2), (3,2), ...very long list... ]
 289 -- i.e. when there are very very long literal lists
 290 -- So I've disabled it for now. We could have special cases
 291 -- for short lists, I suppose.
 292 -- "foldr/cons" forall k z x xs. foldr k z (x:xs) = k x (foldr k z xs)
 293
 294 "foldr/single"  forall k z x. foldr k z [x] = k x z
 295 "foldr/nil"     forall k z.   foldr k z []  = z
 296
 297 "augment/build" forall (g::forall b. (a->b->b) -> b -> b)
 298                        (h::forall b. (a->b->b) -> b -> b) .
 299                        augment g (build h) = build (\c n -> g c (h c n))
 300 "augment/nil"   forall (g::forall b. (a->b->b) -> b -> b) .
 301                         augment g [] = build g
 302  #-}
 303
 304 -- This rule is true, but not (I think) useful:
 305 --      augment g (augment h t) = augment (\cn -> g c (h c n)) t
 306 \end{code}
 307
 308
 309 ----------------------------------------------
 310 --              map
 311 ----------------------------------------------
 312
 313 \begin{code}
 314 map :: (a -> b) -> [a] -> [b]
 315 map _ []     = []
 316 map f (x:xs) = f x : map f xs
 317
 318 -- Note eta expanded
 319 mapFB ::  (elt -> lst -> lst) -> (a -> elt) -> a -> lst -> lst
 320 {-# INLINE [0] mapFB #-}
 321 mapFB c f x ys = c (f x) ys
 322
 323 -- The rules for map work like this.
 324 --
 325 -- Up to (but not including) phase 1, we use the "map" rule to
 326 -- rewrite all saturated applications of map with its build/fold
 327 -- form, hoping for fusion to happen.
 328 -- In phase 1 and 0, we switch off that rule, inline build, and
 329 -- switch on the "mapList" rule, which rewrites the foldr/mapFB
 330 -- thing back into plain map.
 331 --
 332 -- It's important that these two rules aren't both active at once
 333 -- (along with build's unfolding) else we'd get an infinite loop
 334 -- in the rules.  Hence the activation control below.
 335 --
 336 -- The "mapFB" rule optimises compositions of map.
 337 --
 338 -- This same pattern is followed by many other functions:
 339 -- e.g. append, filter, iterate, repeat, etc.
 340
 341 {-# RULES
 342 "map"       [~1] forall f xs.   map f xs                = build (\c n -> foldr (mapFB c f) n xs)
 343 "mapList"   [1]  forall f.      foldr (mapFB (:) f) []  = map f
 344 "mapFB"     forall c f g.       mapFB (mapFB c f) g     = mapFB c (f.g)
 345   #-}
 346 \end{code}
 347
 348
 349 ----------------------------------------------
 350 --              append
 351 ----------------------------------------------
 352 \begin{code}
 353 (++) :: [a] -> [a] -> [a]
 354 (++) []     ys = ys
 355 (++) (x:xs) ys = x : xs ++ ys
 356
 357 {-# RULES
 358 "++"    [~1] forall xs ys. xs ++ ys = augment (\c n -> foldr c n xs) ys
 359   #-}
 360
 361 \end{code}
 362
 363
 364 %*********************************************************
 365 %*                                                      *
 366 \subsection{Type @Bool@}
 367 %*                                                      *
 368 %*********************************************************
 369
 370 \begin{code}
 371 -- |The 'Bool' type is an enumeration.  It is defined with 'False'
 372 -- first so that the corresponding 'Enum' instance will give @'fromEnum'
 373 -- False@ the value zero, and @'fromEnum' True@ the value 1.
 374 data  Bool  =  False | True  deriving (Eq, Ord)
 375         -- Read in GHC.Read, Show in GHC.Show
 376
 377 -- Boolean functions
 378
 379 -- | Boolean \"and\"
 380 (&&)                    :: Bool -> Bool -> Bool
 381 True  && x              =  x
 382 False && _              =  False
 383
 384 -- | Boolean \"or\"
 385 (||)                    :: Bool -> Bool -> Bool
 386 True  || _              =  True
 387 False || x              =  x
 388
 389 -- | Boolean \"not\"
 390 not                     :: Bool -> Bool
 391 not True                =  False
 392 not False               =  True
 393
 394 -- |'otherwise' is defined as the value 'True'; it helps to make
 395 -- guards more readable.  eg.
 396 --
 397 -- >  f x | x \< 0     = ...
 398 -- >      | otherwise = ...
 399 otherwise               :: Bool
 400 otherwise               =  True
 401 \end{code}
 402
 403
 404 %*********************************************************
 405 %*                                                      *
 406 \subsection{The @()@ type}
 407 %*                                                      *
 408 %*********************************************************
 409
 410 The Unit type is here because virtually any program needs it (whereas
 411 some programs may get away without consulting GHC.Tup).  Furthermore,
 412 the renamer currently *always* asks for () to be in scope, so that
 413 ccalls can use () as their default type; so when compiling GHC.Base we
 414 need ().  (We could arrange suck in () only if -fglasgow-exts, but putting
 415 it here seems more direct.)
 416
 417 \begin{code}
 418 data () = ()
 419
 420 instance Eq () where
 421     () == () = True
 422     () /= () = False
 423
 424 instance Ord () where
 425     () <= () = True
 426     () <  () = False
 427     () >= () = True
 428     () >  () = False
 429     max () () = ()
 430     min () () = ()
 431     compare () () = EQ
 432 \end{code}
 433
 434
 435 %*********************************************************
 436 %*                                                      *
 437 \subsection{Type @Ordering@}
 438 %*                                                      *
 439 %*********************************************************
 440
 441 \begin{code}
 442 data Ordering = LT | EQ | GT deriving (Eq, Ord)
 443         -- Read in GHC.Read, Show in GHC.Show
 444 \end{code}
 445
 446
 447 %*********************************************************
 448 %*                                                      *
 449 \subsection{Type @Char@ and @String@}
 450 %*                                                      *
 451 %*********************************************************
 452
 453 \begin{code}
 454 type String = [Char]
 455
 456 data Char = C# Char#
 457
 458 -- We don't use deriving for Eq and Ord, because for Ord the derived
 459 -- instance defines only compare, which takes two primops.  Then
 460 -- '>' uses compare, and therefore takes two primops instead of one.
 461
 462 instance Eq Char where
 463     (C# c1) == (C# c2) = c1 `eqChar#` c2
 464     (C# c1) /= (C# c2) = c1 `neChar#` c2
 465
 466 instance Ord Char where
 467     (C# c1) >  (C# c2) = c1 `gtChar#` c2
 468     (C# c1) >= (C# c2) = c1 `geChar#` c2
 469     (C# c1) <= (C# c2) = c1 `leChar#` c2
 470     (C# c1) <  (C# c2) = c1 `ltChar#` c2
 471
 472 {-# RULES
 473 "x# `eqChar#` x#" forall x#. x# `eqChar#` x# = True
 474 "x# `neChar#` x#" forall x#. x# `neChar#` x# = False
 475 "x# `gtChar#` x#" forall x#. x# `gtChar#` x# = False
 476 "x# `geChar#` x#" forall x#. x# `geChar#` x# = True
 477 "x# `leChar#` x#" forall x#. x# `leChar#` x# = True
 478 "x# `ltChar#` x#" forall x#. x# `ltChar#` x# = False
 479   #-}
 480
 481 chr :: Int -> Char
 482 chr (I# i#) | int2Word# i# `leWord#` int2Word# 0x10FFFF# = C# (chr# i#)
 483             | otherwise                                  = error "Prelude.chr: bad argument"
 484
 485 unsafeChr :: Int -> Char
 486 unsafeChr (I# i#) = C# (chr# i#)
 487
 488 ord :: Char -> Int
 489 ord (C# c#) = I# (ord# c#)
 490 \end{code}
 491
 492 String equality is used when desugaring pattern-matches against strings.
 493
 494 \begin{code}
 495 eqString :: String -> String -> Bool
 496 eqString []       []       = True
 497 eqString (c1:cs1) (c2:cs2) = c1 == c2 && cs1 `eqString` cs2
 498 eqString cs1      cs2      = False
 499
 500 {-# RULES "eqString" (==) = eqString #-}
 501 \end{code}
 502
 503
 504 %*********************************************************
 505 %*                                                      *
 506 \subsection{Type @Int@}
 507 %*                                                      *
 508 %*********************************************************
 509
 510 \begin{code}
 511 data Int = I# Int#
 512 -- ^A fixed-precision integer type with at least the range @[-2^29
 513 -- .. 2^29-1]@.  The exact range for a given implementation can be
 514 -- determined by using 'minBound' and 'maxBound' from the 'Bounded'
 515 -- class.
 516
 517 zeroInt, oneInt, twoInt, maxInt, minInt :: Int
 518 zeroInt = I# 0#
 519 oneInt  = I# 1#
 520 twoInt  = I# 2#
 521
 522 {- Seems clumsy. Should perhaps put minInt and MaxInt directly into MachDeps.h -}
 523 #if WORD_SIZE_IN_BITS == 31
 524 minInt  = I# (-0x40000000#)
 525 maxInt  = I# 0x3FFFFFFF#
 526 #elif WORD_SIZE_IN_BITS == 32
 527 minInt  = I# (-0x80000000#)
 528 maxInt  = I# 0x7FFFFFFF#
 529 #else
 530 minInt  = I# (-0x8000000000000000#)
 531 maxInt  = I# 0x7FFFFFFFFFFFFFFF#
 532 #endif
 533
 534 instance Eq Int where
 535     (==) = eqInt
 536     (/=) = neInt
 537
 538 instance Ord Int where
 539     compare = compareInt
 540     (<)     = ltInt
 541     (<=)    = leInt
 542     (>=)    = geInt
 543     (>)     = gtInt
 544
 545 compareInt :: Int -> Int -> Ordering
 546 (I# x#) `compareInt` (I# y#) = compareInt# x# y#
 547
 548 compareInt# :: Int# -> Int# -> Ordering
 549 compareInt# x# y#
 550     | x# <#  y# = LT
 551     | x# ==# y# = EQ
 552     | otherwise = GT
 553 \end{code}
 554
 555
 556 %*********************************************************
 557 %*                                                      *
 558 \subsection{The function type}
 559 %*                                                      *
 560 %*********************************************************
 561
 562 \begin{code}
 563 -- identity function
 564 id                      :: a -> a
 565 id x                    =  x
 566
 567 -- lazy function; this is just the same as id, but its unfolding
 568 -- and strictness are over-ridden by the definition in MkId.lhs
 569 -- That way, it does not get inlined, and the strictness analyser
 570 -- sees it as lazy.  Then the worker/wrapper phase inlines it.
 571 -- Result: happiness
 572 lazy :: a -> a
 573 lazy x = x
 574
 575 -- constant function
 576 const                   :: a -> b -> a
 577 const x _               =  x
 578
 579 -- function composition
 580 {-# INLINE (.) #-}
 581 (.)       :: (b -> c) -> (a -> b) -> a -> c
 582 (.) f g x = f (g x)
 583
 584 -- flip f  takes its (first) two arguments in the reverse order of f.
 585 flip                    :: (a -> b -> c) -> b -> a -> c
 586 flip f x y              =  f y x
 587
 588 -- right-associating infix application operator (useful in continuation-
 589 -- passing style)
 590 {-# INLINE ($) #-}
 591 ($)                     :: (a -> b) -> a -> b
 592 f $ x                   =  f x
 593
 594 -- until p f  yields the result of applying f until p holds.
 595 until                   :: (a -> Bool) -> (a -> a) -> a -> a
 596 until p f x | p x       =  x
 597             | otherwise =  until p f (f x)
 598
 599 -- asTypeOf is a type-restricted version of const.  It is usually used
 600 -- as an infix operator, and its typing forces its first argument
 601 -- (which is usually overloaded) to have the same type as the second.
 602 asTypeOf                :: a -> a -> a
 603 asTypeOf                =  const
 604 \end{code}
 605
 606 %*********************************************************
 607 %*                                                      *
 608 \subsection{CCallable instances}
 609 %*                                                      *
 610 %*********************************************************
 611
 612 Defined here to avoid orphans
 613
 614 \begin{code}
 615 instance CCallable Char
 616 instance CReturnable Char
 617
 618 instance CCallable   Int
 619 instance CReturnable Int
 620
 621 instance CReturnable () -- Why, exactly?
 622 \end{code}
 623
 624
 625 %*********************************************************
 626 %*                                                      *
 627 \subsection{Generics}
 628 %*                                                      *
 629 %*********************************************************
 630
 631 \begin{code}
 632 data Unit = Unit
 633 #ifndef __HADDOCK__
 634 data (:+:) a b = Inl a | Inr b
 635 data (:*:) a b = a :*: b
 636 #endif
 637 \end{code}
 638
 639
 640 %*********************************************************
 641 %*                                                      *
 642 \subsection{Numeric primops}
 643 %*                                                      *
 644 %*********************************************************
 645
 646 \begin{code}
 647 divInt#, modInt# :: Int# -> Int# -> Int#
 648 x# `divInt#` y#
 649     | (x# ># 0#) && (y# <# 0#) = ((x# -# y#) -# 1#) `quotInt#` y#
 650     | (x# <# 0#) && (y# ># 0#) = ((x# -# y#) +# 1#) `quotInt#` y#
 651     | otherwise                = x# `quotInt#` y#
 652 x# `modInt#` y#
 653     | (x# ># 0#) && (y# <# 0#) ||
 654       (x# <# 0#) && (y# ># 0#)    = if r# /=# 0# then r# +# y# else 0#
 655     | otherwise                   = r#
 656     where
 657     r# = x# `remInt#` y#
 658 \end{code}
 659
 660 Definitions of the boxed PrimOps; these will be
 661 used in the case of partial applications, etc.
 662
 663 \begin{code}
 664 {-# INLINE eqInt #-}
 665 {-# INLINE neInt #-}
 666 {-# INLINE gtInt #-}
 667 {-# INLINE geInt #-}
 668 {-# INLINE ltInt #-}
 669 {-# INLINE leInt #-}
 670 {-# INLINE plusInt #-}
 671 {-# INLINE minusInt #-}
 672 {-# INLINE timesInt #-}
 673 {-# INLINE quotInt #-}
 674 {-# INLINE remInt #-}
 675 {-# INLINE negateInt #-}
 676
 677 plusInt, minusInt, timesInt, quotInt, remInt, divInt, modInt, gcdInt :: Int -> Int -> Int
 678 (I# x) `plusInt`  (I# y) = I# (x +# y)
 679 (I# x) `minusInt` (I# y) = I# (x -# y)
 680 (I# x) `timesInt` (I# y) = I# (x *# y)
 681 (I# x) `quotInt`  (I# y) = I# (x `quotInt#` y)
 682 (I# x) `remInt`   (I# y) = I# (x `remInt#`  y)
 683 (I# x) `divInt`   (I# y) = I# (x `divInt#`  y)
 684 (I# x) `modInt`   (I# y) = I# (x `modInt#`  y)
 685
 686 {-# RULES
 687 "x# +# 0#" forall x#. x# +# 0# = x#
 688 "0# +# x#" forall x#. 0# +# x# = x#
 689 "x# -# 0#" forall x#. x# -# 0# = x#
 690 "x# -# x#" forall x#. x# -# x# = 0#
 691 "x# *# 0#" forall x#. x# *# 0# = 0#
 692 "0# *# x#" forall x#. 0# *# x# = 0#
 693 "x# *# 1#" forall x#. x# *# 1# = x#
 694 "1# *# x#" forall x#. 1# *# x# = x#
 695   #-}
 696
 697 gcdInt (I# a) (I# b) = g a b
 698    where g 0# 0# = error "GHC.Base.gcdInt: gcd 0 0 is undefined"
 699          g 0# _  = I# absB
 700          g _  0# = I# absA
 701          g _  _  = I# (gcdInt# absA absB)
 702
 703          absInt x = if x <# 0# then negateInt# x else x
 704
 705          absA     = absInt a
 706          absB     = absInt b
 707
 708 negateInt :: Int -> Int
 709 negateInt (I# x) = I# (negateInt# x)
 710
 711 gtInt, geInt, eqInt, neInt, ltInt, leInt :: Int -> Int -> Bool
 712 (I# x) `gtInt` (I# y) = x >#  y
 713 (I# x) `geInt` (I# y) = x >=# y
 714 (I# x) `eqInt` (I# y) = x ==# y
 715 (I# x) `neInt` (I# y) = x /=# y
 716 (I# x) `ltInt` (I# y) = x <#  y
 717 (I# x) `leInt` (I# y) = x <=# y
 718
 719 {-# RULES
 720 "x# ># x#"  forall x#. x# >#  x# = False
 721 "x# >=# x#" forall x#. x# >=# x# = True
 722 "x# ==# x#" forall x#. x# ==# x# = True
 723 "x# /=# x#" forall x#. x# /=# x# = False
 724 "x# <# x#"  forall x#. x# <#  x# = False
 725 "x# <=# x#" forall x#. x# <=# x# = True
 726   #-}
 727
 728 {-# RULES
 729 "plusFloat x 0.0"   forall x#. plusFloat#  x#   0.0# = x#
 730 "plusFloat 0.0 x"   forall x#. plusFloat#  0.0# x#   = x#
 731 "minusFloat x 0.0"  forall x#. minusFloat# x#   0.0# = x#
 732 "minusFloat x x"    forall x#. minusFloat# x#   x#   = 0.0#
 733 "timesFloat x 0.0"  forall x#. timesFloat# x#   0.0# = 0.0#
 734 "timesFloat0.0 x"   forall x#. timesFloat# 0.0# x#   = 0.0#
 735 "timesFloat x 1.0"  forall x#. timesFloat# x#   1.0# = x#
 736 "timesFloat 1.0 x"  forall x#. timesFloat# 1.0# x#   = x#
 737 "divideFloat x 1.0" forall x#. divideFloat# x#  1.0# = x#
 738   #-}
 739
 740 {-# RULES
 741 "plusDouble x 0.0"   forall x#. (+##) x#    0.0## = x#
 742 "plusDouble 0.0 x"   forall x#. (+##) 0.0## x#    = x#
 743 "minusDouble x 0.0"  forall x#. (-##) x#    0.0## = x#
 744 "minusDouble x x"    forall x#. (-##) x#    x#    = 0.0##
 745 "timesDouble x 0.0"  forall x#. (*##) x#    0.0## = 0.0##
 746 "timesDouble 0.0 x"  forall x#. (*##) 0.0## x#    = 0.0##
 747 "timesDouble x 1.0"  forall x#. (*##) x#    1.0## = x#
 748 "timesDouble 1.0 x"  forall x#. (*##) 1.0## x#    = x#
 749 "divideDouble x 1.0" forall x#. (/##) x#    1.0## = x#
 750   #-}
 751
 752 -- Wrappers for the shift operations.  The uncheckedShift# family are
 753 -- undefined when the amount being shifted by is greater than the size
 754 -- in bits of Int#, so these wrappers perform a check and return
 755 -- either zero or -1 appropriately.
 756 --
 757 -- Note that these wrappers still produce undefined results when the
 758 -- second argument (the shift amount) is negative.
 759
 760 shiftL#, shiftRL# :: Word# -> Int# -> Word#
 761
 762 a `shiftL#` b   | b >=# WORD_SIZE_IN_BITS# = int2Word# 0#
 763                 | otherwise                = a `uncheckedShiftL#` b
 764
 765 a `shiftRL#` b  | b >=# WORD_SIZE_IN_BITS# = int2Word# 0#
 766                 | otherwise                = a `uncheckedShiftRL#` b
 767
 768 iShiftL#, iShiftRA#, iShiftRL# :: Int# -> Int# -> Int#
 769
 770 a `iShiftL#` b  | b >=# WORD_SIZE_IN_BITS# = 0#
 771                 | otherwise                = a `uncheckedIShiftL#` b
 772
 773 a `iShiftRA#` b | b >=# WORD_SIZE_IN_BITS# = if a <# 0# then (-1#) else 0#
 774                 | otherwise                = a `uncheckedIShiftRA#` b
 775
 776 a `iShiftRL#` b | b >=# WORD_SIZE_IN_BITS# = 0#
 777                 | otherwise                = a `uncheckedIShiftRL#` b
 778
 779 #if WORD_SIZE_IN_BITS == 32
 780 {-# RULES
 781 "narrow32Int#"  forall x#. narrow32Int#   x# = x#
 782 "narrow32Word#" forall x#. narrow32Word#   x# = x#
 783    #-}
 784 #endif
 785
 786 {-# RULES
 787 "int2Word2Int"  forall x#. int2Word# (word2Int# x#) = x#
 788 "word2Int2Word" forall x#. word2Int# (int2Word# x#) = x#
 789   #-}
 790 \end{code}
 791
 792
 793 %********************************************************
 794 %*                                                      *
 795 \subsection{Unpacking C strings}
 796 %*                                                      *
 797 %********************************************************
 798
 799 This code is needed for virtually all programs, since it's used for
 800 unpacking the strings of error messages.
 801
 802 \begin{code}
 803 unpackCString# :: Addr# -> [Char]
 804 {-# NOINLINE [1] unpackCString# #-}
 805 unpackCString# addr
 806   = unpack 0#
 807   where
 808     unpack nh
 809       | ch `eqChar#` '\0'# = []
 810       | otherwise          = C# ch : unpack (nh +# 1#)
 811       where
 812         ch = indexCharOffAddr# addr nh
 813
 814 unpackAppendCString# :: Addr# -> [Char] -> [Char]
 815 unpackAppendCString# addr rest
 816   = unpack 0#
 817   where
 818     unpack nh
 819       | ch `eqChar#` '\0'# = rest
 820       | otherwise          = C# ch : unpack (nh +# 1#)
 821       where
 822         ch = indexCharOffAddr# addr nh
 823
 824 unpackFoldrCString# :: Addr# -> (Char  -> a -> a) -> a -> a
 825 {-# NOINLINE [0] unpackFoldrCString# #-}
 826 -- Don't inline till right at the end;
 827 -- usually the unpack-list rule turns it into unpackCStringList
 828 unpackFoldrCString# addr f z
 829   = unpack 0#
 830   where
 831     unpack nh
 832       | ch `eqChar#` '\0'# = z
 833       | otherwise          = C# ch `f` unpack (nh +# 1#)
 834       where
 835         ch = indexCharOffAddr# addr nh
 836
 837 unpackCStringUtf8# :: Addr# -> [Char]
 838 unpackCStringUtf8# addr
 839   = unpack 0#
 840   where
 841     unpack nh
 842       | ch `eqChar#` '\0'#   = []
 843       | ch `leChar#` '\x7F'# = C# ch : unpack (nh +# 1#)
 844       | ch `leChar#` '\xDF'# =
 845           C# (chr# ((ord# ch                                  -# 0xC0#) `uncheckedIShiftL#`  6# +#
 846                     (ord# (indexCharOffAddr# addr (nh +# 1#)) -# 0x80#))) :
 847           unpack (nh +# 2#)
 848       | ch `leChar#` '\xEF'# =
 849           C# (chr# ((ord# ch                                  -# 0xE0#) `uncheckedIShiftL#` 12# +#
 850                     (ord# (indexCharOffAddr# addr (nh +# 1#)) -# 0x80#) `uncheckedIShiftL#`  6# +#
 851                     (ord# (indexCharOffAddr# addr (nh +# 2#)) -# 0x80#))) :
 852           unpack (nh +# 3#)
 853       | otherwise            =
 854           C# (chr# ((ord# ch                                  -# 0xF0#) `uncheckedIShiftL#` 18# +#
 855                     (ord# (indexCharOffAddr# addr (nh +# 1#)) -# 0x80#) `uncheckedIShiftL#` 12# +#
 856                     (ord# (indexCharOffAddr# addr (nh +# 2#)) -# 0x80#) `uncheckedIShiftL#`  6# +#
 857                     (ord# (indexCharOffAddr# addr (nh +# 3#)) -# 0x80#))) :
 858           unpack (nh +# 4#)
 859       where
 860         ch = indexCharOffAddr# addr nh
 861
 862 unpackNBytes# :: Addr# -> Int# -> [Char]
 863 unpackNBytes# _addr 0#   = []
 864 unpackNBytes#  addr len# = unpack [] (len# -# 1#)
 865     where
 866      unpack acc i#
 867       | i# <# 0#  = acc
 868       | otherwise =
 869          case indexCharOffAddr# addr i# of
 870             ch -> unpack (C# ch : acc) (i# -# 1#)
 871
 872 {-# RULES
 873 "unpack"       [~1] forall a   . unpackCString# a                  = build (unpackFoldrCString# a)
 874 "unpack-list"  [1]  forall a   . unpackFoldrCString# a (:) [] = unpackCString# a
 875 "unpack-append"     forall a n . unpackFoldrCString# a (:) n  = unpackAppendCString# a n
 876
 877 -- There's a built-in rule (in PrelRules.lhs) for
 878 --      unpackFoldr "foo" c (unpackFoldr "baz" c n)  =  unpackFoldr "foobaz" c n
 879
 880   #-}
 881 \end{code}