On: Go 1.13 Release Notes

[omaranto]

Maybe "fixed size" was the wrong way to phrase it. What I meant is that a string points to an unlimited amount of data and all of that unlimited amount of data is taken into account when deciding equality of strings. And my question should have been, is string the only datatype with that feature?

If it is, it means Go is like Lua, where if you want to use any compound data structure as a key in a map, you either marshall it to a string or you implement your own hashtable.

In Python you are allowed to use tuples of immutable objects as keys, for example. Much nicer than serializing everything to strings.

As for "in practice this is rarely a problem", I agree, but prefer languages where the standard library doesn't have these arbitrary limitations. For example I might want to implement multivariate sparse polynomials as maps from exponent tuples to coefficients (the polynomial 3 x^2 y^3 z + 7 x y z^4 corresponds to the map {(2,3,1): 3, (1,1,4): 7}). That's straightforward in Python but awkward in Go (in Go I might be tempted to just set a maximum number of variables and use arrays or exponents as keys).

[tapirl → omaranto]

> In Python you are allowed to use tuples of immutable objects as keys

You can do this in Go too with structs.

[bakery2k → tapirl]

Don't all the keys in a Go map have to have the same type? So if you use structs as keys, they all need to have the same length?

In Python, you can use (1, 2), (3, 4, 5) and (6, 7, 8, 9, 10) all as keys in the same map.

[tapirl → bakery2k]

Same in Go, you can use interface{} values as keys, the concrete values of the interface keys can be a 2-element, 3-element or n-element array values.

    package main
    import "fmt"
    
    func main() {
        var m = map[interface{}]int {
            [2]int{1, 2}: 12,
            [3]int{1, 2, 4}: 123,
            [4]int{1, 2, 3, 4}: 1234,
        }
        fmt.Println(m)
    }

[omaranto → tapirl]

Oh, cool! This still doesn't quite get rid of my complaint since the size of an array must be known at compile time, but it's good that they don't all have to be the same size.