golang interface that depends on interface

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.

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.

For implementing an interface, you need to have exactly the same method name and signature. Means the signature must be with the same types.

As much as it seems weird, these two don't have the same signature:

Foo() B

Foo() b_impl {}

It doesn't matter that b_impl implements B.

To overcome the need to import the package B is declared in, you can use anonymous type. This way the compiler won't require a specific type for the method signature.

type A interface {
    Foo() interface{Bar()}
}

Which also can be written as embedding B:

type A interface {
    Foo() interface{B}
}

Still, a_impl must have same signature, so it also needs to return an anonymous interface. You can also declare the same B interface in the package of a_impl, and embed it in an anonymous interface.

package impl

type B interface {
	Bar()
}

type b_impl struct{}

func (b b_impl) Bar() {}

type a_impl struct{}

func (a a_impl) Foo() interface{B} {
	return b_impl{}
}

I don't know if it's a bad practice or not, probably there are cases which redesign is required instead of doing this.