¿Qué es la tipificación de pato?

La tipificación dinámica (duck typing) es un estilo de tipificación dinámica en el que el tipo de un objeto o variable se determina no en función de su herencia explícita o implementación de interfaz, sino en función de la presencia de un conjunto determinado de métodos o propiedades. Si un objeto "camina como un pato y grazna como un pato", se considera que es un pato.

En Go, la tipificación de pato se implementa a través de interfaces implícitas. La estructura u otro tipo de datos no necesita indicar explícitamente que implementa una interfaz determinada. Es suficiente que el tipo de datos implemente todos los métodos definidos en la interfaz.

Ejemplo:

package main

import "fmt"

// Definimos la interfaz Speaker
type Speaker interface {
	Speak()
}

// Definimos la estructura Dog
type Dog struct{}

// Dog implementa el método Speak()
func (d Dog) Speak() {
	fmt.Println("¡Guau!")
}

// Definimos la estructura Cat
type Cat struct{}

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

// La función recibe un argumento de tipo Speaker
func MakeItSpeak(s Speaker) {
	s.Speak()
}

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

	// Ambos objetos, Dog y Cat, pueden ser pasados a MakeItSpeak,
	// ya que ambos implementan implícitamente Speaker.
	MakeItSpeak(d)
	MakeItSpeak(c)
}

En este ejemplo, ni Dog ni Cat indican explícitamente que implementan Speaker. Sin embargo, dado que ambos tienen el método Speak(), que coincide con la firma del método en la interfaz Speaker, pueden ser utilizados donde se espera un tipo Speaker.

Ventajas de la tipificación de pato en Go:

• Flexibilidad: Permite crear sistemas modulares y extensibles fácilmente.
• Ausencia de jerarquía rígida: No es necesario heredar o implementar explícitamente interfaces al diseñar.
• Facilidad de uso de tipos existentes: Cualquier tipo que tenga los métodos necesarios puede cumplir con la interfaz, incluso si fue desarrollado sin tener en cuenta esa interfaz.