Module { } stdlib/bhc-prelude/hs/BHC/Prelude.hs

Prelude

Types
data Bool { } #
False
True
data Maybe a { } #
Nothing
Just a
Optional values
data Either a b { } #
Left a
Right b
Sum type for error handling
data Ordering { } #
LT
EQ
GT
Comparison result
type ShowS = String -> String { } #
type ReadS a = String -> [(a, String)] { } #
Type Classes
class Eq a { } #

Methods

== :: a -> a -> Bool
/= :: a -> a -> Bool
class Eq a => Ord a { } #

Methods

compare :: a -> a -> Ordering
< :: a -> a -> Bool
<= :: a -> a -> Bool
> :: a -> a -> Bool
>= :: a -> a -> Bool
max :: a -> a -> a
min :: a -> a -> a
class Show a { } #

Methods

showsPrec :: Int -> a -> ShowS
show :: a -> String
showList :: [a] -> ShowS
class Read a { } #

Methods

readsPrec :: Int -> ReadS a
readList :: ReadS [a]
class Enum a { } #

Methods

succ :: a -> a
pred :: a -> a
toEnum :: Int -> a
fromEnum :: a -> Int
enumFrom :: a -> [a]
enumFromThen :: a -> a -> [a]
enumFromTo :: a -> a -> [a]
enumFromThenTo :: a -> a -> a -> [a]
class Bounded a { } #

Methods

minBound :: a
maxBound :: a
class Num a, Ord a => Real a { } #

Methods

toRational :: a -> Rational
class Real a, Enum a => Integral a { } #

Methods

quot :: a -> a -> a
rem :: a -> a -> a
div :: a -> a -> a
mod :: a -> a -> a
quotRem :: a -> a -> (a, a)
divMod :: a -> a -> (a, a)
toInteger :: a -> Integer
class Num a => Fractional a { } #

Methods

/ :: a -> a -> a
recip :: a -> a
fromRational :: Rational -> a
class Fractional a => Floating a { } #

Methods

pi :: a
exp :: a -> a
log :: a -> a
sqrt :: a -> a
** :: a -> a -> a
logBase :: a -> a -> a
sin :: a -> a
cos :: a -> a
tan :: a -> a
asin :: a -> a
acos :: a -> a
atan :: a -> a
sinh :: a -> a
cosh :: a -> a
tanh :: a -> a
asinh :: a -> a
acosh :: a -> a
atanh :: a -> a
class Real a, Fractional a => RealFrac a { } #

Methods

properFraction :: (Integral b) => a -> (b, a)
truncate :: (Integral b) => a -> b
round :: (Integral b) => a -> b
ceiling :: (Integral b) => a -> b
floor :: (Integral b) => a -> b
class RealFrac a, Floating a => RealFloat a { } #

Methods

floatRadix :: a -> Integer
floatDigits :: a -> Int
floatRange :: a -> (Int, Int)
decodeFloat :: a -> (Integer, Int)
encodeFloat :: Integer -> Int -> a
isNaN :: a -> Bool
isInfinite :: a -> Bool
isDenormalized :: a -> Bool
isNegativeZero :: a -> Bool
isIEEE :: a -> Bool
atan2 :: a -> a -> a
class Semigroup a { } #

Methods

<> :: a -> a -> a
class Semigroup a => Monoid a { } #

Methods

mempty :: a
mappend :: a -> a -> a
mconcat :: [a] -> a
class Functor f { } #

Methods

fmap :: (a -> b) -> (f a) -> f b
<$ :: a -> (f b) -> f a
class Functor f => Applicative f { } #

Methods

pure :: a -> f a
<*> :: (f (a -> b)) -> (f a) -> f b
*> :: (f a) -> (f b) -> f b
<* :: (f a) -> (f b) -> f a
liftA2 :: (a -> b -> c) -> (f a) -> (f b) -> f c
class Applicative m => Monad m { } #

Methods

>>= :: (m a) -> (a -> m b) -> m b
>> :: (m a) -> (m b) -> m b
return :: a -> m a
class Applicative f => Alternative f { } #

Methods

empty :: f a
<|> :: (f a) -> (f a) -> f a
some :: (f a) -> f [a]
many :: (f a) -> f [a]
class Alternative m, Monad m => MonadPlus m { } #

Methods

mzero :: m a
mplus :: (m a) -> (m a) -> m a
class Foldable t { } #

Methods

fold :: (Monoid m) => (t m) -> m
foldMap :: (Monoid m) => (a -> m) -> (t a) -> m
foldr :: (a -> b -> b) -> b -> (t a) -> b
foldl :: (b -> a -> b) -> b -> (t a) -> b
foldl' :: (b -> a -> b) -> b -> (t a) -> b
toList :: (t a) -> [a]
null :: (t a) -> Bool
length :: (t a) -> Int
elem :: (Eq a) => a -> (t a) -> Bool
maximum :: (Ord a) => (t a) -> a
minimum :: (Ord a) => (t a) -> a
sum :: (Num a) => (t a) -> a
product :: (Num a) => (t a) -> a
class Functor t, Foldable t => Traversable t { } #

Methods

traverse :: (Applicative f) => (a -> f b) -> (t a) -> f (t b)
sequenceA :: (Applicative f) => (t (f a)) -> f (t a)
mapM :: (Monad m) => (a -> m b) -> (t a) -> m (t b)
sequence :: (Monad m) => (t (m a)) -> m (t a)
class Monad m => MonadFail m { } #

Methods

fail :: String -> m a
Functions
&& :: Bool -> Bool -> Bool { } #
Boolean and (short-circuit)
x :: { } #
|| :: Bool -> Bool -> Bool { } #
Boolean or (short-circuit)
x :: { } #
not :: Bool -> Bool { } #
Boolean negation
otherwise :: Bool { } #
Always True
bool :: a -> a -> Bool -> a { } #
Case analysis for Bool
<*> :: { } #
>>= :: { } #
maybe :: b -> (a -> b) -> (Maybe a) -> b { } #
isJust :: (Maybe a) -> Bool { } #
isNothing :: (Maybe a) -> Bool { } #
fromMaybe :: a -> (Maybe a) -> a { } #
fromJust :: (Maybe a) -> a { } #
<*> :: { } #
>>= :: { } #
either :: (a -> c) -> (b -> c) -> (Either a b) -> c { } #
isLeft :: (Either a b) -> Bool { } #
isRight :: (Either a b) -> Bool { } #
fst :: (a, b) -> a { } #
snd :: (a, b) -> b { } #
curry :: ((a, b) -> c) -> a -> b -> c { } #
uncurry :: (a -> b -> c) -> (a, b) -> c { } #
swap :: (a, b) -> (b, a) { } #
showList__ :: (a -> ShowS) -> [a] -> ShowS { } #
showl :: { } #
shows :: (Show a) => a -> ShowS { } #
fromInteger :: Integer -> a { } #
y :: { } #
negate :: a -> a { } #
<$> :: (Functor f) => (a -> b) -> (f a) -> f b { } #
$> :: (Functor f) => (f a) -> b -> f b { } #
void :: (Functor f) => (f a) -> f () { } #
liftA :: (Applicative f) => (a -> b) -> (f a) -> f b { } #
liftA3 :: (Applicative f) => (a -> b -> c -> d) -> (f a) -> (f b) -> (f c) -> f d { } #
=<< :: (Monad m) => (a -> m b) -> (m a) -> m b { } #
>=> :: (Monad m) => (a -> m b) -> (b -> m c) -> a -> m c { } #
x :: { } #
<=< :: (Monad m) => (b -> m c) -> (a -> m b) -> a -> m c { } #
join :: (Monad m) => (m (m a)) -> m a { } #
ap :: (Monad m) => (m (a -> b)) -> (m a) -> m b { } #
id :: a -> a { } #
const :: a -> b -> a { } #
. :: (b -> c) -> (a -> b) -> a -> c { } #
x :: { } #
flip :: (a -> b -> c) -> b -> a -> c { } #
$ :: (a -> b) -> a -> b { } #
& :: a -> (a -> b) -> b { } #
on :: (b -> b -> c) -> (a -> b) -> a -> a -> c { } #
fix :: (a -> a) -> a { } #
seq :: a -> b -> b { } #
$! :: (a -> b) -> a -> b { } #
map :: (a -> b) -> [a] -> [b] { } #
++ :: [a] -> [a] -> [a] { } #
ys :: { } #
filter :: (a -> Bool) -> [a] -> [a] { } #
head :: [a] -> a { } #
last :: [a] -> a { } #
tail :: [a] -> [a] { } #
init :: [a] -> [a] { } #
null :: [a] -> Bool { } #
length :: [a] -> Int { } #
!! :: [a] -> Int -> a { } #
n :: { } #
reverse :: [a] -> [a] { } #
take :: Int -> [a] -> [a] { } #
drop :: Int -> [a] -> [a] { } #
splitAt :: Int -> [a] -> ([a], [a]) { } #
takeWhile :: (a -> Bool) -> [a] -> [a] { } #
dropWhile :: (a -> Bool) -> [a] -> [a] { } #
span :: (a -> Bool) -> [a] -> ([a], [a]) { } #
otherwise :: Bool { } #
Always True
break :: (a -> Bool) -> [a] -> ([a], [a]) { } #
elem :: (Eq a) => a -> [a] -> Bool { } #
notElem :: (Eq a) => a -> [a] -> Bool { } #
lookup :: (Eq a) => a -> [(a, b)] -> Maybe b { } #
find :: (a -> Bool) -> [a] -> Maybe a { } #
zip :: [a] -> [b] -> [(a, b)] { } #
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)] { } #
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] { } #
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d] { } #
unzip :: [(a, b)] -> ([a], [b]) { } #
unzip3 :: [(a, b, c)] -> ([a], [b], [c]) { } #
iterate :: (a -> a) -> a -> [a] { } #
repeat :: a -> [a] { } #
replicate :: Int -> a -> [a] { } #
cycle :: [a] -> [a] { } #
foldr1 :: (a -> a -> a) -> [a] -> a { } #
foldl1 :: (a -> a -> a) -> [a] -> a { } #
and :: [Bool] -> Bool { } #
or :: [Bool] -> Bool { } #
any :: (a -> Bool) -> [a] -> Bool { } #
all :: (a -> Bool) -> [a] -> Bool { } #
sum :: (Num a) => [a] -> a { } #
product :: (Num a) => [a] -> a { } #
concat :: [[a]] -> [a] { } #
concatMap :: (a -> [b]) -> [a] -> [b] { } #
maximum :: (Ord a) => [a] -> a { } #
minimum :: (Ord a) => [a] -> a { } #
scanl :: (b -> a -> b) -> b -> [a] -> [b] { } #
scanr :: (a -> b -> b) -> b -> [a] -> [b] { } #
lines :: String -> [String] { } #
words :: String -> [String] { } #
unlines :: [String] -> String { } #
unwords :: [String] -> String { } #
sort :: (Ord a) => [a] -> [a] { } #
sortBy :: (a -> a -> Ordering) -> [a] -> [a] { } #
mergeAll :: { } #
mergePairs :: { } #
merge :: { } #
sortOn :: (Ord b) => (a -> b) -> [a] -> [a] { } #
nub :: (Eq a) => [a] -> [a] { } #
nubBy :: (a -> a -> Bool) -> [a] -> [a] { } #
delete :: (Eq a) => a -> [a] -> [a] { } #
deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a] { } #
\\ :: (Eq a) => [a] -> [a] -> [a] { } #
union :: (Eq a) => [a] -> [a] -> [a] { } #
intersect :: (Eq a) => [a] -> [a] -> [a] { } #
subtract :: (Num a) => a -> a -> a { } #
even :: (Integral a) => a -> Bool { } #
odd :: (Integral a) => a -> Bool { } #
gcd :: (Integral a) => a -> a -> a { } #
lcm :: (Integral a) => a -> a -> a { } #
^ :: (Num a, Integral b) => a -> b -> a { } #
^^ :: (Fractional a, Integral b) => a -> b -> a { } #
fromIntegral :: (Integral a, Num b) => a -> b { } #
realToFrac :: (Real a, Fractional b) => a -> b { } #
mapM :: (Traversable t, Monad m) => (a -> m b) -> (t a) -> m (t b) { } #
mapM_ :: (Foldable t, Monad m) => (a -> m b) -> (t a) -> m () { } #
forM :: (Traversable t, Monad m) => (t a) -> (a -> m b) -> m (t b) { } #
forM_ :: (Foldable t, Monad m) => (t a) -> (a -> m b) -> m () { } #
sequence_ :: (Foldable t, Monad m) => (t (m a)) -> m () { } #
when :: (Applicative f) => Bool -> (f ()) -> f () { } #
unless :: (Applicative f) => Bool -> (f ()) -> f () { } #
guard :: (Alternative f) => Bool -> f () { } #
filterM :: (Applicative m) => (a -> m Bool) -> [a] -> m [a] { } #
foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> (t a) -> m b { } #
foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> (t a) -> m () { } #
replicateM :: (Applicative m) => Int -> (m a) -> m [a] { } #
replicateM_ :: (Applicative m) => Int -> (m a) -> m () { } #
error :: String -> a { } #
errorWithoutStackTrace :: String -> a { } #
undefined :: a { } #
fail :: (MonadFail m) => String -> m a { } #
Instances
instance Functor Maybe { }
instance Functor (Either a) { }
instance Functor [] { }
instance Applicative [] { }
instance Monad [] { }
instance Alternative [] { }
instance MonadPlus [] { }
instance Semigroup [a] { }
instance Monoid [a] { }
instance Foldable [] { }
instance Traversable [] { }
instance Functor IO { }
instance Applicative IO { }
instance Monad IO { }