依赖接口的golang接口

Question

I am not sure if these should be two separate questions or one, but it seems to me as one question of two parts - How go interfaces are supposed to be used? I have this two struggles:

The methods of the interfaces are globally scoped: If I have interface A and interface B that both implement the same method Foo, but with different arguments or return types I am unable to implement both at the same time from the same type. For example, I have GetBytes() method in one interface having return type []byte and in another ([]byte, error) How I should overcome this issue?

Another issue I have is when I try to define interface say interface A that has a method that returns interface B that is defined in the same layer. Now if I want to create an object that implements A, if I return struct that implements B go is not smart enough to deduce that this method implements the method in A and it forces me to create dependency on B. This seems to completely defeat the point of the way interfaces work in go at first place. How can I avoid this issue?

for example, if I have:

type B interface {
    Bar()
}

type A interface {
    Foo() B
}

for the following structs :

type b_impl struct{}

func (b b_impl) Bar() {}

type a_impl struct{}

A foo method

func (a a_impl) Foo() b_impl {}

does not satisfy the interface A and I need to make it:

func (a a_impl) Foo() B {}

which makes a dependency to the package where B is declared.

Answer 1

1st question: In go you need to make different function names, when you want to do different tasks. Let's look into the standard library at the strconv package how things are solved there: https://golang.org/pkg/strconv/#pkg-index

Look to the different declaration of the append function there. There are functions for every different type.

So if you expect a FooInt funtion your interface should be also a FooInter, ...

2nd question:As a small example. You don't need to import the whole io package, when you want to use the io.Writer interface. It is totaly ok to copy the Writer declaration into your own package. If you do that correct, every io.Writer implementation will automatically implement your own Writer interface.

After reading the other comments maybe you have a different situation:

Let's say there is a package a and b with the interface a.A and b.B. If there is the situation that:

type A interface{
  Foo() b.B
}

and you have to write an implementation for a.A, then you need to import package b. But that makes your binaries not bigger, because you will always need to import package a, which depends on b.