Ключевое слово

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

Примеры

Например, следующий список ключевых слов:

[{:exit_on_close, true}, {:active, :once}, {:packet_size, 1024}]

Elixir предоставляет специальный и более лаконичный синтаксис для списков ключевых слов, который выглядит так:

[exit_on_close: true, active: :once, packet_size: 1024]

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

iex> ["exit on close": true]
["exit on close": true]

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

Дублирование ключей и порядок

Ключ может иметь дублированные ключи, поэтому это не строго тип данных «ключ-значение». Однако большинство функций в этом модуле ведут себя точно так же, как тип «ключ-значение», поэтому они работают аналогично функциям, которые можно найти в модуле Map. Например, Keyword.get/3 получит первую запись, соответствующую заданному ключу, независимо от того, существуют ли дублированные записи. Аналогично, Keyword.put/3 и Keyword.delete/2 гарантируют, что все дублированные записи для заданного ключа будут удалены при вызове. Однако обратите внимание, что операции со списками ключевых слов должны пройтись по списку, чтобы найти ключи, поэтому эти операции медленнее, чем аналогичные операции с картами.

Несколько функций предназначены для обработки дублированных ключей, например, get_values/2 возвращает все значения для заданного ключа, а delete_first/2 удаляет только одну из существующих записей.

Функции в Keyword не гарантируют никаких свойств, когда дело доходит до порядка. Однако, поскольку список ключевых слов — это просто список, все операции, определенные в Enum и List, также могут быть применены, особенно когда требуется порядок.

Большинство функций в этом модуле работают за линейное время. Это означает, что время выполнения операции растёт пропорционально длине списка.

Синтаксис вызова

Когда списки ключевых слов передаются в качестве последнего аргумента функции, квадратные скобки вокруг списка ключевых слов также могут быть опущены. Например, синтаксис списков ключевых слов:

String.split("1-0", "-", [trim: true, parts: 2])

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

String.split("1-0", "-", trim: true, parts: 2)

Поскольку кортежи, списки, карты и другие элементы обрабатываются одинаково при вызовах функций в синтаксисе Elixir, это свойство также доступно для них:

iex> {1, 2, foo: :bar}
{1, 2, [{:foo, :bar}]}

iex> [1, 2, foo: :bar]
[1, 2, {:foo, :bar}]

iex> %{1 => 2, foo: :bar}
%{1 => 2, :foo => :bar}

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

Функции

delete(ключевые слова, ключ): Удаляет записи в списке ключевых слов для определенного key.
delete_first(ключевые слова, ключ): Удаляет первую запись в списке ключевых слов для определенного key.
drop(ключевые слова, ключи): Удаляет заданные ключи из списка ключевых слов.
equal?(левый, правый): Проверяет, равны ли два ключевых слова.
fetch(ключевые слова, ключ): Извлекает значение для определенного key и возвращает его в кортеже.
fetch!(ключевые слова, ключ): Извлекает значение для определенного key.
get(ключевые слова, ключ, значение по умолчанию \\ nil): Получает значение для определенного key.
get_and_update(ключевые слова, ключ, функция): Получает значение из key и обновляет его, все в одном проходе.
get_and_update!(ключевые слова, ключ, функция): Получает значение из key и обновляет его. Вызывает исключение, если key отсутствует.
get_lazy(ключевые слова, ключ, функция): Получает значение для определенного key.
get_values(ключевые слова, ключ): Получает все значения для определенного key.
has_key?(ключевые слова, ключ): Возвращает, существует ли данный key в заданном keywords.
keys(ключевые слова): Возвращает все ключи из списка ключевых слов.
keyword?(термин): Возвращает true, если term является списком ключевых слов; в противном случае возвращает false.
merge(ключевые слова1, ключевые слова2): Объединяет два списка ключевых слов в один.
merge(ключевые слова1, ключевые слова2, функция): Объединяет два списка ключевых слов в один.
new(): Возвращает пустой список ключевых слов, то есть пустой список.
new(пары): Создаёт список ключевых слов из перечисляемого.
new(пары, преобразование): Создаёт список ключевых слов из перечисляемого с помощью функции преобразования.
pop(ключевые слова, ключ, значение по умолчанию \\ nil): Возвращает первое значение для key и удаляет все связанные записи в списке ключевых слов.
pop!(ключевые слова, ключ): Возвращает первое значение для key и удаляет все связанные записи в списке ключевых слов, вызывая исключение, если key отсутствует.
pop_first(ключевые слова, ключ, значение по умолчанию \\ nil): Возвращает и удаляет первое значение, связанное с key в списке ключевых слов.
pop_lazy(ключевые слова, ключ, функция): Лениво возвращает и удаляет все значения, связанные с key в списке ключевых слов.
pop_values(ключевые слова, ключ): Возвращает все значения для key и удаляет все связанные записи в списке ключевых слов.
put(ключевые слова, ключ, значение): Устанавливает данное value по key.
put_new(ключевые слова, ключ, значение): Устанавливает данное value по key, только если запись key ещё не существует.
put_new_lazy(ключевые слова, ключ, функция): Вычисляет fun и помещает результат под key в списке ключевых слов, если key ещё не присутствует.
replace!(ключевые слова, ключ, значение): Изменяет значение, хранящееся под key на value, только если запись key уже существует в keywords.
split(ключевые слова, ключи): Берёт все записи, соответствующие данным ключам, и извлекает их в отдельный список ключевых слов.
take(ключевые слова, ключи): Берёт все записи, соответствующие данным ключам, и возвращает их в новом списке ключевых слов.
to_list(ключевое): Возвращает сам список ключевых слов.
update(ключевые слова, ключ, начальное, функция): Обновляет key в keywords с помощью заданной функции.
update!(ключевые слова, ключ, функция): Обновляет key с помощью заданной функции.
values(ключевые слова): Возвращает все значения из списка ключевых слов.

Типы

key()

Specs

key() :: atom()

t()

Specs

t() :: [{key(), value()}]

t(значение)

Specs

t(value) :: [{key(), value}]

значение()

Specs

value() :: any()

Функции

delete(keywords, key)

Характеристики

delete(t(), key()) :: t()

Удаляет записи в списке ключевых слов для определенного key.

Если key не существует, возвращает список ключевых слов без изменений. Используйте delete_first/2, чтобы удалить только первую запись в случае дублирующихся ключей.

Примеры

iex> Keyword.delete([a: 1, b: 2], :a)
[b: 2]
iex> Keyword.delete([a: 1, b: 2, a: 3], :a)
[b: 2]
iex> Keyword.delete([b: 2], :a)
[b: 2]

delete_first(keywords, key)

Характеристики

delete_first(t(), key()) :: t()

Удаляет первую запись в списке ключевых слов для определенного key.

Если key не существует, возвращает список ключевых слов без изменений.

Примеры

iex> Keyword.delete_first([a: 1, b: 2, a: 3], :a)
[b: 2, a: 3]
iex> Keyword.delete_first([b: 2], :a)
[b: 2]

drop(keywords, keys)

Характеристики

drop(t(), [key()]) :: t()

Удаляет указанные ключи из списка ключевых слов.

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

Примеры

iex> Keyword.drop([a: 1, b: 2, c: 3], [:b, :d])
[a: 1, c: 3]
iex> Keyword.drop([a: 1, b: 2, b: 3, c: 3, a: 5], [:b, :d])
[a: 1, c: 3, a: 5]

equal?(left, right)

Характеристики

equal?(t(), t()) :: boolean()

Проверяет, равны ли два ключевых слова.

Два ключевых слова считаются равными, если они содержат одинаковые ключи и эти ключи содержат одинаковые значения.

Примеры

iex> Keyword.equal?([a: 1, b: 2], [b: 2, a: 1])
true
iex> Keyword.equal?([a: 1, b: 2], [b: 1, a: 2])
false
iex> Keyword.equal?([a: 1, b: 2, a: 3], [b: 2, a: 3, a: 1])
true

fetch(keywords, key)

Характеристики

fetch(t(), key()) :: {:ok, value()} | :error

Извлекает значение для определенного key и возвращает его в кортеже.

Если key не существует, возвращает :error.

Примеры

iex> Keyword.fetch([a: 1], :a)
{:ok, 1}
iex> Keyword.fetch([a: 1], :b)
:error

fetch!(keywords, key)

Характеристики

fetch!(t(), key()) :: value()

Извлекает значение для определенного key.

Если key не существует, возникает KeyError.

Примеры

iex> Keyword.fetch!([a: 1], :a)
1
iex> Keyword.fetch!([a: 1], :b)
** (KeyError) key :b not found in: [a: 1]

get(keywords, key, default \\ nil)

Характеристики

get(t(), key(), value()) :: value()

Получает значение для определенного key.

Если key не существует, возвращает значение по умолчанию (nil если значение по умолчанию не указано).

Если существуют дублирующие записи, возвращается первая. Используйте get_values/2 для получения всех записей.

Примеры

iex> Keyword.get([], :a)
nil
iex> Keyword.get([a: 1], :a)
1
iex> Keyword.get([a: 1], :b)
nil
iex> Keyword.get([a: 1], :b, 3)
3

С дублирующими ключами:

iex> Keyword.get([a: 1, a: 2], :a, 3)
1
iex> Keyword.get([a: 1, a: 2], :b, 3)
3

get_and_update(keywords, key, fun)

Характеристики

get_and_update(t(), key(), (value() -> {get, value()} | :pop)) :: {get, t()}
when get: term()

Получает значение из key и обновляет его за один проход.

Этот аргумент fun получает значение key (или nil если key отсутствует) и должен возвращать кортеж из двух элементов: значение "получить" (полученное значение, которое может быть обработано перед возвратом) и новое значение, которое необходимо сохранить под key. Функция fun также может вернуть :pop, что означает, что текущее значение должно быть удалено из списка ключевых слов и возвращено.

Возвращаемое значение — это кортеж со значением "получить", возвращенным функцией fun, и новым списком ключевых слов с обновленным значением под key.

Примеры

iex> Keyword.get_and_update([a: 1], :a, fn current_value ->
...>   {current_value, "new value!"}
...> end)
{1, [a: "new value!"]}

iex> Keyword.get_and_update([a: 1], :b, fn current_value ->
...>   {current_value, "new value!"}
...> end)
{nil, [b: "new value!", a: 1]}

iex> Keyword.get_and_update([a: 1], :a, fn _ -> :pop end)
{1, []}

iex> Keyword.get_and_update([a: 1], :b, fn _ -> :pop end)
{nil, [a: 1]}

get_and_update!(keywords, key, fun)

Характеристики

get_and_update!(t(), key(), (value() -> {get, value()})) :: {get, t()}
when get: term()

Получает значение из key и обновляет его. Вызывает исключение, если key отсутствует.

Этот аргумент fun получает значение key и должен возвращать кортеж из двух элементов: значение "получить" (полученное значение, которое может быть обработано перед возвратом) и новое значение, которое необходимо сохранить под key.

Примеры

iex> Keyword.get_and_update!([a: 1], :a, fn current_value ->
...>   {current_value, "new value!"}
...> end)
{1, [a: "new value!"]}

iex> Keyword.get_and_update!([a: 1], :b, fn current_value ->
...>   {current_value, "new value!"}
...> end)
** (KeyError) key :b not found in: [a: 1]

iex> Keyword.get_and_update!([a: 1], :a, fn _ ->
...>   :pop
...> end)
{1, []}

get_lazy(keywords, key, fun)

Характеристики

get_lazy(t(), key(), (() -> value())) :: value()

Получает значение для определенного key.

Если key не существует, лениво вычисляет fun и возвращает результат.

Это полезно, если значение по умолчанию очень дорого вычислять или в целом сложно настраивать и разворачивать снова.

Если существуют дублирующие записи, возвращается первая. Используйте get_values/2 для получения всех записей.

Примеры

iex> keyword = [a: 1]
iex> fun = fn ->
...>   # some expensive operation here
...>   13
...> end
iex> Keyword.get_lazy(keyword, :a, fun)
1
iex> Keyword.get_lazy(keyword, :b, fun)
13

get_values(keywords, key)

Характеристики

get_values(t(), key()) :: [value()]

Получает все значения для определенного key.

Примеры

iex> Keyword.get_values([], :a)
[]
iex> Keyword.get_values([a: 1], :a)
[1]
iex> Keyword.get_values([a: 1, a: 2], :a)
[1, 2]

has_key?(keywords, key)

Характеристики

has_key?(t(), key()) :: boolean()

Возвращает, существует ли данный key в данном keywords.

Примеры

iex> Keyword.has_key?([a: 1], :a)
true
iex> Keyword.has_key?([a: 1], :b)
false

keys(keywords)

Характеристики

keys(t()) :: [key()]

Возвращает все ключи из списка ключевых слов.

Дублирующиеся ключи отображаются дважды в конечном списке ключей.

Примеры

iex> Keyword.keys(a: 1, b: 2)
[:a, :b]
iex> Keyword.keys(a: 1, b: 2, a: 3)
[:a, :b, :a]

keyword?(term)

Характеристики

keyword?(term()) :: boolean()

Возвращает true если term является списком ключевых слов; в противном случае возвращает false.

Примеры

iex> Keyword.keyword?([])
true
iex> Keyword.keyword?(a: 1)
true
iex> Keyword.keyword?([{Foo, 1}])
true
iex> Keyword.keyword?([{}])
false
iex> Keyword.keyword?([:key])
false
iex> Keyword.keyword?(%{})
false

merge(keywords1, keywords2)

Характеристики

merge(t(), t()) :: t()

Объединяет два списка ключевых слов в один.

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

Порядок ключей в возвращаемом ключевом слове не гарантируется.

Примеры

iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4])
[b: 2, a: 3, d: 4]

iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4, a: 5])
[b: 2, a: 3, d: 4, a: 5]

iex> Keyword.merge([a: 1], [2, 3])
** (ArgumentError) expected a keyword list as the second argument, got: [2, 3]

merge(keywords1, keywords2, fun)

Характеристики

merge(t(), t(), (key(), value(), value() -> value())) :: t()

Объединяет два списка ключевых слов в один.

Все ключи, включая дублирующиеся ключи, указанные в keywords2 будут добавлены в keywords1. Указанная функция будет вызвана для разрешения конфликтов.

Если keywords2 содержит дублирующиеся ключи, указанная функция будет вызвана для каждой соответствующей пары в keywords1.

Порядок ключей в возвращаемом ключевом слове не гарантируется.

Примеры

iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4], fn _k, v1, v2 ->
...>   v1 + v2
...> end)
[b: 2, a: 4, d: 4]

iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4, a: 5], fn :a, v1, v2 ->
...>   v1 + v2
...> end)
[b: 2, a: 4, d: 4, a: 5]

iex> Keyword.merge([a: 1, b: 2, a: 3], [a: 3, d: 4, a: 5], fn :a, v1, v2 ->
...>   v1 + v2
...> end)
[b: 2, a: 4, d: 4, a: 8]

iex> Keyword.merge([a: 1, b: 2], [:a, :b], fn :a, v1, v2 ->
...>   v1 + v2
...> end)
** (ArgumentError) expected a keyword list as the second argument, got: [:a, :b]

new()

Характеристики

new() :: []

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

Примеры

iex> Keyword.new()
[]

new(pairs)

Характеристики

new(Enum.t()) :: t()

Создает список ключевых слов из перечислимого.

Дублирующие записи удаляются, последнее значение сохраняется. В отличие от Enum.into(enumerable, []), Keyword.new(enumerable) гарантирует уникальность ключей.

Примеры

iex> Keyword.new([{:b, 1}, {:a, 2}])
[b: 1, a: 2]

iex> Keyword.new([{:a, 1}, {:a, 2}, {:a, 3}])
[a: 3]

new(pairs, transform)

Характеристики

new(Enum.t(), (term() -> {key(), value()})) :: t()

Создает список ключевых слов из перечислимого с помощью функции преобразования.

Дублирующие записи удаляются, последнее значение сохраняется. В отличие от Enum.into(enumerable, [], fun), Keyword.new(enumerable, fun) гарантирует уникальность ключей.

Примеры

iex> Keyword.new([:a, :b], fn x -> {x, x} end)
[a: :a, b: :b]

pop(keywords, key, default \\ nil)

Характеристики

pop(t(), key(), value()) :: {value(), t()}

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

Возвращает кортеж, где первый элемент — первое значение для key, а второй элемент — список ключевых слов со всеми записями, связанными с key удаленными. Если key отсутствует в списке ключевых слов, возвращается {default, keyword_list}.

Если вы не хотите удалять все записи, связанные с key , используйте pop_first/3 вместо этого, эта функция удалит только первую запись.

Примеры

iex> Keyword.pop([a: 1], :a)
{1, []}
iex> Keyword.pop([a: 1], :b)
{nil, [a: 1]}
iex> Keyword.pop([a: 1], :b, 3)
{3, [a: 1]}
iex> Keyword.pop([a: 1, a: 2], :a)
{1, []}

pop!(keywords, key)

Характеристики

pop!(t(), key()) :: {value(), t()}

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

Эта функция ведет себя как pop/3, но вызывает исключение в случае, если key отсутствует в заданном keywords.

Примеры

iex> Keyword.pop!([a: 1], :a)
{1, []}
iex> Keyword.pop!([a: 1, a: 2], :a)
{1, []}
iex> Keyword.pop!([a: 1], :b)
** (KeyError) key :b not found in: [a: 1]

pop_first(keywords, key, default \\ nil)

Характеристики

pop_first(t(), key(), value()) :: {value(), t()}

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

Дублированные ключи не удаляются.

Примеры

iex> Keyword.pop_first([a: 1], :a)
{1, []}
iex> Keyword.pop_first([a: 1], :b)
{nil, [a: 1]}
iex> Keyword.pop_first([a: 1], :b, 3)
{3, [a: 1]}
iex> Keyword.pop_first([a: 1, a: 2], :a)
{1, [a: 2]}

pop_lazy(keywords, key, fun)

Характеристики

pop_lazy(t(), key(), (() -> value())) :: {value(), t()}

Лениво возвращает и удаляет все значения, связанные с key в списке ключевых слов.

Это полезно, если значение по умолчанию очень дорого вычисляется или его трудно настроить и разрушить.

Все дублированные ключи удаляются. См. pop_first/3 для удаления только первой записи.

Примеры

iex> keyword = [a: 1]
iex> fun = fn ->
...>   # some expensive operation here
...>   13
...> end
iex> Keyword.pop_lazy(keyword, :a, fun)
{1, []}
iex> Keyword.pop_lazy(keyword, :b, fun)
{13, [a: 1]}

pop_values(keywords, key)

Характеристики

pop_values(t(), key()) :: {[value()], t()}

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

Возвращает кортеж, где первый элемент — список значений для key, а второй элемент — список ключевых слов со всеми записями, связанными с key удалены. Если key отсутствует в списке ключевых слов, возвращается {[], keyword_list}.

Примеры

iex> Keyword.pop_values([a: 1], :a)
{[1], []}
iex> Keyword.pop_values([a: 1], :b)
{[], [a: 1]}
iex> Keyword.pop_values([a: 1, a: 2], :a)
{[1, 2], []}

put(keywords, key, value)

Характеристики

put(t(), key(), value()) :: t()

Размещает указанное value под key.

Если ранее хранилось значение, все записи удаляются, и значение перезаписывается.

Примеры

iex> Keyword.put([a: 1], :b, 2)
[b: 2, a: 1]
iex> Keyword.put([a: 1, b: 2], :a, 3)
[a: 3, b: 2]
iex> Keyword.put([a: 1, b: 2, a: 4], :a, 3)
[a: 3, b: 2]

put_new(keywords, key, value)

Характеристики

put_new(t(), key(), value()) :: t()

Размещает данное value под key , если запись key уже не существует.

Примеры

iex> Keyword.put_new([a: 1], :b, 2)
[b: 2, a: 1]
iex> Keyword.put_new([a: 1, b: 2], :a, 3)
[a: 1, b: 2]

put_new_lazy(keywords, key, fun)

Характеристики

put_new_lazy(t(), key(), (() -> value())) :: t()

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

Это полезно, если значение очень дорого вычисляется или его трудно настроить и разрушить.

Примеры

iex> keyword = [a: 1]
iex> fun = fn ->
...>   # some expensive operation here
...>   3
...> end
iex> Keyword.put_new_lazy(keyword, :a, fun)
[a: 1]
iex> Keyword.put_new_lazy(keyword, :b, fun)
[b: 3, a: 1]

replace!(keywords, key, value)

Характеристики

replace!(t(), key(), value()) :: t()

Изменяет значение, хранящееся под key на value, только если запись key уже существует в keywords.

Если key отсутствует в keywords, возникает исключение KeyError.

Примеры

iex> Keyword.replace!([a: 1, b: 2, a: 3], :a, :new)
[a: :new, b: 2]
iex> Keyword.replace!([a: 1, b: 2, c: 3, b: 4], :b, :new)
[a: 1, b: :new, c: 3]

iex> Keyword.replace!([a: 1], :b, 2)
** (KeyError) key :b not found in: [a: 1]

split(keywords, keys)

Характеристики

split(t(), [key()]) :: {t(), t()}

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

Возвращает кортеж с новым списком и старым списком с удаленными ключами.

Ключи, для которых нет записей в списке ключевых слов, игнорируются.

Записи с дублированными ключами попадают в один и тот же список ключевых слов.

Примеры

iex> Keyword.split([a: 1, b: 2, c: 3], [:a, :c, :e])
{[a: 1, c: 3], [b: 2]}
iex> Keyword.split([a: 1, b: 2, c: 3, a: 4], [:a, :c, :e])
{[a: 1, c: 3, a: 4], [b: 2]}

take(keywords, keys)

Характеристики

take(t(), [key()]) :: t()

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

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

Примеры

iex> Keyword.take([a: 1, b: 2, c: 3], [:a, :c, :e])
[a: 1, c: 3]
iex> Keyword.take([a: 1, b: 2, c: 3, a: 5], [:a, :c, :e])
[a: 1, c: 3, a: 5]

to_list(keyword)

Характеристики

to_list(t()) :: t()

Возвращает сам список ключевых слов.

Примеры

iex> Keyword.to_list(a: 1)
[a: 1]

update(keywords, key, initial, fun)

Характеристики

update(t(), key(), value(), (value() -> value())) :: t()

Обновляет key в keywords с помощью заданной функции.

Если key не существует, вставляет заданное значение initial.

Если есть дублированные ключи, они все удаляются, и обновляется только первый.

Примеры

iex> Keyword.update([a: 1], :a, 13, &(&1 * 2))
[a: 2]
iex> Keyword.update([a: 1, a: 2], :a, 13, &(&1 * 2))
[a: 2]
iex> Keyword.update([a: 1], :b, 11, &(&1 * 2))
[a: 1, b: 11]

update!(keywords, key, fun)

Характеристики

update!(t(), key(), (value() -> value())) :: t()

Обновляет key с помощью заданной функции.

Если key не существует, генерируется исключение KeyError.

Если есть дублированные ключи, они все удаляются, и обновляется только первый.

Примеры

iex> Keyword.update!([a: 1, b: 2, a: 3], :a, &(&1 * 2))
[a: 2, b: 2]
iex> Keyword.update!([a: 1, b: 2, c: 3], :b, &(&1 * 2))
[a: 1, b: 4, c: 3]

iex> Keyword.update!([a: 1], :b, &(&1 * 2))
** (KeyError) key :b not found in: [a: 1]

values(keywords)

Характеристики

values(t()) :: [value()]

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

Значения из дублированных ключей будут сохранены в окончательном списке значений.

Примеры

iex> Keyword.values(a: 1, b: 2)
[1, 2]
iex> Keyword.values(a: 1, b: 2, a: 3)
[1, 2, 3]