GHC.OldList

Copyright	(c) The University of Glasgow 2001
License	BSD-style (see the file libraries/base/LICENSE)
Maintainer	libraries@haskell.org
Stability	experimental
Portability	portable
Safe Haskell	Safe
Language	Haskell2010

Основные функции

(++) :: [a] -> [a] -> [a] infixr 5 Source

Присоединяет два списка, т.е.,

[x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn]
[x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]

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

head :: [a] -> a Source

Извлекает первый элемент списка, который должен быть непустым.

last :: [a] -> a Source

Извлекает последний элемент списка, который должен быть конечным и непустым.

tail :: [a] -> [a] Source

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

init :: [a] -> [a] Source

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

uncons :: [a] -> Maybe (a, [a]) Source

Разлагает список на его первый элемент и остальную часть списка. Если список пустой, возвращает Nothing. Если список непустой, возвращает Just (x, xs), где x — это первый элемент списка, а xs — его остальная часть.

С момента: 4.8.0.0

null :: [a] -> Bool Source

Проверяет, пуст ли список.

length :: [a] -> Int Source

O(n). length возвращает длину конечного списка в виде Int. Это пример более общей функции genericLength, тип результата которой может быть любым числом.

Преобразования списков

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

map f xs — это список, полученный путём применения f к каждому элементу xs, т.е.,

map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn]
map f [x1, x2, ...] == [f x1, f x2, ...]

reverse :: [a] -> [a] Source

reverse xs возвращает элементы xs в обратном порядке. xs должен быть конечным.

intersperse :: a -> [a] -> [a] Source

Функция intersperse принимает элемент и список и «вставляет» этот элемент между элементами списка. Например,

intersperse ',' "abcde" == "a,b,c,d,e"

intercalate :: [a] -> [[a]] -> [a] Source

intercalate xs xss эквивалентно (concat (intersperse xs xss)). Оно вставляет список xs между списками в xss и конкатенирует результат.

transpose :: [[a]] -> [[a]] Source

Функция transpose транспонирует строки и столбцы своего аргумента. Например,

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

Если некоторые строки короче последующих строк, их элементы пропускаются:

transpose [[10,11],[20],[],[30,31,32]] == [[10,20,30],[11,31],[32]]

subsequences :: [a] -> [[a]] Source

Функция subsequences возвращает список всех подпоследовательностей аргумента.

subsequences "abc" == ["","a","b","ab","c","ac","bc","abc"]

permutations :: [a] -> [[a]] Source

Функция permutations возвращает список всех перестановок аргумента.

permutations "abc" == ["abc","bac","cba","bca","cab","acb"]

Сведение списков (свертки)

foldl :: forall a b. (b -> a -> b) -> b -> [a] -> b Source

foldl, применённая к бинарному оператору, начальному значению (обычно левому тождеству оператора) и списку, сводит список с использованием бинарного оператора слева направо:

foldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xn

Список должен быть конечным.

foldl' :: forall a b. (b -> a -> b) -> b -> [a] -> b Source

Строгая версия foldl.

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

foldl1 — это вариант foldl без аргумента начального значения, поэтому он должен применяться к непустым спискам.

foldl1' :: (a -> a -> a) -> [a] -> a Source

Строгая версия foldl1.

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

foldr, применённая к бинарному оператору, начальному значению (обычно правому тождеству оператора) и списку, сводит список с использованием бинарного оператора справа налево:

foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)

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

foldr1 — это вариант foldr без аргумента начального значения, поэтому он должен применяться к непустым спискам.

Специальные свертки

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

Конкатенирует список списков.

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

Применяет функцию к списку и конкатенирует результаты.

and :: [Bool] -> Bool Source

and возвращает конъюнкцию списка булевых значений. Для того, чтобы результат был True, список должен быть конечным; False, однако, результат получается от False значения в конечном индексе конечного или бесконечного списка.

or :: [Bool] -> Bool Source

or возвращает дизъюнкцию списка булевых значений. Для того, чтобы результат был False, список должен быть конечным; True, однако, результат получается от True значения в конечном индексе конечного или бесконечного списка.

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

Применённая к предикату и списку, функция any определяет, удовлетворяет ли какой-либо элемент списка данному предикату. Для того, чтобы результат был False, список должен быть конечным; True, однако, результат получается от True значения предиката, применённого к элементу в конечном индексе конечного или бесконечного списка.

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

Применённая к предикату и списку, функция all определяет, удовлетворяют ли все элементы списка данному предикату. Для того, чтобы результат был True, список должен быть конечным; False, однако, результат получается от False значения предиката, применённого к элементу в конечном индексе конечного или бесконечного списка.

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

Функция sum вычисляет сумму конечного списка чисел.

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

Функция product вычисляет произведение конечного списка чисел.

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

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

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

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

Создание списков

Сканирование

scanl :: (b -> a -> b) -> b -> [a] -> [b] Source

scanl аналогично foldl, но возвращает список последовательных уменьшенных значений слева:

scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]

Обратите внимание, что

last (scanl f z xs) == foldl f z xs.

scanl' :: (b -> a -> b) -> b -> [a] -> [b] Source

Строго накапливающая версия scanl

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

scanl1 — это вариант scanl, который не имеет аргумента начального значения:

scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]

scanr :: (a -> b -> b) -> b -> [a] -> [b] Source

scanr — это правая двойственная функция scanl. Обратите внимание, что

head (scanr f z xs) == foldr f z xs.

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

scanr1 — это вариант scanr, который не имеет аргумента начального значения.

Накопление отображений

mapAccumL :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y]) Source

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

mapAccumR :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y]) Source

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

Бесконечные списки

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

iterate f x возвращает бесконечный список повторных применений f к x:

iterate f x == [x, f x, f (f x), ...]

repeat :: a -> [a] Source

repeat x — это бесконечный список, где x — значение каждого элемента.

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

replicate n x — это список длины n со значением x для каждого элемента. Это пример более общей функции genericReplicate, в которой n может быть любого целочисленного типа.

cycle :: [a] -> [a] Source

cycle связывает конечный список в циклический, или, эквивалентно, бесконечное повторение исходного списка. Это тождественная функция для бесконечных списков.

Развертывание

unfoldr :: (b -> Maybe (a, b)) -> b -> [a] Source

Функция unfoldr является «двойственной» к foldr; в то время как foldr сводит список к суммарному значению, unfoldr строит список из начального значения. Функция принимает элемент и возвращает Nothing , если процесс создания списка завершён, или возвращает Just (a,b), в этом случае a добавляется в начало списка, и b используется в качестве следующего элемента в рекурсивном вызове. Например,

iterate f == unfoldr (\x -> Just (x, f x))

В некоторых случаях unfoldr может отменить операцию foldr:

unfoldr f' (foldr f z xs) == xs

если выполняется следующее условие:

f' (f x y) = Just (x,y)
f' z       = Nothing

Простой пример использования unfoldr:

unfoldr (\b -> if b == 0 then Nothing else Just (b, b-1)) 10
 [10,9,8,7,6,5,4,3,2,1]

Подсписки

Извлечение подсписков

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

take n, применённая к списку xs, возвращает префикс списка xs длины n, или сам список xs, если n > length xs:

take 5 "Hello World!" == "Hello"
take 3 [1,2,3,4,5] == [1,2,3]
take 3 [1,2] == [1,2]
take 3 [] == []
take (-1) [1,2] == []
take 0 [1,2] == []

Это пример более общей функции genericTake, в которой n может быть любого целочисленного типа.

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

drop n xs возвращает суффикс списка xs после первых n элементов, или сам список [], если n > length xs:

drop 6 "Hello World!" == "World!"
drop 3 [1,2,3,4,5] == [4,5]
drop 3 [1,2] == []
drop 3 [] == []
drop (-1) [1,2] == [1,2]
drop 0 [1,2] == [1,2]

Это пример более общей функции genericDrop, в которой n может быть любого целочисленного типа.

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

splitAt n xs возвращает кортеж, где первым элементом является xs префикс длины n, а вторым — оставшаяся часть списка:

splitAt 6 "Hello World!" == ("Hello ","World!")
splitAt 3 [1,2,3,4,5] == ([1,2,3],[4,5])
splitAt 1 [1,2,3] == ([1],[2,3])
splitAt 3 [1,2,3] == ([1,2,3],[])
splitAt 4 [1,2,3] == ([1,2,3],[])
splitAt 0 [1,2,3] == ([],[1,2,3])
splitAt (-1) [1,2,3] == ([],[1,2,3])

Это эквивалентно (take n xs, drop n xs), когда n не _|_ (splitAt _|_ xs = _|_). splitAt является экземпляром более общего genericSplitAt, в котором n может быть любого целочисленного типа.

takeWhile :: (a -> Bool) -> [a] -> [a] Исходный код

takeWhile, применённое к предикату p и списку xs, возвращает самый длинный префикс (возможно, пустой) из xs элементов, удовлетворяющих p:

takeWhile (< 3) [1,2,3,4,1,2,3,4] == [1,2]
takeWhile (< 9) [1,2,3] == [1,2,3]
takeWhile (< 0) [1,2,3] == []

dropWhile :: (a -> Bool) -> [a] -> [a] Исходный код

dropWhile p xs возвращает суффикс, оставшийся после takeWhile p xs:

dropWhile (< 3) [1,2,3,4,5,1,2,3] == [3,4,5,1,2,3]
dropWhile (< 9) [1,2,3] == []
dropWhile (< 0) [1,2,3] == [1,2,3]

dropWhileEnd :: (a -> Bool) -> [a] -> [a] Исходный код

Функция dropWhileEnd удаляет самый длинный суффикс списка, в котором заданный предикат выполняется для всех элементов. Например:

dropWhileEnd isSpace "foo\n" == "foo"
dropWhileEnd isSpace "foo bar" == "foo bar"
dropWhileEnd isSpace ("foo\n" ++ undefined) == "foo" ++ undefined

С версии: 4.5.0.0

span :: (a -> Bool) -> [a] -> ([a], [a]) Исходный код

span, применённое к предикату p и списку xs, возвращает кортеж, где первый элемент — самый длинный префикс (возможно, пустой) из xs элементов, удовлетворяющих p, а второй элемент — остаток списка:

span (< 3) [1,2,3,4,1,2,3,4] == ([1,2],[3,4,1,2,3,4])
span (< 9) [1,2,3] == ([1,2,3],[])
span (< 0) [1,2,3] == ([],[1,2,3])

span p xs эквивалентно (takeWhile p xs, dropWhile p xs)

break :: (a -> Bool) -> [a] -> ([a], [a]) Исходный код

break, применённое к предикату p и списку xs, возвращает кортеж, где первый элемент — самый длинный префикс (возможно, пустой) из xs элементов, не удовлетворяющих p, а второй элемент — остаток списка:

break (> 3) [1,2,3,4,1,2,3,4] == ([1,2,3],[4,1,2,3,4])
break (< 9) [1,2,3] == ([],[1,2,3])
break (> 9) [1,2,3] == ([1,2,3],[])

break p эквивалентно span (not . p)

stripPrefix :: Eq a => [a] -> [a] -> Maybe [a] Исходный код

Функция stripPrefix удаляет заданный префикс из списка. Она возвращает Nothing, если список не начинался с указанного префикса, или Just список после префикса, если он есть.

stripPrefix "foo" "foobar" == Just "bar"
stripPrefix "foo" "foo" == Just ""
stripPrefix "foo" "barfoo" == Nothing
stripPrefix "foo" "barfoobaz" == Nothing

group :: Eq a => [a] -> [[a]] Исходный код

Функция group берёт список и возвращает список списков, при этом конкатенация результата равна аргументу. Более того, каждый подсписок в результате содержит только равные элементы. Например,

group "Mississippi" = ["M","i","ss","i","ss","i","pp","i"]

Это частный случай groupBy, который позволяет программисту указать свой собственный тест равенства.

inits :: [a] -> [[a]] Исходный код

Функция inits возвращает все начальные сегменты аргумента, начиная с самого короткого. Например,

inits "abc" == ["","a","ab","abc"]

Обратите внимание, что inits имеет следующее свойство строгости: inits (xs ++ _|_) = inits xs ++ _|_

В частности, inits _|_ = [] : _|_

tails :: [a] -> [[a]] Исходный код

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

tails "abc" == ["abc", "bc", "c",""]

Обратите внимание, что tails имеет следующее свойство строгости: tails _|_ = _|_ : _|_

Предикаты

isPrefixOf :: Eq a => [a] -> [a] -> Bool Исходный код

Функция isPrefixOf принимает два списка и возвращает True, если первый список является префиксом второго.

isSuffixOf :: Eq a => [a] -> [a] -> Bool Исходный код

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

isInfixOf :: Eq a => [a] -> [a] -> Bool Исходный код

Функция isInfixOf принимает два списка и возвращает True, если первый список целиком и полностью содержится в любом месте второго.

Пример:

isInfixOf "Haskell" "I really like Haskell." == True
isInfixOf "Ial" "I really like Haskell." == False

Поиск в списках

Поиск по равенству

elem :: Eq a => a -> [a] -> Bool infix 4 Исходный код

elem — предикат принадлежности элемента к списку, обычно записывается в инфиксной форме, например, x `elem` xs. Для получения результата False список должен быть конечным; True, однако, результатом является элемент, равный x, найденный в конечном индексе конечного или бесконечного списка.

notElem :: Eq a => a -> [a] -> Bool infix 4 Исходный код

notElem — отрицание elem.

lookup :: Eq a => a -> [(a, b)] -> Maybe b Исходный код

lookup key assocs осуществляет поиск ключа в списке ассоциаций.

Поиск с предикатом

find :: (a -> Bool) -> [a] -> Maybe a Исходный код

Функция find принимает предикат и список и возвращает первый элемент списка, удовлетворяющий предикату, или Nothing, если такого элемента нет.

filter :: (a -> Bool) -> [a] -> [a] Исходный код

filter, применённая к предикату и списку, возвращает список тех элементов, которые удовлетворяют предикату; т.е.,

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

partition :: (a -> Bool) -> [a] -> ([a], [a]) Исходный код

Функция partition принимает предикат и список и возвращает пару списков элементов, удовлетворяющих и не удовлетворяющих предикату, соответственно; т.е.,

partition p xs == (filter p xs, filter (not . p) xs)

Индексирование списков

Эти функции рассматривают список xs как индексированное множество с индексами, изменяющимися от 0 до length xs - 1.

(!!) :: [a] -> Int -> a infixl 9 Исходный код

Оператор индекса (индексации) списка, начиная с 0. Он является примером более общего genericIndex, который принимает индекс любого целочисленного типа.

elemIndex :: Eq a => a -> [a] -> Maybe Int Исходный код

Функция elemIndex возвращает индекс первого элемента в заданном списке, который равен (по ==) элементу запроса, или Nothing, если такого элемента нет.

elemIndices :: Eq a => a -> [a] -> [Int] Исходный код

Функция elemIndices расширяет elemIndex, возвращая индексы всех элементов, равных элементу запроса, в порядке возрастания.

findIndex :: (a -> Bool) -> [a] -> Maybe Int Source

Функция findIndex принимает предикат и список и возвращает индекс первого элемента в списке, удовлетворяющего предикату, или Nothing если такого элемента нет.

findIndices :: (a -> Bool) -> [a] -> [Int] Source

Функция findIndices расширяет findIndex, возвращая индексы всех элементов, удовлетворяющих предикату, в порядке возрастания.

Объединение и разделение списков

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

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

zip является право-ленивой:

zip [] _|_ = []

zip3 :: [a] -> [b] -> [c] -> [(a, b, c)] Source

zip3 принимает три списка и возвращает список троек, аналогично zip.

zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)] Source

Функция zip4 принимает четыре списка и возвращает список четверок, аналогично zip.

zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)] Source

Функция zip5 принимает пять списков и возвращает список пятерок, аналогично zip.

zip6 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)] Source

Функция zip6 принимает шесть списков и возвращает список шестерок, аналогично zip.

zip7 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)] Source

Функция zip7 принимает семь списков и возвращает список семерок, аналогично zip.

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

zipWith обобщает zip путем объединения с функцией, заданной в качестве первого аргумента, а не функции образования кортежей. Например, zipWith (+) применяется к двум спискам для получения списка соответствующих сумм.

zipWith является право-ленивой:

zipWith f [] _|_ = []

zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d] Source

Функция zipWith3 принимает функцию, которая объединяет три элемента, а также три списка и возвращает список их покомпонентного объединения, аналогично zipWith.

zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e] Source

Функция zipWith4 принимает функцию, которая объединяет четыре элемента, а также четыре списка и возвращает список их покомпонентного объединения, аналогично zipWith.

zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] Source

Функция zipWith5 принимает функцию, которая объединяет пять элементов, а также пять списков и возвращает список их покомпонентного объединения, аналогично zipWith.

zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] Source

Функция zipWith6 принимает функцию, которая объединяет шесть элементов, а также шесть списков и возвращает список их покомпонентного объединения, аналогично zipWith.

zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h] Source

Функция zipWith7 принимает функцию, которая объединяет семь элементов, а также семь списков и возвращает список их покомпонентного объединения, аналогично zipWith.

unzip :: [(a, b)] -> ([a], [b]) Source

unzip преобразует список пар в список первых компонентов и список вторых компонентов.

unzip3 :: [(a, b, c)] -> ([a], [b], [c]) Source

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

unzip4 :: [(a, b, c, d)] -> ([a], [b], [c], [d]) Source

Функция unzip4 принимает список четверок и возвращает четыре списка, аналогично unzip.

unzip5 :: [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e]) Source

Функция unzip5 принимает список пятерок и возвращает пять списков, аналогично unzip.

unzip6 :: [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f]) Source

Функция unzip6 принимает список шестерок и возвращает шесть списков, аналогично unzip.

unzip7 :: [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g]) Source

Функция unzip7 принимает список семерок и возвращает семь списков, аналогично unzip.

Специальные списки

Функции над строками

lines :: String -> [String] Source

lines разбивает строку на список строк по символам новой строки. Результирующие строки не содержат символов новой строки.

words :: String -> [String] Source

words разбивает строку на список слов, которые разделяются пробелами.

unlines :: [String] -> String Source

unlines является обратной операцией к lines. Она соединяет строки после добавления завершающего символа новой строки к каждой.

unwords :: [String] -> String Source

unwords является обратной операцией к words. Она соединяет слова с разделяющими пробелами.

Операции над "множествами"

nub :: Eq a => [a] -> [a] Source

O(n^2). Функция nub удаляет дубликаты из списка. В частности, она сохраняет только первое вхождение каждого элемента. (Название nub означает `сущность'.) Это частный случай nubBy, который позволяет программисту указать собственный тест на равенство.

delete :: Eq a => a -> [a] -> [a] Source

delete x удаляет первое вхождение x из своего списка аргументов. Например,

delete 'a' "banana" == "bnana"

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

(\\) :: Eq a => [a] -> [a] -> [a] infix 5 Source

Функция \\ — это разность списков (неассоциативная). В результате xs \\ ys, первое вхождение каждого элемента ys по очереди (если есть) было удалено из xs. Таким образом

(xs ++ ys) \\ xs == ys.

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

union :: Eq a => [a] -> [a] -> [a] Source

Функция union возвращает объединение двух списков. Например,

"dog" `union` "cow" == "dogcw"

Дубликаты и элементы из первого списка удаляются из второго списка, но если первый список содержит дубликаты, то и результат их будет содержать. Это частный случай unionBy, который позволяет программисту предоставить собственное тестирование на равенство.

intersect :: Eq a => [a] -> [a] -> [a] Source

Функция intersect берёт пересечение двух списков. Например,

[1,2,3,4] `intersect` [2,4,6,8] == [2,4]

Если первый список содержит дубликаты, то и результат их будет содержать.

[1,2,2,3,4] `intersect` [6,4,4,2] == [2,2,4]

Это частный случай intersectBy, который позволяет программисту предоставить собственное тестирование на равенство. Если элемент найден в обоих списках, элемент из первого списка будет использован.

Отсортированные списки

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

Функция sort реализует стабильный алгоритм сортировки. Это частный случай sortBy, который позволяет программисту предоставить собственную функцию сравнения.

sortOn :: Ord b => (a -> b) -> [a] -> [a] Source

Сортирует список, сравнивая результаты применения функции-ключа к каждому элементу. sortOn f эквивалентно sortBy . comparing f, но обладает преимуществом производительности, так как вычисляет f только один раз для каждого элемента входного списка. Это называется парадигмой «украшение-сортировка-удаление», или преобразованием Шварца.

С момента: 4.8.0.0

insert :: Ord a => a -> [a] -> [a] Source

Функция insert принимает элемент и список и вставляет элемент в список в первой позиции, где он меньше или равен следующему элементу. В частности, если список отсортирован перед вызовом, результат также будет отсортирован. Это частный случай insertBy, который позволяет программисту предоставить собственную функцию сравнения.

Обобщенные функции

Операции "By"

По соглашению, перегруженные функции имеют неперегруженный аналог, имя которого имеет суффикс `By'.

Часто удобно использовать эти функции вместе с on, например sortBy (compare `on` fst).

Заданное пользователем равенство (замена контекста Eq)

Предполагается, что предикат определяет эквивалентность.

nubBy :: (a -> a -> Bool) -> [a] -> [a] Source

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

deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a] Source

Функция deleteBy ведет себя как delete, но принимает предикат равенства, заданный пользователем.

deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a] Source

Функция deleteFirstsBy принимает предикат и два списка и возвращает первый список, из которого удалено первое вхождение каждого элемента из второго списка.

unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a] Source

Функция unionBy — это неперегруженная версия union.

intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a] Source

Функция intersectBy — это неперегруженная версия intersect.

groupBy :: (a -> a -> Bool) -> [a] -> [[a]] Source

Функция groupBy — это неперегруженная версия group.

Заданное пользователем сравнение (замена контекста Ord)

Функция предполагается определяет полное упорядочение.

sortBy :: (a -> a -> Ordering) -> [a] -> [a] Source

Функция sortBy — это неперегруженная версия sort.

insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a] Source

Неперегруженная версия insert.

maximumBy :: (a -> a -> Ordering) -> [a] -> a Source

Функция maximumBy принимает функцию сравнения и список и возвращает наибольший элемент списка по функции сравнения. Список должен быть конечным и непустым.

minimumBy :: (a -> a -> Ordering) -> [a] -> a Source

Функция minimumBy принимает функцию сравнения и список и возвращает наименьший элемент списка по функции сравнения. Список должен быть конечным и непустым.

Операции "generic"

Префикс `generic' указывает на перегруженную функцию, являющуюся обобщённой версией функции из Prelude.

genericLength :: Num i => [a] -> i Source

Функция genericLength — это перегруженная версия length. В частности, вместо возвращения Int, она возвращает любой тип, являющийся экземпляром Num. Однако она менее эффективна, чем length.

genericTake :: Integral i => i -> [a] -> [a] Source

Функция genericTake — это перегруженная версия take, которая принимает любое значение Integral в качестве количества элементов для взятия.

genericDrop :: Integral i => i -> [a] -> [a] Source

Функция genericDrop — это перегруженная версия drop, которая принимает любое значение Integral в качестве количества элементов для удаления.

genericSplitAt :: Integral i => i -> [a] -> ([a], [a]) Source

Функция genericSplitAt — это перегруженная версия splitAt, которая принимает любое значение Integral в качестве позиции разделения.

genericIndex :: Integral i => [a] -> i -> a Source

Функция genericIndex — это перегруженная версия !!, которая принимает любое значение Integral в качестве индекса.

genericReplicate :: Integral i => i -> a -> [a] Source

Функция genericReplicate является перегруженной версией replicate, которая принимает любое значение Integral в качестве числа повторений.