Basic associative container requiring unique, Comparable
and Hashable
keys.
The order of the elements of the map is unspecified. Also, all the keys must be Hashable
, and any two keys with equal hashes must be Comparable
with each other at compile-time.
hana::map
is implementation-defined. In particular, one should not take for granted the order of the template parameters and the presence of any additional constructors or assignment operators than what is documented. The canonical way of creating a hana::map
is through hana::make_map
.Comparable
Searchable
Logical
. Also note that operator[]
can be used instead of at_key
. Foldable
Foldable
Any Foldable
of Product
s can be converted to a hana::map
with hana::to<hana::map_tag>
or, equivalently, hana::to_map
. If the Foldable
contains duplicate keys, only the value associated to the first occurence of each key is kept.
Synopsis of associated functions | |
template<> | |
constexpr auto | make< map_tag > |
Function object for creating a hana::map . More... | |
constexpr auto | make_map = make<map_tag> |
Alias to make<map_tag> ; provided for convenience. More... | |
constexpr auto | to_map = to<map_tag> |
Equivalent to to<map_tag> ; provided for convenience. More... | |
constexpr auto | keys |
Returns a Sequence of the keys of the map, in unspecified order. More... | |
constexpr auto | values |
Returns a Sequence of the values of the map, in unspecified order. More... | |
constexpr auto | insert |
Inserts a new key/value pair in a map. More... | |
constexpr auto | erase_key |
Removes a key/value pair from a map. More... | |
Friends | |
template<typename X , typename Y > | |
constexpr auto | operator== (X &&x, Y &&y) |
Equivalent to hana::equal | |
template<typename X , typename Y > | |
constexpr auto | operator!= (X &&x, Y &&y) |
Equivalent to hana::not_equal | |
Public Member Functions | |
constexpr | map ()=default |
Default-construct a map. This constructor only exists when all the elements of the map are default-constructible. | |
constexpr | map (map const &other)=default |
Copy-construct a map from another map. This constructor only exists when all the elements of the map are copy-constructible. | |
constexpr | map (map &&other)=default |
Move-construct a map from another map. This constructor only exists when all the elements of the map are move-constructible. | |
template<typename Key > | |
decltype(auto) constexpr | operator[] (Key &&key) |
Equivalent to hana::at_key | |
Function object for creating a hana::map
.
Given zero or more Product
s representing key/value associations, make<map_tag>
returns a hana::map
associating these keys to these values.
make<map_tag>
requires all the keys to be unique and to have different hashes. If you need to create a map with duplicate keys or with keys whose hashes might collide, use hana::to_map
or insert (key, value)
pairs to an empty map successively. However, be aware that doing so will be much more compile-time intensive than using make<map_tag>
, because the uniqueness of keys will have to be enforced.
Alias to make<map_tag>
; provided for convenience.
Equivalent to to<map_tag>
; provided for convenience.
|
related |
Returns a Sequence
of the keys of the map, in unspecified order.
|
related |
Returns a Sequence
of the values of the map, in unspecified order.
|
related |
Inserts a new key/value pair in a map.
Given a (key, value)
pair, insert
inserts this new pair into a map. If the map already contains this key, nothing is done and the map is returned as-is.
map | The map in which to insert a (key,value) pair. |
pair | An arbitrary Product representing a (key, value) pair to insert in the map. The key must be compile-time Comparable . |
|
related |
Removes a key/value pair from a map.
Returns a new hana::map
containing all the elements of the original, except for the (key, value)
pair whose key
compares equal
to the given key. If the map does not contain such an element, a new map equal to the original is returned.
map | The map in which to erase a key . |
key | A key to remove from the map. It must be compile-time Comparable . |