A type that can be hashed into a
Hasher to produce an integer hash value.
- Xcode 6.0.1+
- Swift Standard Library
You can use any type that conforms to the
Hashable protocol in a set or as a dictionary key. Many types in the standard library conform to
Hashable: Strings, integers, floating-point and Boolean values, and even sets are hashable by default. Some other types, such as optionals, arrays and ranges automatically become hashable when their type arguments implement the same.
Your own custom types can be hashable as well. When you define an enumeration without associated values, it gains
Hashable conformance automatically, and you can add
Hashable conformance to your other custom types by implementing the
hash(into:) method. For structs whose stored properties are all
Hashable, and for enum types that have all-
Hashable associated values, the compiler is able to provide an implementation of
Hashing a value means feeding its essential components into a hash function, represented by the
Hasher type. Essential components are those that contribute to the type’s implementation of
Equatable. Two instances that are equal must feed the same values to
hash(into:), in the same order.
Conforming to the Hashable Protocol
To use your own custom type in a set or as the key type of a dictionary, add
Hashable conformance to your type. The
Hashable protocol inherits from the
Equatable protocol, so you must also satisfy that protocol’s requirements.
The compiler automatically synthesizes your custom type’s
Hashable and requirements when you declare
Hashable conformance in the type’s original declaration and your type meets these criteria:
struct, all its stored properties must conform to
enum, all its associated values must conform to
enumwithout associated values has
Hashableconformance even without the declaration.)
To customize your type’s
Hashable conformance, to adopt
Hashable in a type that doesn’t meet the criteria listed above, or to extend an existing type to conform to
Hashable, implement the
hash(into:) method in your custom type.
hash(into:) implementation, call
combine(_:) on the provided
Hasher instance with the essential components of your type. To ensure that your type meets the semantic requirements of the
Equatable protocols, it’s a good idea to also customize your type’s
Equatable conformance to match.
As an example, consider a
Grid type that describes a location in a grid of buttons. Here’s the initial declaration of the
You’d like to create a set of the grid points where a user has already tapped. Because the
Grid type is not hashable yet, it can’t be used in a set. To add
Hashable conformance, provide an
== operator function and implement the
hash(into:) method in this example feeds the grid point’s
y properties into the provided hasher. These properties are the same ones used to test for equality in the
== operator function.
Grid conforms to the
Hashable protocol, you can create a set of previously tapped grid points.