Suppose I have two pets, a cat named Lucy and a dog named Fido. I have taught them both the same trick, "speak".
In the future I would like to obtain more pets, and teach them different tricks, so in anticipation, I've coded to an interface:
package main
import "fmt"
type Pet interface {
speak() string
}
type Dog struct {
speech string
}
type Cat struct {
speech string
}
func (c Cat) speak() string {
return c.speech
}
func (d Dog) speak() string {
return d.speech
}
func getSpeech(p Pet) string {
return p.speak()
}
func main() {
Fido := Dog{"woof"}
Lucy := Cat{"meow"}
fmt.Println("Fido says:", getSpeech(Fido)) // Fido says: woof
fmt.Println("Lucy says:", getSpeech(Lucy)) // Lucy says: meow
}
Now, although this works well, it seems unnecessarily verbose. I'm clearly repeating myself. Also, assuming all Dogs say "woof" and all Cats say "meow", is it idiomatic to initialize the string inside the struct?
How would you re-factor this code to be more DRY without losing the benefit of an interface?
You can embed a base type in some cases to delegate common fields and methods. This is not inheritance, it is only a form of automatic delegation via composition. Don't try to use this to create type hierarchies like you would in a java-style OOP language.
Here you can delegate the speak method to the Speaker type. In practice this is less useful because the Speaker and its methods have no relationship to the struct where they are embedded, i.e. a Speaker doesn't know which type it's speaking for, nor which individual instance.
https://play.golang.org/p/Bof92jZsNh
type Speaker struct {
Saying string
}
func (s Speaker) speak() string {
return s.Saying
}
type Pet interface {
speak() string
}
type Dog struct {
Speaker
}
type Cat struct {
Speaker
}
func getSpeech(p Pet) string {
return p.speak()
}
func main() {
Fido := Dog{Speaker{Saying: "woof"}}
Lucy := Cat{Speaker{Saying: "meow"}}
fmt.Println("Fido says:", getSpeech(Fido)) // Fido says: woof
fmt.Println("Lucy says:", getSpeech(Lucy)) // Lucy says: meow
}