Co je duck typing v Ruby?

Question

Accepted Answer

**Duck typing** je princip, kde se vhodnost objektu určuje podle **jaké metody vykonává**, nikoli podle jeho třídy nebo typu — "pokud chodí jako kachna a křičí jako kachna, pak je to kachna." V Ruby vám jde o to, že objekt *umí dělat* něco (má metodu), nikoli jaký typ je. To umožňuje flexibilní, polymorfní kód bez dědičnosti nebo rozhraní.

## Princip: chování namísto typu

```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` funguje s **jakýmkoli** objektem, který má metodu `quack` — s `Duck`, s `Person`, s čímkoli. Neověřuje typ; jednoduše zavolá metodu. Jedná se o polymorfismus bez sdílené dědičnosti nebo explicitních rozhraní.

## Duck typing v praxi

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

## Ověřování chování (nikoli typu)

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

Idiotický Ruby používá `respond_to?` (má tuto metodu?) namísto `is_a?` (je to tento typ?) když záleží na flexibilitě — se zaměřením na **schopnost, nikoli třídu**.

## Proč na tom záleží

Duck typing je fundamentálním principem Ruby a definující vlastností toho, jak Ruby dosahuje flexibility a polymorfismu, takže porozumění mu je důležité pro psaní idiomatického Ruby kódu.

Jádrová myšlenka — že vhodnost objektu je určena **tím, co umí dělat (jeho metody), nikoli jeho třídou/typem** — umožňuje flexibilní, polymorfní kód *bez* nutnosti sdílené dědičnosti nebo explicitních rozhraní (na rozdíl od staticky typovaných jazyků, kde polymorfismus vyžaduje společné základní třídy nebo rozhraní).

Je to osvobozující a mocné: metoda pracuje s jakýmkoli objektem, který reaguje na potřebné metody, takže můžete předat cokoli, co "křičí" — různé třídy, vlastní objekty — a prostě to funguje, což činí kód znovu použitelným a přizpůsobivým.

Porozumění duck typingu vysvětluje flexibilní, na chování zaměřený styl Ruby a proč Ruby kód typicky spoléhá na **přítomnost metody** (`respond_to?`) spíše než na **ověřování typu** (`is_a?`) — zaměření se na schopnost namísto třídy je idiomatický Ruby přístup.

Tento princip je základem elegance Ruby a flexibility jejích knihoven a frameworků (které fungují s čímkoli, co poskytuje správné metody, jako cokoli s `each` nebo `<<`).

Pochopení duck typingu — že Ruby záleží na chování, ne na typu, což umožňuje polymorfismus bez rozhraní, a že idiomatický Ruby kontroluje schopnost spíše než třídu — je důležité pro psaní flexibilního, idiomatického Ruby a pro pochopení dynamické, na chování zaměřené filozofie, která Ruby odlišuje od staticky typovaných jazyků.

Jde o základní konceptuální téma, které zachycuje flexibilní design Ruby a je to časté téma v pohovorech, které odráží porozumění dynamickému, duck-typovanému programování.