Different behavior between calling function directly and using pointer

I am new to Go language and got confused with the following code

package main

import "fmt"

// fibonacci is a function that returns
// a function that returns an int.
func fibonacci() func() int {
    previous := 0
    current := 1
    return func () int{
        current = current+previous
        previous = current-previous
        return current
        
    }
}

func main() {
    f := fibonacci
    for i := 0; i < 10; i++ {
        fmt.Println(f()())
    }
}

This code is supposed to print out the Fibonacci Sequence (first 10), but only print out 10 times 1.
but if I change the code to:

func main() {
    f := fibonacci()
    for i := 0; i < 10; i++ {
        fmt.Println(f())
    }
}

Then it is working fine. The output is the Fibonacci sequence.

Could any one help me explain this?

Thanks

fibonacci() creates a new fibonacci generator function. fibonacci()() does the same, and then calls it once, returns the result and discards the generator, never to be used again. If you call that in a loop, it'll just keep creating new generators and only using their first value.

If you want more than just the first value, you need to do exactly what you did in your second example. Store the generator itself in a variable and then call the same generator multiple times.

This has to do with how variables are encapsulated in closures after returning the closure.
Consider the following example (live code on play):

func newClosure() func() {
	i := 0
	fmt.Println("newClosure with &i=", &i)
	return func() {
		fmt.Println(i, &i)
		i++
	}
}    

func main() {
	a := newClosure()
	a()
	a()
	a()
	b := newClosure()
	b()
	a()
}

Running this code will yield something like the following output. I annotated
which line comes from which statement:

newClosure with &i= 0xc010000000    // a := newClosure()
0 0xc010000000                      // a()
1 0xc010000000                      // a()
2 0xc010000000                      // a()
newClosure with &i= 0xc010000008    // b := newClosure()
0 0xc010000008                      // b()
3 0xc010000000                      // a()

In the example, the closure returned by newClosure encapsulates the local variable i.
This corresponds to current and the like in your code. You can see that a and b
have different instances of i, or else the call b() would've printed 3 instead.
You can also see that the i variables have different addresses. (The variable is already
on the heap as go does not have a separate stack memory, so using it in the closure is
no problem at all.)

So, by generating a new closure you're automatically creating a new context for the
closure and the local variables are not shared between the closures. This is the reason
why creating a new closure in the loop does not get you further.

The equivalent in for your code in terms of this example would be:

for i:=0; i < 10; i++ {
    newClosure()()
}

And you've already seen by the output that this will not work.

func fibonacci() func() int return a function literal (closure) that returns an int representing the last generated number in the list.

The first main() method

f := fibonacci
    for i := 0; i < 10; i++ {
        fmt.Println(f()())
    }

f is the generator function, every iteration in the loop invoke f()() that generates a new closure with a new envirement ( previous := 0, current := 1), so , the second invocation returns current which is always equal to 1.

The second main() method

func main() {
    f := fibonacci()
    for i := 0; i < 10; i++ {
        fmt.Println(f())
    }
}

f is the closure (not the generator) with an initial envirement ( previous := 0, current := 1), every iteration in the loop invoke f() witch returns current and modify the envirement, so whith the next call, previous will be 1 and current 2.