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

Предоставляет набор алгоритмов, перечисляющих перечислимые объекты согласно протоколу 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)

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

Функции

all?(enumerable, fun \\ fn x -> x end): Возвращает true, если заданная fun возвращает true для всех элементов в перечисляемом объекте
any?(enumerable, fun \\ fn x -> x end): Возвращает true, если заданная fun возвращает true для любого из элементов в перечисляемом объекте
at(enumerable, index, default \\ nil): Находит элемент по заданному index (нумерация с нуля)
chunk(enumerable, count): Сокращение для chunk(enumerable, count, count)
chunk(enumerable, count, step, leftover \\ nil): Возвращает список списков, содержащих count элементов каждый, где каждый новый блок начинается через step элементы в перечисляемом объекте
chunk_by(enumerable, fun): Разбивает перечисляемый объект на группы по каждому элементу, для которого fun возвращает новое значение
concat(enumerables): Принимая перечисляемый объект перечисляемых объектов, склеивает перечисляемые объекты в один список
concat(left, right): Склеивает перечисляемый объект справа с перечисляемым объектом слева
count(enumerable): Возвращает размер перечисляемого объекта
count(enumerable, fun): Возвращает количество элементов в перечисляемом объекте, для которых fun возвращает истинное значение
dedup(enumerable): Перечисляет enumerable, возвращая список, где все последовательные дублированные элементы сводятся к одному элементу
dedup_by(enumerable, fun): Перечисляет enumerable, возвращая список, где все последовательные дублированные элементы сводятся к одному элементу
drop(enumerable, amount): Опускает amount элементов из перечисляемого объекта
drop_every(enumerable, nth): Возвращает список, содержащий каждый nth элемент перечисляемого объекта, пропущенный, начиная с первого элемента
drop_while(enumerable, fun): Опускает элементы в начале перечисляемого объекта, пока fun возвращает истинное значение
each(enumerable, fun): Вызывает заданную fun для каждого элемента в перечисляемом объекте
empty?(enumerable): Определяет, пуст ли перечисляемый объект
fetch(enumerable, index): Находит элемент по заданному index (нумерация с нуля)
fetch!(enumerable, index): Находит элемент по заданному index (нумерация с нуля)
filter(enumerable, fun): Фильтрует перечисляемый объект, т.е. возвращает только те элементы, для которых fun возвращает истинное значение
filter_map(enumerable, filter, mapper): Фильтрует перечисляемый объект и отображает его элементы за один проход
find(enumerable, default \\ nil, fun): Возвращает первый элемент, для которого fun возвращает истинное значение. Если такой элемент не найден, возвращает default
find_index(enumerable, fun): Аналогично find/3, но возвращает индекс (нумерация с нуля) элемента вместо самого элемента
find_value(enumerable, default \\ nil, fun): Аналогично find/3, но возвращает значение вызова функции вместо самого элемента
flat_map(enumerable, fun): Возвращает новый перечисляемый объект, добавляя результат вызова fun для каждого соответствующего элемента enumerable
flat_map_reduce(enumerable, acc, fun): Отображает и сводит перечисляемый объект, сглаживая полученные результаты (только на один уровень глубины)
group_by(enumerable, key_fun, value_fun \\ fn x -> x end): Разбивает перечисляемый объект на группы на основе key_fun
intersperse(enumerable, element): Вставляет element между каждым элементом перечисления
into(enumerable, collectable): Вставляет данный enumerable в collectable
into(enumerable, collectable, transform): Вставляет данный enumerable в collectable в соответствии с функцией преобразования
join(enumerable, joiner \\ ""): Объединяет заданный перечисляемый объект в строку, используя joiner в качестве разделителя
map(enumerable, fun): Возвращает список, где каждый элемент является результатом вызова fun для каждого соответствующего элемента enumerable
map_every(enumerable, nth, fun): Возвращает список результатов вызова fun для каждого nth элемента enumerable, начиная с первого элемента
map_join(enumerable, joiner \\ "", mapper): Отображает и объединяет заданный перечисляемый объект за один проход
map_reduce(enumerable, acc, fun): Вызывает заданную функцию для каждого элемента в перечисляемом объекте, чтобы свести его к одному элементу, сохраняя накопитель
max(enumerable, empty_fallback \\ fn -> raise(Enum.EmptyError) end): Возвращает максимальный элемент в перечисляемом объекте в соответствии с порядком Эрланга
max_by(enumerable, fun, empty_fallback \\ fn -> raise(Enum.EmptyError) end): Возвращает максимальный элемент в перечисляемом объекте, рассчитанный заданной функцией
member?(enumerable, element): Проверяет, существует ли element в перечисляемом объекте
min(enumerable, empty_fallback \\ fn -> raise(Enum.EmptyError) end): Возвращает минимальный элемент в перечисляемом объекте в соответствии с порядком Эрланга
min_by(enumerable, fun, empty_fallback \\ fn -> raise(Enum.EmptyError) end): Возвращает минимальный элемент в перечисляемом объекте, рассчитанный заданной функцией
min_max(enumerable, empty_fallback \\ fn -> raise(Enum.EmptyError) end): Возвращает кортеж с минимальным и максимальным элементами в перечисляемом объекте в соответствии с порядком Эрланга
min_max_by(enumerable, fun, empty_fallback \\ fn -> raise(Enum.EmptyError) end): Возвращает кортеж с минимальным и максимальным элементами в перечисляемом объекте, рассчитанными заданной функцией
random(enumerable): Возвращает случайный элемент перечисляемого объекта
reduce(enumerable, fun): Вызывает fun для каждого элемента в enumerable, передавая этот элемент и накопитель в качестве аргументов. Значение, возвращаемое fun, сохраняется в накопителе
reduce(enumerable, acc, fun): Вызывает fun для каждого элемента в enumerable, передавая этот элемент и накопитель acc в качестве аргументов. Значение, возвращаемое fun, сохраняется в acc
reduce_while(enumerable, acc, fun): Сводит перечисляемый объект, пока fun возвращает {:halt, term}
reject(enumerable, fun): Возвращает элементы enumerable для которых функция fun возвращает false или nil
reverse(enumerable): Возвращает список элементов в enumerable в обратном порядке
reverse(enumerable, tail): Инвертирует элементы в 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, amount): Возвращает подмножество списка из данного итерируемого объекта, начиная с позиции start с amount элементов, если доступно
sort(enumerable): Сортирует итерируемый объект в соответствии с порядком терминов Erlang
sort(enumerable, fun): Сортирует итерируемый объект по заданной функции
sort_by(enumerable, mapper, sorter \\ &<=/2): Сортирует результаты отображения итерируемого объекта в соответствии с предоставленной sorter функцией
split(enumerable, count): Разделяет enumerable на два итерируемых объекта, оставляя count элементов в первом
split_while(enumerable, fun): Разделяет итерируемый объект на две части в позиции элемента, для которого fun возвращает false в первый раз
split_with(enumerable, fun): Разделяет enumerable на два списка в соответствии с заданной функцией fun
sum(enumerable): Возвращает сумму всех элементов
take(enumerable, count): Берет первые count элементы из итерируемого объекта
take_every(enumerable, nth): Возвращает список каждого nth элемента в итерируемом объекте, начиная с первого элемента
take_random(enumerable, count): Берет 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(enumerables): Объединяет соответствующие элементы из коллекции итерируемых объектов в один список кортежей
zip(enumerable1, enumerable2): Объединяет соответствующие элементы из двух итерируемых объектов в один список кортежей

Типы

default()

default() :: any()

element()

element() :: any()

index()

index() :: integer()

t()

t() :: Enumerable.t()

Функции

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

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

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

Останавливает итерацию при первом вызове, который возвращает false или nil.

Примеры

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()

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

Останавливает итерацию при первом вызове, который возвращает истинное значение (не false или nil).

Примеры

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(), index(), 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, amount)

drop(t(), integer()) :: list()

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

Если задано отрицательное amount, будут удалены amount последних значений.

Перечисляемый объект 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()

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

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

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

Примеры

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, 2, 1], fn(x) -> x < 3 end)
[3, 2, 1]

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(), index()) :: {: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], -3)
{:ok, 2}

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

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

fetch!(enumerable, index)

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

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

Вызывает исключение OutOfBoundsError , если заданный 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())) :: non_neg_integer() | 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, value_fun \\ fn x -> x end)

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

Разбивает перечисляемый объект на группы на основе key_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_every(enumerable, nth, fun)

map_every(t(), non_neg_integer(), (element() -> any())) :: list()

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

Первый элемент всегда передаётся в заданную функцию.

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

Примеры

iex> Enum.map_every(1..10, 2, fn(x) -> x * 2 end)
[2, 2, 6, 4, 10, 6, 14, 8, 18, 10]

iex> Enum.map_every(1..5, 0, fn(x) -> x * 2 end)
[1, 2, 3, 4, 5]

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

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, empty_fallback \\ fn -> raise(Enum.EmptyError) end)

max(t(), (() -> empty_result)) ::
  element() |
  empty_result |
  no_return() when empty_result: any()

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

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

Вызывает предоставленную empty_fallback функцию и возвращает её значение, если enumerable пусто. По умолчанию empty_fallback вызывает Enum.EmptyError.

Примеры

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

iex> Enum.max([], fn -> 0 end)
0

max_by(enumerable, fun, empty_fallback \\ fn -> raise(Enum.EmptyError) end)

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

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

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

Примеры

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"

iex> Enum.max_by([], &String.length/1, fn -> nil end)
nil

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, empty_fallback \\ fn -> raise(Enum.EmptyError) end)

min(t(), (() -> empty_result)) ::
  element() |
  empty_result |
  no_return() when empty_result: any()

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

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

Примеры

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

iex> Enum.min([], fn -> 0 end)
0

min_by(enumerable, fun, empty_fallback \\ fn -> raise(Enum.EmptyError) end)

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

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

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

Примеры

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"

iex> Enum.min_by([], &String.length/1, fn -> nil end)
nil

min_max(enumerable, empty_fallback \\ fn -> raise(Enum.EmptyError) end)

min_max(t(), (() -> empty_result)) ::
  {element(), element()} |
  empty_result |
  no_return() when empty_result: any()

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

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

Примеры

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

iex> Enum.min_max([], fn -> {nil, nil} end)
{nil, nil}

min_max_by(enumerable, fun, empty_fallback \\ fn -> raise(Enum.EmptyError) end)

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

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

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

Примеры

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"}

iex> Enum.min_max_by([], &String.lenth/1, fn -> {nil, nil} end)
{nil, nil}

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, {101, 102, 103})
iex> Enum.random([1, 2, 3])
2
iex> Enum.random([1, 2, 3])
1
iex> Enum.random(1..1_000)
776

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)

reduce_while(t(), any(), (element(), any() -> {:cont, any()} | {:halt, any()})) :: any()

Уменьшает перечислимый объект до тех пор, пока fun не вернёт {:halt, term}.

Возвращаемое значение для fun должно быть

{:cont, acc} продолжить уменьшение с acc в качестве нового накопителя или
{:halt, acc} прервать уменьшение и вернуть 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.

Примеры

# 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 позиций.

С учётом enumerable, он опускает элементы до позиции элемента range.first, затем берёт элементы до позиции элемента range.last (включительно).

Позиции нормализованы, то есть отрицательные позиции будут считаться с конца (например, -1 означает последний элемент перечислимого объекта). Если range.last выходит за пределы, ему присваивается позиция последнего элемента.

Если нормализованная range.first позиция выходит за пределы данного перечислимого объекта или эта позиция больше нормализованной range.last позиции, то возвращается [].

Примеры

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]

# last five elements (negative positions)
iex> Enum.slice(1..30, -5..-1)
[26, 27, 28, 29, 30]

# last five elements (mixed positive and negative positions)
iex> Enum.slice(1..30, 25..-1)
[26, 27, 28, 29, 30]

# out of bounds
iex> Enum.slice(1..10, 11..20)
[]

# range.first is greater than range.last
iex> Enum.slice(1..10, 6..5)
[]

slice(enumerable, start, amount)

slice(t(), index(), non_neg_integer()) :: list()

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

Учитывая enumerable, он пропускает элементы до позиции элемента start, затем берет amount элементов до конца перечисляемого объекта.

Если start выходит за пределы допустимых значений, возвращает [].

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

Примеры

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

# amount to take is greater than the number of elements
iex> Enum.slice(1..10, 5, 100)
[6, 7, 8, 9, 10]

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

# out of bound start position
iex> Enum.slice(1..10, 10, 5)
[]

# out of bound start position (negative)
iex> Enum.slice(1..10, -11, 5)
[]

sort(enumerable)

sort(t()) :: list()

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

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

Примеры

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

sort(enumerable, fun)

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

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

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

Примеры

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, так как 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()}

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

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

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

Примеры

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]}

split_with(enumerable, fun)

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

Разделяет enumerable на два списка в соответствии с заданной функцией fun.

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

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

Примеры

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

iex> Enum.split_with(%{a: 1, b: -2, c: 1, d: -3}, fn({_k, v}) -> v < 0 end)
{[b: -2, d: -3], [a: 1, c: 1]}

iex> Enum.split_with(%{a: 1, b: -2, c: 1, d: -3}, fn({_k, v}) -> v > 50 end)
{[], [a: 1, b: -2, c: 1, d: -3]}

iex> Enum.split_with(%{}, fn({_k, v}) -> v > 50 end)
{[], []}

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()

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

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

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

Примеры

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()

Возвращает count случайных элементов из 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, 4]
iex> Enum.take_random(?a..?z, 5)
'ipybz'

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(), index()}]

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

Если задан offset, индексация будет начинаться с заданного смещения, а не с нуля.

Примеры

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(enumerables)

zip([t()]) :: t()

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

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

Примеры

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

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

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}]