Slice as a key in map

Question

Is it possible to use slices as keys?

There is my attempt:

h := map[[]string]string{
  []string{"a", "b"} : "ab",
}

the compiler gives me an error invalid map key type []string. So either it's not possible or I declared it incorrectly (if so, what would be a correct way?).

Answer 1

The primary reason is that slices in Go are reference types with internal pointers and capacity metadata, making them inherently mutable and unsuitable for hash maps. Allowing slices as keys could lead to unpredictable behavior.

Directly using slices as map keys is not possible. Use a string representation, a custom struct, or fixed-size arrays as alternatives. The best choice depends on your specific use case and constraints.

Answer 2

As mentioned in previous answers, slices cannot be used as keys in a map or in any structure intended to serve as a key. However, there are several workarounds for this limitation.

1. Using Arrays as Keys: While slices cannot be used as keys, arrays can. If you have a natural limit on the number of elements in your slice (for example, a list of country codes), you can safely assume that the list will fit within a certain size, such as 256 elements. You can define the map key as follows:

type mapKey struct {
    arr [256]int
}

func makeKey(s []int) mapKey {
    key := mapKey{}
    copy(key.arr[:], s)
    if len(s) > len(key.arr) {
        // This should never happen
        // Optional panic to prevent silent failure
        panic("slice does not fit inside the key")
    }
    return key
}

2. Using interface{} as a Key: If there is no natural limit on the input slice length, you can use interface{} as a key, provided that it contains a comparable object. Note that if this condition is violated, a runtime panic will occur. The following code demonstrates this approach:

import "reflect"

type mapKey struct {
    arr any
}

func makeKey(s []int) mapKey {
    key := mapKey{}
    inputValue := reflect.ValueOf(s)
    elemType := inputValue.Type().Elem()
    arrayType := reflect.ArrayOf(len(s), elemType)
    asArray := inputValue.Convert(arrayType)
    key.arr = asArray.Interface()
    return key
}

Be cautious with this solution, as reflection can be slow and may lead to multiple heap allocations. Always measure performance and check allocation/CPU profiles in performance-sensitive code.

3. Combining Approaches: You can combine the first two approaches if you know that the length of the slice is typically limited (e.g., 90% or 99% of the time). For instance, if you know that 99% of customers add ten distinct items or fewer to their shopping cart, you can implement the following:

type mapKey struct {
    asArray [10]int
    asInterface any
}

func makeKey(s []int) mapKey {
    key := mapKey{}
    
    if len(s) > len(key.asArray) {
        inputValue := reflect.ValueOf(s)
        elemType := inputValue.Type().Elem()
        arrayType := reflect.ArrayOf(len(s), elemType)
        asArray := inputValue.Convert(arrayType)
        key.asInterface = asArray.Interface()
        return key
    }

    copy(key.asArray[:], s)
    return key
}

In this example, the fast path using an array is utilized for the majority of calls, while the slower path using reflection is used when necessary. This approach has been successfully implemented in a production project. As always, measure performance carefully, as results may vary.

4. Serializing Slices: As mentioned in other answers, slices can be serialized into strings. While this may not be the fastest operation and will incur additional allocation, using fmt.Sprint(s) will generally work in most cases.

5. Implementing a Custom Hashing Function: Another option is to implement your own hashing function for the slice. This can be efficient, resulting in compact keys (e.g., 64-bit). You can then use the hash of the slice as a map key. However, be aware that this approach may lead to unreadable keys in the debugger (though the key can be stored alongside the value). Additionally, consider the potential for hash collisions. The probability of collisions for a 64-bit hash is low unless a large number of values are stored in the map, but you should evaluate whether this risk is acceptable for your specific use case.

Answer 3

No, slices cannot be used as map keys as they have no equality defined.

Answer 4

However, it is possible to use arrays as map keys:

package main

import "fmt"

func main() {
    m := make(map[[2]int]bool)
    m[[2]int{1, 2}] = false
    fmt.Printf("%v", m)
}

Answer 5

Depending on your requirements and the complexity of your data, you could use a string as a map key and then use a hash of your slice as the map key.

The nice thing is you can use this technique with anything that can be converted to or from a slice of bytes.

Here's a quick way to convert your slice of strings into a slice of bytes:

[]byte(strings.Join([]string{},""))

Here's an example using SHA1:

type ByteSliceMap struct {
    buf *bytes.Buffer
    m   map[string][]byte
}

func (b *ByteSliceMap) key(buf []byte) string {
    h := sha1.New()
    h.Write(buf)
    sum := h.Sum(nil)
    return fmt.Sprintf("%x", sum)
}

func (t *ByteSliceMap) value(key []byte) (value []byte, ok bool) {
    value, ok = t.m[t.key(key)]
    return
}


func (t *ByteSliceMap) add(key, value []byte) {
    if t.m == nil {
        t.m = make(map[string][]byte)
    }
    t.m[t.key(key)] = value
}

Working version

Answer 6

One way to get around this problem is to actually create a key from a slice which has well defined comparison operators:

func createKey(s []string) string { return fmt.Sprintf("%q", s) }

m := make(map[string]string)
s := []string{"a","b"}
m[createKey(s)] = "myValue"

In a similar fashion you would have to create functions for creating keys of slices with type different to string.

Answer 7

Volker already told that this is not possible and I will give a little bit more details of why is it so with examples from the spec.

---

Map spec tells you:

The comparison operators == and != must be fully defined for operands of the key type; thus the key type must not be a function, map, or slice.

It already tells you that the slice can't be a key, but you could have checked it also in the comparison spec:

Slice, map, and function values are not comparable.

---

This means that also slice can't be a key, an array can be a key. For example you can write:

h := map[[2]string]string{
  [2]string{"a", "b"} : "ab",
}