Список

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

Списки в 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] используя только такие пары (называемые ячейками cons):

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

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

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

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

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

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
starts_with?(list, prefix): Возвращает true если list начинается с заданного prefix списка; в противном случае возвращает false
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

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

Алгоритм описан в статье «Алгоритм различий O(ND) и его вариации» Э. Майерса.

Скрипт редактирования — это список ключевых слов. Каждый ключ описывает «действие редактирования», которое необходимо выполнить, чтобы приблизить 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]

starts_with?(list, prefix)

starts_with?(list(), list()) :: boolean()

starts_with?(list(), []) :: true

starts_with?([], [...]) :: false

Возвращает true если list начинается с заданного prefix списка; в противном случае возвращает false.

Если prefix пустой список, то возвращает true.

Примеры

iex> List.starts_with?([1, 2, 3], [1, 2])
true

iex> List.starts_with?([1, 2], [1, 2, 3])
false

iex> List.starts_with?([:alpha], [])
true

iex> List.starts_with?([], [:alpha])
false

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.

Примеры

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