最小化Golang中的接口

Question

In golang, interfaces are extremely important for decoupling and composing code, and thus, an advanced go program might easily define 1000s of interfaces .

How do we evolve these interfaces over time, to ensure that they remain minimal?

• Are there commonly used go tools which check for unused functions ?

• Are there best practices for annotating go functions with something similar to java's @Override, which ensures that a declared function is properly implementing a expected contract?

Typically in the java language, it is easy to keep code tightly bound to an interface specification because the advanced tooling allows us to find and remove functions which aren't referenced at all (usually this is highlighted automatically for you in any common IDE).

Answer 1

Are there commonly used go tools which check for unused functions ?

Sort of, but it is really hard to be sure for exported interfaces. oracle can be used to find references to types or methods, but only if you have all of the code that references you availible on your gopath.

can you ensure a type implements a contract?

If you attempt to use a type as an interface, the compiler will complain if it does not have all of the methods. I generally do this by exporting interfaces but not implementations, and making a constructor:

type MyInterface interface{
    Foo()
}
type impl struct{}
func (i *impl) Foo(){}
func NewImpl() MyInterface{
    return &impl{}
}

This will not compile if impl does not implement all of the required functions.

In go, it is not needed to declare that you implement an interface. This allows you to implement an interface without even referencing the package it is defined in. This is pretty much exactly the opposite of "tightly binding to an interface specification", but it does allow for some interesting usage patterns.