Опубликован: 19.09.2008 | Доступ: свободный | Студентов: 654 / 70 | Оценка: 4.50 / 5.00 | Длительность: 21:25:00
Специальности:
Теги:
Лекция 18:

Утилиты работы со списками

< Лекция 17 || Лекция 18: 123 || Лекция 19 >
Аннотация: В этой лекции вы узнаете, как работать со списками. Рассмотрим библиотеку List и основные функции над списками
```module List (
elemIndex, elemIndices,
find, findIndex, findIndices,
nub, nubBy, delete, deleteBy, (\\), deleteFirstsBy,
union, unionBy, intersect, intersectBy,
intersperse, transpose, partition, group, groupBy,
inits, tails, isPrefixOf, isSuffixOf,
mapAccumL, mapAccumR,
sort, sortBy, insert, insertBy, maximumBy, minimumBy,
genericLength, genericTake, genericDrop,
genericSplitAt, genericIndex, genericReplicate,
zip4, zip5, zip6, zip7,
zipWith4, zipWith5, zipWith6, zipWith7,
unzip4, unzip5, unzip6, unzip7, unfoldr,

- ...и то, что экспортирует Prelude
- []((:), []), - Это встроенный синтаксис
map, (++), concat, filter,
head, last, tail, init, null, length, (!!),
foldl, foldl1, scanl, scanl1, foldr, foldr1, scanr, scanr1,
iterate, repeat, replicate, cycle,
take, drop, splitAt, takeWhile, dropWhile, span, break,
lines, words, unlines, unwords, reverse, and, or,
any, all, elem, notElem, lookup,
sum, product, maximum, minimum, concatMap,
zip, zip3, zipWith, zipWith3, unzip, unzip3
) where

infix 5 \\

elemIndex           :: Eq a => a -> [a] -> Maybe Int
elemIndices         :: Eq a => a -> [a] -> [Int]
find                :: (a -> Bool) -> [a] -> Maybe a
findIndex           :: (a -> Bool) -> [a] -> Maybe Int
findIndices         :: (a -> Bool) -> [a] -> [Int]
nub                 :: Eq a => [a] -> [a]
nubBy               :: (a -> a -> Bool) -> [a] -> [a]
delete              :: Eq a => a -> [a] -> [a]
deleteBy            :: (a -> a -> Bool) -> a -> [a] -> [a]
(\\)                :: Eq a => [a] -> [a] -> [a]
deleteFirstsBy      :: (a -> a -> Bool) -> [a] -> [a] -> [a]
union               :: Eq a => [a] -> [a] -> [a]
unionBy             :: (a -> a -> Bool) -> [a] -> [a] -> [a]
intersect        :: Eq a => [a] -> [a] -> [a]
intersectBy      :: (a -> a -> Bool) -> [a] -> [a] -> [a]
intersperse      :: a -> [a] -> [a]
transpose        :: [[a]] -> [[a]]
partition        :: (a -> Bool) -> [a] -> ([a],[a])
group            :: Eq a => [a] -> [[a]]
groupBy          :: (a -> a -> Bool) -> [a] -> [[a]]
inits            :: [a] -> [[a]]
tails            :: [a] -> [[a]]
isPrefixOf       :: Eq a => [a] -> [a] -> Bool
isSuffixOf       :: Eq a => [a] -> [a] -> Bool
mapAccumL        :: (a -> b -> (a, c)) -> a -> [b] -> (a, [c])
mapAccumR        :: (a -> b -> (a, c)) -> a -> [b] -> (a, [c])
unfoldr  :: (b -> Maybe (a,b)) -> b -> [a]
sort             :: Ord a => [a] -> [a]
sortBy           :: (a -> a -> Ordering) -> [a] -> [a]
insert  :: Ord a => a -> [a] -> [a]
insertBy         :: (a -> a -> Ordering) -> a -> [a] -> [a]
maximumBy        :: (a -> a -> Ordering) -> [a] -> a
minimumBy        :: (a -> a -> Ordering) -> [a] -> a
genericLength    :: Integral a => [b] -> a
genericTake  :: Integral a => a -> [b] -> [b]
genericDrop  :: Integral a => a -> [b] -> [b]
genericSplitAt  :: Integral a => a -> [b] -> ([b],[b])
genericIndex  :: Integral a => [b] -> a -> b
genericReplicate :: Integral a => a -> b -> [b]

zip4             :: [a] -> [b] -> [c] -> [d] -> [(a,b,c,d)]
zip5             :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a,b,c,d,e)]
zip6             :: [a] -> [b] -> [c] -> [d] -> [e] -> [f]
-> [(a,b,c,d,e,f)]
zip7             :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
-> [(a,b,c,d,e,f,g)]
zipWith4         :: (a->b->c->d->e) -> [a]->[b]->[c]->[d]->[e]
zipWith5         :: (a->b->c->d->e->f) ->
[a]->[b]->[c]->[d]->[e]->[f]
zipWith6         :: (a->b->c->d->e->f->g) ->
[a]->[b]->[c]->[d]->[e]->[f]->[g]
zipWith7         :: (a->b->c->d->e->f->g->h) ->
[a]->[b]->[c]->[d]->[e]->[f]->[g]->[h]
unzip4           :: [(a,b,c,d)] -> ([a],[b],[c],[d])
unzip5           :: [(a,b,c,d,e)] -> ([a],[b],[c],[d],[e])
unzip6           :: [(a,b,c,d,e,f)] -> ([a],[b],[c],[d],[e],[f])
unzip7           :: [(a,b,c,d,e,f,g)] -> ([a],[b],[c],[d],[e],[f],[g])```

В этой библиотеке определены некоторые редко используемые операции над списками.

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

• elemIndex val list возвращает индекс первого вхождения, если таковые имеются, val в list в виде Just index. Nothing возвращается, если выполняется not (val 'elem' list ).
• elemIndices val list возвращает упорядоченный список индексов вхождений val в list.
• find возвращает первый элемент списка, который удовлетворяет предикату, или Nothing, если нет такого элемента. findIndex возвращает соответствующий индекс. findIndices возвращает список всех таких индексов.

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

Имеется ряд операций над "множествами", определенные над типом List. Nub (означает "сущность") удаляет дублирующие элементы из списка. delete, (\\), union и intersect (и их By -варианты) сохраняют инвариант: их результат не содержит дубликаты, при условии, что их первый аргумент не содержит дубликаты.

• nub удаляет дублирующие элементы из списка. Например:
`nub [1,3,1,4,3,3] = [1,3,4]`
• delete x удаляет первое вхождение x из указанного в его аргументе списка, например,
`delete 'a' "banana" == "bnana"`
• (\\) является разницей списков (неассоциативная операция). В результате xs \\ ys первое вхождение каждого элемента ys поочередно (если таковые имеются) удалены из xs. Таким образом, (xs ++ ys) \\ xs == ys.
• union является объединением списков, например,
`"dog" `union` "cow" == "dogcw"`
• intersect является пересечением списков, например,
`[1,2,3,4] `intersect` [2,4,6,8] == [2,4]`

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

• intersperse sep вставляет sep между элементами указанного в его аргументе списка, Например,
`intersperse ',' "abcde" == "a,b,c,d,e"`
• transpose переставляет строки и столбцы своего аргумента, например,
`transpose [[1,2,3],[4,5,6]] == [[1,4],[2,5],[3,6]]`
• partition принимает в качестве аргументов предикат и список и возвращает пару списков: соответственно те элементы списка, которые удовлетворяют, и те, которые не удовлетворяют предикату, т.е.,
`partition p xs == (filter p xs, filter (not . p) xs)`
• sort реализует устойчивый алгоритм сортировки, заданной здесь в терминах функции insertBy, которая вставляет объекты в список согласно указанному отношению упорядочивания.
• insert помещает новый элемент в упорядоченный список (элементы размещаются по возрастанию).
• group разделяет указанный в его аргументе список на список списков одинаковых, соседних элементов. Например,
`group "Mississippi" == ["M","i","ss","i","ss","i","pp","i"]`
• inits возвращает список начальных сегментов указанного в его аргументе списка, наиболее короткие - в начале списка.
`inits "abc" == ["","a","ab","abc"]`
• tails возвращает список всех конечных сегментов указанного в его аргументе списка, наиболее длинные - в начале списка.
`tails "abc" == ["abc", "bc", "c",""]`
• mapAccumL f s l применяет f по отношению к накапливающему аргументу "состояния" s и к каждому элементу l по очереди.
• mapAccumR похожа на mapAccumL за исключением того, что список обрабатывается справа налево, а не слева направо.
< Лекция 17 || Лекция 18: 123 || Лекция 19 >