AnyHashable

struct AnyHashable

A type-erased hashable value.

The AnyHashable type forwards equality comparisons and hashing operations to an underlying hashable value, hiding its specific underlying type.

You can store mixed-type keys in dictionaries and other collections that require Hashable conformance by wrapping mixed-type keys in AnyHashable instances:

let descriptions: [AnyHashable: Any] = [
    AnyHashable("😄"): "emoji",
    AnyHashable(42): "an Int",
    AnyHashable(Int8(43)): "an Int8",
    AnyHashable(Set(["a", "b"])): "a set of strings"
]
print(descriptions[AnyHashable(42)]!)      // prints "an Int"
print(descriptions[AnyHashable(43)])       // prints "nil"
print(descriptions[AnyHashable(Int8(43))]!) // prints "an Int8"
print(descriptions[AnyHashable(Set(["a", "b"]))]!) // prints "a set of strings"
Inheritance CustomDebugStringConvertible, CustomReflectable, CustomStringConvertible, Equatable, Hashable View Protocol Hierarchy →
Import import Swift

Initializers

init(_:)

Creates a type-erased hashable value that wraps the given instance.

The following example creates two type-erased hashable values: x wraps an Int with the value 42, while y wraps a UInt8 with the same numeric value. Because the underlying types of x and y are different, the two variables do not compare as equal despite having equal underlying values.

let x = AnyHashable(Int(42))
let y = AnyHashable(UInt8(42))

print(x == y)
// Prints "false" because `Int` and `UInt8` are different types

print(x == AnyHashable(Int(42)))
// Prints "true"

base: A hashable value to wrap.

Declaration

init<H where H : Hashable>(_ base: H)

Instance Variables

var base: Any

The value wrapped by this instance.

The base property can be cast back to its original type using one of the casting operators (as?, as!, or as).

let anyMessage = AnyHashable("Hello world!")
if let unwrappedMessage = anyMessage.base as? String {
    print(unwrappedMessage)
}
// Prints "Hello world!"

Declaration

var base: Any { get }
var customMirror: Mirror

The custom mirror for this instance.

If this type has value semantics, the mirror should be unaffected by subsequent mutations of the instance.

Declaration

var customMirror: Mirror { get }
var debugDescription: String

A textual representation of this instance, suitable for debugging.

Declaration

var debugDescription: String { get }
var description: String

A textual representation of this instance.

Instead of accessing this property directly, convert an instance of any type to a string by using the String(describing:) initializer. For example:

struct Point: CustomStringConvertible {
    let x: Int, y: Int

    var description: String {
        return "(\(x), \(y))"
    }
}

let p = Point(x: 21, y: 30)
let s = String(describing: p)
print(s)
// Prints "(21, 30)"

The conversion of p to a string in the assignment to s uses the Point type's description property.

Declaration

var description: String { get }
var hashValue: Int

The hash value.

Hash values are not guaranteed to be equal across different executions of your program. Do not save hash values to use during a future execution.

Declaration

var hashValue: Int { get }

Instance Methods

func ==(_:rhs:)

Returns a Boolean value indicating whether two type-erased hashable instances wrap the same type and value.

Two instances of AnyHashable compare as equal if and only if the underlying types have the same conformance to the Equatable protocol and the underlying values compare as equal.

The following example creates two type-erased hashable values: x wraps an Int with the value 42, while y wraps a UInt8 with the same numeric value. Because the underlying types of x and y are different, the two variables do not compare as equal despite having equal underlying values.

let x = AnyHashable(Int(42))
let y = AnyHashable(UInt8(42))

print(x == y)
// Prints "false" because `Int` and `UInt8` are different types

print(x == AnyHashable(Int(42)))
// Prints "true"

Parameters: lhs: A type-erased hashable value. rhs: Another type-erased hashable value.

Declaration

func ==(lhs: AnyHashable, rhs: AnyHashable) -> Bool