Список

@spec ascii_printable?(list(), 0) :: true

@spec ascii_printable?([], limit) :: true when limit: :infinity | pos_integer()

@spec ascii_printable?([...], limit) :: boolean()
when limit: :infinity | pos_integer()

Проверяет, является ли list списком символов, состоящим только из печатаемых символов ASCII.

Принимает необязательный limit в качестве второго аргумента. ascii_printable?/2 проверяет только печатаемость элементов списка до limit.

Печатаемый список символов в Elixir содержит только печатаемые символы в стандартном семибитовом кодировании ASCII, которые являются символами от 32 до 126 в десятичной записи, плюс следующие управляющие символы:

• ?\a - Звонок
• ?\b - Возврат на одну позицию назад
• ?\t - Горизонтальная табуляция
• ?\n - Перевод строки
• ?\v - Вертикальная табуляция
• ?\f - Форматирование страницы
• ?\r - Возврат каретки
• ?\e - Эскапирование

Для получения дополнительной информации ознакомьтесь с разделом Характерные группы в статье Википедии о стандарте ASCII.

Примеры

iex> List.ascii_printable?(~c"abc")
true

iex> List.ascii_printable?(~c"abc" ++ [0])
false

iex> List.ascii_printable?(~c"abc" ++ [0], 2)
true

Неправильные списки не являются печатаемыми, даже если они состоят только из символов ASCII:

iex> List.ascii_printable?(~c"abc" ++ ?d)
false

@spec delete([], any()) :: []

@spec delete([...], any()) :: list()

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

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

Примеры

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

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

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

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

@spec 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]

@spec duplicate(any(), 0) :: []

@spec duplicate(elem, pos_integer()) :: [elem, ...] when elem: var

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

n - целое число, большее или равное 0.

Если n равно 0, возвращается пустой список.

Примеры

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

iex> List.duplicate("hi", 1)
["hi"]

iex> List.duplicate("bye", 2)
["bye", "bye"]

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

@spec first([], any()) :: any()

@spec first([elem, ...], any()) :: elem when elem: var

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

first/2 был введён в Elixir v1.12.0, в то время как first/1 доступен с v1.0.0.

Примеры

iex> List.first([])
nil

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

iex> List.first([1])
1

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

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

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

Элементы списка со значением nil отбрасываются.

Примеры

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

iex> List.flatten([[], [[], []]])
[]

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

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

Элементы списка со значением nil из list отбрасываются, но не из tail.

Примеры

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

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

@spec 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

iex> List.foldl([1, 2, 3], {0, 0}, fn x, {a1, a2} -> {a1 + x, a2 - x} end)
{6, -6}

@spec 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

iex> List.foldr([1, 2, 3, 4], %{sum: 0, product: 1}, fn x, %{sum: a1, product: a2} -> %{sum: a1 + x, product: a2 * x} end)
%{product: 24, sum: 10}

@spec improper?(maybe_improper_list()) :: boolean()

Возвращает true если list является несобственным списком. В противном случае возвращает false.

Примеры

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

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

@spec 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]

@spec 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]

Эта функция работает для любого списка кортежей:

iex> List.keydelete([{22, "SSH"}, {80, "HTTP"}], 80, 0)
[{22, "SSH"}]

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

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

Если такой кортеж не найден, возвращается default.

Примеры

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

Эта функция работает для любого списка кортежей:

iex> List.keyfind([{22, "SSH"}, {80, "HTTP"}], 22, 0)
{22, "SSH"}

@spec keyfind!([tuple()], any(), non_neg_integer()) :: 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)
** (KeyError) key :c at position 0 not found in: [a: 1, b: 2]

Эта функция работает для любого списка кортежей:

iex> List.keyfind!([{22, "SSH"}, {80, "HTTP"}], 22, 0)
{22, "SSH"}

@spec 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

Эта функция работает для любого списка кортежей:

iex> List.keymember?([{22, "SSH"}, {80, "HTTP"}], 22, 0)
true

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

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

Примеры

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

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

Эта функция работает для любого списка кортежей:

iex> List.keyreplace([{22, "SSH"}, {80, "HTTP"}], 22, 0, {22, "Secure Shell"})
[{22, "Secure Shell"}, {80, "HTTP"}]

@spec keysort(
  [tuple()],
  non_neg_integer(),
  (any(), any() -> boolean())
  | :asc
  | :desc
  | module()
  | {:asc | :desc, module()}
) :: [tuple()]

Принимает список кортежей и сортирует элементы в позиции position кортежей.

Сортировка устойчивая.

Аргумент sorter доступен начиная с Elixir v1.14.0. Аналогично Enum.sort/2, sorter может быть анонимной функцией, атомами :asc или :desc, или модулем, реализующим функцию сравнения.

Примеры

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]

Для сортировки в порядке убывания:

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

Как и в Enum.sort/2, избегайте использования функции по умолчанию для сортировки структур, так как по умолчанию она выполняет структурное сравнение вместо семантического. В таких случаях необходимо передать функцию сортировки как третий элемент или любой модуль, реализующий функцию compare/2. Например, если у вас есть кортежи с именами пользователей и их датами рождения, и вы хотите отсортировать их по дате рождения, как по возрастанию, так и по убыванию, вы должны сделать следующее:

iex> users = [
...>   {"Ellis", ~D[1943-05-11]},
...>   {"Lovelace", ~D[1815-12-10]},
...>   {"Turing", ~D[1912-06-23]}
...> ]
iex> List.keysort(users, 1, Date)
[
  {"Lovelace", ~D[1815-12-10]},
  {"Turing", ~D[1912-06-23]},
  {"Ellis", ~D[1943-05-11]}
]
iex> List.keysort(users, 1, {:desc, Date})
[
  {"Ellis", ~D[1943-05-11]},
  {"Turing", ~D[1912-06-23]},
  {"Lovelace", ~D[1815-12-10]}
]

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

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

Если элемент не существует, он добавляется в конец 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]

Эта функция работает для любого списка кортежей:

iex> List.keystore([{22, "SSH"}], 80, 0, {80, "HTTP"})
[{22, "SSH"}, {80, "HTTP"}]

@spec 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

Эта функция работает для любого списка кортежей:

iex> List.keytake([{22, "SSH"}, {80, "HTTP"}], 80, 0)
{{80, "HTTP"}, [{22, "SSH"}]}

@spec last([], any()) :: any()

@spec last([elem, ...], any()) :: elem when elem: var

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

last/2 была введена в Elixir v1.12.0, а last/1 — с v1.0.0.

Примеры

iex> List.last([])
nil

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

iex> List.last([1])
1

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

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

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

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

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

См. myers_difference/3, если вы хотите обработать вложенные сценарии разницы.

Примеры

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

@spec myers_difference(list(), list(), (term(), term() -> script | nil)) :: script
when script: [{:eq | :ins | :del | :diff, list()}]

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

Это расширение myers_difference/2, где может быть передана функция diff_script, если требуется вычисление вложенных различий. Функция может вернуть список с внутренним сценарием редактирования или nil в случае отсутствия такого сценария. Возвращаемый внутренний сценарий редактирования будет под ключом :diff.

Примеры

iex> List.myers_difference(["a", "db", "c"], ["a", "bc"], &String.myers_difference/2)
[eq: ["a"], diff: [del: "d", eq: "b", ins: "c"], del: ["c"]]

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

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

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

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

Примеры

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]

@spec starts_with?([...], [...]) :: boolean()

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

@spec 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

@spec to_atom(charlist()) :: atom()

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

Elixir поддерживает преобразования из списков символов, которые содержат любые символы Юникода.

Встраивается компилятором.

Примеры

iex> List.to_atom(~c"Elixir")
:Elixir

iex> List.to_atom(~c"🌢 Elixir")
:"🌢 Elixir"

@spec to_charlist(:unicode.charlist()) :: charlist()

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

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

Примеры

iex> ~c"æß" = List.to_charlist([0x00E6, 0x00DF])
[230, 223]

iex> List.to_charlist([0x0061, "bc"])
~c"abc"

iex> List.to_charlist([0x0064, "ee", [~c"p"]])
~c"deep"

@spec to_existing_atom(charlist()) :: atom()

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

Elixir поддерживает преобразования из списков символов, которые содержат любые кодовые точки Юникода. Возбуждает исключение ArgumentError, если атом не существует.

Встраивается компилятором.

Атомы и модули

Поскольку Elixir — это компилируемый язык, атомы, определённые в модуле, существуют только после загрузки указанного модуля, что обычно происходит при выполнении функции в модуле. Поэтому рекомендуется вызывать List.to_existing_atom/1 только для преобразования атомов, определённых в модуле, вызывающем to_existing_atom/1.

Примеры

iex> _ = :my_atom
iex> List.to_existing_atom(~c"my_atom")
:my_atom

iex> _ = :"🌢 Elixir"
iex> List.to_existing_atom(~c"🌢 Elixir")
:"🌢 Elixir"

@spec to_float(charlist()) :: float()

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

Встраивается компилятором.

Примеры

iex> List.to_float(~c"2.2017764e+0")
2.2017764

@spec to_integer(charlist()) :: integer()

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

Встраивается компилятором.

Примеры

iex> List.to_integer(~c"123")
123

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

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

Встраивается компилятором.

Основание должно быть между 2 и 36.

Примеры

iex> List.to_integer(~c"3FF", 16)
1023

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

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

Для преобразования в строку список должен быть пустым или содержать только следующие элементы:

• строки
• целые числа, представляющие кодовые точки Юникода
• список, содержащий один из этих трёх элементов

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

Примеры

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

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

iex> List.to_string([0x0064, "ee", [~c"p"]])
"deep"

iex> List.to_string([])
""

@spec to_tuple(list()) :: tuple()

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

Встраивается компилятором.

Примеры

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

@spec 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]

@spec wrap(term()) :: maybe_improper_list()

Оборачивает term в список, если это не список.

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

Примеры

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

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

iex> List.wrap(nil)
[]

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