Como implementar múltiplas interfaces com assinaturas de métodos idênticos em pacotes diferentes

Suponha que você precise implementar interfaces definidas em pacotes separados com assinaturas de métodos conflitantes . Isso pode ser desafiador, mas Go oferece uma solução.

Vamos considerar um exemplo:

• No pacote A:

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

• No pacote B:

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

Em seu pacote 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
}

Solução:

Para resolver esse conflito, Go oferece uma abordagem concisa:

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

Isso permite verificar se um objeto (de um tipo de interface) está em conformidade com outro tipo de interface (por exemplo, A.Doer) em tempo de execução.

No entanto, o OP destaca uma complicação adicional : a lógica implementada para Do() no Pacote A e no Pacote B é distinta. Para resolver isso, crie wrappers em torno do seu objeto:

• DoerA com C como campo, implementando A.Do() logicamente.
• DoerB com C como campo, implementando B. Do() logicamente.

Ao implementar wrappers distintos, você pode controlar qual método usar com base no tipo de interface esperado (A.Doer ou B.Doer). Isso elimina a necessidade de um único método Do() no objeto C original, que teria dificuldades para implementar ambas as lógicas.