¿Qué es el duck typing en Ruby?

Question

Accepted Answer

El **duck typing** es un principio según el cual la idoneidad de un objeto se determina por **a qué métodos responde**, no por su clase o tipo: "si camina como un pato y grazna como un pato, es un pato". En Ruby, lo que importa es que un objeto *pueda hacer* algo (que tenga el método), no de qué tipo es. Esto permite escribir código flexible y polimórfico sin herencia ni interfaces.

## El principio: comportamiento por encima del 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 con **cualquier** objeto que tenga un método `quack`: un `Duck`, una `Person`, lo que sea. No comprueba el tipo; simplemente llama al método. Esto es polimorfismo sin herencia compartida ni interfaces explícitas.

## Duck typing en el 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
```

## Comprobar el comportamiento (no el 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
```

El Ruby idiomático usa `respond_to?` (¿tiene este método?) en lugar de `is_a?` (¿es de este tipo?) cuando la flexibilidad importa, centrándose en la **capacidad, no en la clase**.

## Por qué es importante

El duck typing es un principio fundamental de Ruby y un rasgo definitorio de cómo Ruby logra flexibilidad y polimorfismo, por lo que entenderlo es importante para escribir Ruby idiomático.

La idea central —que la idoneidad de un objeto se determina por **lo que puede hacer (sus métodos), no por su clase/tipo**— permite escribir código flexible y polimórfico *sin* requerir herencia compartida ni interfaces explícitas (a diferencia de los lenguajes de tipado estático, donde el polimorfismo necesita clases base o interfaces comunes).

Esto es liberador y potente: un método funciona con cualquier objeto que responda a los métodos necesarios, así que puedes pasar cualquier cosa que "grazne" —clases distintas, objetos personalizados— y simplemente funciona, lo que hace que el código sea reutilizable y adaptable.

Comprender el duck typing explica el estilo flexible y orientado al comportamiento de Ruby y por qué el código Ruby normalmente se basa en la **presencia de métodos** (`respond_to?`) en lugar de en **comprobaciones de tipo** (`is_a?`): centrarse en la capacidad por encima de la clase es el enfoque idiomático de Ruby.

Este principio sustenta gran parte de la elegancia de Ruby y la flexibilidad de sus bibliotecas y frameworks (que funcionan con cualquier cosa que proporcione los métodos adecuados, como cualquier cosa con `each` o `<<`).

Dominar el duck typing —que a Ruby le importa el comportamiento y no el tipo, lo que habilita un polimorfismo sin interfaces, y que el Ruby idiomático comprueba la capacidad en lugar de la clase— es importante para escribir Ruby flexible e idiomático y para entender la filosofía dinámica y orientada al comportamiento que distingue a Ruby de los lenguajes de tipado estático.

Es un tema conceptual central que captura el diseño flexible de Ruby y un punto frecuente en entrevistas que refleja la comprensión de la programación dinámica y basada en duck typing.