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.
Note that the actual representation of a hana::map
is an implementation detail. As such, one should not assume anything more than what is explicitly documented as being part of the interface of a map, such as:
hana::map<Pairs...>
is, or is not, a dependent typeIn particular, the last point is very important; hana::map<Pairs...>
is only a shortcut for
which is not something that can be pattern-matched on during template argument deduction, for example.
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... P> | |
constexpr | map (P &&...pairs) |
Construct the map from the provided pairs. P... must be pairs of the same type (modulo ref and cv-qualifiers), and in the same order, as those appearing in Pairs... . The pairs provided to this constructor are emplaced into the map's storage using perfect forwarding. | |
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 . |