Data.List

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

(++) :: [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 :: Foldable t => t a -> Bool Source

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

length :: Foldable t => t a -> Int Source

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

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

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 :: Foldable t => (b -> a -> b) -> b -> t a -> b Source

Левоассоциативная свертка структуры.

foldl f z = foldl f z . toList

foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b Source

Левоассоциативная свертка структуры. но с жёстким применением оператора.

foldl f z = foldl' f z . toList

foldl1 :: Foldable t => (a -> a -> a) -> t a -> a Source

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

foldl1 f = foldl1 f . toList

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

Жёсткая версия foldl1

foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b Source

Правоассоциативная свертка структуры.

foldr f z = foldr f z . toList

foldr1 :: Foldable t => (a -> a -> a) -> t a -> a Source

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

foldr1 f = foldr1 f . toList

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

concat :: Foldable t => t [a] -> [a] Source

Конкатенация всех элементов контейнера списков.

concatMap :: Foldable t => (a -> [b]) -> t a -> [b] Source

Применение функции к всем элементам контейнера и конкатенация получившихся списков.

and :: Foldable t => t Bool -> Bool Source

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

or :: Foldable t => t Bool -> Bool Source

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

any :: Foldable t => (a -> Bool) -> t a -> Bool Source

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

all :: Foldable t => (a -> Bool) -> t a -> Bool Source

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

sum :: (Foldable t, Num a) => t a -> a Source

Функция вычисляет сумму чисел в структуре.

product :: (Foldable t, Num a) => t a -> a Source

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

maximum :: forall a. (Foldable t, Ord a) => t a -> a Source

Наибольший элемент в непустой структуре.

minimum :: forall a. (Foldable t, Ord a) => t a -> a Source

Наименьший элемент в непустой структуре.

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

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

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

аналогична функции 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 :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c) Source

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

mapAccumR :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c) Source

Функция mapAccumR работает как комбинация функций fmap и 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 возвращает кортеж, где первый элемент — префикс длиной 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] Source

Функция 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] Source

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] Source

Функция 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]) Source

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]) Source

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] Source

Функция 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]] Source

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

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

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

inits :: [a] -> [[a]] Source

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

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

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

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

tails :: [a] -> [[a]] Source

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

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

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

Предикаты

isPrefixOf :: Eq a => [a] -> [a] -> Bool Source

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

isSuffixOf :: Eq a => [a] -> [a] -> Bool Source

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

isInfixOf :: Eq a => [a] -> [a] -> Bool Source

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

Пример:

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

isSubsequenceOf :: Eq a => [a] -> [a] -> Bool Source

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

isSubsequenceOf x y эквивалентно elem x (subsequences y).

Примеры

>>> isSubsequenceOf "GHC" "The Glorious Haskell Compiler"
True
>>> isSubsequenceOf ['a','d'..'z'] ['a'..'z']
True
>>> isSubsequenceOf [1..10] [10,9..0]
False

С: 4.8.0.0

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

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

elem :: (Foldable t, Eq a) => a -> t a -> Bool Source

Является ли элемент присутствующим в структуре?

notElem :: (Foldable t, Eq a) => a -> t a -> Bool infix 4 Source

notElem является отрицанием elem.

lookup :: Eq a => a -> [(a, b)] -> Maybe b Source

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

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

find :: Foldable t => (a -> Bool) -> t a -> Maybe a Source

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

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

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

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

partition :: (a -> Bool) -> [a] -> ([a], [a]) Source

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

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

Индексация списков

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

(!!) :: [a] -> Int -> a infixl 9 Source

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

elemIndex :: Eq a => a -> [a] -> Maybe Int Source

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

elemIndices :: Eq a => a -> [a] -> [Int] Source

Функция 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 только один раз для каждого элемента входного списка. Это называется парадигмой decorate-sort-undecorate или преобразованием Schwartziana.

С версии: 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 :: Foldable t => (a -> a -> Ordering) -> t a -> a Source

Наибольший элемент непустого набора относительно данной функции сравнения.

minimumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a Source

Наименьший элемент непустого набора относительно данной функции сравнения.

Операции "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 в качестве количества повторений.