Модуль StdLabels.List

Псевдоним для типа списков.

Возвращает длину (количество элементов) данного списка.

Сравнение длин двух списков. compare_lengths l1 l2 эквивалентно compare (length l1) (length l2), за исключением того, что вычисление останавливается после достижения конца самого короткого списка.

Сравнение длины списка с целым числом. compare_length_with l len эквивалентно compare (length l) len, за исключением того, что вычисление останавливается после не более len итераций по списку.

is_empty l истинно тогда и только тогда, когда l не содержит элементов. Эквивалентно compare_length_with l 0 = 0.

cons x xs является x :: xs

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

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

Возвращает n-й элемент данного списка. Первый элемент (начало списка) имеет позицию 0.

Возвращает n-й элемент данного списка. Первый элемент (начало списка) имеет позицию 0. Возвращает None если список слишком короткий.

Переворачивание списка.

init ~len ~f равно [f 0; f 1; ...; f (len-1)], вычисляемому слева направо.

append l0 l1 добавляет l1 к l0 . Такая же функция, как у инфиксного оператора @.

rev_append l1 l2 переворачивает l1 и конкатенирует его с l2. Это эквивалентно (ListLabels.rev l1) @ l2.

Конкатенация списка списков. Элементы аргумента конкатенируются вместе (в том же порядке) для получения результата. Не хвостовая рекурсия (длина аргумента + длина самого длинного подсписка).

То же, что ListLabels.concat. Не хвостовая рекурсия (длина аргумента + длина самого длинного подсписка).

equal eq [a1; ...; an] [b1; ..; bm] выполняется, когда два входных списка имеют одинаковую длину, и для каждой пары элементов ai, bi в той же позиции выполняется eq ai bi.

Примечание: функция eq может быть вызвана даже если списки имеют разную длину. Если вы знаете, что ваша функция равенства дорогостоящая, вы можете сначала проверить ListLabels.compare_lengths.

compare cmp [a1; ...; an] [b1; ...; bm] выполняет лексикографическое сравнение двух входных списков, используя тот же интерфейс 'a -> 'a -> int что и compare:

• a1 :: l1 меньше a2 :: l2 (отрицательный результат), если a1 меньше a2, или если они равны (результат 0) и l1 меньше l2
• пустой список [] строго меньше, чем непустые списки

Примечание: функция cmp будет вызвана даже если списки имеют разную длину.

iter ~f [a1; ...; an] последовательно применяет функцию f к [a1; ...; an] . Эквивалентно f a1; f a2; ...; f an.

То же, что ListLabels.iter, но функция применяется к индексу элемента в качестве первого аргумента (счет от 0), а сам элемент — в качестве второго аргумента.

map ~f [a1; ...; an] применяет функцию f к a1, ..., an, и строит список [f a1; ...; f an] с результатами, возвращаемыми f.

То же, что ListLabels.map, но функция применяется к индексу элемента в качестве первого аргумента (счет от 0), а сам элемент — в качестве второго аргумента.

rev_map ~f l даёт тот же результат, что и ListLabels.rev (ListLabels.map f l), но более эффективно.

filter_map ~f l применяет f к каждому элементу l, отфильтровывает None элементы и возвращает список аргументов Some элементов.

concat_map ~f l даёт тот же результат, что и ListLabels.concat (ListLabels.map f l). Хвостовая рекурсия.

fold_left_map — это комбинация fold_left и map , которая передает аккумулятор через вызовы f.

fold_left ~f ~init [b1; ...; bn] — это f (... (f (f init b1) b2) ...) bn.

fold_right ~f [a1; ...; an] ~init — это f a1 (f a2 (... (f an init) ...)). Не хвостовая рекурсия.

iter2 ~f [a1; ...; an] [b1; ...; bn] последовательно вызывает f a1 b1; ...; f an bn.

map2 ~f [a1; ...; an] [b1; ...; bn] — это [f a1 b1; ...; f an bn].

rev_map2 ~f l1 l2 даёт тот же результат, что и ListLabels.rev (ListLabels.map2 f l1 l2), но более эффективно.

fold_left2 ~f ~init [a1; ...; an] [b1; ...; bn] — это f (... (f (f init a1 b1) a2 b2) ...) an bn.

fold_right2 ~f [a1; ...; an] [b1; ...; bn] ~init — это f a1 b1 (f a2 b2 (... (f an bn init) ...)).

for_all ~f [a1; ...; an] проверяет, удовлетворяют ли все элементы списка предикату f. То есть, возвращает (f a1) && (f a2) && ... && (f an) для непустого списка и true если список пуст.

exists ~f [a1; ...; an] проверяет, удовлетворяет ли хотя бы один элемент списка предикату f. То есть, возвращает (f a1) || (f a2) || ... || (f an) для непустого списка и false если список пуст.

То же, что и ListLabels.for_all, но для предиката с двумя аргументами.

То же, что и ListLabels.exists, но для предиката с двумя аргументами.

mem a ~set истинно тогда и только тогда, когда a равно элементу set.

То же, что и ListLabels.mem, но для сравнения элементов списка используется физическое равенство вместо структурного равенства.

find ~f l возвращает первый элемент списка l, который удовлетворяет предикату f.

find ~f l возвращает первый элемент списка l, который удовлетворяет предикату f. Возвращает None если в списке l нет значения, удовлетворяющего f.

find_index ~f xs возвращает Some i, где i — индекс первого элемента списка xs, который удовлетворяет f x, если такой элемент существует.

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

find_map ~f l применяет f к элементам l в порядке следования и возвращает первый результат вида Some v, или None если такового нет.

То же, что и find_map, но предикат применяется к индексу элемента (считая с 0) в качестве первого аргумента, а к самому элементу — в качестве второго.

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

find_all — другое имя для ListLabels.filter.

То же, что и ListLabels.filter, но предикат применяется к индексу элемента (считая с 0) в качестве первого аргумента, а к самому элементу — в качестве второго.

partition ~f l возвращает пару списков (l1, l2), где l1 — список всех элементов l, удовлетворяющих предикату f, а l2 — список всех элементов l, которые не удовлетворяют предикату f. Порядок элементов в входном списке сохраняется.

partition_map f l возвращает пару списков (l1, l2), таких что для каждого элемента x входного списка l:

• если f x является Left y1, то y1 находится в l1, и
• если f x является Right y2, то y2 находится в l2.

Элементы вывода включены в l1 и l2 в том же относительном порядке, что и соответствующие элементы входного списка l.

В частности, partition_map (fun x -> if f x then Left x else Right x) l эквивалентно partition f l.

assoc a l возвращает значение, связанное с ключом a в списке пар l. То есть assoc a [ ...; (a,b); ...] = b если (a,b) — левое крайнее связывание a в списке l.

assoc_opt a l возвращает значение, связанное с ключом a в списке пар l. То есть assoc_opt a [ ...; (a,b); ...] = Some b если (a,b) — левое крайнее связывание a в списке l. Возвращает None если в списке l нет значения, связанного с a.

То же, что и ListLabels.assoc, но для сравнения ключей используется физическое равенство вместо структурного равенства.

То же, что и ListLabels.assoc_opt, но для сравнения ключей используется физическое равенство вместо структурного равенства.

То же, что и ListLabels.assoc, но просто возвращает true если связывание существует, и false если связываний для данного ключа нет.

То же, что и ListLabels.mem_assoc, но для сравнения ключей используется физическое равенство вместо структурного равенства.

remove_assoc a l возвращает список пар l без первой пары с ключом a, если таковая имеется. Не рекурсивно по хвосту.

То же, что и ListLabels.remove_assoc, но для сравнения ключей используется физическое равенство вместо структурного равенства. Не рекурсивно по хвосту.

Преобразование списка пар в пару списков: split [(a1,b1); ...; (an,bn)] это ([a1; ...; an], [b1; ...; bn]). Не рекурсивно по хвосту.

Преобразование пары списков в список пар: combine [a1; ...; an] [b1; ...; bn] это [(a1,b1); ...; (an,bn)].

Сортировка списка в порядке возрастания по функции сравнения. Функция сравнения должна возвращать 0, если её аргументы равны, положительное целое число, если первый больше, и отрицательное целое число, если первый меньше (см. Array.sort для полного описания). Например, compare — подходящая функция сравнения. Результирующий список отсортирован по возрастанию. ListLabels.sort гарантированно выполняется с постоянным объёмом памяти (кроме размера результирующего списка) и логарифмическим объёмом стека.

Текущая реализация использует сортировку слиянием. Она выполняется с постоянным объёмом памяти и логарифмическим объёмом стека.

То же, что и ListLabels.sort, но алгоритм сортировки гарантированно стабилен (т.е. элементы, которые равны, сохраняются в исходном порядке).

Текущая реализация использует сортировку слиянием. Она выполняется с постоянным объёмом памяти и логарифмическим объёмом стека.

То же, что и ListLabels.sort или ListLabels.stable_sort, что быстрее на типичных входных данных.

То же, что и ListLabels.sort, но также удаляются дубликаты.

Объединение двух списков: Предполагая, что l1 и l2 отсортированы по функции сравнения cmp, merge ~cmp l1 l2 вернёт отсортированный список, содержащий все элементы l1 и l2. Если несколько элементов равны, элементы l1 будут перед элементами l2.

Итерация по списку.

Создание списка из последовательности.