Specs

access_in(map(), access_key_or_keys(), any()) :: any()

Safe version of Kernel.get_in/2

Specs

atom_keys?(map()) :: boolean()

Determine if a map keys are of type atom/0.

Examples

iex> atom_keys?(%{})
true

iex> atom_keys?(%URI{})
true

iex> atom_keys?(%{atom: true})
true

iex> atom_keys?(%{"string" =>  true})
false

iex> atom_keys?(%{[] =>  "complex"})
false

iex> atom_keys?(%{:atom =>  true, "string" =>  true})
false

Specs

compact(map() | struct(), opts :: Keyword.t() | map()) :: map()

Returns a map with nil values omitted

Specs

complex_keys?(map()) :: boolean()

Determine if a map keys are of type atom/0.

Examples

iex> complex_keys?(%{})
true

iex> complex_keys?(%URI{})
false

iex> complex_keys?(%{atom: true})
false

iex> complex_keys?(%{"string" =>  true})
false

iex> complex_keys?(%{[] =>  "complex"})
true

iex> complex_keys?(%{:atom =>  true, "string" =>  true})
false

Specs

iget(map(), accessor_path()) :: any()

Provide indifferent access to maps.

Specs

iget(map(), accessor_path(), any()) :: any()

Specs

mixed_keys?(map()) :: boolean()

Determine if a map keys are of type atom/0.

Examples

iex> mixed_keys?(%{})
true

iex> mixed_keys?(%URI{})
false

iex> mixed_keys?(%{atom: true})
false

iex> mixed_keys?(%{"string" =>  true})
false

iex> mixed_keys?(%{[] =>  "complex"})
false

iex> mixed_keys?(%{:atom =>  true, "string" =>  true})
true

Specs

sorted_keys(map()) :: [atom() | String.t(), ...]

Returns a sorted list of atom keys found in results.

Specs

string_keys?(map()) :: boolean()

Determine if a map keys are of type String.t/0.

Examples

iex> string_keys?(%{})
true

iex> string_keys?(%URI{})
false

iex> string_keys?(%{atom: true})
false

iex> string_keys?(%{"string" =>  true})
true

iex> string_keys?(%{[] =>  "complex"})
false

iex> string_keys?(%{:atom =>  true, "string" =>  true})
false

Specs

typeof_keys(map() | struct()) :: map_keys_type()

Classifies a map by key type.

Examples

iex> typeof_keys(%{})
:empty

iex> typeof_keys(%URI{})
:atom

iex> typeof_keys(%{atom: true})
:atom

iex> typeof_keys(%{"string" =>  true})
:string

iex> typeof_keys(%{[] =>  "complex"})
:complex

iex> typeof_keys(%{:atom =>  true, "string" =>  true})
:mixed

Specs

typeof_kv(kv()) :: kv_type()

Classifies a kv pair by key type.

Examples

iex> typeof_kv({:atom, true})
:atom

iex> typeof_kv({"string", true})
:string

iex> typeof_kv({[], true})
:complex