Список

Связные списки содержат ноль, один или более элементов в выбранном порядке.

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

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

Два списка могут быть конкатенированы и вычтены с помощью операторов ++/2 и --/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]

Элемент может быть добавлен в начало списка с помощью |:

iex> new = 0
iex> list = [1, 2, 3]
iex> [new | list]
[0, 1, 2, 3]

Списки в 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]

Большинство функций в этом модуле работают за линейное время. Это означает, что время выполнения операции растет с той же скоростью, что и длина списка. Например, length/1 и last/1 будут выполняться за линейное время, потому что им нужно перебрать каждый элемент списка, но first/1 будет выполняться за постоянное время, потому что ему нужен только первый элемент.

Списки также реализуют протокол Enumerable, поэтому многие функции для работы со списками находятся в модуле Enum. Кроме того, следующие функции и операторы для списков находятся в Kernel:

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

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

быть в диапазоне 0..0x10FFFF (0..1_114_111);
и быть вне диапазона 0xD800..0xDFFF (55_296..57_343), который зарезервирован в Юникоде для пар суррогатов UTF-16.

Elixir использует одинарные кавычки для определения списков символов:

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

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

iex> 'abc'
'abc'

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

iex> inspect('abc', charlists: :as_list)
"[97, 98, 99]"
iex> Enum.map('abc', fn num -> 1000 + num end)
[1097, 1098, 1099]

Вы можете использовать помощник IEx.Helpers.i/1, чтобы получить краткое описание списков символов в IEx, когда вы их встретите, в котором отображаются тип, описание и также исходное представление в одном обзоре.

Причина такого поведения — лучше поддерживать библиотеки Erlang, которые могут возвращать текст в виде списков символов вместо строк Elixir. В 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'}
#=>  ]

Можно проверить, состоит ли список только из печатаемых символов ASCII, с помощью ascii_printable?/2.

Несобственные списки никогда не считаются списками символов.

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

Функции

ascii_printable?(list, limit \\ :infinity): Проверяет, является ли list списком символов, состоящим только из печатаемых символов ASCII.
delete(list, element): Удаляет заданный element из list. Возвращает новый список без элемента.
delete_at(list, index): Создаёт новый список, удаляя значение по указанному index.
duplicate(elem, n): Дублирует данный элемент n раз в списке.
first(list, default \\ nil): Возвращает первый элемент в list или default, если list пустой.
flatten(list): Разворачивает данный list вложенных списков.
flatten(list, tail): Разворачивает данный list вложенных списков. Список tail будет добавлен в конец развёрнутого списка.
foldl(list, acc, fun): Складывает (сокращает) заданный список слева с помощью функции. Требует накопитель, который может быть любым значением.
foldr(list, acc, fun): Складывает (сокращает) заданный список справа с помощью функции. Требует накопитель, который может быть любым значением.
improper?(list): Возвращает true, если list является несобственным списком. В противном случае возвращает false.
insert_at(list, index, value): Возвращает список с value, вставленным по указанному index.
keydelete(list, key, position): Получает list кортежей и удаляет первый кортеж, где элемент по position соответствует заданному key. Возвращает новый список.
keyfind(list, key, position, default \\ nil): Получает список кортежей и возвращает первый кортеж, где элемент по position в кортеже соответствует заданному key.
keyfind!(list, key, position): Получает список кортежей и возвращает первый кортеж, где элемент по position в кортеже соответствует заданному key.
keymember?(list, key, position): Получает список кортежей и возвращает true, если существует кортеж, где элемент по position в кортеже соответствует заданному key.
keyreplace(list, key, position, new_tuple): Получает список кортежей и, если идентифицированный элемент с key по position существует, заменяет его на new_tuple.
keysort(list, position, sorter \\ :asc): Получает список кортежей и сортирует элементы по position кортежей.
keystore(list, key, position, new_tuple): Получает list кортежей и заменяет элемент, идентифицируемый key по position на new_tuple.
keytake(list, key, position): Получает list кортежей и возвращает первый кортеж, где элемент по position в кортеже соответствует заданному key, а также list без найденного кортежа.
last(list, default \\ nil): Возвращает последний элемент в list или default, если list пустой.
myers_difference(list1, list2): Возвращает список ключевых слов, представляющих сценарий редактирования.
myers_difference(list1, list2, diff_script): Возвращает список ключевых слов, представляющих сценарий редактирования со вложенными различиями.
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_charlist(list): Преобразует список целых чисел, представляющих кодовые точки Unicode, списки или строки в список символов.
to_existing_atom(charlist): Преобразует список символов в существующий атом.
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(term): Оборачивает term в список, если это не список.
zip(list_of_lists): Сцепляет соответствующие элементы из каждого списка в list_of_lists.

END_OF_DOCUMENT_MARKER

Функции

ascii_printable?(list, limit \\ :infinity)Source

@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 - Эскапирование

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

Примеры

iex> List.ascii_printable?('abc')
true

iex> List.ascii_printable?('abc' ++ [0])
false

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

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

iex> List.ascii_printable?('abc' ++ ?d)
false

delete(list, element)Source

@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)
[]

delete_at(list, index)Source

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

duplicate(elem, n)Source

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

first(list, default \\ nil)Source

@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

flatten(list)Source

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

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

Элементы пустых списков отбрасываются.

Примеры

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

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

flatten(list, tail)Source

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

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

Элементы пустых списков из 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]

foldl(list, acc, fun)Source

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

foldr(list, acc, fun)Source

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

improper?(list)Source

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

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

Примеры

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

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

insert_at(list, index, value)Source

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

keydelete(list, key, position)Source

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

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

@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"}

keyfind!(list, key, position)Source

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

Если соответствующий кортеж не найден, генерируется ошибка.

Примеры

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

keymember?(list, key, position)Source

@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

keyreplace(list, key, position, new_tuple)Source

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

END_OF_DOCUMENT_MARKER

keysort(list, position, sorter \\ :asc)Source

@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, сортировщик может быть анонимной функцией, атомами :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]}
]

keystore(list, key, position, new_tuple)Source

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

keytake(list, key, position)Source

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

last(list, default \\ nil)Source

@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

myers_difference(list1, list2)Source

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

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

Алгоритм описан в статье "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]]

myers_difference(list1, list2, diff_script)Source

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

pop_at(list, index, default \\ nil)Source

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

replace_at(list, index, value)Source

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

@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

to_atom(charlist)Source

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

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

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

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

Примеры

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

iex> List.to_atom('🌢 Elixir')
:"🌢 Elixir"

to_charlist(list)Source

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

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

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

Примеры

iex> List.to_charlist([0x00E6, 0x00DF])
'æß'

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

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

to_existing_atom(charlist)Source

@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('my_atom')
:my_atom

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

to_float(charlist)Source

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

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

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

Примеры

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

to_integer(charlist)Source

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

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

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

Примеры

iex> List.to_integer('123')
123

to_integer(charlist, base)Source

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

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

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

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

Примеры

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

to_string(list)Source

@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", ['p']])
"deep"

iex> List.to_string([])
""

to_tuple(list)Source

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

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

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

Примеры

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

update_at(list, index, fun)Source

@spec 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(term)Source

@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)
[]

zip(list_of_lists)Source

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