Go封闭示例如何工作？

I'm reading a (really good) Go book and saw this example, but I don't see how it works.

func makeEvenGenerator() func() uint {
    i := uint(0)
    return func() (ret uint) {
        ret = i
        i += 2
        return
    }
}
func main() {
    nextEven := makeEvenGenerator()
    fmt.Println(nextEven()) // 0
    fmt.Println(nextEven()) // 2
    fmt.Println(nextEven()) // 4
}

Incrementing i is common closure behaviour. That's fine. But if you look at nextEven, it's a function that takes no arguments and returns a uint called ret. But what's the point of naming the return value? Won't any code that calls this use its own variable name?

And the return statement returns nothing - so what's being printed? How is 0 / 2 / 4 coming out of this function?

And how is this different from doing this:

func makeEvenGenerator() func() uint {
    i := uint(0)
    return func() uint {
        current := i
        i += 2
        return current
    }
}

Which seems much simpler and makes things more obvious. Is there some deep Go / math concept that I'm missing?

The return statement that is returning "nothing" is returning the named result parameter ret. Named result parameters (http://golang.org/doc/effective_go.html#named-results) are syntactic sugar that introduce local variables in the function that will be returned if there's a bare return.

In this specific case, there's no benefit to using one and it probably does confuse more than it helps.

Usually there are two cases where named result parameters are of use: When wanting to change return values from a defer, and for the sake of documenting their use, as can often be seen with functions that return two or more values, such as Read(b []byte) (n int, err error)