Prelude.hs

   1 {-# OPTIONS_GHC -XNoImplicitPrelude #-}
   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 Text.Read
 150 import Text.Show
 151 import Data.List
 152 import Data.Either
 153 import Data.Maybe
 154 import Data.Bool
 155 import Data.Tuple
 156 import Data.Eq
 157 import Data.Ord
 158 #endif
 159
 160 #ifdef __GLASGOW_HASKELL__
 161 import GHC.Base
 162 import GHC.IOBase
 163 import GHC.Exception
 164 import GHC.Read
 165 import GHC.Enum
 166 import GHC.Num
 167 import GHC.Real
 168 import GHC.Float
 169 import GHC.Show
 170 import GHC.Err   ( error, undefined )
 171 #endif
 172
 173 #ifdef __HUGS__
 174 import Hugs.Prelude
 175 #endif
 176
 177 #ifndef __HUGS__
 178 infixr 0 $!
 179
 180 -- -----------------------------------------------------------------------------
 181 -- Miscellaneous functions
 182
 183 -- | Strict (call-by-value) application, defined in terms of 'seq'.
 184 ($!)    :: (a -> b) -> a -> b
 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