Предметный указатель Haskell 98 Prelude Описание Haskell 98
наверх

Предметный указатель Haskell 98 Prelude

Типы и синонимы

Экземпляры, которые не определены с помощью кода на Haskell в Prelude (используется ...), не являются гиперссылками.

data () = ()  deriving (Eq, Ord, Enum, Bounded) (see 6.1.5)
      Instances: Read Show
data [a] = [] | a : [a]  deriving (Eq, Ord) (see 6.1.3)
      Instances: Read Show Functor Monad
data (a,b) = (a,b) deriving (Eq, Ord, Bounded) (see 6.1.4) 
      Instances: Read Show
data a->b (see 6.1.6)
data Bool = False | True deriving (Eq, Ord, Enum, Read, Show, Bounded) (see 6.1.1)
data Char (see 6.1.2)
       Instances: Eq Ord Enum Read Show 
data Double (see 6.4) 
       Instances: Eq Ord Enum Read Show Num Real Fractional RealFrac Floating RealFloat
data Either a b  e=  Left a | Right b deriving (Eq, Ord, Read, Show) (see 6.1.8)
type FilePath =  String (see 7.1)
data Float (see 6.4)
       Instances: Eq Ord Enum Read Show Num Real Fractional RealFrac Floating RealFloat
data Int (see 6.4)
       Instances: Eq Ord Enum Read Show Num Real Integral Bounded
data Integer (see 6.4)
       Instances: Eq Ord Enum Read Show Num Real Integral
data IO a (see 6.1.7)
       Instances: Functor Monad
data IOError (see 6.1.7)
       Instances: Show Eq
data Maybe a  =  Nothing | Just a deriving (Eq, Ord, Read, Show) (see 6.1.8)
        Instances: Functor Monad
data Ordering = LT | EQ | GT  deriving (Eq, Ord, Enum, Read, Show, Bounded) (see 6.1.8)
type ReadS a = String -> [(a,String)] (see 6.3.3)
type ShowS = String -> String (see 6.3.3)
type String = [Char] (see 6.1.2)

Конструкторы

[]
:
(,)
EQ
False
GT
Just
Left
LT
Nothing
Right
True

Классы

class                             Bounded a    (see 6.3.7)
class                             Enum a       (see 6.3.4)
class                             Eq a         (see 6.3.1)
class           (Fractional a) => Floating a   (see 6.4)
class                  (Num a) => Fractional a (see 6.4)
class                             Functor f    (see 6.3.5)
class         (Real a, Enum a) => Integral a   (see 6.4)
class                             Monad m      (see 6.3.6)
class           (Eq a, Show a) => Num a        (see 6.4)
class                   (Eq a) => Ord a        (see 6.3.2)
class                             Read a       (see 6.3.3)
class           (Num a, Ord a) => Real a       (see 6.4)
class (RealFrac a, Floating a) => RealFloat a  (see 6.4)  
class   (Real a, Fractional a) => RealFrac a   (see 6.4)
class                             Show a       (see 6.3.3) 

Функции и методы

(!!)             :: [a] -> Int -> a [0,1,2] !! 1 = 1
($)              :: (a -> b) -> a -> b f x $ g y = f x (g y)    
($!)             :: (a -> b) -> (a -> b) (see 6.2)
(&&)             :: Bool -> Bool -> Bool Логическое `и'
(||)             :: Bool -> Bool -> Bool Логическое `или'
(*)              :: Num a => a -> a -> a 
(**)             :: Floating a => a -> a -> a 
(+)              :: Num a => a -> a -> a
(++)             :: [a] -> [a] -> [a] "abc" ++ "def" = "abcdef"
(-)              :: Num a => a -> a -> a 
(.)              :: (b -> c) -> (a -> b) -> a -> c Композиция функций
(/)              :: Fractional a => a -> a -> a 
(/=)             :: Eq a => a -> a -> Bool не равно
(<)              :: Ord a => a -> a -> Bool 
(<=)             :: Ord a => a -> a -> Bool 
(==)             :: Eq a => a -> a -> Bool 
(=<<)            :: Monad a => (a -> m b) -> m a -> m b  Монадическое связывание имен (see 6.3.6)
(>)              :: Ord a => a -> a -> Bool 
(>=)             :: Ord a => a -> a -> Bool 
(>>)             :: Monad m => m a -> m b -> m b Монадическое связывание имен (see 6.3.6)
(>>=)            :: Monad m => m a -> (a -> m b) -> m b Монадическое связывание имен (see 6.3.6)
(^)              :: (Num a, Integral b) => a -> b -> a 
(^^)             :: (Fractional a, Integral b) => a -> b -> a допустим отрицательный показатель степени
abs              :: Num a => a -> a 
acos             :: Floating a => a -> a 
acosh            :: Floating a => a -> a 
all              :: (a -> Bool) -> [a] -> Bool all (/= 'a') "cba" = False
and              :: [Bool] -> Bool and [True, True, True] = True
any              :: (a -> Bool) -> [a] -> Bool any (== 'c') "abc" = True
appendFile       :: FilePath -> String -> IO ()
applyM           :: Monad m => (a -> m b) -> m a -> m b
asTypeOf         :: a -> a -> a Вид приведения типа
asin             :: Floating a => a -> a 
asinh            :: Floating a => a -> a 
atan             :: Floating a => a -> a 
atan2            :: RealFrac a => a -> a 
atanh            :: Floating a => a -> a 
break            :: (a -> Bool) -> [a] -> ([a], [a]) break (<2) [1,2,3] = ([1],[2,3])
catch            :: IO a -> (IOError -> IO a) -> IO a 
ceiling          :: (RealFrac a, Integral b) => a -> b 
compare          :: Ord a => a -> a -> Ordering 
concat           :: MonadPlus m => [m a] -> m a concat ["a","bc","d"] = "abcd"
concatMap        :: (a -> [b]) -> [a] -> [b]
const            :: a -> b -> a
cos              :: Floating a => a -> a 
cosh             :: Floating a => a -> a 
curry            :: ((a, b) -> c) -> a -> b -> c
cycle            :: [a] -> [a] cycle "abc" = "abcabcabc ..."
decodeFloat      :: RealFloat a => a -> (Integer, Int) 
div              :: Integral a => a -> a -> a 
divMod           :: Integral a => a -> a -> (a, a) 
drop             :: Int -> [a] -> [a] drop 2 "abcd" = "cd"
dropWhile        :: (a -> Bool) -> [a] -> [a] dropWhile (>3) [5,3,5] = [3,5]
either           :: (a -> c) -> (b -> c) -> Either a b -> c
elem             :: Eq a => a -> [a] -> Bool 'a' `elem` "abc" = True
encodeFloat      :: RealFloat a => Integer -> Int -> a 
enumFrom         :: Enum a => a -> [a] [n..]
enumFromThen     :: Enum a => a -> a -> [a] [m,n..]
enumFromThenTo   :: Enum a => a -> a -> a -> [a] [m,n..o]
enumFromTo       :: Enum a => a -> a -> [a] [m..n]
error            :: String -> a  (see 3.1)
even             :: Integral a => a -> Bool
exp              :: Floating a => a -> a 
exponent         :: RealFloat a => a -> Int 
fail             :: Monad m => String -> m a
filter           :: (a -> Bool) -> [a] -> [a]
flip             :: (a -> b -> c) -> (b -> a -> c)
floatDigits      :: RealFloat a => a -> Int 
floatRadix       :: RealFloat a => a -> Integer 
floatRange       :: RealFloat a => a -> (Int, Int) 
floor            :: (RealFrac a, Integral b) => a -> b 
fmap             :: Functor f => (a -> b) -> f a -> f b
foldl            :: (a -> b -> a) -> a -> [b] -> a foldl (+) 0 [a,b,c] = ((0+a)+b)+c
foldl1           :: (a -> a -> a) -> [a] -> a foldl1 (+) [a,b,c] = (a+b)+c
foldr            :: (a -> b -> b) -> b -> [a] -> b foldr (+) 0 [a,b,c] = a+(b+(c+0))
foldr1           :: (a -> a -> a) -> [a] -> a foldr1 (+) [a,b,c] = a+(b+c)
fromEnum         :: Enum a => a -> Int 
fromInteger      :: Num a => Integer -> a (see 3.2)
fromIntegral     :: (Integral a, Num b) => a -> b
fromRational     :: Fractional a => Rational -> a (see 3.2)
fst              :: (a, b) -> a
gcd              :: (Integral a) => a -> a -> a
getChar          :: IO Char конец файла вызывает IOError
getContents      :: IO String
getLine          :: IO String конец файла вызывает IOError
head             :: [a] -> a
id               :: a -> a
init             :: [a] -> [a]init "abcd" = "abc"
interact         :: (String -> String) -> IO ()
ioError          :: IOError -> IO a 
isDenormalized   :: RealFloat a => a -> Bool 
isIEEE           :: RealFloat a => a -> Bool 
isInfinite       :: RealFloat a => a -> Bool 
isNaN            :: RealFloat a => a -> Bool 
isNegativeZero   :: RealFloat a => a -> Bool 
iterate          :: (a -> a) -> a -> [a] iterate (++ " ") "" = ["", " ", "  ",...]
last             :: [a] -> a last "abcde" = "e"
lcm              :: Integral a => a -> a -> a
length           :: [a] -> Int length "Abc" = 3
lex              :: ReadS String lex "abc def" = [("abc"," def")]
lines            :: String -> [String]
log              :: Floating a => a -> a 
logBase          :: Floating a => a -> a -> a 
lookup           :: Eq a => a -> [(a, b)] -> Maybe b
map              :: (a -> b) -> [a] -> [b] 
mapM             :: Monad m => (a -> m b) -> [a] -> m [b]
mapM_            :: Monad m => (a -> m b) -> [a] -> m ()
max              :: Ord a => a -> a -> a 
maxBound         :: Bounded a => a 
maximum          :: Ord a => [a] -> a
maybe            :: b -> (a -> b) -> Maybe a -> b maybe 0 (+1) (Just 1) = 2
min              :: Ord a => a -> a -> a 
minBound         :: Bounded a => a 
minimum          :: Ord a => [a] -> a
mod              :: Integral a => a -> a -> a 
negate           :: Num a => a -> a 
not              :: Bool -> Bool
notElem          :: Eq a => a -> [a] -> Bool
null             :: [a] -> Bool
odd              :: Integral a => a -> Bool
or               :: [Bool] -> Bool
otherwise        :: Bool
pi               :: Floating a => a 
pred             :: Enum a => a -> a pred True = False
print            :: Show a => a -> IO () добавляет символ новой строки
product          :: Num a => [a] -> a
properFraction   :: (RealFrac a, Integral b) => a -> (b, a) 
putChar          :: Char -> IO ()
putStr           :: String -> IO ()
putStrLn         :: String -> IO () добавляет символ новой строки
quot             :: Integral a => a -> a -> a 
quotRem          :: Integral a => a -> a -> (a, a) 
read             :: Read a => String -> a
readFile         :: FilePath -> IO String
readIO           :: Read a => String -> IO a завершается с ошибкой IOError
readList         :: Read a => ReadS [a]
readLn           :: Read a => IO a
readParen        :: Bool -> ReadS a -> ReadS a
reads            :: Read a => ReadS a reads "1 2" :: [(Int,String)] = [(1," 2")]
readsPrec        :: Read a => Int -> ReadS a
realToFrac       :: (Real a, Fractional b) => a -> b
recip            :: Fractional a => a -> a 
rem              :: Integral a => a -> a -> a 
repeat           :: a -> [a] repeat 'a' = "aaaaaaaaa..."
replicate        :: Int -> a -> [a] replicate 4 'a' = "aaaa"
return           :: Monad m => a -> m a 
reverse          :: [a] -> [a] reverse "abc" = "cba"
round            :: (RealFrac a, Integral b) => a -> b 
scaleFloat       :: RealFloat a => Int -> a -> a 
scanl            :: (a -> b -> a) -> a -> [b] -> [a] scanl (+) 0 [1,2,3] = [0,1,3,6]
scanl1           :: (a -> a -> a) -> [a] -> [a] scanl1 (+) [1,2,3] = [1,3,6]
scanr            :: (a -> b -> b) -> b -> [a] -> [b] scanr (+) 0 [1,2,3] = [6,5,3,0]
scanr1           :: (a -> a -> a) -> [a] -> [a] scanr1 (+) [1,2,3] = [6,5,3]
seq              :: a -> b -> b (see 6.2)
sequence         :: Monad m => [m a] -> m [a] 
sequence_        :: Monad m => [m a] -> m () do-операции в последовательности
show             :: Show a => a -> String (see 6.3.3)
showChar         :: Char -> ShowS
showList         :: Show a => [a] -> ShowS
showParen        :: Bool -> ShowS -> ShowS
showString       :: String -> ShowS
shows            :: Show a => a -> ShowS (see 6.3.3)
showsPrec        :: Show a => Int -> a -> ShowS (see 6.3.3)
significand      :: RealFloat a => a -> a 
signum           :: Num a => a -> a 
sin              :: Floating a => a -> a 
sinh             :: Floating a => a -> a 
snd              :: (a, b) -> b
span             :: (a -> Bool) -> [a] -> ([a], [a]) span isAlpha "ab cd" = ("ab"," cd")
splitAt          :: Int -> [a] -> ([a], [a]) splitAt 2 "abcdef" = ("ab","cdef")
sqrt             :: Floating a => a -> a 
subtract         :: Num a => a -> a -> a
succ             :: Enum a => a -> a succ False = True
sum              :: Num a => [a] -> a sum [1,2,3] = 6
tail             :: [a] -> [a] tail "abc" = "bc"
take             :: Int -> [a] -> [a] take 3 "abcde" = "abc"
takeWhile        :: (a -> Bool) -> [a] -> [a] takeWhile (> 2) [3,2,1] = [3]
tan              :: Floating a => a -> a 
tanh             :: Floating a => a -> a 
toEnum           :: Enum a => Int -> a toEnum 0 :: Bool = False
toInteger        :: Integral a => a -> Integer 
toRational       :: Real a => a -> Rational 
truncate         :: (RealFrac a, Integral b) => a -> b 
uncurry          :: (a -> b -> c) -> ((a, b) -> c)
undefined        :: a (see 3.1)
unlines          :: [String] -> String
until            :: (a -> Bool) -> (a -> a) -> a -> a until (> 3) (+ 2) 0 = 4
unwords          :: [String] -> String
unzip            :: [(a, b)] -> ([a], [b]) unzip [('a','b'),('c','d')] = ("ac",bd")
unzip3           :: [(a, b, c)] -> ([a], [b], [c])
userError        :: String  -> IOError
words            :: String -> [String] words "ab d as+3" = ["ab","d","as+3"]
writeFile        :: FilePath -> String -> IO ()
zip              :: [a] -> [b] -> [(a, b)] zip "abc" "de" = [('a','d'), ('b',e')]
zip3             :: [a] -> [b] -> [c] -> [(a, b, c)]
zipWith          :: (a -> b -> c) -> [a] -> [b] -> [c] zipWith (+) [1,2] [3,4] = [4,6]
zipWith3         :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]