Slice type casting in Go

I'm quite new to Go coming from C++ background and have stumbled upon some weird issue.
Here's the code:

package main

import (
"fmt"
"unsafe"
)

func main() {
     arr := []string { "one", "two", "three" }
     address := unsafe.Pointer(&arr)
     addPtr := (*[]string)(unsafe.Pointer(*(*uintptr)(address)))
     fmt.Println((*addPtr)[0])
}

This code fails with:

> runtime error: growslice: len out of range

If i change cast, for example, to this:

addPtr := (*[0]string)(unsafe.Pointer(*(*uintptr)(address)))

The code above works just fine.

I understand that this is a cast to an array pointer and array must have constant size,
but how to cast it to pointer to a slice then?

What's even more confusing that it's possible to take an address of slice and assign it to the pointer like this:

func main() {
     arr := []string { "one", "two", "three" }
     var arrPtr *[]string = &arr
     fmt.Println((*arrPtr)[0])
}

And this time everything will work despite the fact that the type of pointer is the same type that i was casting unsafe pointer to in the first example.
Can someone help to understand what's exactly going on here?

Some background: A slice header contains a pointer to a backing array, length and capacity.

The code in the first part of the question converts a slice header to a pointer to a slice header. The go vet command warns that the code in the question is possible misuse of unsafe.Pointer.

Fix by removing the extra dereference operation so that the code converts from pointer to slice header to pointer to slice header.

arr := []string{"one", "two", "three"}
address := unsafe.Pointer(&arr)
addPtr := (*[]string)(unsafe.Pointer((*uintptr)(address)))
fmt.Println((*addPtr)[0]) // prints one

The conversion to *uintptr is not required. Simplify to:

arr := []string{"one", "two", "three"}
address := unsafe.Pointer(&arr)
addPtr := (*[]string)(unsafe.Pointer(address))
fmt.Println((*addPtr)[0]) // prints one

The unsafe shenanigans are not required. Simplify to:

arr := []string{"one", "two", "three"}
addPtr := &arr
fmt.Println((*addPtr)[0]) // prints one

Convert the slice's backing array pointer to an array pointer using the following code. The code is fragile because it assumes that the first word of the slice header is the pointer to the backing array.

arr := []string{"one", "two", "three"}
address := unsafe.Pointer(&arr)
addPtr := (*[1]string)(unsafe.Pointer(*(*uintptr)(address)))
fmt.Println((*addPtr)[0]) // prints one

The uintptr conversions in the previous snippet are not needed. Simplify to:

arr := []string{"one", "two", "three"}
address := unsafe.Pointer(&arr)
addPtr := (*[]string)(address)
fmt.Println((*addPtr)[0]) // prints one

I hope this helps.