Documentation

Init.Data.Hashable

instance instHashableNat :

Equations

instHashableNat = { hash := fun (n : Nat) => UInt64.ofNat n }

instance instHashablePos :

Hashable String.Pos

Equations

instHashablePos = { hash := fun (p : String.Pos) => UInt64.ofNat p.byteIdx }

instance instHashableProd {α : Type u_1} {β : Type u_2} [Hashable α] [Hashable β] :

Hashable (α × β)

Equations

instHashableProd = { hash := fun (x : α × β) => match x with | (a, b) => mixHash (hash a) (hash b) }

instance instHashableBool :

Equations

instHashableBool = { hash := fun (x : Bool) => match x with | true => 11 | false => 13 }

instance instHashableOption {α : Type u_1} [Hashable α] :

Hashable (Option α)

Equations

instHashableOption = { hash := fun (x : Option α) => match x with | none => 11 | some a => mixHash (hash a) 13 }

instance instHashableList {α : Type u_1} [Hashable α] :

Hashable (List α)

Equations

instHashableList = { hash := fun (as : List α) => List.foldl (fun (r : UInt64) (a : α) => mixHash r (hash a)) 7 as }

instance instHashableArray {α : Type u_1} [Hashable α] :

Hashable (Array α)

Equations

instHashableArray = { hash := fun (as : Array α) => Array.foldl (fun (r : UInt64) (a : α) => mixHash r (hash a)) 7 as }

instance instHashableUInt8 :

Equations

instHashableUInt8 = { hash := fun (n : UInt8) => n.toUInt64 }

instance instHashableUInt16 :

Hashable UInt16

Equations

instHashableUInt16 = { hash := fun (n : UInt16) => n.toUInt64 }

instance instHashableUInt32 :

Hashable UInt32

Equations

instHashableUInt32 = { hash := fun (n : UInt32) => n.toUInt64 }

instance instHashableUInt64 :

Hashable UInt64

Equations

instHashableUInt64 = { hash := fun (n : UInt64) => n }

instance instHashableUSize :

Equations

instHashableUSize = { hash := fun (n : USize) => n.toUInt64 }

instance instHashableByteArray :

Hashable ByteArray

Equations

instHashableByteArray = { hash := fun (as : ByteArray) => ByteArray.foldl (fun (r : UInt64) (a : UInt8) => mixHash r (hash a)) 7 as }

instance instHashableFin {n : Nat} :

Hashable (Fin n)

Equations

instHashableFin = { hash := fun (v : Fin n) => (↑v).toUInt64 }

instance instHashableChar :

Equations

instHashableChar = { hash := fun (c : Char) => c.val.toUInt64 }

instance instHashableInt :

Equations

instHashableInt = { hash := fun (x : Int) => match x with | Int.ofNat n => UInt64.ofNat (2 * n) | Int.negSucc n => UInt64.ofNat (2 * n + 1) }

instance instHashable (P : Prop) :

Equations

instHashable P = { hash := fun (x : P) => 0 }

@[inline]

def hash64 (u : UInt64) :

An opaque (low-level) hash operation used to implement hashing for pointers.

Equations

hash64 u = mixHash u 11

Instances For

class LawfulHashable (α : Type u) [BEq α] [Hashable α] :

LawfulHashable α says that the BEq α and Hashable α instances on α are compatible, i.e., that a == b implies hash a = hash b. This is automatic if the BEq instance is lawful.

hash_eq (a b : α) : (a == b) = true → hash a = hash b
If a == b, then hash a = hash b.

Instances

theorem hash_eq {α : Type u_1} [BEq α] [Hashable α] [LawfulHashable α] {a b : α} :

(a == b) = true → hash a = hash b

@[instance 100]

instance instLawfulHashableOfLawfulBEq {α : Type u_1} [BEq α] [Hashable α] [LawfulBEq α] :

LawfulHashable α