Cos'è il duck typing in Ruby?

Question

Accepted Answer

**Duck typing** è un principio in cui l'idoneità di un oggetto è determinata da **quali metodi implementa**, non dalla sua classe o tipo — "se cammina come un'anatra e gracida come un'anatra, allora è un'anatra". In Ruby, ti importa che un oggetto *possa fare* qualcosa (abbia il metodo), non di che tipo sia. Questo abilita codice flessibile e polimorfico senza ereditarietà o interfacce.

## Perché è importante

```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` funziona con **qualsiasi** oggetto che ha un metodo `quack` — una `Duck`, una `Person`, qualunque cosa. Non controlla il tipo; chiama semplicemente il metodo. Questo è polimorfismo senza ereditarietà condivisa o interfacce esplicite.

## Duck typing nel mondo reale

```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
```

## Verificare il comportamento (non il 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
```

Il Ruby idiomatico usa `respond_to?` (ha questo metodo?) piuttosto che `is_a?` (è di questo tipo?) quando la flessibilità è importante — focalizzandosi su **capacità, non sulla classe**.

Il duck typing è un principio fondamentale di Ruby e una caratteristica distintiva di come Ruby raggiunge flessibilità e polimorfismo, quindi comprenderlo è importante per scrivere Ruby idiomatico.

L'idea centrale — che l'idoneità di un oggetto è determinata da **cosa può fare (i suoi metodi), non dalla sua classe/tipo** — abilita codice flessibile e polimorfico *senza* richiedere ereditarietà condivisa o interfacce esplicite (diversamente dai linguaggi tipati staticamente dove il polimorfismo necessita classi base comuni o interfacce).

Questo è liberatorio e potente: un metodo funziona con qualsiasi oggetto che risponde ai metodi necessari, quindi puoi passare qualunque cosa che "gracidi" — classi diverse, oggetti personalizzati — e funziona semplicemente, rendendo il codice riutilizzabile e adattabile.

Comprendere il duck typing spiega lo stile flessibile e orientato al comportamento di Ruby e perché il codice Ruby tipicamente si affida alla **presenza di metodi** (`respond_to?`) piuttosto che a **controlli di tipo** (`is_a?`) — focalizzarsi sulla capacità piuttosto che sulla classe è l'approccio Ruby idiomatico.

Questo principio è alla base di gran parte dell'eleganza di Ruby e della flessibilità delle sue librerie e framework (che funzionano con qualunque cosa fornisca i metodi giusti, come qualunque cosa con `each` o `<<`).

Comprendere il duck typing — che Ruby si preoccupa del comportamento non del tipo, permettendo polimorfismo senza interfacce, e che il Ruby idiomatico controlla la capacità piuttosto che la classe — è importante per scrivere Ruby flessibile e idiomatico e per comprendere la filosofia dinamica e orientata al comportamento che distingue Ruby dai linguaggi tipati staticamente.

È un argomento concettuale fondamentale che cattura il design flessibile di Ruby e un punto frequente nei colloqui che riflette la comprensione della programmazione dinamica e duck-typed.