The Hashable
concept represents objects that can be normalized to a type-level hash.
In day to day programming, hashes are very important as a way to efficiently lookup objects in maps. While the implementation of maps is very different, the same idea of using hashes for efficient lookup applies in metaprogramming. The Hashable
concept represents objects that can be summarized (possibly with loss of information) to a type, in a way suitable for use in hash-based data structures. Of course, in order for a hash to be well-behaved, it must obey some laws that are explained below.
hash
, satisfying the laws below
First, hana::hash
must return a hana::type
. Furthermore, for any two Hashable
objects x
and y
, it must be the case that
where ==
denotes hana::equal
. In other words, any two objects that compare equal (with hana::equal
) must also have the same hash. However, the reverse is not true, and two different objects may have the same hash. This situation of two different objects having the same hash is called a collision.
hana::integral_constant
, hana::type
, hana::string
IntegralConstant
s Any IntegralConstant
is Hashable
, by normalizing its value to a hana::integral_constant
. The type of the value held in the normalized integral_constant
is unsigned long long
for unsigned integral types, and signed long long
for signed integral types.
Variables | |
constexpr auto | boost::hana::hash |
Returns a hana::type representing the compile-time hash of an object.Given an arbitrary object x , hana::hash returns a hana::type representing the hash of x . In normal programming, hashes are usually numerical values that can be used e.g. as indices in an array as part of the implementation of a hash table. In the context of metaprogramming, we are interested in type-level hashes instead. Thus, hana::hash must return a hana::type object instead of an integer. This hana::type must somehow summarize the object being hashed, but that summary may of course lose some information. More... | |
constexpr auto boost::hana::hash |
#include <boost/hana/fwd/hash.hpp>
Returns a hana::type
representing the compile-time hash of an object.Given an arbitrary object x
, hana::hash
returns a hana::type
representing the hash of x
. In normal programming, hashes are usually numerical values that can be used e.g. as indices in an array as part of the implementation of a hash table. In the context of metaprogramming, we are interested in type-level hashes instead. Thus, hana::hash
must return a hana::type
object instead of an integer. This hana::type
must somehow summarize the object being hashed, but that summary may of course lose some information.
In order for the hash
function to be defined properly, it must be the case that whenever x
is equal to y
, then hash(x)
is equal to hash(y)
. This ensures that hana::hash
is a function in the mathematical sense of the term.
Given a Hashable
H
, the signature is \( \mathtt{hash} : H \to \mathtt{type\_tag} \)
x | An object whose hash is to be computed. |