what is the actual difference between &Struct{field: "blabla"} and Struct{field: "blabla"} (without memory address symbol)?

i.e.

package main

import "fmt"

type rabbit struct {
	food string
}

func (r *rabbit) test() {
	fmt.Println(r.food)
}

func main() {
	roger := &rabbit{"carrot"} //rabbit{"carrot"} would have done the same thing
	roger.food = "salad"
	roger.test()
}

whether you define roger as &rabbit{"carrot"} or rabbit{"carrot"}, you can in any case change its attributes and call pointer receivers. But if you had to implement an interface like in this example

package main

import "fmt"

type interfaccia interface {
	test()
}

type rabbit struct {
	food string
}

func (r *rabbit) test() {
	fmt.Println(r.food)
}
func someFunc(elemento interfaccia) {
	elemento.test()
}

func main() {
	roger := &rabbit{"carrot"} //without pointer receiver you would bump into an error
	someFunc(roger)

}

then you are forced to set roger as pointer receiver due to the interface. and if I had a recursive struct like this:

type rabbit struct {
	food       string
	girlfriend *rabbit
}

then I'm always forced to use the pointer.

My concern is: since &rabbit{"carrot"} includes all things of rabbit{"carrot"}, why should I use the last one?

A method of a type can either have a pointer receiver or a value receiver. There is a caveat while pointer vs value receiver for methods of a type when that type implements an interface

If a type implements all methods of an interface using value receiver, then both value and pointer of that type can be used while assigning to that interface variable or while passing to a function which accept an argument as that interface.

If a type implements all methods of an interface using pointer receiver, then the only pointer of that type can be used while assigning to that interface variable or while passing to a function that accepts an argument as that interface.

see the example in go tour here