Što je duck typing u Rubyju?

Question

Accepted Answer

**Duck typing** je princip gdje se prikladnost objekta određuje prema **koje metode može pozvati**, a ne prema njegovoj klasi ili tipu — "ako hodi kao patka i kvači kao patka, onda je patka." U Rubyju vam je bitno da objekt *može učiniti* nešto (ima metodu), a ne koju tip je. Ovo omogućava fleksibilan, polimorfan kod bez nasljeđivanja ili sučelja.

## Princip: ponašanje umjesto tipa

```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` radi s **bilo kojim** objektom koji ima metodu `quack` — `Duck`, `Person`, bilo čime. Ne provjerava tip; jednostavno poziva metodu. Ovo je polimorfizam bez zajedničkog nasljeđivanja ili eksplicitnih sučelja.

## Duck typing u stvarnom svijetu

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

## Provjera ponašanja (a ne tipa)

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

Idiomatski Ruby koristi `respond_to?` (ima li ovu metodu?) umjesto `is_a?` (je li ovog tipa?) kada je fleksibilnost važna — fokusirajući se na **sposobnost, a ne klasu**.

## Zašto je važno

Duck typing je temeljni princip Rubyja i definirajuća karakteristika kako Ruby postiže fleksibilnost i polimorfizam, pa je razumijevanje ovoga važno za pisanje idiomatskog Rubyja.

Temeljna ideja — da se prikladnost objekta određuje prema **što može činiti (njegove metode), a ne prema svojoj klasi/tipu** — omogućava fleksibilan, polimorfan kod *bez* zahtjeva za zajedničkim nasljeđivanjem ili eksplicitnim sučeljima (za razliku od statički tipiziranih jezika gdje polimorfizam zahtijeva zajedničke bazne klase ili sučelja).

Ovo je oslobađajuće i moćno: metoda radi s bilo kojim objektom koji odgovara potrebnim metodama, pa možete prosljeđivati bilo što što "kvači" — različite klase, prilagođene objekte — i jednostavno radi, čineći kod ponovno iskoristivim i prilagodljivim.

Razumijevanje duck typinga objašnjava fleksibilan, ponašanjem fokusiran stil Rubyja i zašto kod Rubyja obično polazi od **prisutnosti metode** (`respond_to?`) umjesto **provjere tipa** (`is_a?`) — fokusiranje na sposobnost umjesto klase je idiomatski Ruby pristup.

Ovaj princip je temelj većine Rubyjevog elegancije i fleksibilnosti njegovih knjižnica i okvira (koji rade s bilo čime što pruža potrebne metode, kao bilo što s `each` ili `<<`).

Razumijevanje duck typinga — da Ruby brine o ponašanju a ne tipu, omogućavajući polimorfizam bez sučelja, i da idiomatski Ruby provjerava sposobnost umjesto klase — važno je za pisanje fleksibilnog, idiomatskog Rubyja i za razumijevanje dinamične, ponašanjem usmjerene filozofije koja razlikuje Ruby od statički tipiziranih jezika.

To je temeljni konceptualni topic koji hvaća Rubyjevu fleksibilnu dizajn i česta točka u intervjuu koja odražava razumijevanje dinamičkog, duck-tipiziranog programiranja.