Duck Typing em Go

Olá, pessoal!

Como contei em um post anterior, estou aprendendo Go para usar em alguns projetos do trabalho. Neste post curto, vou explicar como usar duck typing em Go, algo que foi bem desafiador para mim quando comecei a aprender a linguagem.

Para começar, vamos ver um exemplo simples em Python:

class Duck:
    def quack(self):
        print("Quack, quack!")


class Person(Duck):
    pass


def quack(obj):
    obj.quack()

def main():
    donald = Duck()
    john = Person()

    quack(donald) -- Quack, quack!
    quack(john) -- Quack, quack!

Neste exemplo um pouco excêntrico, a classe Person consegue “grasnar” como um Duck porque herda da classe Duck. Em Python, não precisamos declarar explicitamente o tipo do objeto na função; simplesmente chamamos o método que queremos usar.

Agora, vamos ver como fazer algo parecido em Go:

package main

import "fmt"

type Dog interface {
	Bark()
}

type Cat interface {
	Meow()
}

type Shihtzu struct {
	Name string
}

type Chartreux struct {
	Name string
}

func (s Shihtzu) Bark() {
	message := fmt.Sprintf("Type: %T - My name is %s! Bark! Bark! Bark!", s, s.Name)
	fmt.Println(message)
}

func (c Chartreux) Meow() {
	message := fmt.Sprintf("Type: %T - My name is %s! Meow! Meow! Meow! ", c, c.Name)
	fmt.Println(message)
}

func main() {
	var dog Dog
	dog = Shihtzu{Name: "Puppy"}
	dog.Bark()

	var cat Cat
	cat = Chartreux{Name: "Kitty"}
	cat.Meow()
}

O código de exemplo acima está neste repositório no GitHub.

Neste exemplo em Go, temos duas interfaces, Dog e Cat, e duas structs, Shihtzu e Chartreux. A interface Dog define um método Bark, enquanto a interface Cat define um método Meow. As structs Shihtzu e Chartreux implementam os métodos Bark e Meow, respectivamente. É importante notar que, embora isso não esteja escrito explicitamente no código, essas structs estão implementando as interfaces.

Em Go, implementamos uma interface simplesmente definindo os métodos exigidos, sem precisar declarar que a struct implementa explicitamente a interface.

Em outras palavras, não precisamos dizer que Shihtzu é um Dog; basta implementar o método Bark para a struct Shihtzu, e o Go entende automaticamente que Shihtzu satisfaz a interface Dog.

Isso é bem diferente de linguagens como Python ou Java, mas, quando você pega o jeito, é direto e fácil de usar.

Espero que este post ajude você a entender melhor o Go e como o duck typing funciona na linguagem!