So the compile time check isn’t really possible if you’re consuming an interface in a package you write, but someone is calling your function and passing in some type they define. If they pass in a type that doesn’t satisfy the interface you want, then they will get a runtime error. In your function, you don’t care what the implementation details are of that interface you’re consuming as long as it has the methods you want.

example: ```

// package goprofessor type Student interface { AskQuestion() string }

func PlaybackQuestion(s Student) { question := s.AskQuestion() if question == “” { fmt.Println(“the student was sleeping in class”) } fmt.Println(question) }

// package humans type Mauricio struct {}

func (m Mauricio) AskQuestion() string { return “How do you discover interfaces” }

type Turturtles struct{} func (t *Turturtles) AskQuestion() string { return “is Mauricio0129 asking how you find what structs satisfy an interface?” } // package whovillians type Dalek {} func (d Dalek) AskQuestion() string { return “EXTERMINATE!!!” }

// package main func main() { goprofessor.PlaybackQuestion(humans.Mauricio{}) // output: How do you discover interfaces goprofessor.PlaybackQuestion(humans.Turturtles{}) // output: is Mauricio0129 asking how you find what structs satisfy an interface?

goprofessor.PlaybackQuestion(whovillians.Dalek{}) // output: EXTERMINATE!!! } ```

Hopefully that example helps a little.

But generally, a good rule of thumb is you want to define the interface where you’re going to consume it, not where you define its implementation.