golang：隐式vs显式func定义

Question

Consider this package:

package A
var X="change me"
var Y=func(i int) int { return i*i) }
func Z(i int) int { return -i) }

The two explicit variables (X,Y) can be changed in another package, say main...

package main
import "A"
func main () {
    A.X="done"
    A.Y=func (i int) int { return i*i*i }
    print(A.X,A.Y(7))
    //... but A.Z apparently can't be changed.
    //A.Z=func (int i) int { return i*i*i } //main.go:8: cannot assign to A.Z
}

Obviously there's a difference between defining a func variable (like Y) and an explicit func (like Z). I have googled this but not found much in the way of enlightenment. It almost seems as if var SomeFunc=func (...) defines indeed a variable, but func SomeFunc(...) defines a constant.

PS: A small goodie I found while researching this which I have not seen mentioned in the Go books I've read so far. A dot before a package import imports names without them having to be qualified:

package main
import . "A"
func main () {
    X="done"
    Y=func (i int) int { return i*i*i }
    print(X,Y(7))
}

Answer 1

There's a difference between declaring a variable initialized with a function value:

var Y=func(i int) int { return i*i) }

and declaring a function:

 func Z(i int) int { return -i) }

The specification says this about declarations:

A declaration binds a non-blank identifier to a constant, type, variable, function, label, or package.

The specification also says:

A function declaration binds an identifier, the function name, to a function.

The declaration of Y binds a variable to the name. This variable is initialized with a function value. The declaration of Z binds a function to the name.

If an explicit period (.) appears instead of a name, all the package's exported identifiers declared in that package's package block will be declared in the importing source file's file block and must be accessed without a qualifier.