(original) (raw)

{-# LANGUAGE Trustworthy #-} {-# LANGUAGE NoImplicitPrelude #-}

module Prelude (

Bool(False, True),
(&&), (||), not, [otherwise](GHC.Base.html#otherwise),

[Maybe](GHC.Maybe.html#Maybe)([Nothing](GHC.Maybe.html#Nothing), [Just](GHC.Maybe.html#Just)),
[maybe](Data.Maybe.html#maybe),

[Either](Data.Either.html#Either)([Left](Data.Either.html#Left), [Right](Data.Either.html#Right)),
[either](Data.Either.html#either),

Ordering(LT, EQ, GT),
Char, [String](GHC.Base.html#String),


[fst](Data.Tuple.html#fst), [snd](Data.Tuple.html#snd), [curry](Data.Tuple.html#curry), [uncurry](Data.Tuple.html#uncurry),


Eq((==), (/=)),
Ord(compare, (<), (<=), (>=), (>), max, min),
[Enum](GHC.Enum.html#Enum)([succ](GHC.Enum.html#succ), [pred](GHC.Enum.html#pred), [toEnum](GHC.Enum.html#toEnum), [fromEnum](GHC.Enum.html#fromEnum), [enumFrom](GHC.Enum.html#enumFrom), [enumFromThen](GHC.Enum.html#enumFromThen),
     [enumFromTo](GHC.Enum.html#enumFromTo), [enumFromThenTo](GHC.Enum.html#enumFromThenTo)),
[Bounded](GHC.Enum.html#Bounded)([minBound](GHC.Enum.html#minBound), [maxBound](GHC.Enum.html#maxBound)),


Int, Integer, Float, Double,
[Rational](GHC.Real.html#Rational), Word,


[Num](GHC.Num.html#Num)(([+](GHC.Num.html#%2B)), (-), ([*](GHC.Num.html#%2A)), [negate](GHC.Num.html#negate), [abs](GHC.Num.html#abs), [signum](GHC.Num.html#signum), [fromInteger](GHC.Num.html#fromInteger)),
[Real](GHC.Real.html#Real)([toRational](GHC.Real.html#toRational)),
[Integral](GHC.Real.html#Integral)([quot](GHC.Real.html#quot), [rem](GHC.Real.html#rem), [div](GHC.Real.html#div), [mod](GHC.Real.html#mod), [quotRem](GHC.Real.html#quotRem), [divMod](GHC.Real.html#divMod), [toInteger](GHC.Real.html#toInteger)),
[Fractional](GHC.Real.html#Fractional)(([/](GHC.Real.html#%2F)), [recip](GHC.Real.html#recip), [fromRational](GHC.Real.html#fromRational)),
[Floating](GHC.Float.html#Floating)([pi](GHC.Float.html#pi), [exp](GHC.Float.html#exp), [log](GHC.Float.html#log), [sqrt](GHC.Float.html#sqrt), ([**](GHC.Float.html#%2A%2A)), [logBase](GHC.Float.html#logBase), [sin](GHC.Float.html#sin), [cos](GHC.Float.html#cos), [tan](GHC.Float.html#tan),
         [asin](GHC.Float.html#asin), [acos](GHC.Float.html#acos), [atan](GHC.Float.html#atan), [sinh](GHC.Float.html#sinh), [cosh](GHC.Float.html#cosh), [tanh](GHC.Float.html#tanh), [asinh](GHC.Float.html#asinh), [acosh](GHC.Float.html#acosh), [atanh](GHC.Float.html#atanh)),
[RealFrac](GHC.Real.html#RealFrac)([properFraction](GHC.Real.html#properFraction), [truncate](GHC.Real.html#truncate), [round](GHC.Real.html#round), [ceiling](GHC.Real.html#ceiling), [floor](GHC.Real.html#floor)),
[RealFloat](GHC.Float.html#RealFloat)([floatRadix](GHC.Float.html#floatRadix), [floatDigits](GHC.Float.html#floatDigits), [floatRange](GHC.Float.html#floatRange), [decodeFloat](GHC.Float.html#decodeFloat),
          [encodeFloat](GHC.Float.html#encodeFloat), [exponent](GHC.Float.html#exponent), [significand](GHC.Float.html#significand), [scaleFloat](GHC.Float.html#scaleFloat), [isNaN](GHC.Float.html#isNaN),
          [isInfinite](GHC.Float.html#isInfinite), [isDenormalized](GHC.Float.html#isDenormalized), [isIEEE](GHC.Float.html#isIEEE), [isNegativeZero](GHC.Float.html#isNegativeZero), [atan2](GHC.Float.html#atan2)),


[subtract](GHC.Num.html#subtract), [even](GHC.Real.html#even), [odd](GHC.Real.html#odd), [gcd](GHC.Real.html#gcd), [lcm](GHC.Real.html#lcm), ([^](GHC.Real.html#%5E)), ([^^](GHC.Real.html#%5E%5E)),
[fromIntegral](GHC.Real.html#fromIntegral), [realToFrac](GHC.Real.html#realToFrac),


[Semigroup](GHC.Base.html#Semigroup)(([<>](GHC.Base.html#%3C%3E))),
[Monoid](GHC.Base.html#Monoid)([mempty](GHC.Base.html#mempty), [mappend](GHC.Base.html#mappend), [mconcat](GHC.Base.html#mconcat)),


[Functor](GHC.Base.html#Functor)([fmap](GHC.Base.html#fmap), ([<$](GHC.Base.html#%3C%24))), ([<$>](Data.Functor.html#%3C%24%3E)),
[Applicative](GHC.Base.html#Applicative)([pure](GHC.Base.html#pure), ([<*>](GHC.Base.html#%3C%2A%3E)), ([*>](GHC.Base.html#%2A%3E)), ([<*](GHC.Base.html#%3C%2A))),
[Monad](GHC.Base.html#Monad)(([>>=](GHC.Base.html#%3E%3E%3D)), ([>>](GHC.Base.html#%3E%3E)), [return](GHC.Base.html#return), [fail](GHC.Base.html#fail)),
[mapM_](Data.Foldable.html#mapM%5F), [sequence_](Data.Foldable.html#sequence%5F), ([=<<](GHC.Base.html#%3D%3C%3C)),


[Foldable](Data.Foldable.html#Foldable)([elem](Data.Foldable.html#elem),      
         
         [foldMap](Data.Foldable.html#foldMap),   
         [foldr](Data.Foldable.html#foldr),     
         
         [foldl](Data.Foldable.html#foldl),     
         
         [foldr1](Data.Foldable.html#foldr1),    
         [foldl1](Data.Foldable.html#foldl1),    
         [maximum](Data.Foldable.html#maximum),   
         [minimum](Data.Foldable.html#minimum),   
         [product](Data.Foldable.html#product),   
         [sum](Data.Foldable.html#sum)),      
         

[Traversable](Data.Traversable.html#Traversable)([traverse](Data.Traversable.html#traverse), [sequenceA](Data.Traversable.html#sequenceA), [mapM](Data.Traversable.html#mapM), [sequence](Data.Traversable.html#sequence)),


[id](GHC.Base.html#id), [const](GHC.Base.html#const), ([.](GHC.Base.html#.)), [flip](GHC.Base.html#flip), ([$](GHC.Base.html#%24)), [until](GHC.Base.html#until),
[asTypeOf](GHC.Base.html#asTypeOf), [error](GHC.Err.html#error), [errorWithoutStackTrace](GHC.Err.html#errorWithoutStackTrace), [undefined](GHC.Err.html#undefined),
seq, ([$!](GHC.Base.html#%24%21)),


[map](GHC.Base.html#map), ([++](GHC.Base.html#%2B%2B)), [filter](GHC.List.html#filter),
[head](GHC.List.html#head), [last](GHC.List.html#last), [tail](GHC.List.html#tail), [init](GHC.List.html#init), [null](Data.Foldable.html#null), [length](Data.Foldable.html#length), ([!!](GHC.List.html#%21%21)),
[reverse](GHC.List.html#reverse),

[and](Data.Foldable.html#and), [or](Data.Foldable.html#or), [any](Data.Foldable.html#any), [all](Data.Foldable.html#all),
[concat](Data.Foldable.html#concat), [concatMap](Data.Foldable.html#concatMap),


[scanl](GHC.List.html#scanl), [scanl1](GHC.List.html#scanl1), [scanr](GHC.List.html#scanr), [scanr1](GHC.List.html#scanr1),

[iterate](GHC.List.html#iterate), [repeat](GHC.List.html#repeat), [replicate](GHC.List.html#replicate), [cycle](GHC.List.html#cycle),

[take](GHC.List.html#take), [drop](GHC.List.html#drop), [splitAt](GHC.List.html#splitAt), [takeWhile](GHC.List.html#takeWhile), [dropWhile](GHC.List.html#dropWhile), [span](GHC.List.html#span), [break](GHC.List.html#break),

[notElem](Data.Foldable.html#notElem), [lookup](GHC.List.html#lookup),

[zip](GHC.List.html#zip), [zip3](GHC.List.html#zip3), [zipWith](GHC.List.html#zipWith), [zipWith3](GHC.List.html#zipWith3), [unzip](GHC.List.html#unzip), [unzip3](GHC.List.html#unzip3),

[lines](Data.OldList.html#lines), [words](Data.OldList.html#words), [unlines](Data.OldList.html#unlines), [unwords](Data.OldList.html#unwords),


[ShowS](GHC.Show.html#ShowS),
[Show](GHC.Show.html#Show)([showsPrec](GHC.Show.html#showsPrec), [showList](GHC.Show.html#showList), [show](GHC.Show.html#show)),
[shows](GHC.Show.html#shows),
[showChar](GHC.Show.html#showChar), [showString](GHC.Show.html#showString), [showParen](GHC.Show.html#showParen),

[ReadS](Text.ParserCombinators.ReadP.html#ReadS),
[Read](GHC.Read.html#Read)([readsPrec](GHC.Read.html#readsPrec), [readList](GHC.Read.html#readList)),
[reads](Text.Read.html#reads), [readParen](GHC.Read.html#readParen), [read](Text.Read.html#read), [lex](GHC.Read.html#lex),


IO,


[putChar](System.IO.html#putChar),
[putStr](System.IO.html#putStr), [putStrLn](System.IO.html#putStrLn), [print](System.IO.html#print),

[getChar](System.IO.html#getChar),
[getLine](System.IO.html#getLine), [getContents](System.IO.html#getContents), [interact](System.IO.html#interact),

[FilePath](GHC.IO.html#FilePath),
[readFile](System.IO.html#readFile), [writeFile](System.IO.html#writeFile), [appendFile](System.IO.html#appendFile), [readIO](System.IO.html#readIO), [readLn](System.IO.html#readLn),

[IOError](GHC.IO.Exception.html#IOError), [ioError](GHC.IO.Exception.html#ioError), [userError](GHC.IO.Exception.html#userError),

) 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