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

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

В 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 для примеров и документации.

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

Типы

acc()
default()
element()
index(): Индекс, начинающийся с нуля. Он также может быть отрицательным целым числом.
t()

Функции

all?(enumerable, fun \\ fn x -> x end): Возвращает true если заданная fun возвращает истинное значение (ни false ни nil) для всех элементов в enumerable.
any?(enumerable, fun \\ fn x -> x end): Возвращает true если заданная fun возвращает true для любого из элементов в enumerable.
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 элементы в enumerable.
chunk_while(enumerable, acc, chunk_fun, after_fun): Разбивает перечислимый объект на группы с точным управлением, когда каждая группа выдается.
concat(enumerables): Принимая на вход перечислимый объект перечислимых объектов, объединяет enumerables в один список.
concat(left, right): Объединяет перечислимый объект слева с перечислимым объектом справа.
count(enumerable): Возвращает размер enumerable.
count(enumerable, fun): Возвращает количество элементов в enumerable, для которых fun возвращает истинное значение.
dedup(enumerable): Перечисляет enumerable, возвращая список, где все последовательные дублирующие элементы сводятся к одному элементу.
dedup_by(enumerable, fun): Перечисляет enumerable, возвращая список, где все последовательные дублирующие элементы сводятся к одному элементу.
drop(enumerable, amount): Удаляет amount элементов из enumerable.
drop_every(enumerable, nth): Возвращает список каждого nth элемента в enumerable удаленного, начиная с первого элемента.
drop_while(enumerable, fun): Удаляет элементы в начале enumerable пока fun возвращает истинное значение.
each(enumerable, fun): Вызывает заданную fun для каждого элемента в enumerable.
empty?(enumerable): Определяет, является ли enumerable пустым.
fetch(enumerable, index): Находит элемент по заданному index (нумерация с нуля).
fetch!(enumerable, index): Находит элемент по заданному index (нумерация с нуля).
filter(enumerable, fun): Фильтрация enumerable, т.е. возвращает только те элементы, для которых 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): Разбивает enumerable на группы на основе key_fun.
intersperse(enumerable, element): Вставляет element между каждым элементом перечисления.
into(enumerable, collectable): Вставляет заданный enumerable в collectable.
into(enumerable, collectable, transform): Вставляет заданный enumerable в collectable в соответствии с функцией преобразования.
join(enumerable, joiner \\ ""): Объединяет заданный enumerable в строку, используя joiner в качестве разделителя.
map(enumerable, fun): Возвращает список, где каждый элемент является результатом вызова fun для каждого соответствующего элемента enumerable.
map_every(enumerable, nth, fun): Возвращает список результатов вызова fun для каждого nth элемента enumerable, начиная с первого элемента.
map_join(enumerable, joiner \\ "", mapper): Применяет и объединяет заданный enumerable за один проход.
map_reduce(enumerable, acc, fun): Вызывает заданную функцию для каждого элемента в enumerable для сведения к одному элементу, сохраняя накопитель.
max(enumerable, empty_fallback \\ fn -> raise(Enum.EmptyError) end): Возвращает максимальный элемент в enumerable в соответствии с порядком Erlang.
max_by(enumerable, fun, empty_fallback \\ fn -> raise(Enum.EmptyError) end): Возвращает максимальный элемент в enumerable, вычисленный заданной функцией.
member?(enumerable, element): Проверяет, существует ли element в enumerable.
min(enumerable, empty_fallback \\ fn -> raise(Enum.EmptyError) end): Возвращает минимальный элемент в enumerable в соответствии с порядком Erlang.
min_by(enumerable, fun, empty_fallback \\ fn -> raise(Enum.EmptyError) end): Возвращает минимальный элемент в enumerable, вычисленный заданной функцией.
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): Возвращает случайный элемент из enumerable.
reduce(enumerable, fun): Вызывает fun для каждого элемента в enumerable с накопителем.
reduce(enumerable, acc, fun): Вызывает fun для каждого элемента в enumerable с накопителем.
reduce_while(enumerable, acc, fun): Сводит enumerable пока fun возвращает {:halt, term}.
reject(enumerable, fun): Возвращает список элементов в enumerable за исключением тех, для которых функция fun возвращает истинное значение.
reverse(enumerable): Возвращает список элементов в enumerable в обратном порядке.
reverse(enumerable, tail)

END_OF_DOCUMENT_MARKER

Обращает элементы в enumerable, добавляет tail, и возвращает их как список.
reverse_slice(enumerable, start_index, count): Обращает enumerable в диапазоне от начального start_index до count элементов.
scan(enumerable, fun): Применяет данную функцию к каждому элементу в enumerable, сохраняя результат в списке и передавая его как накопитель для следующего вычисления. Использует первый элемент в enumerable в качестве начального значения.
scan(enumerable, acc, fun): Применяет данную функцию к каждому элементу в enumerable, сохраняя результат в списке и передавая его как накопитель для следующего вычисления. Использует заданное acc значение в качестве начального значения.
shuffle(enumerable): Возвращает список со случайным порядком элементов enumerable.
slice(enumerable, index_range): Возвращает подмножество списка заданного enumerable по index_range.
slice(enumerable, start_index, amount): Возвращает подмножество списка заданного enumerable, начиная с start_index (нумерация с нуля) с amount количеством элементов, если доступно.
sort(enumerable): Сортирует enumerable согласно порядку Erlang.
sort(enumerable, fun): Сортирует enumerable с помощью заданной функции.
sort_by(enumerable, mapper, sorter \\ &<=/2): Сортирует результаты отображения enumerable в соответствии с предоставленной функцией sorter.
split(enumerable, count): Разделяет enumerable на два перечисляемых объекта, оставив count элементов в первом.
split_while(enumerable, fun): Разделяет перечисляемый объект на две части в позиции элемента, для которого fun возвращает ложное значение (false или nil).
split_with(enumerable, fun): Разделяет enumerable на два списка в соответствии с заданной функцией fun.
sum(enumerable): Возвращает сумму всех элементов.
take(enumerable, amount): Берет первые amount элементы из enumerable.
take_every(enumerable, nth): Возвращает список каждого nth элемента в enumerable, начиная с первого элемента.
take_random(enumerable, count): Берет count случайных элементов из enumerable.
take_while(enumerable, fun): Берет элементы с начала enumerable до тех пор, пока fun возвращает истинное значение.
to_list(enumerable): Преобразует enumerable в список.
uniq(enumerable): Перечисляет enumerable, удаляя все дублированные элементы.
uniq_by(enumerable, fun): Перечисляет enumerable, удаляя элементы, для которых функция fun возвращает дублированные элементы.
unzip(enumerable): Обратное к zip/2. Извлекает кортежи из двух элементов из заданного enumerable и группирует их вместе.
with_index(enumerable, offset \\ 0): Возвращает enumerable с каждым элементом, обернутым в кортеж вместе с его индексом.
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 оценивается как истинное значение (ни false , ни nil) для всех элементов в enumerable.

Итерация останавливается при первом вызове, возвращающем либо 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

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

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 оценивается как истинное значение для любого из элементов в enumerable.

Итерация останавливается при первом вызове, возвращающем истинное значение (ни 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

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

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 находит последний элемент).

Примеры

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 элементов в enumerable.

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

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

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

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

Примеры

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

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

Эта функция производит тот же результат, что и оператор 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()

Возвращает размер enumerable.

Примеры

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

count(enumerable, fun)

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

Возвращает количество элементов в enumerable, для которых 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 элементов из enumerable.

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

Первый элемент всегда пропускается, если 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()

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

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

Примеры

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

empty?(enumerable)

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

Определяет, пуст ли enumerable.

Возвращает 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 извлекает последний элемент).

Примеры

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

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

Вызывает исключение OutOfBoundsError если заданный index выходит за пределы диапазона enumerable.

Примеры

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

Фильтрует enumerable, т.е. возвращает только те элементы, для которых 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
    # transform to integer
    {int, _rest} -> [int]
    # skip the value
    :error -> []
  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()

Разделяет enumerable на группы на основе key_fun.

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

Примеры

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.

Обратите внимание, что передача непустого списка в качестве collectable устарела. Если вы собираете в непустой список ключевых слов, рассмотрите использование Keyword.merge/2. Если вы собираете в непустой список, рассмотрите что-то вроде to_list(enumerable) ++ collectable.

Примеры

iex> Enum.into([1, 2], [])
[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()

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

Если joiner не передаётся, он по умолчанию равен пустой строке.

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

Примеры

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

Преобразует и объединяет заданный enumerable за один проход.

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

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

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

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

Возвращает максимальный элемент в enumerable в соответствии с порядком 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
when empty_result: any()

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

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

Примеры

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

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

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

member?(enumerable, element)

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

Проверяет, существует ли element в enumerable.

Членство проверяется с помощью оператора совпадения (===/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
when empty_result: any()

Возвращает минимальный элемент в enumerable в соответствии с порядком 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
when empty_result: any()

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

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

Примеры

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

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

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

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

Вызывает 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 пуст.

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

Редукция как строительный блок

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

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

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

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

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

reduce_while(enumerable, acc, fun)

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

Уменьшает enumerable до тех пор, пока fun не вернёт {:halt, term}.

Возвращаемое значение для fun ожидается следующим:

{:cont, acc} для продолжения уменьшения с acc в качестве нового аккумулятора или
{:halt, acc} для прекращения уменьшения

Если fun возвращает {:halt, acc}, уменьшение прекращается, и функция возвращает acc. В противном случае, если перечисление исчерпано, функция возвращает аккумулятор последнего {:cont, acc}.

Примеры

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

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_index, count)

reverse_slice(t(), non_neg_integer(), non_neg_integer()) :: list()

Инвертирует enumerable в диапазоне от начального start_index до count элементов.

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

Примеры

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

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

Примеры

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

scan(enumerable, acc, fun)

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

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

Примеры

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

shuffle(enumerable)

shuffle(t()) :: list()

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

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

Примеры

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

(с 1.6.0)

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

Возвращает подмножество списка из заданного enumerable с помощью index_range.

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

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

Если index_range.last выходит за пределы, он присваивается как индекс последнего элемента.

Если нормализованный index_range.first выходит за пределы заданного enumerable, или этот индекс больше нормализованного index_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 indexes)
iex> Enum.slice(1..30, -5..-1)
[26, 27, 28, 29, 30]

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

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

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

slice(enumerable, start_index, amount)

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

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

Дано enumerable, опускаются элементы перед элементом start_index, затем берётся amount элементов, возвращая столько элементов, сколько возможно, если их недостаточно.

Возвращает [] если amount равен 0 или если start_index выходит за пределы.

Примеры

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 index
iex> Enum.slice(1..10, 10, 5)
[]

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

sort(enumerable)

sort(t()) :: list()

Сортирует enumerable в соответствии с порядком Erlang.

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

Примеры

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

sort(enumerable, fun)

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

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

Эта функция использует алгоритм слияния. Заданная функция должна сравнивать два аргумента и возвращать 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()

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

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

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

Примеры

Используя стандартное значение по умолчанию <=/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 или nil) в первый раз.

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

Примеры

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

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

iex> Enum.split_while([1, 2, 3, 4], fn x -> x > 0 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 элементы из enumerable.

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

Примеры

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

Первый элемент всегда включается, если только 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()

Возвращает элементы с начала enumerable до тех пор, пока 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()]}

Обратная функция zip/2. Извлекает кортежи из двух элементов из данного enumerable и группирует их вместе.

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

Эта функция терпит неудачу, если 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()}]

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

Если задан 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)

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