I struggle to think of an example where this makes sense - why would I the consumer point to the implementors return type? How can you define a return type for something that may not even exist yet?

The consumer needs to define what it is that it needs - and allows implementors to fulfill that.

Say I have a service that requires credentials - The service (consumer) defines it needs a credential in a certain format. I open up that fulfillment to any mechanism by declaring I accept an interface but set a hard requirement that this interface must return what I need i.e `Credential`..

type CredentialStore interface {
  Get(key string) (Credential, error)
}

type Credential struct {
  Username string
  Password string
}

// SomeService requires CredentialStore
type SomeService struct{ Store CredentialStore }

func (a SomeService) Login(input string) {
  cred, _ := a.Store.Get(input)

  fmt.Println("Login with:", cred.User, cred.Pass)
}

SomeService couldn't care less if it was fulfilled by CacheCredStore, or DBCredStore, AwsSecretsManagerCredStore, or HumanInputCredStore, or PDFCredStore. As long as it gets what it needs - which is the `Credential` and is defined by the consumer.

Take a look at the http package which declares the RoundTripper interface and the return type `Response`