text: 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
  IntegralConstants
  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.
  Initial value:
  #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} \)