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

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

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

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

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

Примеры

iex> Keyword.drop([a: 1, a: 2], [:a])
[]
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]

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

Сравнение значений выполняется с помощью ===/3, что означает, что целые числа не эквивалентны числам с плавающей точкой:

iex> Keyword.equal?([a: 1.0], [a: 1])
false

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

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

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

Примеры

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

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

@spec filter(t(), ({key(), value()} -> as_boolean(term()))) :: t()

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

См. также reject/2, который отбрасывает все записи, где функция возвращает истинное значение.

Примеры

iex> Keyword.filter([one: 1, two: 2, three: 3], fn {_key, val} -> rem(val, 2) == 1 end)
[one: 1, three: 3]

@spec from_keys([key()], value()) :: t(value())

Создает ключевое слово из заданных keys и фиксированного value.

Примеры

iex> Keyword.from_keys([:foo, :bar, :baz], :atom)
[foo: :atom, bar: :atom, baz: :atom]
iex> Keyword.from_keys([], :atom)
[]

@spec get(t(), key(), default()) :: value() | default()

Получает значение под заданным 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

@spec get_and_update(t(), key(), (value() | nil ->
                              {current_value, new_value :: value()} | :pop)) ::
  {current_value, new_keywords :: t()}
when current_value: value()

Получает значение из 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: 2], :a, fn number ->
...>   {2 * number, 3 * number}
...> end)
{4, [a: 6]}

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

@spec get_and_update!(t(), key(), (value() ->
                               {current_value, new_value :: value()} | :pop)) ::
  {current_value, new_keywords :: t()}
when current_value: value()

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

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

Возвращает кортеж, содержащий текущее значение, возвращенное 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)
** (KeyError) key :b not found in: [a: 1]

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

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

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

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

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

Примеры

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

@spec intersect(keyword(), keyword(), (key(), value(), value() -> value())) ::
  keyword()

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

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

Примеры

iex> Keyword.intersect([a: 1, b: 2], [b: "b", c: "c"])
[b: "b"]

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

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

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

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

Примеры

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

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

iex> Keyword.keys([{:a, 1}, {"b", 2}, {:c, 3}])
** (ArgumentError) expected a keyword list, but an entry in the list is not a two-element tuple with an atom as its first element, got: {"b", 2}

@spec keyword?(term()) :: boolean()

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

Когда term является списком, он обрабатывается до конца.

Примеры

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

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

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

@spec new() :: []

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

Примеры

iex> Keyword.new()
[]

@spec new(Enumerable.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]

@spec new(Enumerable.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]

@spec pop(t(), key(), default()) :: {value() | default(), 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, []}

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

@spec pop_first(t(), key(), default()) :: {value() | default(), 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]}

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

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

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

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

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

Примеры

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

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

Помещает заданное value под указанный key.

Если значение под 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]

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

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

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

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

Примеры

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

@spec reject(t(), ({key(), value()} -> as_boolean(term()))) :: t()

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

См. также filter/2.

Примеры

iex> Keyword.reject([one: 1, two: 2, three: 3], fn {_key, val} -> rem(val, 2) == 1 end)
[two: 2]

@spec replace(t(), key(), value()) :: t()

Помещает значение под key только если key уже существует в keywords.

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

Примеры

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

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

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

Устанавливает значение по ключу key только если ключ 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]

@spec replace_lazy(t(), key(), (existing_value :: value() -> new_value :: value())) ::
  t()

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

В отличие от replace/3, это может быть полезно, когда вычисление значения ресурсоёмко.

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

Примеры

iex> Keyword.replace_lazy([a: 1, b: 2], :a, fn v -> v * 4 end)
[a: 4, b: 2]

iex> Keyword.replace_lazy([a: 2, b: 2, a: 1], :a, fn v -> v * 4 end)
[a: 8, b: 2]

iex> Keyword.replace_lazy([a: 1, b: 2], :c, fn v -> v * 4 end)
[a: 1, b: 2]

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

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

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

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

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

Примеры

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

@spec split_with(t(), ({key(), value()} -> as_boolean(term()))) :: {t(), t()}

Разделяет список ключевых слов keywords на два списка ключевых слов в соответствии с заданной функцией fun.

Предоставленная функция fun получает каждую пару «ключ-значение» в списке {key, value} в качестве единственного аргумента. Возвращает кортеж с первым списком ключевых слов, содержащим все элементы из keywords, для которых применение keywords возвращает истинное значение, и второй список ключевых слов со всеми элементами, для которых применение fun возвращает ложное значение (fun или false).

Примеры

iex> Keyword.split_with([a: 1, b: 2, c: 3], fn {_k, v} -> rem(v, 2) == 0 end)
{[b: 2], [a: 1, c: 3]}

iex> Keyword.split_with([a: 1, b: 2, c: 3, b: 4], fn {_k, v} -> rem(v, 2) == 0 end)
{[b: 2, b: 4], [a: 1, c: 3]}

iex> Keyword.split_with([a: 1, b: 2, c: 3, b: 4], fn {k, v} -> k in [:a, :c] and rem(v, 2) == 0 end)
{[], [a: 1, b: 2, c: 3, b: 4]}

iex> Keyword.split_with([], fn {_k, v} -> rem(v, 2) == 0 end)
{[], []}

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

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

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

Примеры

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]

@spec to_list(t()) :: t()

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

Примеры

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

@spec update(t(), key(), default :: value(), (existing_value :: value() ->
                                          new_value :: value())) :: t()

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

Если ключ key не существует, вставляет заданное значение default. Не передает значение default через функцию обновления.

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

Примеры

iex> Keyword.update([a: 1], :a, 13, fn existing_value -> existing_value * 2 end)
[a: 2]

iex> Keyword.update([a: 1, a: 2], :a, 13, fn existing_value -> existing_value * 2 end)
[a: 2]

iex> Keyword.update([a: 1], :b, 11, fn existing_value -> existing_value * 2 end)
[a: 1, b: 11]

@spec update!(t(), key(), (current_value :: value() -> new_value :: value())) :: t()

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

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

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

Примеры

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]

@spec validate(
  keyword(),
  values :: [atom() | {atom(), term()}]
) :: {:ok, keyword()} | {:error, [atom()]}

Проверяет, что у данного списка ключевых слов keyword есть только ключи из values.

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

Если в списке ключевых слов есть только заданные ключи, возвращает список {:ok, keyword} с применёнными значениями по умолчанию. Иначе возвращает список {:error, invalid_keys} с недопустимыми ключами.

См. также: validate!/2.

Примеры

iex> {:ok, result} = Keyword.validate([], [one: 1, two: 2])
iex> Enum.sort(result)
[one: 1, two: 2]

iex> {:ok, result} = Keyword.validate([two: 3], [one: 1, two: 2])
iex> Enum.sort(result)
[one: 1, two: 3]

Если передаются атомы, они поддерживаются в качестве ключей, но не предоставляют значение по умолчанию:

iex> {:ok, result} = Keyword.validate([], [:one, two: 2])
iex> Enum.sort(result)
[two: 2]

iex> {:ok, result} = Keyword.validate([one: 1], [:one, two: 2])
iex> Enum.sort(result)
[one: 1, two: 2]

Передача неизвестных ключей возвращает ошибку:

iex> Keyword.validate([three: 3, four: 4], [one: 1, two: 2])
{:error, [:four, :three]}

Передача одного и того же ключа несколько раз также возвращает ошибку:

iex> Keyword.validate([one: 1, two: 2, one: 1], [:one, :two])
{:error, [:one]}

@spec validate!(
  keyword(),
  values :: [atom() | {atom(), term()}]
) :: keyword()

Аналогично validate/2, но возвращает список ключевых слов или генерирует ошибку.

Примеры

iex> Keyword.validate!([], [one: 1, two: 2]) |> Enum.sort()
[one: 1, two: 2]
iex> Keyword.validate!([two: 3], [one: 1, two: 2]) |> Enum.sort()
[one: 1, two: 3]

Если передаются атомы, они поддерживаются в качестве ключей, но не предоставляют значение по умолчанию:

iex> Keyword.validate!([], [:one, two: 2]) |> Enum.sort()
[two: 2]
iex> Keyword.validate!([one: 1], [:one, two: 2]) |> Enum.sort()
[one: 1, two: 2]

Передача неизвестных ключей генерирует ошибку:

iex> Keyword.validate!([three: 3], [one: 1, two: 2])
** (ArgumentError) unknown keys [:three] in [three: 3], the allowed keys are: [:one, :two]

Передача одного и того же ключа несколько раз также генерирует ошибку:

iex> Keyword.validate!([one: 1, two: 2, one: 1], [:one, :two])
** (ArgumentError) duplicate keys [:one] in [one: 1, two: 2, one: 1]

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

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

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

Примеры

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