What is stored in a slice/array of funcs?

I cannot seem to find an answer anywhere in the documentation

Given a slice like:

var funcs []func()

What is the underlying backing array?

At first I thought it would be an array of function pointers, but I have since seen that this is possible:

funcs = append(funcs, f.SomeFunc)
funcs[0]() // calls SomeFunc on the f 

Where f is any type that has a method/receiver function defined for it.

So what is the underlying implementation?

Example program

package main

import "fmt"

func PrintStandalone() {
	fmt.Println("Standalone")
}

type Point struct {
	x int
	y int
}

func (p *Point) PrintPoint() {
	fmt.Println("X: ", p.x, " Y: ", p.y)
}

type Coordinate struct {
	lat  int
	long int
}

func (c Coordinate) PrintCoordinate() {
	fmt.Println("Lat: ", c.lat, " Long: ", c.long)
}

func main() {

	p := Point{x: 1, y: 2}
	c := Coordinate{lat: 3, long: 4}

	var funcs []func()

	funcs = append(funcs, PrintStandalone)
	funcs = append(funcs, p.PrintPoint)
	funcs = append(funcs, c.PrintCoordinate)

	for _, fn := range funcs {
		fn()
	}

	p = Point{x: 5, y: 6}
	c = Coordinate{lat: 7, long: 8}

	for _, fn := range funcs {
		fn()
	}
}

When run, this program prints

Standalone
X:  1  Y:  2
Lat:  3  Long:  4
Standalone
X:  5  Y:  6
Lat:  3  Long:  4

Indicating that, depending on whether the receiver method is by pointer or by value, the function is called on the "same object" or on a copy of it.

> So what is the underlying type [of []func()]?

It is func().

The conceptual problem you seem to face is that methods are (more or less) plain functions in Go just having an additional receiver that is not part of the (call) signature). Details on this method values can be found here https://go.dev/ref/spec#Method_values.

In addition to @Volker's answer, it might also help to imagine methods as functions that return closures over their receiver. I.e.

func (p *Point) PrintPoint() {
    fmt.Println("X: ", p.x, " Y: ", p.y)
}

is conceptually the same as

func PrintPoint(p *Point) func() {
    func() {
        fmt.Println("X: ", p.x, " Y: ", p.y)
    }
}

Now p.PrintPoint just becomes a simple function invocation PrintPoint(&p) which returns a func() -- the exact type your slice is supposed to hold. The closure semantics also explain why value and pointer receivers behave the way they do.