How to support multiple versions of the same interface?

Question content

I am writing a go module that implements a structure that satisfies the interface. We only want to maintain a single version of the library, but our customers use multiple versions of one of our dependencies.

The dependencies provide the interface we want to implement, as shown below.

type supercoolinterface interface {
    dooldcoolthing(value string)
}

Our implementation is like this.

type supercoolimpl struct {}

func (sc *supercoolimpl) dooldcoolthing(value string) {}

New versions of dependencies add new types in the types module.

type newtype struct {
  value string
}

The dependency adds a method to the interface.

type supercoolinterface interface {
    dooldcoolthing(value string)
    donewcoolthing(value types.newtype)
}

Now, if I implement the new method, it won't compile with the old version of the library because types.newtype doesn't exist. However, I can't satisfy the new version of the interface if I don't implement the new version.

type SuperCoolImpl struct {}

func (sc *SuperCoolImpl) DoOldCoolThing(value string) {}
func (sc *SuperCoolImpl) DoNewCoolThing(value types.NewType) {}

Do we need to fork the code to support this version? In languages ​​with preprocessors, there is a simple solution, so I'm assuming go must have a solution that I'm missing.

We plan to continue developing and supporting both versions, so it would be annoying to need to ensure consistency between two different versions. I'm hoping I can do something with reflection or something similar to the c preprocessor where I can define a preprocessor value and only implement the method if we instruct the version of the library to have the correct type.

Correct answer

I found a solution that works for my situation.

Thanks to @Burak Serdar for pointing me in the right direction.

My solution was to put the old implementation into the impl/v0 package and the new implementation into the impl/v1 package.

Clients using older versions of dependencies will use impl/v0, and clients using newer versions of dependencies will use impl/v1.

Since golang only compiles directly imported code, only packages with the correct interface version will be compiled, so both directions will be compiled successfully.

This alleviates my concerns about having to fork the entire library.

Edit: If anyone uses this solution, there is a problem if you are currently running your tests using go test ./... . The command seems to try to build every module whether it contains tests or not.

But you can exclude the tests using go test $(go list ./... | grep -v <path_to_ignore>)</path_to_ignore> and then you can run these against the correct version in another command test.

The above is the detailed content of How to support multiple versions of the same interface?. For more information, please follow other related articles on the PHP Chinese website!