The Golang Trinity: Functions, Methods, Interfaces

Function: Does something with inputs

Method Does something attached to a type

Interface Says what methods a type must have

A method is a function with a receiver.

An interface is a set of method signatures.

If a type has those methods → it satisfies the interface. Automatically.

No implements. No inheritance. Just behavior.

// Function

func Add(a, b int) int { return a + b }

type Counter struct{ val int }

// Method (receiver is the "attachment")

func (c Counter) Add(n int) int { return c.val + n }

1. Function vs. Method
   // Function
   func Add(a, b int) int { return a + b }

type Counter struct{ val int }

// Method (receiver is the "attachment")

func (c Counter) Add(n int) int { return c.val + n }

Same logic. Different style.

Use functions for stateless operations.

Use methods when behavior belongs to a type.

1. The Interface Glue

type Stringer interface {

String() string

}

type User struct{ Name string }

// User now implements Stringer automatically

func (u User) String() string { return u.Name }

func Print(s Stringer) { fmt.Println(s.String()) }

func main() {

Print(User{Name: "Alice"}) // Works!

}

Key: The function Print doesn't care about User. It cares about the String() method.

1. The Twist: Functions Can Be Interfaces
   This is the pattern that confuses people.

// An interface

type Handler interface {

Handle(string)

}

// A function type

type HandlerFunc func(string)

// The trick: attach the Handle method to the function type

func (f HandlerFunc) Handle(s string) {

f(s) // calls itself

}

// Now any function with signature func(string) works as a Handler

func Log(s string) { fmt.Println("LOG:", s) }

func main() {

var h Handler = HandlerFunc(Log)

h.Handle("test") // LOG: test

}

Why is this useful?

It lets you use simple functions where interfaces are expected.

The standard http.HandlerFunc works exactly like this.

1. Putting It All Together
   go
   type Greeter interface { Greet() string }

type Person struct{ Name string }

func (p Person) Greet() string { return "Hi, " + p.Name }

type GreetFunc func() string

func (gf GreetFunc) Greet() string { return gf() }

func Party(g Greeter) { fmt.Println(g.Greet()) }

func main() {

Party(Person{Name: "Bob"}) // Method

Party(GreetFunc(func() string { // Function as interface

return "Surprise!"

}))

}

The Golden Rule

Accept interfaces, return structs.

Functions orchestrate.

Methods define behavior on types.

Interfaces abstract the what from the how.

Your Turn

What's your favorite small interface from the standard library?

io.Reader? fmt.Stringer? http.Handler?

Drop it below 👇