Substitute an interface for another one - go

Question

Recently, I stumbled upon an interesting article regarding the organization of Go code.
I was highly interested in the third approach: 'Independent Packages'.
It's said packages should NOT depend on each other, but defines their own interface to interact with
other packages.
Now, I face a problem with the approach.
I'm building a CLI applications that's able to execute various commands, one after each other.
It's important that these commands can share data.
First, I have built a contain in which I can register commands.
This resides in the package: commands.
import (
"sync"
)
// PRIVATE: Defines the API for sharing data between different commands.
type context interface {
SetAPIKey(string)
}
// Command defines the API that a command should satisfy to become eligible for being registered in the container
type Command interface {
GetName() string
SetProperty(prop, val string) error
Execute(context) error
}
// Container exposes the API for registration and retrieving of services.
type Container struct {
mutex sync.RWMutex
registeredCommands map[string]Command
}
// Add adds the command `cmd` to the container.
func (c *Container) Add(cmd Command) {
c.withLock(func() {
if c.registeredCommands == nil {
c.registeredCommands = make(map[string]Command)
}
c.registeredCommands[cmd.GetName()] = cmd
})
}
// Get retrieves the command who's name is equal to `name`.
func (c *Container) Get(name string) Command {
return c.withRLock(func() Command {
if c.registeredCommands == nil {
return nil
}
if cmd, ok := c.registeredCommands[name]; ok {
return cmd
}
return nil
})
}
// PRIVATE: Create a lock and execute the function `handler`.
// The lock is being released when the function `handler` is executed.
func (c *Container) withLock(handler func()) {
c.mutex.Lock()
defer c.mutex.Unlock()
handler()
}
// PRIVATE: Create a "read" lock and execute the function `handler`.
// The lock is being released when the function `handler` is executed.
func (c *Container) withRLock(handler func() Command) Command {
c.mutex.RLock()
defer c.mutex.RUnlock()
return handler()
}
Next I have command which implements the Command interface.
NOTE: This is stored in another package: rest.
import (
"bytes"
"encoding/json"
"encoding/xml"
"errors"
"fmt"
"io/ioutil"
"net/http"
)
// PRIVATE: Defines the API for sharing data between different commands.
type context interface {
SetAPIKey(string)
}
// GetAPIKey is the command that allows the retrieval of a API key using the REST API.
type GetAPIKey struct {
}
// GetName returns the name of the command `cmd`.
func (GetAPIKey) GetName() string {
return "API.REST.getAPIKey"
}
// SetProperty assigns value `val` to property `prop`.
func (cmd *GetAPIKey) SetProperty(prop, val string) error {
return nil
}
// Execute runs the command.
func (cmd GetAPIKey) Execute(ctx context) error {
ctx.SetAPIKey(xmlResponse.Key)
return nil
}
The MAIN entry point of the application is defined as follows:
// PRIVATE: Defines the container in which all the available commands are registered.
var container commands.Container
// PRIVATE: Defines an API for sharing data between different commands.
type context struct {
apiKey string
}
func (ctx *context) SetAPIKey(value string) {
ctx.apiKey = value
}
// PRIVATE: Represents the 'MAIN' entry point for the application.
// This method is executed when the application is started.
func main() {
ctx := &context{}
container := new(commands.Container)
container.Add(&rest.GetAPIKey{})
command := container.Get("API.REST.getAPIKey")
command.SetProperty("baseURI", "")
command.SetProperty("environmentNameOrURL", "")
command.SetProperty("userName", "")
command.SetProperty("password", "")
err := command.Execute(ctx)
if err != nil {
fmt.Println(err)
}
}
However this code does NOT compile.
It yields the following error:
.\app.go:53:16: cannot use &rest.GetAPIKey literal (type *rest.GetAPIKey) as type commands.Command in argument to container.Add:
*rest.GetAPIKey does not implement commands.Command (wrong type for Execute method)
have Execute(rest.context) error
want Execute(commands.context) error
Is there any way to make this code work?
So the context interface is defined in 2 places.

Answer 1

This will not work because the function signatures don't match. You can do:
Make Context a shared interface, so every package can use it. This does not necessarily introduce dependencies between packages using it.
Use context.Context, and expect to see the key in there. This is essentially the same as #1 but using a known predefined type
Use interface{} instead of context, and use type assertion to convert it to the local context type.