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

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

scan(enumerable, acc, fun): Применяет заданную функцию к каждому элементу в перечисляемом объекте, сохраняя результат в списке и передавая его в качестве накопителя для следующего вычисления. Использует заданное acc в качестве начального значения
shuffle(enumerable): Возвращает список с элементами enumerable перемешанными
slice(enumerable, range): Возвращает подмножество списка заданного перечисляемого объекта, с позиции range.first до позиции range.last
slice(enumerable, start, amount): Возвращает подмножество списка заданного перечисляемого объекта, начиная с позиции start с amount элементами, если доступно
sort(enumerable): Сортирует перечисляемый объект в соответствии с порядком Erlang
sort(enumerable, fun): Сортирует перечисляемый объект по заданной функции
sort_by(enumerable, mapper, sorter \\ &<=/2): Сортирует результаты отображения перечисляемого объекта в соответствии с предоставленной sorter функцией
split(enumerable, count): Разбивает enumerable на два перечисляемых объекта, оставляя count элементов в первом
split_while(enumerable, fun): Разбивает перечисляемый объект на две части в позиции элемента, для которого fun возвращает false в первый раз
split_with(enumerable, fun): Разбивает enumerable на два списка в соответствии с заданной функцией fun
sum(enumerable): Возвращает сумму всех элементов
take(enumerable, count): Берет первые count элементы из перечисляемого объекта
take_every(enumerable, nth): Возвращает список каждого nth элемента в перечисляемом объекте, начиная с первого элемента
take_random(enumerable, count): Берет count случайных элементов из enumerable
take_while(enumerable, fun): Берет элементы с начала перечисляемого объекта, пока fun возвращает истинное значение
to_list(enumerable): Преобразует enumerable в список
uniq(enumerable): Перечисляет enumerable, удаляя все дублируемые элементы
uniq_by(enumerable, fun): Перечисляет enumerable, удаляя элементы, для которых функция fun вернула дублированные элементы
unzip(enumerable): Обратная операция к Enum.zip/2; извлекает кортежи из двух элементов из перечисляемого объекта и группирует их вместе
with_index(enumerable, offset \\ 0): Возвращает перечисляемый объект с каждым элементом, заключенным в кортеж вместе с его индексом
zip(enumerables): Объединяет соответствующие элементы из набора перечисляемых объектов в один список кортежей
zip(enumerable1, enumerable2): Объединяет соответствующие элементы из двух перечисляемых объектов в один список кортежей

Типы

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

Разбивает enum с подробным управлением, когда каждый фрагмент выводится.

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

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

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

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

Примеры

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

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

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

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

drop_every(enumerable, nth)

drop_every(t(), non_neg_integer()) :: list()

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

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

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

Примеры

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

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

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

drop_while(enumerable, fun)

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

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

Примеры

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

each(enumerable, fun)

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

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

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

Примеры

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

empty?(enumerable)

empty?(t()) :: boolean()

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

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

Примеры

iex> Enum.empty?([])
true

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

fetch(enumerable, index)

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

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

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

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

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

Примеры

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

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

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

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

fetch!(enumerable, index)

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

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

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

Примеры

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

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

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

filter(enumerable, fun)

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

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

См. также reject/2, который отбрасывает все элементы, где функция возвращает 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> enum = 1..100
iex> n = 3
iex> Enum.flat_map_reduce(enum, 0, fn i, acc ->
...>   if acc < n, do: {[i], acc + 1}, else: {:halt, acc}
...> end)
{[1, 2, 3], 3}

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

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

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

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

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

Примеры

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

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

intersperse(enumerable, element)

intersperse(t(), element()) :: list()

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

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

Примеры

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

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

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

into(enumerable, collectable)

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

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

Примеры

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

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

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

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

into(enumerable, collectable, transform)

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

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

Примеры

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

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 для каждого 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

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

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

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

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

Примеры

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

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

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

member?(enumerable, element)

member?(t(), element()) :: boolean()

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

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

Примеры

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

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

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

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

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

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

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

Примеры

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

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

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

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

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

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

Примеры

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

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

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

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

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

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

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

Примеры

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

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

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

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

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

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

Примеры

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

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

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

random(enumerable)

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

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

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

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

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

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

Примеры

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

reduce(enumerable, fun)

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

Вызывает fun для каждого элемента в enumerable с накопителем.

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

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

Если вы хотите использовать другое значение для накопителя, используйте Enumerable.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(enumerable, [], 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.

Примеры

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

slice(enumerable, range)

slice(t(), Range.t()) :: list()

Возвращает подмножество списка заданного перечислимого объекта, с range.first по range.last позиции.

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

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

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

Примеры

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

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

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

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

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

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

slice(enumerable, start, amount)

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

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

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

Если start выходит за пределы, возвращается [].

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

Примеры

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

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

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

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

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

sort(enumerable)

sort(t()) :: list()

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

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

Примеры

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

sort(enumerable, fun)

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

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

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

Примеры

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

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

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

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

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

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

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

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

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

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

Примеры

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

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

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

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

split(enumerable, count)

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

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

Если count — отрицательное число, оно начинает счёт с конца перечислимого к началу.

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

Примеры

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

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

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

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

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

split_while(enumerable, fun)

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

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

Примеры

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

split_with(enumerable, fun)

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

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

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

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

Примеры

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

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

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

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

sum(enumerable)

sum(t()) :: number()

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

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

Примеры

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

take(enumerable, count)

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

Берет первые count элементы из перечислимого.

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

Примеры

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

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

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

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

take_every(enumerable, nth)

take_every(t(), non_neg_integer()) :: list()

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

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

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

Примеры

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

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

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

take_random(enumerable, count)

take_random(t(), non_neg_integer()) :: list()

Берет count случайных элементов из enumerable.

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

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

Примеры

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

take_while(enumerable, fun)

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

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

Примеры

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

to_list(enumerable)

to_list(t()) :: [element()]

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

Примеры

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

uniq(enumerable)

uniq(t()) :: list()

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

Примеры

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

uniq_by(enumerable, fun)

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

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

Функция fun отображает каждый элемент в терм. Два элемента считаются дубликатами, если значение, возвращаемое fun, равно для обоих из них.

Сохраняется первое вхождение каждого элемента.

Пример

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

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

unzip(enumerable)

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

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

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

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

Примеры

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

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

with_index(enumerable, offset \\ 0)

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

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

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

Примеры

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

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

zip(enumerables)

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

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

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

Примеры

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

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

zip(enumerable1, enumerable2)

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

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

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

Примеры

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

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