Manejo de interfaces con firmas de métodos idénticas en diferentes paquetes

En Go, cuando se trata de múltiples interfaces con la misma firma de método pero definidas en paquetes separados, pueden surgir situaciones en las que un tipo que implementa ambas interfaces genera un comportamiento inesperado.

Considere estas dos interfaces (Doer) y funciones (FuncA y FuncB) definidas en diferentes paquetes:

// Package A
type Doer interface { Do() string }
func FuncA(doer Doer)

// Package B
type Doer interface { Do() string }
func FuncB(doer Doer)

Si un tipo C implementa Doer desde ambos paquetes y la implementación difiere:

// Package main
type C int
func (c C) Do() string { return "A-specific implementation" }

func main() {
    cA := C(0); A.FuncA(cA)
    cB := C(0); B.FuncB(cB) // Behavior differs due to varying `Do()` implementations
}

Para abordar este problema, el sistema de tipos de Go enfatiza la coincidencia por nombre y la coherencia en los tipos. Si bien permite que un objeto satisfaga múltiples interfaces, la implementación del método compartido debe cumplir con todos los contratos de interfaz aplicables.

En el escenario anterior, una solución alternativa implica implementar tipos de contenedor:

// Package main
type DoerA struct { C C }
func (d DoerA) Do() string { return "A-specific implementation" }
type DoerB struct { C C }
func (d DoerB) Do() string { return "B-specific implementation" }

func main() {
    cA := DoerA{C(0)}; A.FuncA(cA)
    cB := DoerB{C(0)}; B.FuncB(cB) // Correct behavior with separate implementations
}

Al crear estos contenedores, puede controlar la implementación de Do() en función del uso previsto de la interfaz, lo que garantiza la coherencia dentro de los respectivos contextos del paquete.