What is the function-as-interface pattern in Go and how does it enable flexible APIs?

// Define an interface
type Transformer interface {
    Transform(s string) string
}

// Named function type
type TransformFunc func(string) string

// Implement the interface on the function type
func (f TransformFunc) Transform(s string) string { return f(s) }

// Usage: pass a closure directly
func applyAll(s string, ts ...Transformer) string {
    for _, t := range ts {
        s = t.Transform(s)
    }
    return s
}

result := applyAll("  hello world  ",
    TransformFunc(strings.TrimSpace),
    TransformFunc(strings.ToUpper),
    TransformFunc(func(s string) string { return "[" + s + "]" }),
)
fmt.Println(result) // [HELLO WORLD]

// Struct implementing the same interface — full control over state
type PrefixTransformer struct{ Prefix string }
func (p PrefixTransformer) Transform(s string) string {
    return p.Prefix + s
}

result2 := applyAll("world",
    PrefixTransformer{Prefix: "Hello, "},
    TransformFunc(strings.ToUpper),
)
fmt.Println(result2) // HELLO, WORLD