How can two different types implement the same method in golang using interfaces?

Question

Say I have two structs:

type First struct {
    str string
}
type Second struct {
    str string
}

And I want both of them to implement interface A:

type A interface {
    PrintStr() //print First.str or Second.str
}

It seems redundant to have an implementation for both First and Second structs like so:

func (f First) PrintStr() {
    fmt.Print(f.str)
}

func (s Second) PrintStr() {
    fmt.Print(s.str)
}

Is there a way I can have one implementation for all the structs implementing interface A? Something like this, but it doesn't seem to work:

func (a A) PrintStr() {
    fmt.Print(a.str)
}

Thank you!

It also seems a little bit redundant to have 2 structs with the same types. — TheHippo
– TheHippo, Commented Jul 19, 2015 at 20:47
Yes, but this is a toy example. First and Second could share some fields and not others. The point is that I want a function to behave in the exact same way for two different types, without having repeated code. — Ekaterina
– Ekaterina, Commented Jul 19, 2015 at 20:54

TheHippo · Accepted Answer · 2015-07-21 17:31:12Z

29

No you can't, but you could create a base type and then embed it into your 2 struct, therefore only needing an implementation for the base type:

type WithString struct {
    str string
}

type First struct {
    WithString
}

type Second struct {
    WithString
}

type A interface {
    PrintStr() //print First.str or Second.str
}

func (w WithString) PrintStr() {
    fmt.Print(w.str)
}

Usage:

a := First{
    WithString: WithString{
        str: "foo",
    },
}

Complete Example on Playground

Embed documentation

edited Jul 21, 2015 at 17:31

answered Jul 19, 2015 at 20:59

TheHippo

63.3k15 gold badges77 silver badges101 bronze badges

Sign up to request clarification or add additional context in comments.

6 Comments

Joey Over a year ago

what is this sorcery where you define a struct with a non-variable member?! from your answer: type First struct { WithString }... is there any documentation on this? defining a type struct as another type?

SirDarius Over a year ago

@Joey this is called embedding and it is a well known technique, see golang.org/doc/effective_go.html#embedding

Arun Gopalpuri Over a year ago

@TheHippo - what's the point of that interface in your example?

nogjam Over a year ago

@SirDarius Thanks for that link. I've had a hard time finding examples of embedding with structs, and this tells me without a doubt that it's possible. I need to read Effective Go in its entirety.

nogjam Over a year ago

Here's an example of embedding in action: github.com/gonum/gonum/blob/v0.9.3/mat/matrix.go#L36

|

SirDarius · Accepted Answer · 2015-07-20 08:35:18Z

If the printing logic depends on the interface but not on the structs themselves, then it is better to move printing to a free function that operates over an interface.

In your case, the PrintStr method is used to print a string which is a member of each structure.
In this case, it means that each structure should implement an interface that returns the necessary string used for printing, and PrintStr becomes a function taking a Printable parameter.

type First struct {
    str string
}
type Second struct {
    str string
}

type Printable interface {
     String() string
}

func (p First) String() string {
    return p.str
}

func (p Second) String() string {
    return p.str
}

func PrintStr(p Printable) {
    fmt.Print(p.String())
}

Your use of the A interface is non-idiomatic because an interface should not depend on the implementation of its functionality.

Instead, with this solution, you can still keep the A interface, but simplify each implementation:

func (f First) PrintStr() {
    PrintStr(f)
}

func (s Second) PrintStr() {
    PrintStr(s)
}

It is still redundant, but the logic lies in the function that is called from there, limiting the need to do copy-pasting in case of modification of the printing logic.

This pattern is common in the Go standard library, because many useful functions are built upon interfaces which they cannot extend, for example io.Reader.
It is a simple interface with only one method, but it is used thoroughly from many other packages.
If you look at the ioutil.ReadAll function, it could be argued that it could have been implemented as another method of the io.Reader interface, however this keeps readers simpler, concentrating on their single method, while allowing any implementor to use ReadAll for free.

mihaic · Accepted Answer · 2015-07-19 20:51:33Z

2

Maybe not the best way to solve your problem, but you could use a wrapper in order to avoid "implementing" the function twice, something like this:

type First struct {
    str StringWrapper
}
type Second struct {
    str StringWrapper
}


type StringWrapper struct {
    str string
}
func (f StringWrapper) PrintStr() {
    fmt.Print(f.str)
}

func main() {
    var a First = First{str:StringWrapper{str: "aaa"}};
    a.str.PrintStr();
}

answered Jul 19, 2015 at 20:51

mihaic

1852 silver badges7 bronze badges

1 Comment

user12817546 Over a year ago

This answer is the same as @TheHippo. See play.golang.org/p/yyRG9B_K7lk. Except no interface.

Pablo Arranz · Accepted Answer · 2019-01-21 21:44:35Z

-1

Why don't you just leave that function out of the interface and pass type A as a parameter?

type A interface {}

type First struct {
    str string
}
type Second struct {
    str string
}

func PrintStr(a A) {
    fmt.Print(a.str)
}

answered Jan 21, 2019 at 21:44

Pablo Arranz

152 bronze badges

1 Comment

izaban Over a year ago

This is wrong, you will get the following error when trying to define the PrintStr function a.str undefined (type A is interface with no methods)

Collectives™ on Stack Overflow

How can two different types implement the same method in golang using interfaces?

4 Answers 4

6 Comments

Comments

1 Comment

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

6 Comments

Comments

1 Comment

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related