What's special about an empty list returned from a map[string][]string

Here's a weird situation where I don't understand what Go is doing. I ended with some code that used the default value of map that hasn't had that key inserted into it yet.

package main

import (
	"fmt"
	"reflect"
)

func main() {
	mmm := map[string][]string{}
	nnn := map[string][]string {
		"a": {},
	}
	
	x := mmm["a"]
	y := nnn["a"]
	z := []string{}
	
	fmt.Println(reflect.DeepEqual(x,y))
	fmt.Println(reflect.DeepEqual(x,z))
	fmt.Println(reflect.DeepEqual(y,z))

	fmt.Printf("%T, %T, %T", x, y, z)
}

I get the unexpected output

false
false
true
[]string, []string, []string

where I would expect true across the board. What is it about the default value of a map that does this?

If you add another printing line:

fmt.Printf("%#v, %#v, %#v", x, y, z)

It'll all become clear. It outputs (try it on the Go Playground):

[]string(nil), []string{}, []string{}

x is a slice being nil, and y is a non-nil slice having 0 length, just like z.

Indexing a map with a key that's not in the map, it results in the zero value for the value type of the map. In your case the value type is []string, its a slice type, and zero value for slice types is nil.

And reflect.DeepEqual() documents that a nil slice and a non-nilslice are not equal:

> Note that a non-nil empty slice and a nil slice (for example, []byte{} and []byte(nil)) are not deeply equal.

First, just a quick correction, this kind of data type is called a "slice", not a "list".

When you look-up a map key that doesn't exist, you get the "zero value" of the map's value type. In the case of slices, the zero-value is a nil slice. A nil slice generally behaves much like an empty slice (for example, the len of a nil slice is zero), but they are not considered to be the same. Equality is not actually defined for slices in Go, so it is up to reflect.DeepEqual to decide what equality means here.

You'll see this note in the documentation explaining the behaviour here:
> Slice values are deeply equal when all of the following are true: they are both nil or both non-nil, they have the same length, and either they point to the same initial entry of the same underlying array (that is, &x[0] == &y[0]) or their corresponding elements (up to length) are deeply equal. Note that a non-nil empty slice and a nil slice (for example, []byte{} and []byte(nil)) are not deeply equal.