O que é tipagem de pato?

A tipificação de pato (duck typing) é um estilo de tipagem dinâmica em que o tipo de um objeto ou variável é determinado não com base na sua herança explícita ou implementação de interface, mas com base na presença de um conjunto específico de métodos ou propriedades. Se um objeto "anda como um pato e grasna como um pato", então considera-se que ele é um pato.

Em Go, a tipificação de pato é implementada através de interfaces implícitas. A estrutura ou qualquer outro tipo de dado não precisa indicar explicitamente que implementa uma determinada interface. Basta que o tipo de dado implemente todos os métodos definidos na interface.

Exemplo:

package main

import "fmt"

// Define a interface Speaker
type Speaker interface {
	Speak()
}

// Define a estrutura Dog
type Dog struct{}

// Dog implementa o método Speak()
func (d Dog) Speak() {
	fmt.Println("Au au!")
}

// Define a estrutura Cat
type Cat struct{}

// Cat implementa o método Speak()
func (c Cat) Speak() {
	fmt.Println("Miau!")
}

// A função aceita um argumento do tipo Speaker
func MakeItSpeak(s Speaker) {
	s.Speak()
}

func main() {
	d := Dog{}
	c := Cat{}

	// Ambos objetos, Dog e Cat, podem ser passados para MakeItSpeak,
	// pois ambos implicitamente implementam Speaker.
	MakeItSpeak(d)
	MakeItSpeak(c)
}

Neste exemplo, nem Dog nem Cat indicam explicitamente que implementam Speaker. No entanto, como ambos possuem o método Speak(), que corresponde à assinatura do método na interface Speaker, eles podem ser usados onde se espera um Speaker.

Vantagens da tipificação de pato em Go:

• Flexibilidade: Permite criar sistemas modulares e extensíveis facilmente.
• Ausência de hierarquia rígida: Não é necessário herdar ou implementar explicitamente interfaces ao projetar.
• Facilidade de uso de tipos existentes: Qualquer tipo que tenha os métodos necessários pode cumprir a interface, mesmo que tenha sido desenvolvido sem considerar essa interface.