Условные выражения

тип:

abs :: Num a => a -> a

описание:

Возвращает абсолютное значение (модуль) числа.

определение:

abs x

| x >= 0 = x

| otherwise = -x

использование:

Prelude> abs (-3)

3

тип:

all :: (a -> Bool) -> [a] -> Bool

описание:

Применяется к предикатам и спискам, возвращает True (истина), если все элементы списка удовлетворяют предикату, и False (ложь) - в противном случае. Подобна оператору any.

определение:

all p xs = and (map p xs)

использование:

Prelude> all (<11) [1..10]

True

Prelude> all isDigit "123abc"

False

тип:

and :: [Bool] -> Bool

описание:

Логическое «и» списка значений типа boolean (смотрите также «or»).

определение:

and xs = foldr (&&) True xs

использование:

Prelude> and [True, True, False, True]

False

Prelude> and [True, True, True, True]

True

Prelude> and []

True

тип:

any :: (a -> Bool) -> [a] -> Bool

описание:

Применяется к предикатам и спискам, возвращает True (истина), если все элементы списка удовлетворяют предикату, и False (ложь) - в противном случае. Подобна оператору all.

определение:

any p xs = or (map p xs)

использование:

Prelude> any (<11) [1..10]

True

Prelude> any isDigit "123abc"

True

Prelude> any isDigit "alphabetics"

False

тип:

atan :: Floating a => a -> a

описание:

Тригонометрическая функция, инвертирующая tan.

определение:

defined internally.

использование:

Prelude> atan pi

1.26263

тип:

break :: (a -> Bool) -> [a] -> ([a],[a])

описание:

Учитывая предикат и список, разбивает список на 2 списка в точке, где предикат впервые удовлетворяет условию. Если предикат никогда не удовлетворяет условию, то в качестве первого элемента возвращается список полностью, а второй представляет собой пустой список ([]).

определение:

break p xs

= span p' xs

where

p' x = not (p x)

использование:

Prelude> break isSpace "hello there fred"

("hello", " there fred")

Prelude> break isDigit "no digits here"

("no digits here","")

тип:

ceiling :: (RealFrac a, Integral b) => a -> b

описание:

Возвращает наименьшее целое, не меньшее, чем этот аргумент.

использование:

Prelude> ceiling 3.8

4

Prelude> ceiling (-3.8)

-3

see also:

floor

тип:

chr :: Int -> Char

описание:

Применяется к целым числам диапазона 0 -- 255, возвращает символ по таблице ascii, который соответствует этому коду. Этот оператор противоположен оператору ord. Ошибка может возникнуть в случае выхода за границы диапазона.

определение:

defined internally.

использование:

Prelude> chr 65

'A'

Prelude> (ord (chr 65)) == 65

True

see also:

ord

тип:

compare :: Ord a => a -> a -> Ordering

описание:

Применяется к значениям одинакового типа. Результатом будет: EQ, если два выражения совпадают; GT, если первое выражение строго больше второго; и LT, если первое выражение меньше либо равно второму.

определение:

compare x y

| x == y = EQ

| x < y = LT

| otherwise = GT

использование:

Prelude> compare "aadvark" "zebra"

LT

тип:

concat :: [[a]] -> [a]

описание:

Применяется к списку список, соединяет их вместе, используя оператор ++.

определение:

concat xs = foldr (++) [] xs

использование:

Prelude> concat [[1,2,3], [4], [], [5,6,7,8]]

[1, 2, 3, 4, 5, 6, 7, 8]

тип:

concatMap :: (a -> [b]) -> [a] -> [b]

описание:

Учитывая функцию map given a function which maps a value to a list, and a list of elements of the same type as the value, applies the function to the list and then concatenates the result (thus flattening the resulting list).

определение:

concatMap f = concat . map f

использование:

Prelude> concatMap show [1,2,3,4]

"1234"

тип:

const :: const :: a -> b -> a

описание:

Создаёт постоянное значение, которое будет соответствовать первому выражению, независимо от значения второго.

определение:

const k _ = k

использование:

Prelude> const 12 "lucky"

12

тип:

cos :: Floating a => a -> a

описание:

Тригонометрическая функция косинуса, аргументы интерпретируются, чтобы быть в радианах.

определение:

defined internally.

использование:

Prelude> cos pi

-1.0

Prelude> cos (pi/2)

-4.37114e-08

тип:

digitToInt :: Char -> Int

описание:

Конвертирует цифры в соответствующее значение целого типа.

определение:

digitToInt :: Char -> Int

digitToInt c

| isDigit c = fromEnum c - fromEnum '0'

| c >= 'a' && c <= 'f' = fromEnum c - fromEnum 'a' + 10

| c >= 'A' && c <= 'F' = fromEnum c - fromEnum 'A' + 10

| otherwise = error "Char.digitToInt: not a digit"

использование:

Prelude> digitToInt '3'

3

тип:

div :: Integral a => a -> a -> a

описание:

Целочисленное деление.

определение:

defined internally.

использование:

Prelude> 16 `div` 9

1

Prelude> (-12) `div` 5

-3

замечание:

`div` - такое целочисленное деление, что результат является обрезанным к отрицательной значению.

тип:

drop :: Int -> [a] -> [a]

описание:

Применяется к числу или списку, возвращает список, удалив определённое количество элементов из начала списка. Если список содержит меньше элементов, чем указанное число, то возвращается [].

определение:

drop 0 xs = xs

drop _ [] = []

drop n (_:xs) | n>0 = drop (n-1) xs

drop _ _ = error "PreludeList.drop: negative argument"

использование:

Prelude> drop 3 [1..10]

[4, 5, 6, 7, 8, 9, 10]

Prelude> drop 4 "abc"

""

тип:

dropWhile :: (a -> Bool) -> [a] -> [a]

описание:

Применяется к предикату и списку, возвращает список, удалив из его начала элементы, удовлетворяющие условию предиката.

определение:

dropWhile p [] = []

dropWhile p (x:xs)

| p x = dropWhile p xs

| otherwise = (x:xs)

использование:

Prelude> dropWhile (<5) [1..10]

[5, 6, 7, 8, 9, 10]

тип:

elem :: Eq a => a -> [a] -> Bool

описание:

Применяется к значению и списку, возвращает Истину, если значение находится в списке и Ложь в противном случае. Элементы списка должны иметь тот же тип, как значение.

определение:

elem x xs = any (== x) xs

использование:

Prelude> elem 5 [1..10]

True

Prelude> elem "rat" ["fat", "cat", "sat", "flat"]

False

тип:

error :: String -> a

описание:

Применяется к строке, создаёт ошибку в программе с соответствующим сообщением в строке.

определение:

defined internally.

использование:

error "this is an error message"

тип:

even :: Integral a => a -> Bool

описание:

Примененный к числовому аргументу, возвращает Истину, если аргумент чётный, и Ложь – в противном случае.

определение:

even n = n `rem` 2 == 0

использование:

Prelude> even 2

True

Prelude> even (11 * 3)

False

тип:

exp :: Floating a => a -> a

описание:

Экспоненциальная функция (exp n эквивалентна eⁿ).

определение:

defined internally.

использование:

Prelude> exp 1

2.71828

тип:

filter :: (a -> Bool) -> [a] -> [a]

описание:

Применяется к предикату и списку, возвращает список, содержащий все элементы, которые удовлетворяют предикату.

определение:

filter p xs = [k | k <- xs, p k]

использование:

Prelude> filter isDigit "fat123cat456"

"123456"

тип:

flip :: (a -> b -> c) -> b -> a -> c

описание:

Применяется к бинарной функции, возвращает ту же самую функцию с обратным порядком аргументов.

определение:

flip f x y = f y x

использование:

Prelude> flip elem [1..10] 5

True

тип:

floor :: (RealFrac a, Integral b) => a -> b

описание:

Возвращает самое большое целое число не большее чем его аргумент.

использование:

Prelude> floor 3.8

3

Prelude> floor (-3.8)

-4

see also:

ceiling

тип:

foldl :: (a -> b -> a) -> a -> [b] -> a

описание:

Складывает список, используя данный двоичный оператор и данное перед списком значение в левоориентированном направлении.

foldl op r [a, b, c] → ((r `op` a) `op` b) `op` c

определение:

foldl f z [] = z

foldl f z (x:xs) = foldl f (f z x) xs

использование:

Prelude> foldl (+) 0 [1..10]

55

Prelude> foldl (flip (:)) [] [1..10]

[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

тип:

foldr :: (a -> b -> b) -> b -> [a] -> b

описание:

Складывает список, используя данный двоичный оператор и данное перед списком значение в правоориентированном направлении.

foldr op r [a, b, c] → a `op` (b `op` (c `op` r))

определение:

foldr f z [] = z

foldr f z (x:xs) = f x (foldr f z xs)

использование:

Prelude> foldr (++) [] ["con", "cat", "en", "ate"]

"concatenate"

тип:

fromInt :: Num a => Int -> a

описание:

Конвертирует значение типа Int до числового типа, который находится в классе Num.

использование:

Prelude> (fromInt 3)::Float

3.0

тип:

fromInteger :: Num a => Integer -> a

описание:

Конвертирует значение типа Integer до числового типа, который находится в классе Num.

использование:

Prelude> (fromInteger 10000000000)::Float

1.0e+10

тип:

fst :: (a, b) -> a

описание:

Возвращает первый элемент пары

определение:

fst (x, _) = x

использование:

Prelude> fst ("harry", 3)

"harry"

тип:

gcd :: Integral a => a -> a -> a

описание:

Возвращает наибольший общий делитель между двумя составными аргументами.

определение:

gcd 0 0 = error "Prelude.gcd: gcd 0 0 is undefined"

gcd x y = gcd' (abs x) (abs y)

where

gcd' x 0 = x

gcd' x y = gcd' y (x `rem` y)

использование:

Prelude> gcd 2 10

2

Prelude> gcd (-7) 13

1

тип:

head :: [a] -> a

описание:

Возвращает первый элемент, непустой список. Если применяется к пустому списку, результат ошибочен.

определение:

head (x:_) = x

использование:

Prelude> head [1..10]

1

Prelude> head ["this", "and", "that"]

"this"

тип:

id :: a -> a

описание:

Функция идентичности, возвращает значение ее аргумента.

определение:

id x = x

использование:

Prelude> id 12

12

Prelude> id (id "fred")

"fred"

Prelude> (map id [1..10]) == [1..10]

True

тип:

init :: [a] -> [a]

описание:

Возвращает все, кроме последнего элемента списка аргументов. Список аргументов должен иметь по крайней мере один элемент. Если init применяется к пустому списку, то происходит ошибка.

определение:

init [x] = []

init (x:xs) = x : init xs

использование:

Prelude> init [1..10]

[1, 2, 3, 4, 5, 6, 7, 8, 9]

тип:

isAlpha :: Char -> Bool

описание:

Применяется к символьному аргументу, возвращает Истину, если символ является буквой, и Ложь – в противном случае.

определение:

isAlpha c = isUpper c || isLower c

использование:

Prelude> isAlpha 'a'

True

Prelude> isAlpha '1'

False

тип:

isDigit :: Char -> Bool

описание:

Применяется к символьному аргументу, возвращает Истину, если символ является цифрой, и Ложь – в противном случае.

определение:

isDigit c = c >= '0' && c <= '9'

использование:

Prelude> isDigit '1'

True

Prelude> isDigit 'a'

False

тип:

isLower :: Char -> Bool

описание:

Применяется к символьному аргументу, возвращает Истину, если символ нижнего регистра, и Ложь – в противном случае.

определение:

isLower c = c >= 'a' && c <= 'z'

использование:

Prelude> isLower 'a'

True

Prelude> isLower 'A'

False

Prelude> isLower '1'

False

тип:

isSpace :: Char -> Bool

описание:

Возвращает Истину, если символьный аргумент является одним из символов, приведённых ниже (в определении), Ложь – в противном случае.

определение:

isSpace c = c == ' ' || c == '\t' || c == '\n' ||

c == '\r' || c == '\f' || c == '\v'

использование:

Prelude> dropWhile isSpace " \nhello \n"

"hello \n"

тип:

isUpper :: Char -> Bool

описание:

Применяется к символьному аргументу, возвращает Истину, если символ верхнего регистра, и Ложь – в противном случае.

определение:

isUpper c = c >= 'A' && c <= 'Z'

использование:

Prelude> isUpper 'A'

True

Prelude> isUpper 'a'

False

Prelude> isUpper '1'

False

тип:

iterate :: (a -> a) -> a -> [a]

описание:

итерирует f x, возвращает список следующего вида: [x,f(x),f(f(x)),...].

определение:

iterate f x = x : iterate f (f x)

использование:

Prelude> iterate (+1) 1

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, .....

тип:

last :: [a] -> a

описание:

Применяется к непустому списку, возвращает последний элемент списка.

определение:

last [x] = x

last (_:xs) = last xs

использование:

Prelude> last [1..10]

10

тип:

lcm :: Integral a => a -> a -> a

описание:

Возвращает наименьший общий множитель двух аргументов.

определение:

lcm _ 0 = 0

lcm 0 _ = 0

lcm x y = abs ((x `quot` gcd x y) * y)

использование:

Prelude> lcm 2 10

10

Prelude> lcm 2 11

22

тип:

length :: [a] -> Int

описание:

Возвращает количество элементов списка.

определение:

length [] = 0

length (x:xs) = 1 + length xs

использование:

Prelude> length [1..10]

10

тип:

lines :: String -> [String]

описание:

Применяется к списку символов, содержащему новые строки (\n). Возвращает список списков, разделяя исходный в тех местах, где содержится ‘\n’. В результате символы, обозначающие новую строку удаляются.

определение:

lines [] = []

lines (x:xs)

= l : ls

where

(l, xs') = break (== '\n') (x:xs)

ls

| xs' == [] = []

| otherwise = lines (tail xs')

использование:

Prelude> lines "hello world\nit's me,\neric\n"

["hello world", "it's me,", "eric"]

тип:

log :: Floating a => a -> a

описание:

Возвращает натуральный логарифм аргумента.

определение:

defined internally.

использование:

Prelude> log 1

0.0

Prelude> log 3.2

1.16315

тип:

map :: (a -> b) -> [a] -> [b]

описание:

Учитывая функцию и список любого типа, возвращает список, где каждый элемент - результат применения функции к соответствующему элементу в начальном списке.

определение:

map f xs = [f x | x <- xs]

использование:

Prelude> map sqrt [1..5]

[1.0, 1.41421, 1.73205, 2.0, 2.23607]

тип:

max :: Ord a => a -> a -> a

описание:

Применяется к двум значениям одинакового типа. Возвращает максимальное значение этих двух элементов.

определение:

max x y

| x >= y = x

| otherwise = y

использование:

Prelude> max 1 2

2

тип:

maximum :: Ord a => [a] -> a

описание:

Применяется к непустому списку. Возвращает максимальный элемент списка.

определение:

maximum xs = foldl1 max xs

использование:

Prelude> maximum [-10, 0 , 5, 22, 13]

22

тип:

min :: Ord a => a -> a -> a

описание:

Применяется к двум значениям одинакового типа. Возвращает минимальное значение этих двух элементов.

определение:

min x y

| x <= y = x

| otherwise = y

использование:

Prelude> min 1 2

1

тип:

minimum :: Ord a => [a] -> a

описание:

Применяется к непустому списку. Возвращает минимальный элемент списка.

определение:

minimum xs = foldl1 min xs

использование:

Prelude> minimum [-10, 0 , 5, 22, 13]

-10

тип:

mod :: Integral a => a -> a -> a

описание:

Возвращает остаток от деления двух аргументов.

определение:

defined internally.

использование:

Prelude> 16 `mod` 9

7

тип:

not :: Bool -> Bool

описание:

Возвращает логическое отрицание аргумента типа boolean.

определение:

not True = False

not False = True

использование:

Prelude> not (3 == 4)

True

Prelude> not (10 > 2)

False

описание:

Возвращает True, если элемент, предшествующий этой функции не входит в последующий список.

использование:

Prelude> 3 `notElem` [1,2,3]

False

Prelude> 4 `notElem` [1,2,3]

True

тип:

null :: [a] -> Bool

описание:

Возвращает True, если аргументом является пустой список, и False – в противном случае.

определение:

null [] = True

null (_:_) = False

использование:

Prelude> null []

True

Prelude> null (take 3 [1..10])

False

тип:

odd :: Integral a => a -> Bool

описание:

Возвращает True, если аргумент нечётный, и False – в противном случае.

определение:

odd = not . even

использование:

Prelude> odd 1

True

Prelude> odd (2 * 12)

False

тип:

or :: [Bool] -> Bool

описание:

Применяется к списку значений типа Boolean. Возвращает логическое «или».

определение:

or xs = foldr (||) False xs

использование:

Prelude> or [False, False, True, False]

True

Prelude> or [False, False, False, False]

False

Prelude> or []

False

тип:

ord :: Char -> Int

описание:

Применяется к символу, возвращает его код из таблицы ascii.

определение:

defined internally.

использование:

Prelude> ord 'A'

65

Prelude> (chr (ord 'A')) == 'A'

True

see also:

chr

тип:

pi :: Floating a => a

описание:

Вещественное число пи.

определение:

defined internally.

использование:

Prelude> pi

3.14159

Prelude> cos pi

-1.0

тип:

pred :: Enum a => a -> a

описание:

Применяется к значениям перечисляемого типа. Возвращает предыдущее значение перечисления. Если аргумент является первым значением, то произойдёт ошибка.

использование:

Prelude> pred 1

0

Prelude> pred True

False

тип:

putStr :: String -> IO ()

описание:

Принимает строку в качестве аргумента и возвращает как результат ввод/вывод. Побочный эффект применения putStr - то, что строка печатается на экране.

определение:

defined internally.

использование:

Prelude> putStr "Hello World\nI'm here!"

Hello World

I'm here!

тип:

product :: Num a => [a] -> a

описание:

Применяется к списку чисел. Возвращает их произведение.

определение:

product xs = foldl (*) 1 xs

использование:

Prelude> product [1..10]

3628800

тип:

quot :: Integral a => a -> a -> a

описание:

Возвращает фактор после целочисленного деления первого аргумента на второй.

определение:

defined internally.

использование:

Prelude> 16 `quot` 8

2

Prelude> quot 16 9

1

тип:

rem :: Integral a => a -> a -> a

описание:

Возвращает остаток от деления первого аргумента на второй.

определение:

defined internally.

использование:

Prelude> 16 `rem` 8

0

Prelude> rem 16 9

7

замечание:

Следующее равенство содержит:

(x `quot` y)*y + (x `rem` y) == x

тип:

repeat :: a -> [a]

описание:

Учитывая значение, возвращает бесконечный список таких же элементов.

определение:

repeat x

= xs

where xs = x:xs

использование:

Prelude> repeat 12

[12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12 ....

тип:

replicate :: Int -> a -> [a]

описание:

Учитывая целое число (>=0) и значение, возвращает список, содержащий указанное количество раз это значение.

определение:

replicate n x = take n (repeat x)

использование:

Prelude> replicate 3 "apples"

["apples", "apples", "apples"]

тип:

reverse :: [a] -> [a]

описание:

Применяется к конечному списку любого типа. Возвращает список тех же элементов, но в обратном порядке.

определение:

reverse = foldl (flip (:)) []

использование:

Prelude> reverse [1..10]

[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

тип:

round :: (RealFrac a, Integral b) => a -> b

описание:

Округляет аргумент к ближайшему целому числу.

использование:

Prelude> round 3.2

3

Prelude> round 3.5

4

Prelude> round (-3.2)

-3

тип:

show :: Show a => a -> String

описание:

Преобразовывает значение (которое должно быть членом класса Show), к строковому представлению.

определение:

defined internally.

использование:

Prelude> "six plus two equals " ++ (show (6 + 2))

"six plus two equals 8"

тип:

sin :: Floating a => a -> a

описание:

Тригонометрическая функция синуса.

определение:

defined internally.

использование:

Prelude> sin (pi/2)

1.0

Prelude> ((sin pi)^2) + ((cos pi)^2)

1.0

тип:

snd :: (a, b) -> b

описание:

Возвращает второй элемент из пары элементов.

определение:

snd (_, y) = y

использование:

Prelude> snd ("harry", 3)

3

тип:

sort :: Ord a => [a] -> [a]

описание:

Сортирует элементы списка в порядке возрастания.

использование:

List> sort [1, 4, -2, 8, 11, 0]

[-2,0,1,4,8,11]

замечание:

This is not defined within the Prelude. You must import the List.hs module to use this function.

тип:

span :: (a -> Bool) -> [a] -> ([a],[a])

описание:

Учитывая предикат и список, разделяет список на два списка (возвращаются как пара), таких, что элементы в первом берутся из головы списка, пока предикат удовлетворен, а элементы во втором списке - оставшиеся, как только предикат не удовлетворен.

определение:

span p [] = ([],[])

span p xs@(x:xs')

| p x = (x:ys, zs)

| otherwise = ([],xs)

where (ys,zs) = span p xs'

использование:

Prelude> span isDigit "123abc456"

("123", "abc456")

тип:

splitAt :: Int -> [a] -> ([a],[a])

описание:

Учитывая целое число (>=0) и список, разделяет, список на два списка (возвращаются как пара) в соответствии с данным целым числом. Если целое число больше, чем длина списка, то возвращается кортеж, содержащий весь список в качестве его первого элемента и пустой список в качестве его второго элемента.

определение:

splitAt 0 xs = ([],xs)

splitAt _ [] = ([],[])

splitAt n (x:xs)

| n > 0 = (x:xs',xs'')

where

(xs',xs'') = splitAt (n-1) xs

splitAt _ _ = error "PreludeList.splitAt: negative argument"

использование:

Prelude> splitAt 3 [1..10]

([1, 2, 3], [4, 5, 6, 7, 8, 9, 10])

Prelude> splitAt 5 "abc"

("abc", "")

тип:

sqrt :: Floating a => a -> a

описание:

Возвращает корень из числа.

определение:

sqrt x = x ** 0.5

использование:

Prelude> sqrt 16

4.0

тип:

subtract :: Num a => a -> a -> a

описание:

Вычитает его первый аргумент из второго.

определение:

subtract = flip (-)

использование:

Prelude> subtract 7 10

3

тип:

succ :: Enum a => a -> a

описание:

Применяется к значению перечисляемого типа. Возвращает последующий аргумент в перечислении. Если его аргумент будет последним, то произойдет ошибка.

определение:

defined internally.

использование:

Prelude> succ 'a'

'b'

Prelude> succ False

True

тип:

sum :: Num a => [a] -> a

описание:

Вычисляет сумму элементов списка.

определение:

sum xs = foldl (+) 0 xs

использование:

Prelude> sum [1..10]

55

тип:

tail :: [a] -> [a]

описание:

Применяется к непустому списку. Возвращает хвост списка.

определение:

tail (_:xs) = xs

использование:

Prelude> tail [1,2,3]

[2,3]

Prelude> tail "hugs"

"ugs"

тип:

take :: Int -> [a] -> [a]

описание:

Применяется к целому числу (>=0) и списку. Возвращает указанное число элементов из начала списка. Если список имеет меньше, чем необходимо элементов, то возвращается весь список.

определение:

take 0 _ = []

take _ []= []

take n (x:xs)

| n > 0 = x : take (n-1) xs

take _ _ = error "PreludeList.take: negative argument"

использование:

Prelude> take 4 "goodbye"

"good"

Prelude> take 10 [1,2,3]

[1,2,3]

тип:

takeWhile :: (a -> Bool) -> [a] -> [a]

описание:

Применяется к предикату и списку. Возвращает список, содержащий элементы из начала списка, пока предикат удовлетворен.

определение:

takeWhile p [] = []

takeWhile p (x:xs)

| p x = x : takeWhile p xs

| otherwise = []

использование:

Prelude> takeWhile (<5) [1, 2, 3, 10, 4, 2]

[1, 2, 3]

тип:

tan :: Floating a => a -> a

описание:

Тригонометрическая функция тангенса.

определение:

defined internally.

использование:

Prelude> tan (pi/4)

1.0

тип:

toLower :: Char -> Char

описание:

Преобразовывает заглавную букву в строчную. Если эта функция будет применена к аргументу, который не является заглавным, то результатом будет тот же аргумент.

определение:

toLower c

| isUpper c = toEnum (fromEnum c - fromEnum 'A' + fromEnum 'a')

| otherwise = c

использование:

Prelude> toLower 'A'

'a'

Prelude> toLower '3'

'3'

тип:

toUpper :: Char -> Char

описание:

Преобразовывает строчную букву в заглавную. Если эта функция будет применена к аргументу, который не является строчным, то результатом будет тот же аргумент.

определение:

toUpper c

| isLower c = toEnum (fromEnum c - fromEnum 'a' + fromEnum 'A')

| otherwise = c

использование:

Prelude> toUpper 'a'

'A'

Prelude> toUpper '3'

'3'

тип:

truncate :: (RealFrac a, Integral b) => a -> b

описание:

Отсекает дробную часть вещественного числа, возвращая только целую часть.

использование:

Prelude> truncate 3.2

3

Prelude> truncate (-3.2)

-3

тип:

undefined :: a

описание:

Неопределённое значение. Оно является членом каждого типа.

определение:

undefined

| False = undefined

тип:

unlines :: [String] -> String

описание:

Преобразовывает список строк в единую, помещая символ новой строки между каждой из них.

определение:

unlines xs

= concat (map addNewLine xs)

where

addNewLine l = l ++ "\n"

использование:

Prelude> unlines ["hello world", "it's me,", "eric"]

"hello world\nit's me,\neric\n"

тип:

until :: (a -> Bool) -> (a -> a) -> a -> a

описание:

Учитывая предикат, унарную функцию и значение, рекурсивно применяется функция к значению до тех пор, пока предикат не будет удовлетворен. Если предикат никогда не удовлетворяется, вычисления никогда не закончатся.

определение:

until p f x

| p x = x

| otheriwise = until p f (f x)

использование:

Prelude> until (>1000) (*2) 1

1024

тип:

unwords :: [String] -> String

описание:

Объединяет список строк в единственную, помещая между каждой из них пробел.

определение:

unwords [] = []

unwords ws

= foldr1 addSpace ws

where

addSpace w s = w ++ (' ':s)

использование:

Prelude> unwords ["the", "quick", "brown", "fox"]

"the quick brown fox"

тип:

words :: String -> [String]

описание:

Разбивает строку на аргументы и объединяет их в список такой, что каждое слово разграничено одним или более whitespace символами (см. функцию isSpace).

определение:

words s

| findSpace == [] = []

| otherwise = w : words s''

where

(w, s'') = break isSpace findSpace

findSpace = dropWhile isSpace s

использование:

Prelude> words "the quick brown\n\nfox"

["the", "quick", "brown", "fox"]

тип:

zip :: [a] -> [b] -> [(a,b)]

описание:

Применяется к двум спискам. Возвращает список пар, состоящих из соответствующих элементов первого и второго списков. Если два списка имеют различную длину, то длина получающегося списка равна длине самого короткого.

определение:

zip xs ys

= zipWith pair xs ys

where

pair x y = (x, y)

использование:

Prelude> zip [1..6] "abcd"

[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

тип:

zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

описание:

Применяется к бинарной функции и двум спискам. Возвращает список, состоящий из применённой функции к соответствующим элементам первого и второго списков.

определение:

zipWith z (a:as) (b:bs) = z a b : zipWith z as bs

zipWith _ _ _ = []

использование:

Prelude> zipWith (+) [1..5] [6..10]

[7, 9, 11, 13, 15]

тип:

(!!) :: [a] -> Int -> a

описание:

Учитывая список и число, возвращает элемент списка, позиция которого равна тому же числу.

использование:

Prelude> [1..10] !! 0

1

Prelude> "a string" !! 3

't'

замечание:

the valid subscripts for a list l are: 0 .. (length l) - 1. Therefore, negative subscripts are not allowed, nor are subsripts greater than one less than the length of the list argument. Subscripts out of this range will result in a program error.

тип:

(.) :: (b -> c) -> (a -> b) -> a -> c

описание:

Составляет две функции в единую.

использование:

Prelude> (sqrt . sum ) [1,2,3,4,5]

3.87298

замечание:

(f.g.h) x is equivalent to f (g (h x)).

тип:

(**) :: Floating a => a -> a -> a

описание:

Возводит первый аргумент в степень второго. Аргументы должны быть вещественного типа, и результат также будет вещественным.

использование:

Prelude> 3.2**pi

38.6345

тип:

(^) :: (Num a, Integral b) => a -> b -> a

описание:

Возводит первый аргумент в степень второго. Первый аргумент должен быть числового типа, а второй должен быть целочисленного типа. Результат будет такого же типа, как и первый аргумент.

использование:

Prelude> 3.2^4

104.858

тип:

(^^) :: (Fractional a, Integral b) => a -> b -> a

описание:

Возводит первый аргумент в степень второго. Первый аргумент должен быть вещественного типа, а второй должен быть целочисленного типа. Результат будет такого же типа, как и первый аргумент.

использование:

Prelude> 3.142^^4

97.4596

тип:

(%) :: Integral a => a -> a -> Ratio a

описание:

Берутся два числа целочисленного типа и возвращается самое простое отношение двух.

использование:

Prelude> 20 % 4

5 % 1

Prelude> (5 % 4)^2

25 % 16

тип:

(*) :: Num a => a -> a -> a

описание:

Возвращает произведение двух аргументов.

использование:

Prelude> 6 * 2.0

12.0

тип:

(/) :: Fractional a => a -> a -> a

описание:

Возвращает результат деления первого аргумента на второй. Оба аргумента должны быть вещественного типа.

использование:

Prelude> 12.0 / 2

6.0

тип:

(+) :: Num a => a -> a -> a

описание:

Возвращает сумму аргументов.

использование:

Prelude> 3 + 4

7

Prelude> (4 % 5) + (1 % 5)

1 % 1

тип:

(-) :: Num a => a -> a -> a

описание:

Возвращает результат вычитания второго аргумента из первого.

использование:

Prelude> 4 - 3

1

Prelude> 4 - (-3)

7

тип:

(:) :: a -> [a] -> [a]

описание:

Добавляет элемент в начало списка.

использование:

Prelude> 1:[2,3]

[1,2,3]

Prelude> True:[]

[True]

Prelude> 'h':"askell"

"haskell"

тип:

(++) :: [a] -> [a] -> [a]

описание:

Складывает списки.

использование:

Prelude> [1,2,3] ++ [4,5,6]

[1,2,3,4,5,6]

Prelude> "foo " ++ "was" ++ " here"

"foo was here"

тип:

(/=) :: Eq a => a -> a -> Bool

описание:

True, если первый аргумент не равен второму, а в противном случае – False. Равенство определяется оператором ==.

использование:

Prelude> 3 /= 4

True

Prelude> [1,2,3] /= [1,2,3]

False

тип:

(==) :: Eq a => a -> a -> Bool

описание:

True, если первый аргумент равен второму, а в противном случае – False.

использование:

Prelude> 3 == 4

False

Prelude> [1,2,3] == [1,2,3]

True

тип:

(<) :: Ord a => a -> a -> Bool

описание:

Возвращает True, если первый аргумент строго меньше второго, а в противном случае – False.

использование:

Prelude> 1 < 2

True

Prelude> 'a' < 'z'

True

Prelude> True < False

False

тип:

(<=) :: Ord a => a -> a -> Bool

описание:

Возвращает True, если первый аргумент меньше либо равен второму, а в противном случае – False.

использование:

Prelude> 3 <= 4

True

Prelude> 4 <= 4

True

Prelude> 5 <= 4

False

тип:

(>) :: Ord a => a -> a -> Bool

описание:

Возвращает True, если первый аргумент строго больше второго, а в противном случае – False.

использование:

Prelude> 2 > 1

True

Prelude> 'a' > 'z'

False

Prelude> True > False

True

тип:

(>=) :: Ord a => a -> a -> Bool

описание:

Возвращает True, если первый аргумент больше либо равен второму, а в противном случае – False.

использование:

Prelude> 4 >= 3

True

Prelude> 4 >= 4

True

Prelude> 4 >= 5

False

тип:

(&&) :: Bool -> Bool -> Bool

описание:

Возвращает логическую конъюнкцию аргументов типа boolean.

использование:

Prelude> True && True

True

Prelude> (3 < 4) && (4 < 5) && False

False

тип:

(||) :: Bool -> Bool -> Bool

описание:

Возвращает логическую дизъюнкцию аргументов типа boolean

использование:

Prelude> True || False

True

Prelude> (3 < 4) || (4 > 5) || False

True