Source Map

Карты являются основной структурой данных «ключ-значение» в Elixir.

Карты могут быть созданы с помощью синтаксиса %{} и пары «ключ-значение» могут быть выражены как key => value:

iex> %{}
%{}
iex> %{"one" => :two, 3 => "four"}
%{3 => "four", "one" => :two}

Пары «ключ-значение» в карте не следуют никакому порядку (поэтому распечатанная карта в примере выше имеет другой порядок, чем карта, которая была создана).

Карты не накладывают никаких ограничений на тип ключа: любой элемент может быть ключом в карте. Как структура «ключ-значение», карты не допускают дублирующих ключей. Ключи сравниваются с использованием оператора точного равенства (===/2). Если в литерале карты определены конфликтующие ключи, то последний из них преобладает.

Когда ключ в паре «ключ-значение» является атомом, может использоваться сокращенный синтаксис key: value (как и во многих других специальных формах):

iex> %{a: 1, b: 2}
%{a: 1, b: 2}

Если вы хотите смешать сокращенный синтаксис с =>, сокращенный синтаксис должен стоять в конце:

iex> %{"hello" => "world", a: 1, b: 2}
%{:a => 1, :b => 2, "hello" => "world"}

Доступ к ключам в картах можно получить с помощью некоторых функций в этом модуле (таких как Map.get/3 или Map.fetch/2) или с помощью синтаксиса map[], предоставленного модулем Access:

iex> map = %{a: 1, b: 2}
iex> Map.fetch(map, :a)
{:ok, 1}
iex> map[:b]
2
iex> map["non_existing_key"]
nil

Для доступа к атомным ключам можно также использовать обозначение map.key. Обратите внимание, что map.key вызовет исключение KeyError, если map не содержит ключ :key, по сравнению с map[:key], которое вернет nil.

map = %{foo: "bar", baz: "bong"}
map.foo
#=> "bar"
map.non_existing_key
** (KeyError) key :non_existing_key not found in: %{baz: "bong", foo: "bar"}

Избегайте скобок

Не добавляйте скобки при доступе к полям, как в data.key(). Если используются скобки, Elixir будет ожидать, что data будет атомом, представляющим модуль, и попытается вызвать функцию key/0 в нем.

Два синтаксиса для доступа к ключам показывают двойственную природу карт. Синтаксис map[key] используется для динамически создаваемых карт, которые могут иметь любой ключ любого типа. map.key используется с картами, которые содержат предопределенный набор атомных ключей, которые, как ожидается, всегда будут присутствовать. Структуры, определенные с помощью defstruct/1, являются одним из примеров таких «статических карт», где ключи также могут проверяться во время компиляции.

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

iex> %{} = %{foo: "bar"}
%{foo: "bar"}
iex> %{a: a} = %{:a => 1, "b" => 2, [:c, :e, :e] => 3}
iex> a
1

Но это вызовет исключение MatchError:

%{:c => 3} = %{:a => 1, 2 => :b}

Переменные могут использоваться в качестве ключей карты как при записи литералов карты, так и при сопоставлении:

iex> n = 1
1
iex> %{n => :one}
%{1 => :one}
iex> %{^n => :one} = %{1 => :one, 2 => :two, 3 => :three}
%{1 => :one, 2 => :two, 3 => :three}

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

iex> map = %{one: 1, two: 2}
iex> %{map | one: "one"}
%{one: "one", two: 2}

Или любой другой ключ:

iex> other_map = %{"three" => 3, "four" => 4}
iex> %{other_map | "three" => "three"}
%{"four" => 4, "three" => "three"}

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

%{map | three: 3}

Функции в этом модуле, которым необходимо найти определенный ключ, работают за логарифмическое время. Это означает, что время, необходимое для поиска ключей, увеличивается по мере роста карты, но оно не прямо пропорционально размеру карты. По сравнению с поиском элемента в списке, он работает лучше, потому что списки имеют линейную временную сложность. Некоторые функции, такие как keys/1 и values/1, работают за линейное время, потому что им нужно добраться до каждого элемента в карте.

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

map_size/1

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

Функции

delete(map, key): Удаляет запись в map для конкретного key.
drop(map, keys): Удаляет заданные keys из map.
equal?(map1, map2): Проверяет, равны ли две карты.
fetch(map, key): Извлекает значение для конкретного key в заданной map.
fetch!(map, key): Извлекает значение для конкретного key в заданной map, вызывая ошибку, если map не содержит key.
filter(map, fun): Возвращает карту, содержащую только те пары из map, для которых fun возвращает истинное значение.
from_keys(keys, value): Создает карту из заданных keys и фиксированного value.
from_struct(struct): Преобразует struct в карту.
get(map, key, default \\ nil): Получает значение для конкретного key в map.
get_and_update(map, key, fun): Получает значение из key и обновляет его за один проход.
get_and_update!(map, key, fun): Получает значение из key и обновляет его за один проход. Вызывает ошибку, если нет key.
get_lazy(map, key, fun): Получает значение для конкретного key в map.
has_key?(map, key): Возвращает, существует ли данный key в заданной map.
intersect(map1, map2): Пересекает две карты, возвращая карту с общими ключами.
intersect(map1, map2, fun): Пересекает две карты, возвращая карту с общими ключами и разрешая конфликты с помощью функции.
keys(map): Возвращает все ключи из map.
merge(map1, map2): Объединяет две карты в одну.
merge(map1, map2, fun): Объединяет две карты в одну, разрешая конфликты с помощью заданной fun.
new(): Возвращает новую пустую карту.
new(enumerable): Создает карту из enumerable.
new(enumerable, transform): Создает карту из enumerable с помощью заданной функции преобразования.
pop(map, key, default \\ nil): Удаляет значение, связанное с key в map, и возвращает значение и обновленную карту.
pop!(map, key): Удаляет значение, связанное с key в map, и возвращает значение и обновленную карту, или вызывает ошибку, если key отсутствует.
pop_lazy(map, key, fun): Лениво возвращает и удаляет значение, связанное с key в map.
put(map, key, value): Помещает заданное value под key в map.
put_new(map, key, value): Помещает заданное value под key, если запись key ещё не существует в map.
put_new_lazy(map, key, fun): Вычисляет fun и помещает результат под key в map, если key ещё не присутствует.
reject(map, fun): Возвращает карту, исключая пары из map, для которых fun возвращает истинное значение.
replace(map, key, value): Помещает значение под key, только если key уже существует в map.
replace!(map, key, value): Помещает значение под key, только если key уже существует в map.
replace_lazy(map, key, fun): Заменяет значение под key с помощью данной функции, только если key уже существует в map.
split(map, keys): Берёт все записи, соответствующие заданным keys в map, и извлекает их в отдельную карту.
split_with(map, fun): Разделяет map на две карты в соответствии с заданной функцией fun.
take(map, keys): Возвращает новую карту со всеми парами ключ-значение в map, где ключ находится в keys.
to_list(map): Преобразует map в список.
update(map, key, default, fun): Обновляет key в map с помощью данной функции.
update!(map, key, fun): Обновляет key с помощью данной функции.
values(map): Возвращает все значения из map.

Типы

key()Source

@type key() :: any()

value()Source

@type value() :: any()

Функции

delete(map, key)Source

@spec delete(map(), key()) :: map()

Удаляет запись в map для указанного key.

Если key не существует, возвращает map без изменений.

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

Примеры

iex> Map.delete(%{a: 1, b: 2}, :a)
%{b: 2}
iex> Map.delete(%{b: 2}, :a)
%{b: 2}

drop(map, keys)Source

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

Удаляет заданные keys из map.

Если keys содержит ключи, которых нет в map, они просто игнорируются.

Примеры

iex> Map.drop(%{a: 1, b: 2, c: 3}, [:b, :d])
%{a: 1, c: 3}

equal?(map1, map2)Source

@spec equal?(map(), map()) :: boolean()

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

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

Обратите внимание, что эта функция существует для полноты, поэтому модули Map и Keyword предоставляют аналогичные API. На практике разработчики часто сравнивают карты, используя ==/2 или ===/2 напрямую.

Примеры

iex> Map.equal?(%{a: 1, b: 2}, %{b: 2, a: 1})
true
iex> Map.equal?(%{a: 1, b: 2}, %{b: 1, a: 2})
false

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

iex> Map.equal?(%{a: 1.0}, %{a: 1})
false

fetch(map, key)Source

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

Извлекает значение для указанного key в заданной map.

Если map содержит заданный key, то его значение возвращается в виде {:ok, value}. Если map не содержит key, возвращается :error.

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

Примеры

iex> Map.fetch(%{a: 1}, :a)
{:ok, 1}
iex> Map.fetch(%{a: 1}, :b)
:error

fetch!(map, key)Source

@spec fetch!(map(), key()) :: value()

Извлекает значение для указанного key в заданной map, выдавая ошибку, если map не содержит key.

Если map содержит key, возвращается соответствующее значение. Если map не содержит key, возникает исключение KeyError.

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

Примеры

iex> Map.fetch!(%{a: 1}, :a)
1

filter(map, fun)Source

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

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

fun получает ключ и значение каждого из элементов карты в виде пары ключ-значение.

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

Соображения производительности

Если вы обнаружите, что делаете несколько вызовов Map.filter/2 и Map.reject/2 в конвейере, вероятно, будет эффективнее использовать Enum.map/2 и Enum.filter/2 вместо этого и преобразовать в карту в конце, используя Map.new/1.

Примеры

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

from_keys(keys, value)Source

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

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

Примеры

iex> Map.from_keys([1, 2, 3], :number)
%{1 => :number, 2 => :number, 3 => :number}

from_struct(struct)Source

@spec from_struct(atom() | struct()) :: map()

Преобразует struct в карту.

Он принимает модуль структуры или саму структуру и просто удаляет поле __struct__ из данной структуры или из новой структуры, созданной из данного модуля.

Пример

defmodule User do
  defstruct [:name]
end

Map.from_struct(User)
#=> %{name: nil}

Map.from_struct(%User{name: "john"})
#=> %{name: "john"}

get(map, key, default \\ nil)Source

@spec get(map(), key(), value()) :: value()

Получает значение для указанного key в map.

Если key присутствует в map, возвращается его значение value. В противном случае возвращается default.

Если default не указано, используется nil.

Примеры

iex> Map.get(%{}, :a)
nil
iex> Map.get(%{a: 1}, :a)
1
iex> Map.get(%{a: 1}, :b)
nil
iex> Map.get(%{a: 1}, :b, 3)
3
iex> Map.get(%{a: nil}, :a, 1)
nil

get_and_update(map, key, fun)Source

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

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

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

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

Примеры

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

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

iex> Map.get_and_update(%{a: 1}, :a, fn _ -> :pop end)
{1, %{}}

iex> Map.get_and_update(%{a: 1}, :b, fn _ -> :pop end)
{nil, %{a: 1}}

get_and_update!(map, key, fun)Source

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

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

Ведет себя точно так же, как get_and_update/3, но вызывает исключение KeyError, если key отсутствует в map.

Примеры

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

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

iex> Map.get_and_update!(%{a: 1}, :a, fn _ ->
...>   :pop
...> end)
{1, %{}}

get_lazy(map, key, fun)Source

@spec get_lazy(map(), key(), (-> value())) :: value()

Получает значение для указанного key в map.

Если key присутствует в map, возвращается его значение value. В противном случае вычисляется fun и возвращается его результат.

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

Примеры

iex> map = %{a: 1}
iex> fun = fn ->
...>   # some expensive operation here
...>   13
...> end
iex> Map.get_lazy(map, :a, fun)
1
iex> Map.get_lazy(map, :b, fun)
13

has_key?(map, key)Source

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

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

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

Примеры

iex> Map.has_key?(%{a: 1}, :a)
true
iex> Map.has_key?(%{a: 1}, :b)
false

intersect(map1, map2)Source

@spec intersect(map(), map()) :: map()

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

Значения в возвращаемой карте являются значениями пересекающихся ключей в map2.

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

Примеры

iex> Map.intersect(%{a: 1, b: 2}, %{b: "b", c: "c"})
%{b: "b"}

intersect(map1, map2, fun)Source

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

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

Заданная функция будет вызвана при наличии дублирующихся ключей; её аргументами являются key (дублирующийся ключ), value1 (значение key в map1) и value2 (значение key в map2). Значение, возвращаемое fun, используется в качестве значения под key в результирующей карте.

Примеры

iex> Map.intersect(%{a: 1, b: 2}, %{b: 2, c: 3}, fn _k, v1, v2 ->
...>   v1 + v2
...> end)
%{b: 4}

keys(map)Source

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

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

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

Примеры

Map.keys(%{a: 1, b: 2})
[:a, :b]

merge(map1, map2)Source

@spec merge(map(), map()) :: map()

Объединяет две карты в одну.

Все ключи в map2 будут добавлены в map1, перезаписывая любые существующие (т.е., ключи в map2 имеют приоритет над ключами в map1).

Если у вас есть структура и вы хотите добавить набор ключей в структуру, не используйте эту функцию, так как она объединит все ключи в правой части со структурой, даже если ключ не является частью структуры. Вместо этого используйте struct/2.

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

Примеры

iex> Map.merge(%{a: 1, b: 2}, %{a: 3, d: 4})
%{a: 3, b: 2, d: 4}

merge(map1, map2, fun)Source

@spec merge(map(), map(), (key(), value(), value() -> value())) :: map()

Объединяет две карты в одну, разрешая конфликты с помощью заданной fun.

Все ключи в map2 будут добавлены в map1. Заданная функция будет вызвана при наличии дублирующихся ключей; её аргументами являются key (дублирующийся ключ), value1 (значение key в map1) и value2 (значение key в map2). Значение, возвращаемое fun, используется в качестве значения под key в результирующей карте.

Примеры

iex> Map.merge(%{a: 1, b: 2}, %{a: 3, d: 4}, fn _k, v1, v2 ->
...>   v1 + v2
...> end)
%{a: 4, b: 2, d: 4}

new()Source

@spec new() :: map()

Возвращает новую пустую карту.

Примеры

iex> Map.new()
%{}

new(enumerable)Source

@spec new(Enumerable.t()) :: map()

Создает карту из enumerable.

Дублирующиеся ключи удаляются; последний ключ сохраняется.

Примеры

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

new(enumerable, transform)Source

@spec new(Enumerable.t(), (term() -> {key(), value()})) :: map()

Создает карту из enumerable с помощью заданной функции преобразования.

Дублирующиеся ключи удаляются; последний ключ сохраняется.

Примеры

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

iex> Map.new(%{a: 2, b: 3, c: 4}, fn {key, val} -> {key, val * 2} end)
%{a: 4, b: 6, c: 8}

pop(map, key, default \\ nil)Source

@spec pop(map(), key(), default) :: {value(), updated_map :: map()} | {default, map()}
when default: value()

Удаляет значение, связанное с key в map и возвращает значение и обновленную карту.

Если key присутствует в map, возвращается {value, updated_map}, где value — значение ключа, а updated_map — результат удаления key из map. Если key отсутствует в map, возвращается {default, map}.

Примеры

iex> Map.pop(%{a: 1}, :a)
{1, %{}}
iex> Map.pop(%{a: 1}, :b)
{nil, %{a: 1}}
iex> Map.pop(%{a: 1}, :b, 3)
{3, %{a: 1}}

pop!(map, key)Source

@spec pop!(map(), key()) :: {value(), updated_map :: map()}

Удаляет значение, связанное с key в map и возвращает значение и обновленную карту, или вызывает исключение, если key отсутствует.

Ведет себя так же, как pop/3, но вызывает исключение, если key отсутствует в map.

Примеры

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

pop_lazy(map, key, fun)Source

@spec pop_lazy(map(), key(), (-> value())) :: {value(), map()}

Лениво возвращает и удаляет значение, связанное с key в map.

Если key присутствует в map, возвращается {value, new_map}, где value — значение ключа, а new_map — результат удаления key из map. Если key отсутствует в map, возвращается {fun_result, map}, где fun_result — результат применения fun.

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

Примеры

iex> map = %{a: 1}
iex> fun = fn ->
...>   # some expensive operation here
...>   13
...> end
iex> Map.pop_lazy(map, :a, fun)
{1, %{}}
iex> Map.pop_lazy(map, :b, fun)
{13, %{a: 1}}

put(map, key, value)Source

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

Помещает заданное value под key в map.

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

Примеры

iex> Map.put(%{a: 1}, :b, 2)
%{a: 1, b: 2}
iex> Map.put(%{a: 1, b: 2}, :a, 3)
%{a: 3, b: 2}

put_new(map, key, value)Source

@spec put_new(map(), key(), value()) :: map()

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

Примеры

iex> Map.put_new(%{a: 1}, :b, 2)
%{a: 1, b: 2}
iex> Map.put_new(%{a: 1, b: 2}, :a, 3)
%{a: 1, b: 2}

put_new_lazy(map, key, fun)Source

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

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

Эта функция полезна, если вы хотите вычислить значение для помещения под key только если key ещё не присутствует, например, когда значение дорого вычисляется или его сложно настроить и снова демонтировать.

Примеры

iex> map = %{a: 1}
iex> fun = fn ->
...>   # some expensive operation here
...>   3
...> end
iex> Map.put_new_lazy(map, :a, fun)
%{a: 1}
iex> Map.put_new_lazy(map, :b, fun)
%{a: 1, b: 3}

reject(map, fun)Source

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

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

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

Примеры

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

replace(map, key, value)Source

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

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

Примеры

iex> Map.replace(%{a: 1, b: 2}, :a, 3)
%{a: 3, b: 2}

iex> Map.replace(%{a: 1}, :b, 2)
%{a: 1}

replace!(map, key, value)Source

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

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

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

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

Примеры

iex> Map.replace!(%{a: 1, b: 2}, :a, 3)
%{a: 3, b: 2}

iex> Map.replace!(%{a: 1}, :b, 2)
** (KeyError) key :b not found in: %{a: 1}

replace_lazy(map, key, fun)Source

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

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

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

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

Примеры

iex> Map.replace_lazy(%{a: 1, b: 2}, :a, fn v -> v * 4 end)
%{a: 4, b: 2}

iex> Map.replace_lazy(%{a: 1, b: 2}, :c, fn v -> v * 4 end)
%{a: 1, b: 2}

split(map, keys)Source

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

Берёт все записи, соответствующие заданным keys в map, и извлекает их в отдельную карту.

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

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

Примеры

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

split_with(map, fun)Source

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

Разделяет map на две карты в соответствии с заданной функцией fun.

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

Примеры

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

iex> Map.split_with(%{a: 1, b: -2, c: 1, d: -3}, fn {k, _v} -> k in [:b, :d] end)
{%{b: -2, d: -3}, %{a: 1, c: 1}}

iex> Map.split_with(%{a: 1, b: -2, c: 1, d: -3}, fn {_k, v} -> v > 50 end)
{%{}, %{a: 1, b: -2, c: 1, d: -3}}

iex> Map.split_with(%{}, fn {_k, v} -> v > 50 end)
{%{}, %{}}

take(map, keys)Source

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

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

Если keys содержит ключи, которых нет в map, они просто игнорируются.

Примеры

iex> Map.take(%{a: 1, b: 2, c: 3}, [:a, :c, :e])
%{a: 1, c: 3}

to_list(map)Source

@spec to_list(map()) :: [{term(), term()}]

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

Каждая пара ключ-значение в карте преобразуется в двухэлементный кортеж {key, value} в результирующем списке.

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

Примеры

iex> Map.to_list(%{a: 1})
[a: 1]
iex> Map.to_list(%{1 => 2})
[{1, 2}]

update(map, key, default, fun)Source

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

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

Если key присутствует в map, то существующее значение передаётся в fun, и его результат используется в качестве обновлённого значения key. Если key отсутствует в map, default вставляется в качестве значения key. Значение по умолчанию не будет передано через функцию обновления.

Примеры

iex> Map.update(%{a: 1}, :a, 13, fn existing_value -> existing_value * 2 end)
%{a: 2}
iex> Map.update(%{a: 1}, :b, 11, fn existing_value -> existing_value * 2 end)
%{a: 1, b: 11}

update!(map, key, fun)Source

@spec update!(map(), key(), (existing_value :: value() -> new_value :: value())) ::
  map()

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

Если key присутствует в map, то существующее значение передаётся в fun, и его результат используется в качестве обновлённого значения key. Если key отсутствует в map, генерируется исключение KeyError.

Примеры

iex> Map.update!(%{a: 1}, :a, &(&1 * 2))
%{a: 2}

iex> Map.update!(%{a: 1}, :b, &(&1 * 2))
** (KeyError) key :b not found in: %{a: 1}

values(map)Source

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

Возвращает все значения из map.

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

Примеры

Map.values(%{a: 1, b: 2})
[1, 2]