Golang OOP澄清

Question

I have two interfaces written in go, one which is a subset of the other

type x interface {
    a()
}

type y interface {
    a()
    b()
}

I also have a struct that has methods as such

type z struct {
    some string
}

func (s z) a() {
    // do stuff
}

func (s z) b() {
    // do stuff
}

I have a few questions regarding this, namely:

1. Am I right to say that z implements both x and y?
2. What is the OOP concept for one struct implementing multiple interfaces in this way?

I tried asking a few colleagues, who seem to lean towards polymorphism as the answer although they are not too sure. The wikipedia entry for polymorphism says that it "is the provision of a single interface to entities of different types", but this feels like the direct reverse to me. I have also found in other sources (eg. this) that Go is "not really a OOP language".

Answer 1

Yes, z implements both x and y. You can prove that by using a variable declaration to assign a concrete type to an interface type:

var _ x = z{}
var _ y = z{}

That gives you a compile time check to ensure that a type implements the interfaces you want it to.

As a side note, if you explicitly wanted y to be x + some more methods, then it'd make sense to write it like this:

interface y {
    x
    b()
}

About the naming, if a type implements two different interfaces which share some methods, I'd call it just that - a type that's implementing two different interfaces. One interface being a subset of another doesn't matter.

Moreover in Go, types (non struct types as well) are not associated with interfaces when they are defined. Even if a type was not written to implement some interface, you can make it implement any number of interfaces by defining new interfaces with different names and/or different combinations of methods from the type. That makes giving a name to the concept even harder - how would you know the name at the time of type definition when interfaces may be defined later in another package?