Prelude.hs

{-# LANGUAGE Trustworthy #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE RebindableSyntax #-}

-- 
-- -----------------------------------------------------------------------------
-- -- |
-- -- 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,
    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 (..),
--     RealFloat(floatRadix, floatDigits, floatRange, decodeFloat,
--               encodeFloat, exponent, significand, scaleFloat, isNaN,
--               isInfinite, isDenormalized, isIEEE, isNegativeZero, atan2),
-- 
--     -- *** Numeric functions
--     subtract, even, odd, gcd, lcm, (^), (^^),
--     fromIntegral, realToFrac,
-- 
--     -- ** Monoids
    Monoid(mempty, mappend, mconcat),
-- 
--     -- ** Monads and functors
    Functor(fmap, (<$)), (<$>),
    Applicative(pure, (<*>), (*>), (<*)),
    Monad((>>=), (>>), return),
--     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
    map, (++), filter,
    head, last, tail, init, null, length, (!!),
    reverse,
--     -- *** Special folds
    and, or, any, all,
    concat, concatMap,
--     -- ** Building lists
--     -- *** Scans
    scanl, scanl1, scanr, scanr1,
--     -- *** Infinite lists
    iterate, repeat, replicate, cycle,
--     -- ** Sublists
    take, drop, splitAt, takeWhile, dropWhile, span, break,
--     -- ** Searching lists
    notElem, lookup,
--     -- ** Zipping and unzipping lists
    zip, zip3, zipWith, zipWith3, unzip, unzip3,
--     -- ** Functions on strings
    lines, words, unlines, 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,
-- 
    implies, iff

  ) where
-- 
-- import Control.Monad
import System.IO
-- import System.IO.Error
import Data.List
import Data.Either
import Data.Foldable    ( Foldable(..) )
import Data.Functor     ( (<$>) )
import Data.Maybe
import Data.Traversable ( Traversable(..) )
import Data.Tuple
-- 
import GHC.Base hiding ( foldr, mapM, sequence )
import Text.Read
import GHC.Enum
import GHC.Num
import GHC.Real
import GHC.Float
import GHC.Show

import GHC.Integer2

implies :: Bool -> Bool -> Bool
implies True False = False
implies _ _ = True

iff :: Bool -> Bool -> Bool
iff x y = (implies x y) && (implies y x)