How go's map hash function workes so different type with "same" value result in different key?

Question

I know the value is not same so I double qouted it, what I want to know is how go's map hash works so that cusKey and a is different in type result in the key is different.

package main

import (
    "fmt"
)

type key int

const cusKey key = 1
const a int = 1


func main() {
    dic := make(map[interface{}]interface{})
    dic[cusKey] = 5
    dic[a] = 6
    fmt.Println(dic[cusKey])
    fmt.Println(dic[a])
}

the output is

5
6

How go achieve this? The two keys value are all 1.

I know in go if the type is different, two value is different. So the two 1 is not identical.

But how actually go's map did it? I tried to find out at map.go in source, but I can't found where go implement the hash funcion. Is it calculates hash of the keys with type annotations?

icza · Accepted Answer · 2020-02-22T14:22:30.927

11

a and cusKey cannot be equal because they have different types. a is of type int, and cusKey is of type key (which has int as its underlying type, but it is a different type).

Go maps require keys to be comparable. Spec: Map types:

The comparison operators == and != must be fully defined for operands of the key type

The key type of your dic map is interface{}, it's an interface type, and interface values are comparable if Spec: Comparison operators:

Interface values are comparable. Two interface values are equal if they have identical dynamic types and equal dynamic values or if both have value nil.

An interface value stores the dynamic type and value, schematically, it's a "(value, type)" pair. When interface values are compared, the type is compared too, and if they don't match, the interface value comparison will yield false. For details about interface representation, see Go Data Structures: Interfaces (by Russ Cox).

For internals about Go's map, check out Dave Cheney: How the Go runtime implements maps efficiently (without generics).

edited Feb 22 '20 at 14:22

answered Feb 21 '20 at 15:26

icza

389,944
63
907
827

So map's hash function will use the "(value, type)" pair when calculate hash for a `interface{}`, thus they are different keys in a look up operation? – Li Jinyao Feb 22 '20 at 06:00
@LiJinyao Yes. Added a link which writes about Go's map implementation, check that out. – icza Feb 22 '20 at 12:27
j@LiJinyao Somehow my edit disappeared, (re-)added the link now. – icza Feb 22 '20 at 14:22
Thanks! That link helps me a lot. – Li Jinyao Feb 26 '20 at 12:28

score 7 · Answer 2 · answered Feb 21 '20 at 15:25

The keys are of type interface{}. Interface values in Go have two fields: the underlying value's type descriptor, and a pointer to the value itself. Two interface values with different underlying types are therefore not equal, even if the underlying values would be considered equal.

How go's map hash function workes so different type with "same" value result in different key?

2 Answers2