Модуль ListLabels

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

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

Сравнивает длины двух списков. 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

singleton x возвращает список из одного элемента [x].

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

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

Возвращает 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.

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

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), а вторым — сам элемент.

take n l возвращает префикс l длины n или копию l, если n > length l. Если n отрицательно, возвращается пустой список.

Предупреждение. Только в версии 5.3 эта функция вызывает Invalid_argument при отрицательных значениях n.

drop n l возвращает суффикс l после n элементов или [], если n > length l. Если n отрицательно, результатом будет l.

Предупреждение. Только в версии 5.3 эта функция вызывает Invalid_argument при отрицательных значениях n.

take_while p l — самый длинный (возможно, пустой) префикс l, содержащий только элементы, удовлетворяющие p.

drop_while p l — самый длинный (возможно, пустой) суффикс l, начинающийся с первого элемента, который не удовлетворяет p.

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]). Не хвосторекурсивна.

split_map ~f l эквивалентно split (map ~f l), но позволяет избежать выделения промежуточных списков.

Преобразует пару списков в список пар: 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. Не хвосторекурсивна (суммарная длина аргументов).

Выполняет итерацию по списку.

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