Ce este duck typing în Ruby?

Question

Accepted Answer

**Duck typing** este un principiu în care adecvarea unui obiect este determinată de **ce metode poate apela**, nu de clasa sau tipul acestuia — "dacă merge ca o rață și cântă ca o rață, atunci este o rață". În Ruby, te interesează că un obiect *poate face* ceva (are metoda), nu ce tip este. Aceasta permite cod flexibil și polimorf fără moștenire sau interfețe.

## Principiul: comportament peste tip

```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` funcționează cu **orice** obiect care are o metodă `quack` — un `Duck`, o `Person`, orice. Nu verifică tipul; pur și simplu apelează metoda. Acesta este polimorfismul fără moștenire comună sau interfețe explicite.

## Duck typing în lumea 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
```

## Verificarea comportamentului (nu a tipului)

```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 idiomativ folosește `respond_to?` (are această metodă?) în locul `is_a?` (este acest tip?) când flexibilitatea este importantă — concentrandu-se pe **capacitate, nu pe clasă**.

## De ce conteaza

Duck typing este un principiu fundamental în Ruby și o caracteristică definitorie a modului în care Ruby realizează flexibilitate și polimorfism, deci înțelegerea acestuia este importantă pentru scrierea Ruby idiomativ.

Idea centrală — că adecvarea unui obiect este determinată de **ce poate face (metodele sale), nu de clasa/tipul acestuia** — permite cod flexibil și polimorf *fără* a necesita moștenire comună sau interfețe explicite (spre deosebire de limbajele tipate static în care polimorfismul necesită clase de bază comune sau interfețe).

Aceasta este liberatoare și puternică: o metodă funcționează cu orice obiect care răspunde la metodele necesare, deci puteți transmite orice care "cântă" — clase diferite, obiecte personalizate — și pur și simplu funcționează, făcând codul reutilizabil și adaptabil.

Înțelegerea duck typing explică stilul flexibil și orientat pe comportament al Ruby și de ce codul Ruby se bazează de obicei pe **prezența metodei** (`respond_to?`) mai degrabă decât pe **verificări de tip** (`is_a?`) — concentrarea pe capacitate peste clasă este abordarea idiomatică Ruby.

Acest principiu este la baza multor din eleganța Ruby și a flexibilității bibliotecilor și framework-urilor sale (care funcționează cu orice furnizează metodele corecte, cum ar fi orice cu `each` sau `<<`).

Înțelegerea duck typing — că Ruby se preocupă de comportament nu de tip, permițând polimorfism fără interfață, și că Ruby idiomativ verifică capacitate mai degrabă decât clasă — este importantă pentru scrierea Ruby flexibilă și idiomatică și pentru înțelegerea filosofiei dinamice și orientate pe comportament care deosebește Ruby de limbajele tipate static.

Este un subiect conceptual fundamental care captează designul flexibil al Ruby și un punct frequent de interviu reflectând înțelegerea programării dinamice și duck-typed.