Function Implementing Interface vs. Struct Implementing Interface

When implementing an interface with a single method in Go, when should a function be used vs. a struct?

Contrived example: Say I have a logging interface with a single method:

type Logger interface {
	Log(message string)
}

Option 1: Use a Struct:

package main

import (
	"fmt"
)

type Controller struct {
	l     Logger
}
func (c Controller) Run() {
	c.l.Log("done")
}

type Logger interface {
	Log(message string)
}

// Empty struct with method implementing the interface
type LoggerImpl struct {}
func (li LoggerImpl) Log(message string) {
	fmt.Println(message)
}

func main() {
	l := LoggerImpl{}
	c := Controller{l: l}
	c.Run()
}

Option #2 - Use a Function

package main

import (
	"fmt"
)

type Controller struct {
	l     Logger
}
func (c Controller) Run() {
	c.l.Log("done")
}

type Logger interface {
	Log(message string)
}

type LoggerAdapter func(message string)

func (lg LoggerAdapter) Log(message string) {
	lg(message)
}

func LogOutput(message string) {
	fmt.Println(message)
}

func main() {
	l := LoggerAdapter(LogOutput)
	c := Controller{l: l}
	c.Run()
}

Both work, but it seems like the function option is less resilient to change?

Is there an example of where using a function to implement an interface is a much better idea than using a struct? Or perhaps, downsides to using the struct option in certain scenarios?

You see this in net/http with Handler and HandlerFunc. A function that satisfies an interface is convenient - you can pass in a closure even:

c := Controller{
    l: LoggerAdapter(func(message string) {fmt.Println(message)}),
}

But a function can't have fields and it's unusual for it to have additional useful methods. Func types like this tend to have a single method that just calls the function.

If you need a more complex type, that's what a struct is, so you can use that.