Why are some slices nil?

I put together this code to demonstrate my confusion:
https://go.dev/play/p/HVp7p0w74Un

the two slices, x and y are identical in terms of data (none), length and capacity. But one of them is nil and the other is not. I understand this as a fact but I don't understand WHY it should be the case.
Basically I'm trying to learn Go and I don't know how to think about this in order to remember it.
So, why does x evaluate to nil while y does not?

A slice is nil if the underlying array it points to is nil. If a slice is initialized, even if it's capacity is zero, it is not nil. This is useful in distinguishing between an uninitialized slice and a slice of length 0.

In your program, you can assign the slice y to nil:

y := make([]int, 0)
fmt.Println(y, len(y), cap(y)) // [] 0 0
fmt.Println(y == nil) // false
y = nil
fmt.Println(y == nil) // true
fmt.Println(y, len(y), cap(y)) // [] 0 0

> The Go Programming Language Specification
>
> The zero value
>
> When storage is allocated for a variable, either through a declaration or a call of new, or when a new value is created, either through a composite literal or a call of make, and no explicit initialization is provided, the variable or value is given a default value. Each element of such a variable or value is set to the zero value for its type: false for booleans, 0 for numeric types, "" for strings, and nil for pointers, functions, interfaces, slices, channels, and maps.

The zero value for a slice is nil.

The implementation of a slice

type slice struct {
    array unsafe.Pointer
    len   int
    cap   int
}

The zero value is the zero value for each of the struct fields, that is binary zero each of the struct fields.

When you declare a slice like this var x []int you are creating a nil slice.
What you are actually telling the compiler is: "create a slice of type []int" and since no value is assigned, x is assigned the zero
value for a slice, which is nil.

If you don't want it to be nil you need to express it with a non nil literal var x []int{}

Here {} is an empty array literal and empty doesn't mean nil so this slice is not a nil slice.

This is somehow equivalent to declaring y := make([]int, 0).

You could also initialize a slice with some values in the array literal: var x []int{1, 2, 3}

make function in Go, will allocate memory as specified in the capacity parameter. Therefore, it has a non-nil reference. Without make, it will only declare the slice but won't allocate memory space. Therefore, it refers to nil.