Interfaces satisfying interfaces

<< this post is mostly just a refresher for myself >>

Interfaces are often confusing for me. When I started parsing through some of the core/v1 kubernetes code, something stuck out to me: there are a lot of interfaces in here. Some only needing a single method to be satisfied.

Within this, a common theme was interfaces satisfying interfaces. This is a weak point of mine, so I crafted up a quick example to jog my memory.

---

Here's the code:

func main(){
    var a nested
    c := cat{}
    a = c
    a.Speak()
    d := dog{}
    a = d
    a.Speak()
}

type nested interface {
    random
}

type random interface {
    animal
}

type animal interface {
    Speak()
}

type cat struct{}
type dog struct{}

func (c cat) Speak() {
    fmt.Println("meow")
}

func (d dog) Speak() {
    fmt.Println("woof")
}

---

As you can see, there are three interfaces here: nested, random, and animal. However, only one of these has an actual method attached to it: animal. The other 2 are simply requiring other interfaces to be satisfied.

From there, I set up two object types, cat and dog, which both have the Speak() method. As you can see, it just prints out a statement.

Once in the main function, I set up a nested variable, which is an interface. This interface only requires an object that satisfies random which requires animal which requires any object type that has a method Speak(). In this case, bot the cat and dog objects do.

From there, I set the a variable to a dog or cat variable and call the methods.

---

This, however, will not work if we try to call a.Speak() before assigning an object that satisfies all of these conditions. If, for instance, I had the below code:

func main(){
    var a nested
    a.Speak()
}

It would cause a panic because the interface is currently <nil>.

---

Anyways, it was a good refresher on interfaces within Go for myself :)