module Prelude
data []
(:) :: a -> [a] -> [a]
[] :: [a]
keyword |
keyword ->
keyword <-
keyword @
keyword !
keyword ::
keyword ~
keyword _
keyword as
keyword case
keyword class
keyword data
keyword default
keyword deriving
keyword do
keyword else
keyword forall
keyword hiding
keyword if
keyword import
keyword in
keyword infix
keyword infixl
keyword infixr
keyword instance
keyword let
keyword module
keyword newtype
keyword of
keyword qualified
keyword then
keyword type
keyword where


module Ix
index :: Ix a => (a,a) -> a -> Int
inRange :: Ix a => (a,a) -> a -> Bool
rangeSize :: Ix a => (a,a) -> Int
range :: Ix a => (a,a) -> [a]

module List
tails :: [a] -> [[a]]
intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
group :: Eq a => [a] -> [[a]]
sortBy :: (a -> a -> Ordering) -> [a] -> [a]
find :: (a -> Bool) -> [a] -> Maybe a
delete :: Eq a => a -> [a] -> [a]
(\\) :: Eq a => [a] -> [a] -> [a]
nubBy :: (a -> a -> Bool) -> [a] -> [a]
unzip4 :: [(a,b,c,d)] -> ([a],[b],[c],[d])
unzip5 :: [(a,b,c,d,e)] -> ([a],[b],[c],[d],[e])
unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
union :: Eq a => [a] -> [a] -> [a]
elemIndices :: Eq a => a -> [a] -> [Int]
zip6 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a,b,c,d,e,f)]
findIndex :: (a -> Bool) -> [a] -> Maybe Int
genericReplicate :: Integral a => a -> b -> [b]
maximumBy :: (a -> a -> a) -> [a] -> a
minimumBy :: (a -> a -> a) -> [a] -> a
inits :: [a] -> [[a]]
intersect :: Eq a => [a] -> [a] -> [a]
transpose :: [[a]] -> [[a]]
groupBy :: (a -> a -> Bool) -> [a] -> [[a]]
insert :: Ord a => a -> [a] -> [a]
unzip6 :: [(a,b,c,d,e,f)] -> ([a],[b],[c],[d],[e],[f])
unzip7 :: [(a,b,c,d,e,f,g)] -> ([a],[b],[c],[d],[e],[f],[g])
intersperse :: a -> [a] -> [a]
zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a,b,c,d,e)]
zip4 :: [a] -> [b] -> [c] -> [d] -> [(a,b,c,d)]
zip7 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a,b,c,d,e,f,g)]
partition :: (a -> Bool) -> [a] -> ([a],[a])
zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
isPrefixOf :: Eq a => [a] -> [a] -> Bool
genericIndex :: Integral a => [b] -> a -> b
isSuffixOf :: Eq a => [a] -> [a] -> Bool
findIndices :: (a -> Bool) -> [a] -> [Int]
mapAccumR :: (a -> b -> (a,c)) -> a -> [b] -> (a,[c])
genericSplitAt :: Integral a => a -> [b] -> ([b],[b])
sort :: Ord a => [a] -> [a]
mapAccumL :: (a -> b -> (a,c)) -> a -> [b] -> (a,[c])
genericTake :: Integral a => a -> [b] -> [b]
genericLength :: Integral a => [b] -> a
insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]
zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]
elemIndex :: Eq => a -> [a] -> Maybe Int
zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
unfoldr :: (a -> Maybe (b,a)) -> a -> [b]
deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]
genericDrop :: Integral a => a -> [b] -> [b]
nub :: Eq a => [a] -> [a]

module Numeric
showSigned :: Real a => (a -> ShowS) -> Int -> a -> ShowS
floatToDigits :: RealFloat a => Integer -> a -> ([Int],Int)
readInt :: Integral a => a -> (Char -> Bool) -> (Char -> Int) -> ReadS a
showGFloat :: RealFloat a => Maybe Int -> a -> ShowS
showInt :: Integral a => a -> ShowS
readOct :: Integral a => ReadS a
fromRat :: RealFloat a => Rational -> a
readFloat :: RealFloat a => ReadS a
showFFloat :: RealFloat a => Maybe Int -> a -> ShowS
readSigned :: Real a => ReadS a -> ReadS a
readDec :: Integral a => ReadS a
showEFloat :: RealFloat a => Maybe Int -> a -> ShowS
lexDigits :: ReadS String
showFloat :: RealFloat a => a -> ShowS
readHex :: Integral a => ReadS a

module IO
hGetChar :: Handle -> IO Char
hGetPosn :: Handle -> IO HandlePosn
isUserError :: IOError -> Bool
bracket_ :: IO a -> (a -> IO b) -> IO c -> IO c
hIsEOF :: Handle -> IO Bool
try :: IO a -> IO (Either IOError a)
hGetContents :: Handle -> IO String
hIsClosed :: Handle -> IO Bool
isEOFError :: IOError -> Bool
hGetLine :: Handle -> IO String
hFileSize :: Handle -> IO Integer
isEOF :: IO Bool
isAlreadyInUseError :: IOError -> Bool
hReady :: Handle -> IO Bool
isPermissionError :: IOError -> Bool
hPutStrLn :: Handle -> String -> IO ()
hIsSeekable :: Handle -> IO Bool
stdout :: Handle
stderr :: Handle
isIllegalOperation :: IOError -> Bool
hClose :: Handle -> IO ()
hPrint :: Show a => Handle -> a -> IO ()
isFullError :: IOError -> Bool
hIsReadable :: Handle -> IO Bool
ioeGetErrorString :: IOError -> String
hFlush :: Handle -> IO ()
isAlreadyExistsError :: IOError -> Bool
hLookAhead :: Handle -> IO Char
ioeGetHandle :: IOError -> Maybe Handle
hIsWritable :: Handle -> IO Bool
bracket :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c
hPutStr :: Handle -> String -> IO ()
hIsOpen :: Handle -> IO Bool
hPutChar :: Handle -> Char -> IO ()
hSetBuffering :: Handle -> BufferMode -> IO ()
ioeGetFileName :: IOError -> Maybe FilePath
stdin :: Handle
isDoesNotExistError :: IOError -> Bool
openFile :: FilePath -> IOMode -> IO Handle
hGetBuffering :: Handle -> IO BufferMode
hSeek :: Handle -> SeekMode -> Integer -> IO ()
hWaitForInput :: Handle -> Int -> IO Bool
hSetPosn :: HandlePosn -> IO ()

module System
exitFailure :: IO a
getArgs :: IO [String]
exitWith :: ExitCode -> IO a
system :: String -> IO ExitCode
getProgName :: IO String
getEnv :: String -> IO String

module CPUTime
getCPUTime :: IO Integer
cpuTimePrecision :: Integer

module Random
split :: RandomGen a => a -> (a,a)
randoms :: (Random a, RandomGen b) => b -> [a]
next :: RandomGen a => a -> (Int,a)
getStdGen :: IO StdGen
randomIO :: Random a => IO a
setStdGen :: StdGen -> IO ()
getStdRandom :: (StdGen -> (a, StdGen)) -> IO a
randomRs :: (Random a, RandomGen b) => (a,a) -> b -> [a]
randomRIO :: Random a => (a,a) -> IO a
randomR :: (Random a, RandomGen b) => (a,a) -> b -> (a,b)
newStdGen :: IO StdGen
random :: (Random a, RandomGen b) => b -> (a,b)
mkStdGen :: Int -> StdGen

module Array
accum :: Ix a => (b -> c -> b) -> Array a b -> [(a,c)] -> Array a b
array :: Ix a => (a,a) -> [(a,b)] -> Array a b
ixmap :: (Ix a, Ix b) => (a,a) -> (a -> b) -> Array b c -> Array a c
bounds :: Ix a => Array a b -> (a,a)
accumArray :: Ix a => (b -> c -> b) -> b -> (a,a) -> [(a,c)] -> Array a b
elems :: Ix a => Array a b -> [b]
listArray :: Ix a => (a,a) -> [b] -> Array a b
(!) :: Ix a => Array a b -> a -> b
(//) :: Ix a => Array a b -> [(a,b)] -> Array a b
assocs :: Ix a => Array a b -> [(a,b)]
indices :: Ix a => Array a b -> [a]

module Time
formatCalendarTime :: TimeLocale -> String -> CalendarTime -> String
diffClockTimes :: ClockTime -> ClockTime -> TimeDiff
getClockTime :: IO ClockTime
addToClockTime :: TimeDiff -> ClockTime -> ClockTime
toClockTime :: CalendarTime -> ClockTime
toUTCTime :: ClockTime -> CalendarTime
toCalendarTime :: ClockTime -> IO CalendarTime
calendarTimeToString :: CalendarTime -> String

module Locale
defaultTimeLocale :: TimeLocale

module Complex
mkPolar :: RealFloat a => a -> a -> Complex a
polar :: RealFloat a => Complex a -> (a,a)
cis :: RealFloat a => a -> Complex a
conjugate :: RealFloat a => Complex a -> Complex a
phase :: RealFloat a => Complex a -> a
magnitude :: RealFloat a => Complex a -> a
imagPart :: RealFloat a => Complex a -> a
(:+) :: RealFloat a => a -> a -> Complex a
realPart :: RealFloat a => Complex a -> a

module Monad
msum :: MonadPlus a => [a b] -> a b
zipWithM :: Monad a => (b -> c -> a d) -> [b] -> [c] -> a [d]
filterM :: Monad a => (b -> a Bool) -> [b] -> a [b]
mapAndUnzipM :: Monad a => (b -> a (c,d)) -> [b] -> a ([c],[d])
liftM :: Monad a => (b -> c) -> a b -> a c
foldM :: Monad a => (b -> c -> a b) -> b -> [c] -> a b
ap :: Monad a => a (b -> c) -> a b -> a c
zipWithM_ :: Monad a => (b -> c -> a d) -> [b] -> [c] -> a ()
join :: Monad a => a (a b) -> a b
liftM3 :: Monad a => (b -> c -> d -> e) -> a b -> a c -> a d -> a e
when :: Monad a => Bool -> a () -> a ()
guard :: MonadPlus a => Bool -> a ()
liftM2 :: Monad a => (b -> c -> d) -> a b -> a c -> a d
unless :: Monad a => Bool -> a () -> a ()
liftM4 :: Monad a => (b -> c -> d -> e -> f) -> a b -> a c -> a d -> a e -> a f
liftM5 :: Monad a => (b -> c -> d -> e -> f -> g) -> a b -> a c -> a d -> a e -> a f -> a g

module Directory
getPermissions :: FilePath -> IO Permissions
setPermissions :: FilePath -> Permissions -> IO ()
searchable :: Permissions -> Bool
createDirectory :: FilePath -> IO ()
removeFile :: FilePath -> IO ()
writable :: Permissions -> Bool
getModificationTime :: FilePath -> IO ClockTime
executable :: Permissions -> Bool
readable :: Permissions -> Bool
renameDirectory :: FilePath -> FilePath -> IO ()
doesDirectoryExist :: FilePath -> IO Bool
getCurrentDirectory :: IO FilePath
removeDirectory :: FilePath -> IO ()
renameFile :: FilePath -> FilePath -> IO ()
setCurrentDirectory :: FilePath -> IO ()
doesFileExist :: FilePath -> IO Bool
getDirectoryContents :: FilePath -> IO [FilePath]

module Char
showLitChar :: Char -> ShowS
isUpper :: Char -> Bool
isPrint :: Char -> Bool
chr :: Int -> Char
ord :: Char -> Int
isDigit :: Char -> Bool
toLower :: Char -> Char
isOctDigit :: Char -> Bool
digitToInt :: Char -> Int
isSpace :: Char -> Bool
toUpper :: Char -> Char
isAscii :: Char -> Bool
lexLitChar :: ReadS String
isHexDigit :: Char -> Bool
readLitChar :: ReadS Char
isLatin1 :: a -> Bool
isAlphaNum :: Char -> Bool
intToDigit :: Int -> Char
isControl :: Char -> Bool
isLower :: Char -> Bool
isAlpha :: Char -> Bool

module Ratio
approxRational :: RealFrac a => a -> a -> Rational
denominator :: Integral a => Ratio a -> a
(%) :: Integral a => a -> a -> Ratio a
numerator :: Integral a => Ratio a -> a

module Maybe
isJust :: Maybe a -> Bool
listToMaybe :: [a] -> Maybe a
fromMaybe :: a -> Maybe a -> a
isNothing :: Maybe a -> Bool
fromJust :: Maybe a -> a
mapMaybe :: (a -> Maybe b) -> [a] -> [b]
maybeToList :: Maybe a -> [a]
catMaybes :: [Maybe a] -> [a]