How can I support multiple versions of same interface?

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

The dependency provides an interface we want to implement, like this.

type SuperCoolInterface interface {
    DoOldCoolThing(value string)
}

And our implementation is like this.

type SuperCoolImpl struct {}

func (sc *SuperCoolImpl) DoOldCoolThing(value string) {}

The new version of the dependency adds a new type in a 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, since types.NewType does not exist. However, if I don't implement the new version, I won't satisfy the new version of the interface.

type SuperCoolImpl struct {}

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

Do we need to fork our code in order to support this version? In languages with preprocessors there is an easy solution for this, so I am assuming Go must have a solution I am missing.

We are planning to continue development and support both versions, so it would be annoying to need to ensure two different version maintain consistency. I was hoping I could do something with reflection or something similar to C's preprocessor where I can define a preprocessor value and only implement the method when we indicate the version of the library has the correct type.

I figured out a solution that works for my situation.

Thanks @Burak Serdar for aiming me in the right direction.

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

The clients who use the old version of the dependency will use impl/v0, and the clients that use the new version of the dependency will use impl/v1.

Since golang only compiles the code that was imported directly, only the package with the correct version of the interface will be compiled, so will successfully compile in both directions.

The alleviates my concern about having to fork the entire library.

Edit: If anyone uses this solution there is one gotcha if you are currently running your tests with go test ./.... That command seems to try and build every module, regardless of if it has tests in it or not.

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