content: {-# LANGUAGE Trustworthy #-}
  {-# LANGUAGE NoImplicitPrelude #-}
  {-# LANGUAGE ExplicitNamespaces #-}
  
  -----------------------------------------------------------------------------
  -- |
  -- Module      :  Prelude
  -- Copyright   :  (c) The University of Glasgow 2001
  -- License     :  BSD-style (see the file libraries/base/LICENSE)
  --
  -- Maintainer  :  libraries@haskell.org
  -- Stability   :  stable
  -- Portability :  portable
  --
  -- The Prelude: a standard module. The Prelude is imported by default
  -- into all Haskell modules unless either there is an explicit import
  -- statement for it, or the NoImplicitPrelude extension is enabled.
  --
  -----------------------------------------------------------------------------
  
  module Prelude (
  
      -- * Standard types, classes and related functions
  
      -- ** Basic data types
      Bool(False, True),
      (&&), (||), not, otherwise,
  
      Maybe(Nothing, Just),
      maybe,
  
      Either(Left, Right),
      either,
  
      Ordering(LT, EQ, GT),
      Char, String,
  
      -- *** Tuples
      fst, snd, curry, uncurry,
  
      -- ** Basic type classes
      Eq((==), (/=)),
      Ord(compare, (<), (<=), (>=), (>), max, min),
      Enum(succ, pred, toEnum, fromEnum, enumFrom, enumFromThen,
           enumFromTo, enumFromThenTo),
      Bounded(minBound, maxBound),
  
      -- ** Numbers
  
      -- *** Numeric types
      Int, Integer, Float, Double,
      Rational, Word,
  
      -- *** Numeric type classes
      Num((+), (-), (*), negate, abs, signum, fromInteger),
      Real(toRational),
      Integral(quot, rem, div, mod, quotRem, divMod, toInteger),
      Fractional((/), recip, fromRational),
      Floating(pi, exp, log, sqrt, (**), logBase, sin, cos, tan,
               asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh),
      RealFrac(properFraction, truncate, round, ceiling, floor),
      RealFloat(floatRadix, floatDigits, floatRange, decodeFloat,
                encodeFloat, exponent, significand, scaleFloat, isNaN,
                isInfinite, isDenormalized, isIEEE, isNegativeZero, atan2),
  
      -- *** Numeric functions
      subtract, even, odd, gcd, lcm, (^), (^^),
      fromIntegral, realToFrac,
  
      -- ** Semigroups and Monoids
      Semigroup((<>)),
      Monoid(mempty, mappend, mconcat),
  
      -- ** Monads and functors
      Functor(fmap, (<$)), (<$>),
      Applicative(pure, (<*>), (*>), (<*), liftA2),
      Monad((>>=), (>>), return),
      MonadFail(fail),
      mapM_, sequence_, (=<<),
  
      -- ** Folds and traversals
      Foldable(elem,      -- :: (Foldable t, Eq a) => a -> t a -> Bool
               -- fold,   -- :: Monoid m => t m -> m
               foldMap,   -- :: Monoid m => (a -> m) -> t a -> m
               foldr,     -- :: (a -> b -> b) -> b -> t a -> b
               -- foldr', -- :: (a -> b -> b) -> b -> t a -> b
               foldl,     -- :: (b -> a -> b) -> b -> t a -> b
               foldl', -- :: (b -> a -> b) -> b -> t a -> b
               foldr1,    -- :: (a -> a -> a) -> t a -> a
               foldl1,    -- :: (a -> a -> a) -> t a -> a
               maximum,   -- :: (Foldable t, Ord a) => t a -> a
               minimum,   -- :: (Foldable t, Ord a) => t a -> a
               product,   -- :: (Foldable t, Num a) => t a -> a
               sum),      -- :: Num a => t a -> a
               -- toList) -- :: Foldable t => t a -> [a]
  
      Traversable(traverse, sequenceA, mapM, sequence),
  
      -- ** Miscellaneous functions
      id, const, (.), flip, ($), until,
      asTypeOf, error, errorWithoutStackTrace, undefined,
      seq, ($!),
  
      -- * List operations
      List.map, (List.++), List.filter,
      List.head, List.last, List.tail, List.init, (List.!!),
      Foldable.null, Foldable.length,
      List.reverse,
      -- *** Special folds
      Foldable.and, Foldable.or, Foldable.any, Foldable.all,
      Foldable.concat, Foldable.concatMap,
      -- ** Building lists
      -- *** Scans
      List.scanl, List.scanl1, List.scanr, List.scanr1,
      -- *** Infinite lists
      List.iterate, List.repeat, List.replicate, List.cycle,
      -- ** Sublists
      List.take, List.drop,
      List.takeWhile, List.dropWhile,
      List.span, List.break,
      List.splitAt,
      -- ** Searching lists
      Foldable.notElem,
      List.lookup,
      -- ** Zipping and unzipping lists
      List.zip, List.zip3,
      List.zipWith, List.zipWith3,
      List.unzip, List.unzip3,
      -- ** Functions on strings
      List.lines, List.words, List.unlines, List.unwords,
  
      -- * Converting to and from @String@
      -- ** Converting to @String@
      ShowS,
      Show(showsPrec, showList, show),
      shows,
      showChar, showString, showParen,
      -- ** Converting from @String@
      ReadS,
      Read(readsPrec, readList),
      reads, readParen, read, lex,
  
      -- * Basic Input and output
      IO,
      -- ** Simple I\/O operations
      -- All I/O functions defined here are character oriented.  The
      -- treatment of the newline character will vary on different systems.
      -- For example, two characters of input, return and linefeed, may
      -- read as a single newline character.  These functions cannot be
      -- used portably for binary I/O.
      -- *** Output functions
      putChar,
      putStr, putStrLn, print,
      -- *** Input functions
      getChar,
      getLine, getContents, interact,
      -- *** Files
      FilePath,
      readFile, writeFile, appendFile, readIO, readLn,
      -- ** Exception handling in the I\/O monad
      IOError, ioError, userError,
  
      -- ** The equality types
      type (~)
    ) where
  
  import GHC.Internal.Control.Monad
  import GHC.Internal.System.IO
  import GHC.Internal.System.IO.Error
  import qualified GHC.Internal.Data.List as List
  import GHC.Internal.Data.Either
  import GHC.Internal.Data.Foldable    ( Foldable(..) )
  import qualified GHC.Internal.Data.Foldable as Foldable
  import GHC.Internal.Data.Functor     ( (<$>) )
  import GHC.Internal.Data.Maybe
  import GHC.Internal.Data.Traversable ( Traversable(..) )
  import GHC.Internal.Data.Tuple
  
  import GHC.Internal.Base hiding ( foldr, mapM, sequence )
  import GHC.Internal.Text.Read
  import GHC.Internal.Enum
  import GHC.Internal.Num
  import GHC.Internal.Real
  import GHC.Internal.Float
  import GHC.Internal.Show
  