Cómo implementar múltiples interfaces con firmas de métodos idénticas en diferentes paquetes

Supongamos que necesita implementar interfaces definidas en paquetes separados con firmas de métodos en conflicto . Esto puede ser un desafío, pero Go proporciona una solución.

Consideremos un ejemplo:

• En el paquete A:

  package A
  
  type Doer interface {
    Do() string
  }
  
  func FuncA(doer A.Doer) {
    // Use doer.Do() here to implement functionality
  }

• En el paquete B:

  package B
  
  type Doer interface {
    Do() string
  }
  
  func FuncB(doer B.Doer) {
    // Use doer.Do() here to implement functionality
  }

En su paquete principal:

package main

import (
    "path/to/A"
    "path/to/B"
)

type C int

// C implements both A.Doer and B.Doer, but the implementation of Do() aligns with A.
func (c C) Do() string {
    return "C implements both A and B"
}

func main() {
    c := C(0)
    A.FuncA(c) // Acceptable as C implements A.Doer
    B.FuncB(c) // Error, as the Do() implementation in C doesn't meet B.Doer requirements
}

Solución:

Para resolver este conflicto, Go ofrece un enfoque conciso:

if _, ok := obj.(A.Doer); ok {
}

Esto le permite verificar si un objeto (de un tipo de interfaz) se ajusta a otro tipo de interfaz (por ejemplo, A.Doer) en tiempo de ejecución.

Sin embargo, el OP destaca una complicación adicional : la lógica implementada para Do() en el Paquete A y el Paquete B es distinta. Para solucionar esto, cree envoltorios alrededor de su objeto:

• DoerA con C como campo, implementando A.Do() lógicamente.
• DoerB con C como campo, implementando B. Do() lógicamente.

Al implementar contenedores distintos, puede controlar qué método usar según el tipo de interfaz esperado (A.Doer o B.Doer). Esto elimina la necesidad de un único método Do() en el objeto C original, que tendría dificultades para implementar ambas lógicas.