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

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

В Elixir, структура, позволяющая перебор, — это любой тип данных, реализующий протокол Enumerable. List ([1, 2, 3]), Map (%{foo: 1, bar: 2}) и Range (1..3) являются распространенными типами данных, используемыми в качестве структур, позволяющих перебор:

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

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

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

iex> Enum.sum(1..3)
6

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

Однако, во многих случаях существуют другие структуры, позволяющие перебор, такие как MapSet и тип данных, возвращаемый File.stream!/3, который позволяет проходить по файлу так, как будто он является структурой, позволяющей перебор.

Функции в этом модуле работают за линейное время. Это означает, что чем больше структура, позволяющая перебор, тем больше времени займет выполнение желаемой операции. Это ожидаемо при операциях, таких как Enum.map/2. В конце концов, если мы хотим пройтись по каждому элементу в списке, чем длиннее список, тем больше элементов нам нужно пройти, и тем больше времени это займет.

Это линейное поведение также ожидается при операциях, таких как count/1, member?/2, at/2 и аналогичных. Хотя Elixir позволяет типам данных предоставлять эффективные варианты для таких операций, не следует ожидать, что это всегда будет доступно, так как модуль Enum предназначен для работы с широким спектром типов данных, и не все типы данных могут обеспечить оптимизированное поведение.

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

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

Функции

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 возвращает истинное значение
reverse(enumerable): Возвращает список элементов в enumerable в обратном порядке
reverse(enumerable, tail): Обращает элементы в enumerable, добавляет tail, и возвращает его в виде списка
reverse_slice(enumerable, start, count): Обращает перечислимый объект в диапазоне от начальной позиции start до count элементов

END_OF_DOCUMENT_MARKER

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

Примеры

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

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

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

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

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

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 item, acc ->
...>   if rem(item, 2) == 0 do
...>     {:cont, Enum.reverse([item | acc]), []}
...>   else
...>     {:cont, [item | 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, возвращая список, где все последовательные дублированные элементы сводятся к одному элементу.

Элементы сравниваются с помощью ===/2.

Если вы хотите удалить все дублированные элементы, независимо от порядка, см. 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()

Удаляет 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()) :: 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

fetch(enumerable, index)

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

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

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

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

Примеры

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

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 не может фильтровать и преобразовывать элемент одновременно. Если вы хотите это сделать, рассмотрите использование 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 x, acc ->
...>   if acc < n, do: {[x], acc + 1}, else: {:halt, acc}
...> end)
{[1, 2, 3], 3}

iex> Enum.flat_map_reduce(1..5, 0, fn x, acc -> {[[x]], acc + x} 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) (since 1.4.0)

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

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

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

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

Если 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]

Для выбора максимального значения из двух используйте Kernel.max/2.

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 в перечислимом объекте.

Членство проверяется оператором совпадения (===/2).

Примеры

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]

Для выбора минимального значения из двух используйте Kernel.min/2.

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

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

Например, мы можем реализовать 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 x, acc ->
...>   if x < 3, do: {:cont, acc + x}, else: {:halt, acc}
...> end)
3

reject(enumerable, fun)

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

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

См. также 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, добавляет tail, и возвращает его как список.

Это оптимизация для enumerable |> Enum.reverse() |> Enum.concat(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) (с версии 1.6.0)

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

Примеры

Используя по умолчанию 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()}

Разделяет 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) (с версии 1.4.0)

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, 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) (с версии 1.4.0)

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