O que é duck typing em Ruby?

Question

Accepted Answer

**Duck typing** é um princípio onde a adequação de um objeto é determinada pelo **quais métodos ele responde**, não pela sua classe ou tipo — "se anda como um pato e grasna como um pato, é um pato". Em Ruby, você se importa que um objeto *consiga fazer* algo (tenha o método), não qual é o seu tipo. Isso permite código flexível e polimórfico sem herança ou interfaces.

## O princípio: comportamento sobre tipo

```ruby
# this method works with ANY object that has a `quack` method —
# regardless of its class. No interface or inheritance required.
def make_it_quack(duck)
  duck.quack            # only cares that `duck` responds to `quack`
end

class Duck
  def quack = "Quack!"
end
class Person
  def quack = "I'm imitating a duck!"
end

make_it_quack(Duck.new)     # "Quack!"
make_it_quack(Person.new)   # "I'm imitating a duck!" — works! (it has quack)
```

`make_it_quack` funciona com **qualquer** objeto que tenha um método `quack` — um `Duck`, uma `Person`, qualquer coisa. Ele não verifica o tipo; simplesmente chama o método. Isso é polimorfismo sem herança compartilhada ou interfaces explícitas.

## Duck typing no mundo real

```ruby
# Ruby code typically relies on method presence, not type checks
def process(items)
  items.each { |i| puts i }   # works with ANY object that has `each`
  # → an Array, a Set, a Range, a custom Enumerable... all "quack" with each
end

# the << operator: works on anything that defines it
def append_to(collection, item)
  collection << item          # works on Array, String, IO, Logger... they all have <<
end
```

## Verificando comportamento (não tipo)

```ruby
# ✅ duck-typed — check if it responds to a method (behavior)
if obj.respond_to?(:each)
  obj.each { ... }
end

# ❌ less Ruby-like — checking the class/type
if obj.is_a?(Array)   # rigid; duck typing prefers checking capability
end
```

Ruby idiomático usa `respond_to?` (ele tem este método?) em vez de `is_a?` (é este tipo?) quando a flexibilidade importa — focando em **capacidade, não classe**.

## Por que isso importa

Duck typing é um princípio fundamental de Ruby e uma característica definidora de como Ruby alcança flexibilidade e polimorfismo, então entender isso é importante para escrever Ruby idiomático.

A ideia central — que a adequação de um objeto é determinada pelo **o que ele consegue fazer (seus métodos), não sua classe/tipo** — permite código flexível e polimórfico *sem* requerer herança compartilhada ou interfaces explícitas (ao contrário de linguagens tipadas estaticamente onde polimorfismo precisa de classes base comuns ou interfaces).

Isso é libertador e poderoso: um método funciona com qualquer objeto que responda aos métodos necessários, então você pode passar qualquer coisa que "grasne" — classes diferentes, objetos customizados — e funciona, tornando o código reutilizável e adaptável.

Entender duck typing explica o estilo flexível e focado em comportamento de Ruby e por que código Ruby tipicamente se baseia em **presença de método** (`respond_to?`) em vez de **verificações de tipo** (`is_a?`) — focar em capacidade em vez de classe é a abordagem Ruby idiomática.

Este princípio fundamenta grande parte da elegância de Ruby e da flexibilidade de suas bibliotecas e frameworks (que funcionam com qualquer coisa que fornece os métodos certos, como qualquer coisa com `each` ou `<<`).

Compreender duck typing — que Ruby se importa com comportamento não tipo, permitindo polimorfismo sem interface, e que Ruby idiomático verifica capacidade em vez de classe — é importante para escrever Ruby flexível e idiomático e para entender a filosofia dinâmica e orientada a comportamento que distingue Ruby de linguagens tipadas estaticamente.

É um tópico conceitual central que captura o design flexível de Ruby e um ponto frequente em entrevistas refletindo compreensão de programação dinâmica e duck-typed.