Перечисление

Предоставляет набор алгоритмов, перечисляющих перечислимые объекты согласно протоколу Enumerable.

iex> Enum.map([1, 2, 3], fn(x) -> x * 2 end)
[2, 4, 6]

Некоторые типы, такие как карты, генерируют специфический формат при перечислении. Например, аргументом всегда является кортеж {key, value} для карт:

iex> map = %{a: 1, b: 2}
iex> Enum.map(map, fn {k, v} -> {k, v * 2} end)
[a: 2, b: 4]

Обратите внимание, что функции в модуле Enum являются неленивыми: они всегда начинают перечисление заданного перечислимого объекта. Модуль Stream позволяет ленивое перечисление перечислимых объектов и предоставляет бесконечные потоки.

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

Enum.each Stream.cycle([1, 2, 3]), &IO.puts(&1)

Краткое описание

Типы

default()

element()

index()

t()

Функции

all?(перечисляемый, функция \\ fn x -> x end)

Вызывает заданную fun для каждого элемента в перечисляемом объекте. Итерация останавливается при первом вызове, который возвращает false или nil. Возвращает false , если хотя бы один вызов возвращает false или nil. В противном случае возвращает true

any?(перечисляемый, функция \\ fn x -> x end)

Вызывает заданную fun для каждого элемента в перечисляемом объекте. Итерация останавливается при первом вызове, который возвращает истинное значение. Возвращает true , если хотя бы один вызов возвращает истинное значение. В противном случае возвращает false

at(перечисляемый, индекс, значение_по_умолчанию \\ nil)

Находит элемент по заданному index (нумерация с нуля)

chunk(перечисляемый, количество)

Сокращение для chunk(enumerable, count, count)

chunk(перечисляемый, количество, шаг, остаток \\ nil)

Возвращает список списков, содержащих count элементов каждый, где каждый новый фрагмент начинается step элементов в перечисляемом объекте

chunk_by(перечисляемый, функция)

Разделяет перечисляемый объект на группы по каждому элементу, для которого fun возвращает новое значение

concat(перечисляемые)

Принимая перечисляемый список перечисляемых объектов, склеивает перечисляемые объекты в один список

concat(левый, правый)

Объединяет перечисляемый объект справа с перечисляемым объектом слева

count(перечисляемый)

Возвращает размер перечисляемого объекта

count(перечисляемый, функция)

Возвращает количество элементов в перечисляемом объекте, для которых fun возвращает истинное значение

dedup(перечисляемый)

Перечисляет enumerable, возвращая список, где все последовательные дублированные элементы сводятся к одному элементу

dedup_by(перечисляемый, функция)

Перечисляет enumerable, возвращая список, где все последовательные дублированные элементы сводятся к одному элементу

drop(перечисляемый, n)

Удаляет первые n элементы из перечисляемого объекта

drop_every(перечисляемый, n-й)

Возвращает список каждого nth элемента в перечисляемом объекте, пропущенного, начиная с первого элемента

drop_while(перечисляемый, функция)

Удаляет элементы в начале перечисляемого объекта, пока fun возвращает истинное значение

each(перечисляемый, функция)

Вызывает заданную fun для каждого элемента в перечисляемом объекте

empty?(перечисляемый)

Определяет, пуст ли перечисляемый объект

fetch(перечисляемый, индекс)

Находит элемент по заданному index (нумерация с нуля)

fetch!(перечисляемый, индекс)

Находит элемент по заданному index (нумерация с нуля)

filter(перечисляемый, функция)

Фильтров перечисляемый объект, т.е. возвращает только те элементы, для которых fun возвращает истинное значение

filter_map(перечисляемый, фильтр, отобразитель)

Фильтров перечисляемый объект и отображает его элементы за один проход

find(перечисляемый, значение_по_умолчанию \\ nil, функция)

Возвращает первый элемент, для которого fun возвращает истинное значение. Если такой элемент не найден, возвращает default

find_index(перечисляемый, функция)

Аналогично find/3, но возвращает индекс (нумерация с нуля) элемента вместо самого элемента

find_value(перечисляемый, значение_по_умолчанию \\ nil, функция)

Аналогично find/3, но возвращает значение вызова функции вместо самого элемента

flat_map(перечисляемый, функция)

Возвращает новый перечисляемый объект, добавляя результат вызова fun для каждого соответствующего элемента enumerable

flat_map_reduce(перечисляемый, acc, функция)

Отображает и сводит перечисляемый объект, сглаживая полученные результаты (только на один уровень)

group_by(перечисляемый, функция_ключа, функция_отображения \\ fn x -> x end)

Разделяет перечисляемый объект на группы на основе fun

intersperse(перечисляемый, элемент)

Вставляет element между каждым элементом перечисления

into(перечисляемый, собираемый)

Вставляет заданный enumerable в collectable

into(перечисляемый, собираемый, преобразование)

Вставляет заданный enumerable в collectable в соответствии с функцией преобразования

join(перечисляемый, разделитель \\ "")

Объединяет заданный перечисляемый объект в строку, используя joiner в качестве разделителя

map(перечисляемый, функция)

Возвращает список, где каждый элемент является результатом вызова fun для каждого соответствующего элемента enumerable

map_join(перечисляемый, разделитель \\ "", отобразитель)

Отображает и объединяет заданный перечисляемый объект за один проход

map_reduce(перечисляемый, acc, функция)

Вызывает заданную функцию для каждого элемента в перечисляемом объекте, чтобы свести его к одному элементу, сохраняя накопитель

max(перечисляемый)

Возвращает максимальный элемент в перечисляемом объекте в соответствии с порядком Erlang

max_by(перечисляемый, функция)

Возвращает максимальный элемент в перечисляемом объекте, рассчитанный по заданной функции

member?(перечисляемый, элемент)

Проверяет, существует ли element в перечисляемом объекте

min(перечисляемый)

Возвращает минимальный элемент в перечисляемом объекте в соответствии с порядком Erlang

min_by(перечисляемый, функция)

Возвращает минимальный элемент в перечисляемом объекте, рассчитанный по заданной функции

min_max(перечисляемый)

Возвращает кортеж с минимальным и максимальным элементами в перечисляемом объекте в соответствии с порядком Erlang

min_max_by(перечисляемый, функция)

Возвращает кортеж с минимальным и максимальным элементами в перечисляемом объекте, рассчитанных по заданной функции

partition(перечисляемый, функция)

Разделяет enumerable на два списка, где первый содержит элементы, для которых fun возвращает истинное значение, а второй – для которых fun возвращает false или nil

random(перечисляемый)

Возвращает случайный элемент перечисляемого объекта

reduce(перечисляемый, функция)

Вызывает fun для каждого элемента в enumerable, передавая этот элемент и накопитель в качестве аргументов. Возвращаемое значение fun сохраняется в накопителе

reduce(перечисляемый, acc, функция)

Вызывает fun для каждого элемента в enumerable, передавая этот элемент и накопитель acc в качестве аргументов. Возвращаемое значение fun сохраняется в acc

reduce_while(перечисляемый, acc, функция)

Сводит перечисляемый объект, пока не будет выпущен halt

reject(перечисляемый, функция)

Возвращает элементы enumerable, для которых функция fun возвращает false или nil

reverse(перечисляемый)

Возвращает список элементов в enumerable в обратном порядке

reverse(перечисляемый, хвост)

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

reverse_slice(enumerable, start, count)

Обращает порядок элементов перечислимого объекта в диапазоне от начальной позиции start до count элементов

scan(enumerable, fun)

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

scan(enumerable, acc, fun)

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

shuffle(enumerable)

Возвращает список со случайным порядком элементов из enumerable

slice(enumerable, range)

Возвращает подмножество списка из заданного перечислимого объекта. Опускает элементы до позиции range.first, затем берет элементы до позиции range.last (включительно)

slice(enumerable, start, count)

Возвращает подмножество списка из заданного перечислимого объекта. Опускает элементы до позиции start, затем берет count элементов

sort(enumerable)

Сортирует перечислимый объект в соответствии с порядком Erlang

sort(enumerable, fun)

Сортирует перечислимый объект по заданной функции

sort_by(enumerable, mapper, sorter \\ &<=/2)

Сортирует результаты отображения перечислимого объекта по заданной функции sorter

split(enumerable, count)

Разделяет enumerable на два перечислимых объекта, оставляя count элементов в первом. Если count отрицательное число, оно начинает счёт с конца перечислимого объекта

split_while(enumerable, fun)

Разделяет перечислимый объект на две части в позиции элемента, для которого fun возвращает false в первый раз

sum(enumerable)

Возвращает сумму всех элементов

take(enumerable, count)

Берет первые count элементов из перечислимого объекта

take_every(enumerable, nth)

Возвращает список каждого nth элемента в перечислимом объекте, начиная с первого элемента

take_random(enumerable, count)

Берет случайные элементы из enumerable

take_while(enumerable, fun)

Берет элементы с начала перечислимого объекта, пока fun возвращает истинное значение

to_list(enumerable)

Преобразует enumerable в список

uniq(enumerable)

Перечисляет enumerable, удаляя все дублируемые элементы

uniq_by(enumerable, fun)

Перечисляет enumerable, удаляя элементы, для которых функция fun возвратила дубликаты

unzip(enumerable)

Обратное к Enum.zip/2; извлекает кортежи из двух элементов из перечислимого объекта и группирует их вместе

with_index(enumerable, offset \\ 0)

Возвращает перечислимый объект с каждым элементом, упакованным в кортеж вместе с его индексом

zip(enumerable1, enumerable2)

Комбинирует соответствующие элементы из двух перечислимых объектов в один список кортежей

Типы

default()

default() :: any

element()

element() :: any

index()

index() :: non_neg_integer

t()

t() :: Enumerable.t

Функции

all?(enumerable, fun \\ fn x -> x end)

all?(t, (element -> as_boolean(term))) :: boolean

Вызывает заданную fun для каждого элемента в перечислимом объекте. Останавливает итерацию при первом вызове, который возвращает false или nil. Возвращает false , если хотя бы один вызов возвращает false или nil. В противном случае возвращает true

Примеры

iex> Enum.all?([2, 4, 6], fn(x) -> rem(x, 2) == 0 end)
true

iex> Enum.all?([2, 3, 4], fn(x) -> rem(x, 2) == 0 end)
false

Если функция не задана, по умолчанию проверяет, являются ли все элементы в перечислимом объекте истинными значениями.

iex> Enum.all?([1, 2, 3])
true

iex> Enum.all?([1, nil, 3])
false

any?(enumerable, fun \\ fn x -> x end)

any?(t, (element -> as_boolean(term))) :: boolean

Вызывает заданную fun для каждого элемента в перечислимом объекте. Останавливает итерацию при первом вызове, который возвращает истинное значение. Возвращает true , если хотя бы один вызов возвращает истинное значение. В противном случае возвращает false

Примеры

iex> Enum.any?([2, 4, 6], fn(x) -> rem(x, 2) == 1 end)
false

iex> Enum.any?([2, 3, 4], fn(x) -> rem(x, 2) == 1 end)
true

Если функция не задана, по умолчанию проверяет, является ли хотя бы один элемент в перечислимом объекте истинным значением.

iex> Enum.any?([false, false, false])
false

iex> Enum.any?([false, true, false])
true

at(enumerable, index, default \\ nil)

at(t, integer, default) :: element | default

Находит элемент по заданному index (нумерация с нуля).

Возвращает default , если index выходит за пределы границ.

Можно передать отрицательное index, что означает, что перечисление выполняется один раз, и enumerable считает с конца (например, -1 находит последний элемент).

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

Примеры

iex> Enum.at([2, 4, 6], 0)
2

iex> Enum.at([2, 4, 6], 2)
6

iex> Enum.at([2, 4, 6], 4)
nil

iex> Enum.at([2, 4, 6], 4, :none)
:none

chunk(enumerable, count)

chunk(t, pos_integer) :: [list]

Является сокращением для chunk(enumerable, count, count)

chunk(enumerable, count, step, leftover \\ nil)

chunk(t, pos_integer, pos_integer, t | nil) :: [list]

Возвращает список списков, содержащих по count элементов каждый, где каждый новый фрагмент начинается step элементов в перечислимом объекте.

step необязательный параметр, и если его не передать, он по умолчанию равен count, т.е. фрагменты не перекрываются.

Если последний фрагмент не содержит count элементов для заполнения фрагмента, элементы берутся из leftover при его передаче.

Если leftover передан и не содержит достаточного количества элементов для заполнения фрагмента, возвращается частичный фрагмент с менее чем count элементами. Если leftover не передан или равен nil, частичный фрагмент отбрасывается из результата.

Если count больше, чем количество элементов в перечислимом объекте, и leftover не передан, возвращается пустой список.

Примеры

iex> Enum.chunk([1, 2, 3, 4, 5, 6], 2)
[[1, 2], [3, 4], [5, 6]]

iex> Enum.chunk([1, 2, 3, 4, 5, 6], 3, 2)
[[1, 2, 3], [3, 4, 5]]

iex> Enum.chunk([1, 2, 3, 4, 5, 6], 3, 2, [7])
[[1, 2, 3], [3, 4, 5], [5, 6, 7]]

iex> Enum.chunk([1, 2, 3, 4], 3, 3, [])
[[1, 2, 3], [4]]

iex> Enum.chunk([1, 2, 3, 4], 10)
[]

iex> Enum.chunk([1, 2, 3, 4], 10, 10, [])
[[1, 2, 3, 4]]

chunk_by(enumerable, fun)

chunk_by(t, (element -> any)) :: [list]

Разделяет перечислимый объект на каждый элемент, для которого fun возвращает новое значение.

Возвращает список списков.

Примеры

iex> Enum.chunk_by([1, 2, 2, 3, 4, 4, 6, 7, 7], &(rem(&1, 2) == 1))
[[1], [2, 2], [3], [4, 4, 6], [7, 7]]

concat(enumerables)

concat(t) :: t

Принимая перечислимый объект перечислимых объектов, объединяет перечислимые объекты в один список.

Примеры

iex> Enum.concat([1..3, 4..6, 7..9])
[1, 2, 3, 4, 5, 6, 7, 8, 9]

iex> Enum.concat([[1, [2], 3], [4], [5, 6]])
[1, [2], 3, 4, 5, 6]

concat(left, right)

concat(t, t) :: t

Объединяет перечислимый объект справа с перечислимым объектом слева.

Эта функция производит тот же результат, что и оператор Kernel.++/2 для списков.

Примеры

iex> Enum.concat(1..3, 4..6)
[1, 2, 3, 4, 5, 6]

iex> Enum.concat([1, 2, 3], [4, 5, 6])
[1, 2, 3, 4, 5, 6]

count(enumerable)

count(t) :: non_neg_integer

Возвращает размер перечислимого объекта.

Примеры

iex> Enum.count([1, 2, 3])
3

count(enumerable, fun)

count(t, (element -> as_boolean(term))) :: non_neg_integer

Возвращает количество элементов в перечислимом объекте, для которых fun возвращает истинное значение.

Примеры

iex> Enum.count([1, 2, 3, 4, 5], fn(x) -> rem(x, 2) == 0 end)
2

dedup(enumerable)

dedup(t) :: list

Перечисляет enumerable, возвращая список, где все последовательные дублированные элементы сведены к одному элементу.

Элементы сравниваются с использованием ===

Если вы хотите удалить все дублированные элементы, независимо от порядка, см. uniq/1.

Примеры

iex> Enum.dedup([1, 2, 3, 3, 2, 1])
[1, 2, 3, 2, 1]

iex> Enum.dedup([1, 1, 2, 2.0, :three, :"three"])
[1, 2, 2.0, :three]

dedup_by(enumerable, fun)

dedup_by(t, (element -> term)) :: list

Перечисляет enumerable, возвращая список, в котором все последовательные дублируемые элементы сводятся к одному элементу.

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

Примеры

iex> Enum.dedup_by([{1, :a}, {2, :b}, {2, :c}, {1, :a}], fn {x, _} -> x end)
[{1, :a}, {2, :b}, {1, :a}]

iex> Enum.dedup_by([5, 1, 2, 3, 2, 1], fn x -> x > 2 end)
[5, 1, 3, 2]

drop(enumerable, n)

drop(t, integer) :: list

Опускает первые n элементы из перечисляемого объекта.

Если задано отрицательное значение n, будут опущены последние n значения.

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

Примеры

iex> Enum.drop([1, 2, 3], 2)
[3]

iex> Enum.drop([1, 2, 3], 10)
[]

iex> Enum.drop([1, 2, 3], 0)
[1, 2, 3]

iex> Enum.drop([1, 2, 3], -1)
[1, 2]

drop_every(enumerable, nth)

drop_every(t, non_neg_integer) :: list | no_return

Возвращает список каждого nth элемента в перечисляемом объекте, опущенного, начиная с первого элемента.

Первый элемент всегда опускается, если nth не равно 0.

Второй аргумент, определяющий каждый nth элемент, должен быть целым неотрицательным числом, в противном случае будет поднято исключение FunctionClauseError.

Примеры

iex> Enum.drop_every(1..10, 2)
[2, 4, 6, 8, 10]

iex> Enum.drop_every(1..10, 0)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

iex> Enum.drop_every([1, 2, 3], 1)
[]

drop_while(enumerable, fun)

drop_while(t, (element -> as_boolean(term))) :: list

Опускает элементы в начале перечисляемого объекта, пока fun возвращает истинное значение.

Примеры

iex> Enum.drop_while([1, 2, 3, 4, 5], fn(x) -> x < 3 end)
[3, 4, 5]

each(enumerable, fun)

each(t, (element -> any)) :: :ok

Вызывает заданную fun для каждого элемента в перечисляемом объекте.

Возвращает :ok.

Примеры

Enum.each(["some", "example"], fn(x) -> IO.puts x end)
"some"
"example"
#=> :ok

empty?(enumerable)

empty?(t) :: boolean

Определяет, является ли перечисляемый объект пустым.

Возвращает true если enumerable пуст, в противном случае false.

Примеры

iex> Enum.empty?([])
true

iex> Enum.empty?([1, 2, 3])
false

fetch(enumerable, index)

fetch(t, integer) :: {:ok, element} | :error

Находит элемент по заданному index (нумерация с нуля).

Возвращает {:ok, element} если найден, в противном случае :error.

Можно передать отрицательное index, что означает, что enumerable перечисляется один раз, а index подсчитывается с конца (например, -1 извлекает последний элемент).

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

Примеры

iex> Enum.fetch([2, 4, 6], 0)
{:ok, 2}

iex> Enum.fetch([2, 4, 6], 2)
{:ok, 6}

iex> Enum.fetch([2, 4, 6], 4)
:error

fetch!(enumerable, index)

fetch!(t, integer) :: element | no_return

Находит элемент по заданному index (нумерация с нуля).

Вызывает исключение OutOfBoundsError если заданный index выходит за пределы диапазона перечисляемого объекта.

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

Примеры

iex> Enum.fetch!([2, 4, 6], 0)
2

iex> Enum.fetch!([2, 4, 6], 2)
6

iex> Enum.fetch!([2, 4, 6], 4)
** (Enum.OutOfBoundsError) out of bounds error

filter(enumerable, fun)

filter(t, (element -> as_boolean(term))) :: list

Фильтрует перечисляемый объект, т.е. возвращает только те элементы, для которых fun возвращает истинное значение.

См. также reject/2.

Примеры

iex> Enum.filter([1, 2, 3], fn(x) -> rem(x, 2) == 0 end)
[2]

filter_map(enumerable, filter, mapper)

filter_map(t, (element -> as_boolean(term)), (element -> element)) :: list

Фильтрует перечисляемый объект и отображает его элементы за один проход.

Примеры

iex> Enum.filter_map([1, 2, 3], fn(x) -> rem(x, 2) == 0 end, &(&1 * 2))
[4]

find(enumerable, default \\ nil, fun)

find(t, default, (element -> any)) :: element | default

Возвращает первый элемент, для которого fun возвращает истинное значение. Если такой элемент не найден, возвращает default.

Примеры

iex> Enum.find([2, 4, 6], fn(x) -> rem(x, 2) == 1 end)
nil

iex> Enum.find([2, 4, 6], 0, fn(x) -> rem(x, 2) == 1 end)
0

iex> Enum.find([2, 3, 4], fn(x) -> rem(x, 2) == 1 end)
3

find_index(enumerable, fun)

find_index(t, (element -> any)) :: index | nil

Аналогично find/3, но возвращает индекс (нумерация с нуля) элемента вместо самого элемента.

Примеры

iex> Enum.find_index([2, 4, 6], fn(x) -> rem(x, 2) == 1 end)
nil

iex> Enum.find_index([2, 3, 4], fn(x) -> rem(x, 2) == 1 end)
1

find_value(enumerable, default \\ nil, fun)

find_value(t, any, (element -> any)) :: any | nil

Аналогично find/3, но возвращает значение вызова функции вместо самого элемента.

Примеры

iex> Enum.find_value([2, 4, 6], fn(x) -> rem(x, 2) == 1 end)
nil

iex> Enum.find_value([2, 3, 4], fn(x) -> rem(x, 2) == 1 end)
true

iex> Enum.find_value([1, 2, 3], "no bools!", &is_boolean/1)
"no bools!"

flat_map(enumerable, fun)

flat_map(t, (element -> t)) :: list

Возвращает новый перечисляемый объект, добавляя результат вызова fun для каждого соответствующего элемента enumerable.

Указанная функция должна возвращать перечисляемый объект.

Примеры

iex> Enum.flat_map([:a, :b, :c], fn(x) -> [x, x] end)
[:a, :a, :b, :b, :c, :c]

iex> Enum.flat_map([{1, 3}, {4, 6}], fn({x, y}) -> x..y end)
[1, 2, 3, 4, 5, 6]

iex> Enum.flat_map([:a, :b, :c], fn(x) -> [[x]] end)
[[:a], [:b], [:c]]

flat_map_reduce(enumerable, acc, fun)

flat_map_reduce(t, acc, fun) :: {[any], any} when fun: (element, acc -> {t, acc} | {:halt, acc}), acc: any

Отображает и сводит перечисляемый объект, уплощая полученные результаты (только на один уровень вглубь).

Ожидает накопитель и функцию, которая принимает каждый элемент перечисляемого объекта и должна возвращать кортеж, содержащий новый перечисляемый объект (часто список) с новым накопителем или кортеж с :halt в качестве первого элемента и накопителем как вторым.

Примеры

iex> enum = 1..100
iex> n = 3
iex> Enum.flat_map_reduce(enum, 0, fn i, acc ->
...>   if acc < n, do: {[i], acc + 1}, else: {:halt, acc}
...> end)
{[1, 2, 3], 3}

iex> Enum.flat_map_reduce(1..5, 0, fn(i, acc) -> {[[i]], acc + i} end)
{[[1], [2], [3], [4], [5]], 15}

group_by(enumerable, key_fun, mapper_fun \\ fn x -> x end)

group_by(t, (element -> any), (element -> any)) :: map

Разбивает перечисляемый объект на группы на основе fun.

Результат — это карта, где каждый ключ задается key_fun, а каждое значение — это список элементов, заданных value_fun Порядок сохраняется.

Примеры

iex> Enum.group_by(~w{ant buffalo cat dingo}, &String.length/1)
%{3 => ["ant", "cat"], 7 => ["buffalo"], 5 => ["dingo"]}

iex> Enum.group_by(~w{ant buffalo cat dingo}, &String.length/1, &String.first/1)
%{3 => ["a", "c"], 7 => ["b"], 5 => ["d"]}

intersperse(enumerable, element)

intersperse(t, element) :: list

Вставляет element между каждым элементом перечисления.

Сложность: O(n).

Примеры

iex> Enum.intersperse([1, 2, 3], 0)
[1, 0, 2, 0, 3]

iex> Enum.intersperse([1], 0)
[1]

iex> Enum.intersperse([], 0)
[]

into(enumerable, collectable)

into(Enumerable.t, Collectable.t) :: Collectable.t

Вставляет данный enumerable в collectable.

Примеры

iex> Enum.into([1, 2], [0])
[0, 1, 2]

iex> Enum.into([a: 1, b: 2], %{})
%{a: 1, b: 2}

iex> Enum.into(%{a: 1}, %{b: 2})
%{a: 1, b: 2}

iex> Enum.into([a: 1, a: 2], %{})
%{a: 2}

into(enumerable, collectable, transform)

into(Enumerable.t, Collectable.t, (term -> term)) :: Collectable.t

Вставляет данный enumerable в collectable в соответствии с функцией преобразования.

Примеры

iex> Enum.into([2, 3], [3], fn x -> x * 3 end)
[3, 6, 9]

join(enumerable, joiner \\ "")

join(t, String.t) :: String.t

Объединяет данный перечисляемый объект в бинарный, используя joiner в качестве разделителя.

Если joiner не задан, используется пустая строка.

Все элементы в перечисляемом объекте должны быть преобразуемы в бинарный, иначе произойдет ошибка.

Примеры

iex> Enum.join([1, 2, 3])
"123"

iex> Enum.join([1, 2, 3], " = ")
"1 = 2 = 3"

map(enumerable, fun)

map(t, (element -> any)) :: list

Возвращает список, где каждый элемент является результатом вызова fun для каждого соответствующего элемента из enumerable.

Для карт функция ожидает кортеж ключ-значение.

Примеры

iex> Enum.map([1, 2, 3], fn(x) -> x * 2 end)
[2, 4, 6]

iex> Enum.map([a: 1, b: 2], fn({k, v}) -> {k, -v} end)
[a: -1, b: -2]

map_join(enumerable, joiner \\ "", mapper)

map_join(t, String.t, (element -> any)) :: String.t

Отображает и объединяет данный перечисляемый объект за один проход.

joiner может быть либо бинарным, либо списком, и результат будет того же типа, что и joiner Если joiner не задан, используется пустая строка.

Все элементы в перечисляемом объекте должны быть преобразуемы в бинарный, иначе произойдет ошибка.

Примеры

iex> Enum.map_join([1, 2, 3], &(&1 * 2))
"246"

iex> Enum.map_join([1, 2, 3], " = ", &(&1 * 2))
"2 = 4 = 6"

map_reduce(enumerable, acc, fun)

map_reduce(t, any, (element, any -> {any, any})) :: {any, any}

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

Возвращает кортеж, где первый элемент — это отображённый перечисляемый объект, а второй — конечный накопитель.

Функция fun, получает два аргумента: первый — элемент, а второй — накопитель. fun должна возвращать кортеж из двух элементов в формате {result, accumulator}.

Для карт первый элемент кортежа должен быть кортежем {key, value}.

Примеры

iex> Enum.map_reduce([1, 2, 3], 0, fn(x, acc) -> {x * 2, x + acc} end)
{[2, 4, 6], 6}

max(enumerable)

max(t) :: element | no_return

Возвращает максимальный элемент в перечисляемом объекте в соответствии с порядком Erlang.

Если несколько элементов считаются максимальными, возвращается первый найденный.

Вызывает исключение Enum.EmptyError если enumerable пустой.

Примеры

iex> Enum.max([1, 2, 3])
3

max_by(enumerable, fun)

max_by(t, (element -> any)) :: element | no_return

Возвращает максимальный элемент в перечислимом множестве, рассчитанный с помощью заданной функции.

Если несколько элементов считаются максимальными, возвращается первый найденный.

Вызывает исключение Enum.EmptyError, если enumerable пусто.

Примеры

iex> Enum.max_by(["a", "aa", "aaa"], fn(x) -> String.length(x) end)
"aaa"

iex> Enum.max_by(["a", "aa", "aaa", "b", "bbb"], &String.length/1)
"aaa"

member?(enumerable, element)

member?(t, element) :: boolean

Проверяет, существует ли element в перечислимом множестве.

Членство проверяется с помощью оператора соответствия (===)

Примеры

iex> Enum.member?(1..10, 5)
true
iex> Enum.member?(1..10, 5.0)
false

iex> Enum.member?([1.0, 2.0, 3.0], 2)
false
iex> Enum.member?([1.0, 2.0, 3.0], 2.000)
true

iex> Enum.member?([:a, :b, :c], :d)
false

min(enumerable)

min(t) :: element | no_return

Возвращает минимальный элемент в перечислимом множестве в соответствии с порядком терминов Erlang.

Если несколько элементов считаются минимальными, возвращается первый найденный.

Вызывает исключение Enum.EmptyError, если enumerable пусто.

Примеры

iex> Enum.min([1, 2, 3])
1

min_by(enumerable, fun)

min_by(t, (element -> any)) :: element | no_return

Возвращает минимальный элемент в перечислимом множестве, рассчитанный с помощью заданной функции.

Если несколько элементов считаются минимальными, возвращается первый найденный.

Вызывает исключение Enum.EmptyError, если enumerable пусто.

Примеры

iex> Enum.min_by(["a", "aa", "aaa"], fn(x) -> String.length(x) end)
"a"

iex> Enum.min_by(["a", "aa", "aaa", "b", "bbb"], &String.length/1)
"a"

min_max(enumerable)

min_max(t) :: {element, element} | no_return

Возвращает кортеж с минимальным и максимальным элементами в перечислимом множестве в соответствии с порядком терминов Erlang.

Если несколько элементов считаются максимальными или минимальными, возвращается первый найденный.

Вызывает исключение Enum.EmptyError, если enumerable пусто.

Примеры

iex> Enum.min_max([2, 3, 1])
{1, 3}

min_max_by(enumerable, fun)

min_max_by(t, (element -> any)) ::
  {element, element} |
  no_return

Возвращает кортеж с минимальным и максимальным элементами в перечислимом множестве, рассчитанный с помощью заданной функции.

Если несколько элементов считаются максимальными или минимальными, возвращается первый найденный.

Вызывает исключение Enum.EmptyError, если enumerable пусто.

Примеры

iex> Enum.min_max_by(["aaa", "bb", "c"], fn(x) -> String.length(x) end)
{"c", "aaa"}

iex> Enum.min_max_by(["aaa", "a", "bb", "c", "ccc"], &String.length/1)
{"a", "aaa"}

partition(enumerable, fun)

partition(t, (element -> any)) :: {list, list}

Разделяет enumerable на два списка, где первый содержит элементы, для которых fun возвращает истинное значение, а второй – для которых fun возвращает false или nil.

Примеры

iex> Enum.partition([1, 2, 3], fn(x) -> rem(x, 2) == 0 end)
{[2], [1, 3]}

random(enumerable)

random(t) :: element | no_return

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

Вызывает исключение Enum.EmptyError, если enumerable пусто.

Эта функция использует модуль :rand Erlang для вычисления случайного значения. Обратитесь к его документации для настройки другого алгоритма случайных чисел или другого начального значения.

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

Примеры

# Although not necessary, let's seed the random algorithm
iex> :rand.seed(:exsplus, {1, 2, 3})
iex> Enum.random([1, 2, 3])
2
iex> Enum.random([1, 2, 3])
1

reduce(enumerable, fun)

reduce(t, (element, any -> any)) :: any

Вызывает fun для каждого элемента в enumerable, передавая этот элемент и накопитель в качестве аргументов. Возвращаемое значение fun сохраняется в накопителе.

Первый элемент перечислимого множества используется в качестве начального значения накопителя. Если вы хотите использовать другое значение для накопителя, используйте Enumerable.reduce/3. Эта функция не будет вызывать указанную функцию для перечислимых множеств, состоящих из одного элемента.

Возвращает накопитель.

Обратите внимание, что поскольку первый элемент перечислимого множества используется в качестве начального значения накопителя, fun будет выполняться только n - 1 раз, где n – длина перечислимого множества.

Примеры

iex> Enum.reduce([1, 2, 3, 4], fn(x, acc) -> x * acc end)
24

reduce(enumerable, acc, fun)

reduce(t, any, (element, any -> any)) :: any

Вызывает fun для каждого элемента в enumerable, передавая этот элемент и накопитель acc в качестве аргументов. Возвращаемое значение fun сохраняется в acc.

Возвращает накопитель.

Примеры

iex> Enum.reduce([1, 2, 3], 0, fn(x, acc) -> x + acc end)
6

reduce_while(enumerable, acc, fun)

Рекурсивно обрабатывает перечислимое множество до тех пор, пока halt не будет возвращено.

Возвращаемое значение для fun ожидается как {:cont, acc}, вернуть {:halt, acc} чтобы преждевременно завершить рекурсию.

Возвращает накопитель.

Примеры

iex> Enum.reduce_while(1..100, 0, fn i, acc ->
...>   if i < 3, do: {:cont, acc + i}, else: {:halt, acc}
...> end)
3

reject(enumerable, fun)

reject(t, (element -> as_boolean(term))) :: list

Возвращает элементы enumerable, для которых функция fun возвращает false или nil.

См. также filter/2.

Примеры

iex> Enum.reject([1, 2, 3], fn(x) -> rem(x, 2) == 0 end)
[1, 3]

reverse(enumerable)

reverse(t) :: list

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

Примеры

iex> Enum.reverse([1, 2, 3])
[3, 2, 1]

reverse(enumerable, tail)

reverse(t, t) :: list

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

Это оптимизация для Enum.concat(Enum.reverse(enumerable), tail).

Примеры

iex> Enum.reverse([1, 2, 3], [4, 5, 6])
[3, 2, 1, 4, 5, 6]

reverse_slice(enumerable, start, count)

reverse_slice(t, non_neg_integer, non_neg_integer) :: list

Обращает перечислимое множество в диапазоне от начальной позиции start до count элементов.

Если count больше размера остальной части перечислимого множества, то эта функция обратит остальную часть перечислимого множества.

Примеры

iex> Enum.reverse_slice([1, 2, 3, 4, 5, 6], 2, 4)
[1, 2, 6, 5, 4, 3]

scan(enumerable, fun)

scan(t, (element, any -> any)) :: list

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

Примеры

iex> Enum.scan(1..5, &(&1 + &2))
[1, 3, 6, 10, 15]

scan(enumerable, acc, fun)

scan(t, any, (element, any -> any)) :: list

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

Примеры

iex> Enum.scan(1..5, 0, &(&1 + &2))
[1, 3, 6, 10, 15]

shuffle(enumerable)

shuffle(t) :: list

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

Эта функция использует модуль :rand Erlang для вычисления случайного значения. Обратитесь к его документации для настройки другого алгоритма случайных чисел или другого начального значения.

Примеры

# Although not necessary, let's seed the random algorithm
iex> :rand.seed(:exsplus, {1, 2, 3})
iex> Enum.shuffle([1, 2, 3])
[2, 1, 3]
iex> Enum.shuffle([1, 2, 3])
[2, 3, 1]

slice(enumerable, range)

slice(t, Range.t) :: list

Возвращает подмножество списка заданного перечислимого множества. Опускает элементы до позиции range.first, затем берет элементы до позиции range.last (включительно).

Позиции вычисляются путем добавления количества элементов в перечислимом множестве к отрицательным позициям (например, позиция -3 в перечислимом множестве с количеством 5 становится позицией 2).

Первая позиция (после добавления количества к отрицательным позициям) должна быть меньше или равна последней позиции.

Если начало диапазона не является допустимым смещением для данного перечислимого множества или если диапазон в обратном порядке, возвращает [].

Примеры

iex> Enum.slice(1..100, 5..10)
[6, 7, 8, 9, 10, 11]

iex> Enum.slice(1..10, 5..20)
[6, 7, 8, 9, 10]

iex> Enum.slice(1..10, 11..20)
[]

iex> Enum.slice(1..10, 6..5)
[]

slice(enumerable, start, count)

slice(t, integer, non_neg_integer) :: list

Возвращает подмножество списка заданного перечислимого множества. Опускает элементы до позиции start, затем берет count элементов.

Если количество больше enumerable длины, возвращает как можно больше. Если ноль, то возвращает [].

Примеры

iex> Enum.slice(1..100, 5, 10)
[6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

iex> Enum.slice(1..10, 5, 100)
[6, 7, 8, 9, 10]

iex> Enum.slice(1..10, 5, 0)
[]

sort(enumerable)

sort(t) :: list

Сортирует перечислимое множество в соответствии с порядком терминов Erlang.

Использует алгоритм слияния.

Примеры

iex> Enum.sort([3, 2, 1])
[1, 2, 3]

sort(enumerable, fun)

sort(t, (element, element -> boolean)) :: list

Сортирует перечислимое множество по заданной функции.

Эта функция использует алгоритм слияния. Заданная функция должна сравнивать два аргумента и возвращать false, если первый аргумент следует за вторым.

Примеры

iex> Enum.sort([1, 2, 3], &(&1 > &2))
[3, 2, 1]

Алгоритм сортировки будет стабильным, если заданная функция возвращает true для значений, считающихся равными:

iex> Enum.sort ["some", "kind", "of", "monster"], &(byte_size(&1) <= byte_size(&2))
["of", "some", "kind", "monster"]

Если функция не возвращает true для равных значений, сортировка не является стабильной, и порядок равных элементов может быть перемешан. Например:

iex> Enum.sort ["some", "kind", "of", "monster"], &(byte_size(&1) < byte_size(&2))
["of", "kind", "some", "monster"]

sort_by(enumerable, mapper, sorter \\ &<=/2)

sort_by(t, (element -> mapped_element), (mapped_element, mapped_element -> boolean)) :: list when mapped_element: element

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

Эта функция отображает каждый элемент перечисляемого объекта с помощью функции mapper. Затем перечисляемый объект сортируется по отображённым элементам с использованием функции sorter, которая по умолчанию равна Kernel.<=/2.

sort_by/3 отличается от sort/2 тем, что вычисляет значение сравнения для каждого элемента в перечисляемом объекте только один раз вместо одного раза для каждого элемента в каждом сравнении. Если одна и та же функция вызывается для обоих элементов, использование sort_by/3 также более компактно.

Этот метод также известен как преобразование Шварца или идиома Lisp decorate-sort-undecorate, поскольку функция mapper декорирует исходный enumerable; затем функция sorter сортирует декорации; и, наконец, перечисляемый объект снимает декорации, так что остаются только исходные элементы, но теперь в отсортированном порядке.

Примеры

Используя функцию sorter по умолчанию <=/2.

iex> Enum.sort_by ["some", "kind", "of", "monster"], &byte_size/1
["of", "some", "kind", "monster"]

Используя пользовательскую функцию sorter для изменения порядка:

iex> Enum.sort_by ["some", "kind", "of", "monster"], &byte_size/1, &>=/2
["monster", "some", "kind", "of"]

split(enumerable, count)

split(t, integer) :: {list, list}

Разделяет перечисляемый объект на два перечисляемых объекта, оставив count элементов в первом. Если count — отрицательное число, счёт начинается с конца перечисляемого объекта к началу.

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

Примеры

iex> Enum.split([1, 2, 3], 2)
{[1, 2], [3]}

iex> Enum.split([1, 2, 3], 10)
{[1, 2, 3], []}

iex> Enum.split([1, 2, 3], 0)
{[], [1, 2, 3]}

iex> Enum.split([1, 2, 3], -1)
{[1, 2], [3]}

iex> Enum.split([1, 2, 3], -5)
{[], [1, 2, 3]}

split_while(enumerable, fun)

split_while(t, (element -> as_boolean(term))) :: {list, list}

Разделяет перечисляемый объект на две части в позиции элемента, для которого fun возвращает false в первый раз.

Примеры

iex> Enum.split_while([1, 2, 3, 4], fn(x) -> x < 3 end)
{[1, 2], [3, 4]}

sum(enumerable)

sum(t) :: number

Возвращает сумму всех элементов.

Вызывает исключение ArithmeticError, если enumerable содержит нечисловое значение.

Примеры

iex> Enum.sum([1, 2, 3])
6

take(enumerable, count)

take(t, integer) :: list

Берёт первые count элементы из перечисляемого объекта.

count должно быть целым числом. Если задано отрицательное count, будут взяты последние count значения. В таком случае перечисляемый объект полностью перебирается, сохраняя до 2 * count элементов в памяти. После достижения конца перечисляемого объекта возвращаются последние count элементов.

Примеры

iex> Enum.take([1, 2, 3], 2)
[1, 2]

iex> Enum.take([1, 2, 3], 10)
[1, 2, 3]

iex> Enum.take([1, 2, 3], 0)
[]

iex> Enum.take([1, 2, 3], -1)
[3]

take_every(enumerable, nth)

take_every(t, non_neg_integer) :: list | no_return

Возвращает список каждого nth элемента в перечисляемом объекте, начиная с первого элемента.

Первый элемент всегда включается, если только nth не равно 0.

Второй аргумент, определяющий каждый nth элемент, должен быть целым неотрицательным числом, иначе будет вызвано исключение FunctionClauseError.

Примеры

iex> Enum.take_every(1..10, 2)
[1, 3, 5, 7, 9]

iex> Enum.take_every(1..10, 0)
[]

iex> Enum.take_every([1, 2, 3], 1)
[1, 2, 3]

take_random(enumerable, count)

take_random(t, non_neg_integer) :: list

Берёт случайные элементы из enumerable.

Обратите внимание, что эта функция пройдёт по всему enumerable для получения случайного подсписка.

См. random/1 для примечаний по реализации и семени случайности.

Примеры

# Although not necessary, let's seed the random algorithm
iex> :rand.seed(:exsplus, {1, 2, 3})
iex> Enum.take_random(1..10, 2)
[5, 8]
iex> Enum.take_random(?a..?z, 5)
'fhjni'

take_while(enumerable, fun)

take_while(t, (element -> as_boolean(term))) :: list

Берёт элементы с начала перечисляемого объекта, пока fun возвращает истинное значение.

Примеры

iex> Enum.take_while([1, 2, 3], fn(x) -> x < 3 end)
[1, 2]

to_list(enumerable)

to_list(t) :: [element]

Преобразует enumerable в список.

Примеры

iex> Enum.to_list(1..3)
[1, 2, 3]

uniq(enumerable)

uniq(t) :: list

Перебирает enumerable, удаляя все дублированные элементы.

Примеры

iex> Enum.uniq([1, 2, 3, 3, 2, 1])
[1, 2, 3]

uniq_by(enumerable, fun)

uniq_by(t, (element -> term)) :: list

Перебирает enumerable, удаляя элементы, для которых функция fun возвращает дублированные элементы.

Функция fun отображает каждый элемент в термин, используемый для определения дубликатов элементов.

Пример

iex> Enum.uniq_by([{1, :x}, {2, :y}, {1, :z}], fn {x, _} -> x end)
[{1, :x}, {2, :y}]

iex> Enum.uniq_by([a: {:tea, 2}, b: {:tea, 2}, c: {:coffee, 1}], fn {_, y} -> y end)
[a: {:tea, 2}, c: {:coffee, 1}]

unzip(enumerable)

unzip(t) :: {[element], [element]}

Обратная функция Enum.zip/2; извлекает пары элементов из перечисляемого объекта и группирует их вместе.

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

Эта функция завершается неудачей, если enumerable является или может быть преобразована в список кортежей, содержащих точно два элемента в каждом кортеже.

Примеры

iex> Enum.unzip([{:a, 1}, {:b, 2}, {:c, 3}])
{[:a, :b, :c], [1, 2, 3]}

iex> Enum.unzip(%{a: 1, b: 2})
{[:a, :b], [1, 2]}

with_index(enumerable, offset \\ 0)

with_index(t, integer) :: [{element, integer}]

Возвращает перечисляемый объект, где каждый элемент заключён в кортеж вместе с его индексом.

Примеры

iex> Enum.with_index([:a, :b, :c])
[a: 0, b: 1, c: 2]

iex> Enum.with_index([:a, :b, :c], 3)
[a: 3, b: 4, c: 5]

zip(enumerable1, enumerable2)

zip(t, t) :: [{any, any}]

Объединяет соответствующие элементы из двух перечисляемых объектов в один список кортежей.

Объединение завершается, как только какой-либо перечисляемый объект завершается.

Примеры

iex> Enum.zip([1, 2, 3], [:a, :b, :c])
[{1, :a}, {2, :b}, {3, :c}]

iex> Enum.zip([1, 2, 3, 4, 5], [:a, :b, :c])
[{1, :a}, {2, :b}, {3, :c}]