Prelude.hs

   1 {-# OPTIONS_GHC -XNoImplicitPrelude -XBangPatterns #-}
   2 -----------------------------------------------------------------------------
   3 -- |
   4 -- Module      :  Prelude
   5 -- Copyright   :  (c) The University of Glasgow 2001
   6 -- License     :  BSD-style (see the file libraries/base/LICENSE)
   7 --
   8 -- Maintainer  :  libraries@haskell.org
   9 -- Stability   :  stable
  10 -- Portability :  portable
  11 --
  12 -- The Prelude: a standard module imported by default into all Haskell
  13 -- modules.  For more documentation, see the Haskell 98 Report
  14 -- <http://www.haskell.org/onlinereport/>.
  15 --
  16 -----------------------------------------------------------------------------
  17
  18 module Prelude (
  19
  20     -- * Standard types, classes and related functions
  21
  22     -- ** Basic data types
  23     Bool(False, True),
  24     (&&), (||), not, otherwise,
  25
  26     Maybe(Nothing, Just),
  27     maybe,
  28
  29     Either(Left, Right),
  30     either,
  31
  32     Ordering(LT, EQ, GT),
  33     Char, String,
  34
  35     -- *** Tuples
  36     fst, snd, curry, uncurry,
  37
  38 #if defined(__NHC__)
  39     []((:), []),        -- Not legal Haskell 98;
  40                         -- ... available through built-in syntax
  41     module Data.Tuple,  -- Includes tuple types
  42     ()(..),             -- Not legal Haskell 98
  43     (->),               -- ... available through built-in syntax
  44 #endif
  45 #ifdef __HUGS__
  46     (:),                -- Not legal Haskell 98
  47 #endif
  48
  49     -- ** Basic type classes
  50     Eq((==), (/=)),
  51     Ord(compare, (<), (<=), (>=), (>), max, min),
  52     Enum(succ, pred, toEnum, fromEnum, enumFrom, enumFromThen,
  53          enumFromTo, enumFromThenTo),
  54     Bounded(minBound, maxBound),
  55
  56     -- ** Numbers
  57
  58     -- *** Numeric types
  59     Int, Integer, Float, Double,
  60     Rational,
  61
  62     -- *** Numeric type classes
  63     Num((+), (-), (*), negate, abs, signum, fromInteger),
  64     Real(toRational),
  65     Integral(quot, rem, div, mod, quotRem, divMod, toInteger),
  66     Fractional((/), recip, fromRational),
  67     Floating(pi, exp, log, sqrt, (**), logBase, sin, cos, tan,
  68              asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh),
  69     RealFrac(properFraction, truncate, round, ceiling, floor),
  70     RealFloat(floatRadix, floatDigits, floatRange, decodeFloat,
  71               encodeFloat, exponent, significand, scaleFloat, isNaN,
  72               isInfinite, isDenormalized, isIEEE, isNegativeZero, atan2),
  73
  74     -- *** Numeric functions
  75     subtract, even, odd, gcd, lcm, (^), (^^),
  76     fromIntegral, realToFrac,
  77
  78     -- ** Monads and functors
  79     Monad((>>=), (>>), return, fail),
  80     Functor(fmap),
  81     mapM, mapM_, sequence, sequence_, (=<<),
  82
  83     -- ** Miscellaneous functions
  84     id, const, (.), flip, ($), until,
  85     asTypeOf, error, undefined,
  86     seq, ($!),
  87
  88     -- * List operations
  89     map, (++), filter,
  90     head, last, tail, init, null, length, (!!),
  91     reverse,
  92     -- ** Reducing lists (folds)
  93     foldl, foldl1, foldr, foldr1,
  94     -- *** Special folds
  95     and, or, any, all,
  96     sum, product,
  97     concat, concatMap,
  98     maximum, minimum,
  99     -- ** Building lists
 100     -- *** Scans
 101     scanl, scanl1, scanr, scanr1,
 102     -- *** Infinite lists
 103     iterate, repeat, replicate, cycle,
 104     -- ** Sublists
 105     take, drop, splitAt, takeWhile, dropWhile, span, break,
 106     -- ** Searching lists
 107     elem, notElem, lookup,
 108     -- ** Zipping and unzipping lists
 109     zip, zip3, zipWith, zipWith3, unzip, unzip3,
 110     -- ** Functions on strings
 111     lines, words, unlines, unwords,
 112
 113     -- * Converting to and from @String@
 114     -- ** Converting to @String@
 115     ShowS,
 116     Show(showsPrec, showList, show),
 117     shows,
 118     showChar, showString, showParen,
 119     -- ** Converting from @String@
 120     ReadS,
 121     Read(readsPrec, readList),
 122     reads, readParen, read, lex,
 123
 124     -- * Basic Input and output
 125     IO,
 126     -- ** Simple I\/O operations
 127     -- All I/O functions defined here are character oriented.  The
 128     -- treatment of the newline character will vary on different systems.
 129     -- For example, two characters of input, return and linefeed, may
 130     -- read as a single newline character.  These functions cannot be
 131     -- used portably for binary I/O.
 132     -- *** Output functions
 133     putChar,
 134     putStr, putStrLn, print,
 135     -- *** Input functions
 136     getChar,
 137     getLine, getContents, interact,
 138     -- *** Files
 139     FilePath,
 140     readFile, writeFile, appendFile, readIO, readLn,
 141     -- ** Exception handling in the I\/O monad
 142     IOError, ioError, userError, catch
 143
 144   ) where
 145
 146 #ifndef __HUGS__
 147 import Control.Monad
 148 import System.IO
 149 import System.IO.Error
 150 import Data.List
 151 import Data.Either
 152 import Data.Maybe
 153 import Data.Tuple
 154 #endif
 155
 156 #ifdef __GLASGOW_HASKELL__
 157 import GHC.Base
 158 -- import GHC.IO
 159 -- import GHC.IO.Exception
 160 import Text.Read
 161 import GHC.Enum
 162 import GHC.Num
 163 import GHC.Real
 164 import GHC.Float
 165 import GHC.Show
 166 import GHC.Err   ( undefined )
 167 #endif
 168
 169 #ifdef __HUGS__
 170 import Hugs.Prelude
 171 #endif
 172
 173 #ifndef __HUGS__
 174 infixr 0 $!
 175 #endif
 176
 177 -- -----------------------------------------------------------------------------
 178 -- Miscellaneous functions
 179
 180 -- | Strict (call-by-value) application, defined in terms of 'seq'.
 181 ($!)    :: (a -> b) -> a -> b
 182 #ifdef __GLASGOW_HASKELL__
 183 f $! x  = let !vx = x in f vx  -- see #2273
 184 #elif !defined(__HUGS__)
 185 f $! x  = x `seq` f x
 186 #endif
 187
 188 #ifdef __HADDOCK__
 189 -- | The value of @'seq' a b@ is bottom if @a@ is bottom, and otherwise
 190 -- equal to @b@.  'seq' is usually introduced to improve performance by
 191 -- avoiding unneeded laziness.
 192 seq :: a -> b -> b
 193 seq _ y = y
 194 #endif