Elixir v1.2.6 Dict behaviour

WARNING: this module is deprecated.

If you need a general dictionary, use the Map module. If you need to manipulate keyword lists, use Keyword.

To convert maps into keywords and vice-versa, use the new function in the respective modules.

Summary

Types

key :: any
t :: list | map
value :: any

Functions

delete(dict, key)

Specs

delete(t, key) :: t
drop(dict, keys)

Specs

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

Specs

empty(t) :: t
equal?(dict1, dict2)

Specs

equal?(t, t) :: boolean
fetch(dict, key)

Specs

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

Specs

fetch!(t, key) :: value | no_return
get(dict, key, default \\ nil)

Specs

get(t, key, value) :: value
get_and_update(dict, key, fun)

Specs

get_and_update(t, key, (value -> {value, value})) :: {value, t}
get_lazy(dict, key, fun)

Specs

get_lazy(t, key, (() -> value)) :: value
has_key?(dict, key)

Specs

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

Specs

keys(t) :: [key]
merge(dict1, dict2)

Specs

merge(t, t) :: t
merge(dict1, dict2, fun)

Specs

merge(t, t, (key, value, value -> value)) :: t
pop(dict, key, default \\ nil)

Specs

pop(t, key, value) :: {value, t}
pop_lazy(dict, key, fun)

Specs

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

Specs

put(t, key, value) :: t
put_new(dict, key, val)

Specs

put_new(t, key, value) :: t
put_new_lazy(dict, key, fun)

Specs

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

Specs

size(t) :: non_neg_integer
split(dict, keys)

Specs

split(t, [key]) :: {t, t}
take(dict, keys)

Specs

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

Specs

to_list(t) :: list
update(dict, key, initial, fun)

Specs

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

Specs

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

Specs

values(t) :: [value]

Callbacks

delete(t, key)

Specs

delete(t, key) :: t
drop(t, arg1)

Specs

drop(t, Enum.t) :: t
equal?(t, t)

Specs

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

Specs

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

Specs

fetch!(t, key) :: value | no_return
get(t, key)

Specs

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

Specs

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

Specs

get_and_update(t, key, (value -> {value, value})) :: {value, t}
get_lazy(t, key, list)

Specs

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

Specs

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

Specs

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

Specs

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

Specs

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

Specs

new :: t
pop(t, key)

Specs

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

Specs

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

Specs

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

Specs

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

Specs

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

Specs

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

Specs

size(t) :: non_neg_integer
split(t, arg1)

Specs

split(t, Enum.t) :: {t, t}
take(t, arg1)

Specs

take(t, Enum.t) :: t
to_list(t)

Specs

to_list(t) :: list
update(t, key, value, list)

Specs

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

Specs

update!(t, key, (value -> value)) ::
  t |
  no_return
values(t)

Specs

values(t) :: [value]