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

Предоставляет набор алгоритмов, перечисляющих перечислимые объекты в соответствии с протоколом 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_by(enumerable, fun): Разбивает перечислимый объект на фрагменты по каждому элементу, для которого fun возвращает новое значение
chunk_every(enumerable, count): Сокращенная запись для chunk_every(enumerable, count, count)
chunk_every(enumerable, count, step, leftover \\ []): Возвращает список списков, содержащих count элементов каждый, где каждый новый фрагмент начинается step элементов в перечислимом объекте
chunk_while(enumerable, acc, chunk_fun, after_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 возвращает истинное значение
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): Возвращает максимальный элемент в перечислимом объекте согласно порядку Erlang
max_by(enumerable, fun, empty_fallback \\ fn -> raise(Enum.EmptyError) end): Возвращает максимальный элемент в перечислимом объекте, рассчитанный данной функцией
member?(enumerable, element): Проверяет, существует ли element в перечислимом объекте
min(enumerable, empty_fallback \\ fn -> raise(Enum.EmptyError) end): Возвращает минимальный элемент в перечислимом объекте согласно порядку Erlang
min_by(enumerable, fun, empty_fallback \\ fn -> raise(Enum.EmptyError) end): Возвращает минимальный элемент в перечислимом объекте, рассчитанный данной функцией
min_max(enumerable, empty_fallback \\ fn -> raise(Enum.EmptyError) end): Возвращает кортеж с минимальным и максимальным элементами в перечислимом объекте согласно порядку Erlang
min_max_by(enumerable, fun, empty_fallback \\ fn -> raise(Enum.EmptyError) end): Возвращает кортеж с минимальным и максимальным элементами в перечислимом объекте, рассчитанными данной функцией
random(enumerable): Возвращает случайный элемент перечислимого объекта
reduce(enumerable, fun): Вызывает fun для каждого элемента в enumerable с накопителем
reduce(enumerable, acc, fun): Вызывает fun для каждого элемента в enumerable с накопителем
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)

END_OF_DOCUMENT_MARKER

Применяет заданную функцию к каждому элементу в перечислимом объекте, сохраняя результат в списке и передавая его в качестве аккумулятора для следующего вычисления. Использует первый элемент в перечислимом объекте в качестве начального значения
scan(enumerable, acc, fun): Применяет заданную функцию к каждому элементу в перечислимом объекте, сохраняя результат в списке и передавая его в качестве аккумулятора для следующего вычисления. Использует заданное acc значение в качестве начального значения
shuffle(enumerable): Возвращает список с элементами enumerable перемешанными
slice(enumerable, arg): Возвращает подмножество списка заданного перечислимого объекта, от позиции 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, amount): Берет первые amount элементы из перечислимого объекта
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): Скрепляет соответствующие элементы из двух перечислимых объектов в один список кортежей

Типы

acc()

acc() :: any()

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 перечисляется один раз, и index подсчитывается с конца (например, -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_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]]

chunk_every(enumerable, count)

chunk_every(t(), pos_integer()) :: [list()]

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

chunk_every(enumerable, count, step, leftover \\ [])

chunk_every(t(), pos_integer(), pos_integer(), t() | :discard) :: [list()]

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

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

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

Если :discard передано в leftover, последняя группа отбрасывается, если у неё не ровно count элементов.

Примеры

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

iex> Enum.chunk_every([1, 2, 3, 4, 5, 6], 3, 2, :discard)
[[1, 2, 3], [3, 4, 5]]

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

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

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

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

chunk_while(enumerable, acc, chunk_fun, after_fun)

chunk_while(
  t(),
  acc(),
  (element(), acc() ->
     {:cont, chunk, acc()} | {:cont, acc()} | {:halt, acc()}),
  (acc() -> {:cont, chunk, acc()} | {:cont, acc()})
) :: Enumerable.t()
when chunk: any()

Группирует enumerable с подробным контролем при генерации каждой группы.

chunk_fun получает текущий элемент и аккумулятор и должен вернуть {:cont, element, acc} для генерации заданной группы и продолжения с аккумулятором или {:cont, acc} для того, чтобы не генерировать группу и продолжить с возвращаемым аккумулятором.

after_fun вызывается при завершении итерации и также должен вернуть {:cont, element, acc} или {:cont, acc}

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

Примеры

iex> chunk_fun = fn i, acc ->
...>   if rem(i, 2) == 0 do
...>     {:cont, Enum.reverse([i | acc]), []}
...>   else
...>     {:cont, [i | acc]}
...>   end
...> end
iex> after_fun = fn
...>   [] -> {:cont, []}
...>   acc -> {:cont, Enum.reverse(acc), []}
...> end
iex> Enum.chunk_while(1..10, [], chunk_fun, after_fun)
[[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]

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

Функция 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()

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

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

Примеры

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

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

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

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

Примеры

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

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

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

Можно передать отрицательный индекс, что означает, что перечисляемый объект будет перечислен один раз, а индекс будет отсчитываться с конца (например, -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()

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

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

Примеры

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, который отбрасывает все элементы, где функция возвращает true.

Примеры

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

Обратите внимание, что filter не может фильтровать и преобразовывать элемент одновременно. Если вы хотите это сделать, рассмотрите использование flat_map/2. Например, если вы хотите преобразовать все строки, представляющие целое число, и отбросить некорректные в одном проходе:

strings = ["1234", "abc", "12ab"]
Enum.flat_map(strings, fn string ->
  case Integer.parse(string) do
    {int, _rest} -> [int] # transform to integer
    :error -> [] # skip the value
  end
end)

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 и сплющивает результат.

Эта функция возвращает новый перечисляемый объект, созданный путем добавления результатов вызова fun для каждого элемента из enumerable вместе; концептуально это аналогично комбинации map/2 и concat/1.

Примеры

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> enumerable = 1..100
iex> n = 3
iex> Enum.flat_map_reduce(enumerable, 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"], 5 => ["dingo"], 7 => ["buffalo"]}

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

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]

iex> Enum.into(%{a: 1, b: 2}, %{c: 3}, fn {k, v} -> {k, v * 2} end)
%{a: 2, b: 4, c: 3}

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 для каждого n-го элемента enumerable, начиная с первого элемента.

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

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

Если nth равно 0, то enumerable напрямую преобразуется в список без применения fun.

Примеры

iex> Enum.map_every(1..10, 2, fn x -> x + 1000 end)
[1001, 2, 1003, 4, 1005, 6, 1007, 8, 1009, 10]

iex> Enum.map_every(1..10, 3, fn x -> x + 1000 end)
[1001, 2, 3, 1004, 5, 6, 1007, 8, 9, 1010]

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

iex> Enum.map_every([1, 2, 3], 1, fn x -> x + 1000 end)
[1001, 1002, 1003]

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

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

Применяет отображение и объединение к заданному перечисляемому объекту в одном проходе.

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

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

Примеры

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

Тот факт, что эта функция использует порядок терминов Erlang, означает, что сравнение является структурным, а не семантическим. Например:

iex> Enum.max([~D[2017-03-31], ~D[2017-04-01]])
~D[2017-03-31]

В примере выше, max/1 вернула 31 марта, а не 1 апреля, потому что структурное сравнение сравнивает день до года. Это можно исправить, используя max_by/1 и полагаясь на структуры, в которых наиболее значимые цифры стоят первыми. В данном случае мы можем использовать Date.to_erl/1, чтобы получить представление кортежа с полями год, месяц и день:

iex> Enum.max_by([~D[2017-03-31], ~D[2017-04-01]], &Date.to_erl/1)
~D[2017-04-01]

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

iex> Enum.min([~D[2017-03-31], ~D[2017-04-01]])
~D[2017-04-01]

В примере выше, min/1 вернула 1 апреля, а не 31 марта, потому что структурное сравнение сравнивает день до года. Это можно исправить, используя min_by/1 и полагаясь на структуры, в которых наиболее значимые цифры стоят первыми. В данном случае мы можем использовать Date.to_erl/1, чтобы получить представление кортежа с полями год, месяц и день:

iex> Enum.min_by([~D[2017-03-31], ~D[2017-04-01]], &Date.to_erl/1)
~D[2017-03-31]

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.length/1, fn -> {nil, nil} end)
{nil, nil}

random(enumerable)

random(t()) :: element() | no_return()

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

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

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

Реализация основана на алгоритме выбора случайной выборки выборки по резервуару. Предполагается, что возвращаемая выборка помещается в память; входной 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 с аккумулятором.

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

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

Поскольку первый элемент перечисляемого объекта используется в качестве начального значения аккумулятора, fun будет вызываться только n - 1 раз, где n — длина перечисляемого объекта. Эта функция не вызовет указанную функцию для перечисляемых объектов длиной в один элемент.

Если вы хотите использовать другое значение для аккумулятора, используйте Enum.reduce/3.

Примеры

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. Функция вызывается для каждого элемента в перечисляемом объекте с аккумулятором. Результат, возвращаемый функцией, используется в качестве аккумулятора для следующей итерации. Функция возвращает последний аккумулятор.

Примеры

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

Снижение как строительный блок

Снижение (иногда называемое fold) — это базовый строительный блок в функциональном программировании. Почти все функции в модуле Enum могут быть реализованы на основе снижения. Эти функции часто полагаются на другие операции, такие как Enum.reverse/1, которые оптимизированы временем выполнения.

Например, мы могли бы реализовать map/2 в терминах reduce/3 следующим образом:

def my_map(enumerable, fun) do
  enumerable
  |> Enum.reduce([], fn(x, acc) -> [fun.(x) | acc] end)
  |> Enum.reverse
end

В примере выше Enum.reduce/3 накапливает результат каждого вызова fun в список в обратном порядке, который правильно упорядочивается в конце вызовом Enum.reverse/1.

Реализация функций, таких как map/2, filter/2 и другие, является хорошим упражнением для понимания силы Enum.reduce/3. Когда операцию нельзя выразить ни одной из функций в модуле Enum, разработчики, скорее всего, прибегнут к reduce/3.

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.

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

Примеры

# 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, arg)

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’s.

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

Примеры

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 также более компактно.

Примеры

Использование по умолчанию 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"]

Сортировка по нескольким свойствам - сначала по размеру, а затем по первой букве (это использует тот факт, что кортежи сравниваются по элементам):

iex> Enum.sort_by(["some", "kind", "of", "monster"], &{byte_size(&1), String.first(&1)})
["of", "kind", "some", "monster"]

split(enumerable, count)

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

Разделяет перечислимый объект на два перечислимых объекта, оставляя 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()}

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

Разделяет данный перечислимый объект на два списка, вызывая fun с каждым элементом перечислимого объекта в качестве единственного аргумента. Возвращает кортеж с первым списком, содержащим все элементы перечислимого объекта, для которых применение 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, amount)

take(t(), integer()) :: list()

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

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

Примеры

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 сопоставляет каждый элемент с термином. Два элемента считаются дубликатами, если возвращаемое значение функции 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()

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