Список

Функции, работающие со (связанными) списками.

Списки в Elixir задаются в квадратных скобках:

iex> [1, "two", 3, :four]
[1, "two", 3, :four]

Два списка могут быть конкатенированы и вычтены, используя операторы Kernel.++/2 и Kernel.--/2:

iex> [1, 2, 3] ++ [4, 5, 6]
[1, 2, 3, 4, 5, 6]
iex> [1, true, 2, false, 3, true] -- [true, false]
[1, 2, 3, true]

Списки в Elixir фактически являются связанными списками, что означает, что они внутренне представлены парами, содержащими голову и хвост списка:

iex> [head | tail] = [1, 2, 3]
iex> head
1
iex> tail
[2, 3]

Аналогично, мы можем записать список [1, 2, 3], используя только такие пары (называемые ячейками конс):

iex> [1 | [2 | [3 | []]]]
[1, 2, 3]

Некоторые списки, называемые несобственными списками, не имеют пустого списка в качестве второго элемента в последней ячейке конс:

iex> [1 | [2 | [3 | 4]]]
[1, 2, 3 | 4]

Хотя несобственные списки обычно избегают, они используются в некоторых особых случаях, таких как сущности iodata и chardata (см. модуль IO).

Из-за их представления на основе ячеек конс, добавление элемента в начало списка всегда быстро (постоянное время), а добавление в конец становится медленнее по мере увеличения размера списка (линейное время):

iex> list = [1, 2, 3]
iex> [0 | list]   # fast
[0, 1, 2, 3]
iex> list ++ [4]  # slow
[1, 2, 3, 4]

Модуль Kernel содержит множество функций для работы со списками и разрешённых в охранных условиях. Например, Kernel.hd/1 для получения головы, Kernel.tl/1 для получения хвоста и Kernel.length/1 для расчёта длины. Имейте в виду, что, аналогично добавлению в конец списка, вычисление длины требует обхода всего списка.

Список символов

Если список состоит из целых чисел без знака, его также можно назвать списком символов. Elixir использует одинарные кавычки для определения списков символов:

iex> 'héllo'
[104, 233, 108, 108, 111]

В частности, списки символов могут быть напечатаны в одинарных кавычках, если они содержат только напечатываемые символы ASCII:

iex> 'abc'
'abc'

Причина этого поведения заключается в лучшей поддержке библиотек Erlang, которые могут возвращать текст как списки символов вместо строк Elixir. Одним из таких примеров является функция Application.loaded_applications/0:

Application.loaded_applications
#=>  [{:stdlib, 'ERTS  CXC 138 10', '2.6'},
      {:compiler, 'ERTS  CXC 138 10', '6.0.1'},
      {:elixir, 'elixir', '1.0.0'},
      {:kernel, 'ERTS  CXC 138 10', '4.1'},
      {:logger, 'logger', '1.0.0'}]

Модули списков и перечислений

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

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

Резюме

Функции

delete(list, item): Удаляет заданный item из list. Возвращает новый список без элемента.
delete_at(list, index): Создаёт новый список, удалив значение по указанному index.
duplicate(elem, n): Дублирует заданный элемент n раз в списке.
first(list): Возвращает первый элемент в list или nil, если list пустой.
flatten(list): Разворачивает данный list вложенных списков.
flatten(list, tail): Разворачивает данный list вложенных списков. Список tail будет добавлен в конец развернутого списка.
foldl(list, acc, function): Складывает (сводит) данный список слева с помощью функции. Требуется накопитель.
foldr(list, acc, function): Складывает (сводит) данный список справа с помощью функции. Требуется накопитель.
insert_at(list, index, value): Возвращает список с value вставленным по указанному index.
keydelete(list, key, position): Принимает list кортежей и удаляет первый кортеж, где элемент по position соответствует заданному key. Возвращает новый список.
keyfind(list, key, position, default \\ nil): Принимает список кортежей и возвращает первый кортеж, где элемент по position в кортеже соответствует заданному key.
keymember?(list, key, position): Принимает список кортежей и возвращает true , если существует кортеж, где элемент по position в кортеже соответствует заданному key.
keyreplace(list, key, position, new_tuple): Принимает список кортежей и заменяет элемент, определяемый key по position , если он существует.
keysort(list, position): Принимает список кортежей и сортирует элементы по position кортежей. Сортировка стабильная.
keystore(list, key, position, new_tuple): Принимает list кортежей и заменяет элемент, определяемый key по position.
keytake(list, key, position): Принимает list кортежей и возвращает первый кортеж, где элемент по position в кортеже соответствует заданному key, а также list без найденного кортежа.
last(list): Возвращает последний элемент в list или nil , если list пустой.
myers_difference(list1, list2): Возвращает список ключевых слов, представляющий сценарий редактирования.
pop_at(list, index, default \\ nil): Возвращает и удаляет значение по указанному index в list.
replace_at(list, index, value): Возвращает список с заменённым значением по указанному index.
to_atom(charlist): Преобразует список символов в атом.
to_existing_atom(charlist): Преобразует список символов в существующий атом. Возбуждает ArgumentError, если атом не существует.
to_float(charlist): Возвращает число с плавающей запятой, текстовое представление которого charlist.
to_integer(charlist): Возвращает целое число, текстовое представление которого charlist.
to_integer(charlist, base): Возвращает целое число, текстовое представление которого charlist в системе счисления base.
to_string(list): Преобразует список целых чисел, представляющих код символов, списки или строки в строку.
to_tuple(list): Преобразует список в кортеж.
update_at(list, index, fun): Возвращает список с обновлённым значением по указанному index.
wrap(list): Оборачивает аргумент в список.
zip(list_of_lists): Запаковывает соответствующие элементы из каждого списка в list_of_lists.

Функции

delete(list, item)

delete(list(), any()) :: list()

Удаляет заданный item из list. Возвращает новый список без элемента.

Если item встречается более одного раза в list, удаляется только первое вхождение.

Примеры

iex> List.delete([:a, :b, :c], :a)
[:b, :c]

iex> List.delete([:a, :b, :b, :c], :b)
[:a, :b, :c]

delete_at(list, index)

delete_at(list(), integer()) :: list()

Создаёт новый список, удалив значение по указанному index.

Отрицательные индексы указывают смещение от конца list . Если index выходит за пределы, возвращается исходный list.

Примеры

iex> List.delete_at([1, 2, 3], 0)
[2, 3]

iex> List.delete_at([1, 2, 3], 10)
[1, 2, 3]

iex> List.delete_at([1, 2, 3], -1)
[1, 2]

duplicate(elem, n)

duplicate(elem, non_neg_integer()) :: [elem] when elem: var

Дублирует заданный элемент n раз в списке.

Примеры

iex> List.duplicate("hello", 3)
["hello", "hello", "hello"]

iex> List.duplicate([1, 2], 2)
[[1, 2], [1, 2]]

first(list)

first([elem]) :: nil | elem when elem: var

Возвращает первый элемент в list или nil , если list пустой.

Примеры

iex> List.first([])
nil

iex> List.first([1])
1

iex> List.first([1, 2, 3])
1

flatten(list)

flatten(deep_list) :: list() when deep_list: [any() | deep_list]

Выравнивает заданный list вложенных списков.

Примеры

iex> List.flatten([1, [[2], 3]])
[1, 2, 3]

flatten(list, tail)

flatten(deep_list, [elem]) :: [elem] when deep_list: [elem | deep_list], elem: var

Выравнивает заданный list вложенных списков. Список tail будет добавлен в конец выровненного списка.

Примеры

iex> List.flatten([1, [[2], 3]], [4, 5])
[1, 2, 3, 4, 5]

foldl(list, acc, function)

foldl([elem], acc, (elem, acc -> acc)) :: acc when elem: var, acc: var

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

Примеры

iex> List.foldl([5, 5], 10, fn(x, acc) -> x + acc end)
20

iex> List.foldl([1, 2, 3, 4], 0, fn(x, acc) -> x - acc end)
2

foldr(list, acc, function)

foldr([elem], acc, (elem, acc -> acc)) :: acc when elem: var, acc: var

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

Примеры

iex> List.foldr([1, 2, 3, 4], 0, fn(x, acc) -> x - acc end)
-2

insert_at(list, index, value)

insert_at(list(), integer(), any()) :: list()

Возвращает список с value вставленным по указанному index.

Обратите внимание, что index ограничен длиной списка. Отрицательные индексы указывают смещение от конца list.

Примеры

iex> List.insert_at([1, 2, 3, 4], 2, 0)
[1, 2, 0, 3, 4]

iex> List.insert_at([1, 2, 3], 10, 0)
[1, 2, 3, 0]

iex> List.insert_at([1, 2, 3], -1, 0)
[1, 2, 3, 0]

iex> List.insert_at([1, 2, 3], -10, 0)
[0, 1, 2, 3]

keydelete(list, key, position)

keydelete([tuple()], any(), non_neg_integer()) :: [tuple()]

Получает list кортежей и удаляет первый кортеж, где элемент в position соответствует заданному key. Возвращает новый список.

Примеры

iex> List.keydelete([a: 1, b: 2], :a, 0)
[b: 2]

iex> List.keydelete([a: 1, b: 2], 2, 1)
[a: 1]

iex> List.keydelete([a: 1, b: 2], :c, 0)
[a: 1, b: 2]

keyfind(list, key, position, default \\ nil)

keyfind([tuple()], any(), non_neg_integer(), any()) :: any()

Получает список кортежей и возвращает первый кортеж, где элемент в position в кортеже соответствует заданному key.

Примеры

iex> List.keyfind([a: 1, b: 2], :a, 0)
{:a, 1}

iex> List.keyfind([a: 1, b: 2], 2, 1)
{:b, 2}

iex> List.keyfind([a: 1, b: 2], :c, 0)
nil

keymember?(list, key, position)

keymember?([tuple()], any(), non_neg_integer()) :: boolean()

Получает список кортежей и возвращает true, если существует кортеж, где элемент в position в кортеже соответствует заданному key.

Примеры

iex> List.keymember?([a: 1, b: 2], :a, 0)
true

iex> List.keymember?([a: 1, b: 2], 2, 1)
true

iex> List.keymember?([a: 1, b: 2], :c, 0)
false

keyreplace(list, key, position, new_tuple)

keyreplace([tuple()], any(), non_neg_integer(), tuple()) :: [tuple()]

Получает список кортежей и заменяет элемент, определяемый key в position.

Примеры

iex> List.keyreplace([a: 1, b: 2], :a, 0, {:a, 3})
[a: 3, b: 2]

keysort(list, position)

keysort([tuple()], non_neg_integer()) :: [tuple()]

Получает список кортежей и сортирует элементы в position кортежей. Сортировка стабильная.

Примеры

iex> List.keysort([a: 5, b: 1, c: 3], 1)
[b: 1, c: 3, a: 5]

iex> List.keysort([a: 5, c: 1, b: 3], 0)
[a: 5, b: 3, c: 1]

keystore(list, key, position, new_tuple)

keystore([tuple()], any(), non_neg_integer(), tuple()) :: [tuple(), ...]

Получает list кортежей и заменяет элемент, определяемый key в position.

Если элемент не существует, он добавляется в конец list.

Примеры

iex> List.keystore([a: 1, b: 2], :a, 0, {:a, 3})
[a: 3, b: 2]

iex> List.keystore([a: 1, b: 2], :c, 0, {:c, 3})
[a: 1, b: 2, c: 3]

keytake(list, key, position)

keytake([tuple()], any(), non_neg_integer()) ::
  {tuple(), [tuple()]} |
  nil

Получает list кортежей и возвращает первый кортеж, где элемент в position в кортеже соответствует заданному key, а также list без найденного кортежа.

Если такой кортеж не найден, nil будет возвращено.

Примеры

iex> List.keytake([a: 1, b: 2], :a, 0)
{{:a, 1}, [b: 2]}

iex> List.keytake([a: 1, b: 2], 2, 1)
{{:b, 2}, [a: 1]}

iex> List.keytake([a: 1, b: 2], :c, 0)
nil

last(list)

last([elem]) :: nil | elem when elem: var

Возвращает последний элемент в list или nil если list пустой.

Примеры

iex> List.last([])
nil

iex> List.last([1])
1

iex> List.last([1, 2, 3])
3

myers_difference(list1, list2)

myers_difference(list(), list()) ::
  [{:eq | :ins | :del, list()}] |
  nil

Возвращает список ключевых слов, представляющий сценарий редактирования.

Алгоритм описан в статье «An O(ND) Difference Algorithm and Its Variations» Э. Майерса.

Сценарий редактирования — это список ключевых слов. Каждый ключ описывает «действие редактирования», которое необходимо выполнить, чтобы приблизить list1 к равенству с list2; ключ может быть :eq, :ins, или :del. Каждое значение — это подсписок list1 или list2, который нужно вставить (если соответствующий ключ :ins ), удалить (если соответствующий ключ — :del ), или оставить без изменений (если соответствующий ключ — :eq ) в list1 , чтобы приблизиться к list2.

Примеры

iex> List.myers_difference([1, 4, 2, 3], [1, 2, 3, 4])
[eq: [1], del: [4], eq: [2, 3], ins: [4]]

pop_at(list, index, default \\ nil)

pop_at(list(), integer(), any()) :: {any(), list()}

Возвращает и удаляет значение по указанному index в list.

Отрицательные индексы указывают смещение от конца list Если index выходит за пределы, возвращается исходное list.

Примеры

iex> List.pop_at([1, 2, 3], 0)
{1, [2, 3]}
iex> List.pop_at([1, 2, 3], 5)
{nil, [1, 2, 3]}
iex> List.pop_at([1, 2, 3], 5, 10)
{10, [1, 2, 3]}
iex> List.pop_at([1, 2, 3], -1)
{3, [1, 2]}

replace_at(list, index, value)

replace_at(list(), integer(), any()) :: list()

Возвращает список с изменённым значением по указанному index.

Примеры

iex> List.replace_at([1, 2, 3], 0, 0)
[0, 2, 3]

iex> List.replace_at([1, 2, 3], 10, 0)
[1, 2, 3]

iex> List.replace_at([1, 2, 3], -1, 0)
[1, 2, 0]

iex> List.replace_at([1, 2, 3], -10, 0)
[1, 2, 3]

to_atom(charlist)

to_atom(charlist()) :: atom()

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

В настоящее время Elixir не поддерживает преобразования из списков символов, содержащих символы Юникода, большие чем 0xFF.

Встроенный компилятором.

Примеры

iex> List.to_atom('elixir')
:elixir

to_existing_atom(charlist)

to_existing_atom(charlist()) :: atom()

Преобразует список символов в существующий атом. Вызывает ArgumentError, если атом не существует.

Встроенный компилятором.

Примеры

iex> _ = :my_atom
iex> List.to_existing_atom('my_atom')
:my_atom

iex> List.to_existing_atom('this_atom_will_never_exist')
** (ArgumentError) argument error

to_float(charlist)

to_float(charlist()) :: float()

Возвращает число с плавающей точкой, текстовое представление которого charlist.

Встроенный компилятором.

Примеры

iex> List.to_float('2.2017764e+0')
2.2017764

to_integer(charlist)

to_integer(charlist()) :: integer()

Возвращает целое число, текстовое представление которого charlist.

Встроенный компилятором.

Примеры

iex> List.to_integer('123')
123

to_integer(charlist, base)

to_integer(charlist(), 2..36) :: integer()

Возвращает целое число, текстовое представление которого charlist в системе счисления base.

Встроенный компилятором.

Примеры

iex> List.to_integer('3FF', 16)
1023

to_string(list)

to_string(:unicode.charlist()) :: String.t()

Преобразует список целых чисел, представляющих кодовые точки, списки или строки в строку.

Обратите внимание, что эта функция ожидает список целых чисел, представляющих кодовые точки UTF-8. Если у вас есть список байтов, необходимо использовать модуль :binary.

Примеры

iex> List.to_string([0x00E6, 0x00DF])
"æß"

iex> List.to_string([0x0061, "bc"])
"abc"

to_tuple(list)

to_tuple(list()) :: tuple()

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

Встроенный компилятором.

Примеры

iex> List.to_tuple([:share, [:elixir, 163]])
{:share, [:elixir, 163]}

update_at(list, index, fun)

update_at([elem], integer(), (elem -> any())) :: list() when elem: var

Возвращает список с обновлённым значением по указанному index.

Отрицательные индексы указывают смещение от конца list Если index выходит за пределы, возвращается исходный list.

Примеры

iex> List.update_at([1, 2, 3], 0, &(&1 + 10))
[11, 2, 3]

iex> List.update_at([1, 2, 3], 10, &(&1 + 10))
[1, 2, 3]

iex> List.update_at([1, 2, 3], -1, &(&1 + 10))
[1, 2, 13]

iex> List.update_at([1, 2, 3], -10, &(&1 + 10))
[1, 2, 3]

wrap(list)

wrap(list() | any()) :: list()

Оборачивает аргумент в список.

Если аргумент уже список, возвращает список. Если аргумент nil, возвращает пустой список.

Примеры

iex> List.wrap("hello")
["hello"]

iex> List.wrap([1, 2, 3])
[1, 2, 3]

iex> List.wrap(nil)
[]

zip(list_of_lists)

zip([list()]) :: [tuple()]

Заархивирует соответствующие элементы из каждого списка в list_of_lists.

Архивирование завершается, как только завершается любой список.

Примеры

iex> List.zip([[1, 2], [3, 4], [5, 6]])
[{1, 3, 5}, {2, 4, 6}]

iex> List.zip([[1, 2], [3], [5, 6]])
[{1, 3, 5}]