Список модуля

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

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

Сравнивает длины двух списков. 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. Эквивалентно (List.rev l1) @ l2.

Объединяет список списков. Все элементы аргумента объединяются (в том же порядке), образуя результат. Без хвостовой рекурсии (длина аргумента + длина самого длинного вложенного списка).

То же, что и List.concat. Без хвостовой рекурсии (длина аргумента + длина самого длинного вложенного списка).

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

Примечание: функция eq может быть вызвана, даже если списки имеют разную длину. Если функция сравнения на равенство затратна, сначала можно проверить List.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.

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

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

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

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

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

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

concat_map f l даёт тот же результат, что и List.concat (List.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 даёт тот же результат, что и List.rev (List.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.

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

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

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

То же, что и List.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 — другое название для List.filter.

То же, что и List.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.

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

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

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

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

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

То же, что и List.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 подходит в качестве функции сравнения. Полученный список отсортирован по возрастанию. Гарантируется, что List.sort использует постоянный объём памяти в куче (помимо размера результирующего списка) и логарифмический объём памяти в стеке.

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

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

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

То же, что и List.sort или List.stable_sort — в зависимости от того, какой вариант быстрее для типичных входных данных.

То же, что и List.sort, но также удаляет дубликаты: если несколько элементов равны при сравнении, сохраняется только первый.

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

Итерирует по списку.

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