Como verificar a conformidade da estrutura com a interface em Go?

Em Go, a correspondência de uma estrutura com uma interface é verificada implicitamente durante a compilação. Se a estrutura implementar todos os métodos exigidos pela interface, ela é automaticamente considerada compatível com essa interface. Não é necessário indicar explicitamente a compatibilidade.

Pode usar os seguintes métodos para verificar a compatibilidade durante a compilação:

1. Atribuir a estrutura a uma variável do tipo interface.
2. Passar a estrutura para uma função que espera um argumento do tipo interface.

Exemplo com atribuição:

// Definir a interface
type MyInterface interface {
	DoSomething()
	GetValue() int
}

// Definir a estrutura que deve cumprir a interface
type MyStruct struct {
	value int
}

// Métodos da estrutura que implementam MyInterface
func (s MyStruct) DoSomething() {
	// alguma lógica
}

func (s MyStruct) GetValue() int {
	return s.value
}

// Verificação de compatibilidade durante a compilação:
// Atribuímos uma instância da estrutura a uma variável do tipo interface.
// Se MyStruct não implementar MyInterface, o compilador dará um erro.
var _ MyInterface = MyStruct{}

Exemplo com passar para uma função:

// Função que aceita um argumento do tipo interface MyInterface
func Process(item MyInterface) {
	item.DoSomething()
	_ = item.GetValue() // usamos o valor
}

// Em outro lugar do código:
// Criamos uma instância de MyStruct
myInstance := MyStruct{value: 42}

// Passamos a instância da estrutura para uma função que espera a interface.
// Se MyStruct não implementar MyInterface, o compilador dará um erro.
Process(myInstance)

Essas abordagens garantem que a estrutura esteja em conformidade com a interface definida mesmo antes de executar o programa, o que é um aspecto importante da segurança de tipos em Go.