Wat is duck typing in Ruby?

Question

Accepted Answer

**Duck typing** is een principe waarbij de geschiktheid van een object wordt bepaald door **welke methoden het kan aanroepen**, niet door de klasse of het type — "als het loopt als een eend en kwaakt als een eend, dan is het een eend." In Ruby gaat het erom dat een object *iets kan doen* (heeft de methode), niet wat het type is. Dit maakt flexibele, polymorfische code mogelijk zonder overerving of interfaces.

## Het principe: gedrag boven type

```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` werkt met **elk** object dat een `quack` methode heeft — een `Duck`, een `Person`, wat dan ook. Het controleert het type niet; het roept gewoon de methode aan. Dit is polymorfisme zonder gedeelde overerving of expliciete interfaces.

## Duck typing in de praktijk

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

## Controleren op gedrag (niet op type)

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

Idiomatisch Ruby gebruikt `respond_to?` (heeft het deze methode?) in plaats van `is_a?` (is het dit type?) wanneer flexibiliteit van belang is — waarbij de focus ligt op **mogelijkheid, niet op klasse**.

## Waarom het belangrijk is

Duck typing is een fundamenteel Ruby-principe en een bepalende eigenschap van hoe Ruby flexibiliteit en polymorfisme bereikt, dus het begrijpen ervan is belangrijk voor het schrijven van idiomatisch Ruby.

Het kernidee — dat de geschiktheid van een object wordt bepaald door **wat het kan doen (zijn methoden), niet door zijn klasse/type** — maakt flexibele, polymorfische code mogelijk *zonder* dat gedeelde overerving of expliciete interfaces nodig zijn (in tegenstelling tot statisch getypeerde talen waar polymorfisme gemeenschappelijke basisklassen of interfaces vereist).

Dit is bevrijdend en krachtig: een methode werkt met elk object dat reageert op de benodigde methoden, dus je kunt alles doorgeven dat "kwaakt" — verschillende klassen, aangepaste objecten — en het werkt gewoon, waardoor code herbruikbaar en aanpasbaar wordt.

Het begrijpen van duck typing verklaart Ruby's flexibele, gedragsgerichte stijl en waarom Ruby-code meestal vertrouwt op **methode-aanwezigheid** (`respond_to?`) in plaats van **typecontroles** (`is_a?`) — de focus op mogelijkheid boven klasse is de idiomatische Ruby-benadering.

Dit principe ligt aan de basis van veel van Ruby's elegantie en de flexibiliteit van zijn libraries en frameworks (die werken met alles dat de juiste methoden biedt, zoals alles met `each` of `<<`).

Duck typing begrijpen — dat Ruby gaat om gedrag niet type, interface-vrije polymorfisme mogelijk maakt, en dat idiomatisch Ruby mogelijkheid controleert in plaats van klasse — is belangrijk voor het schrijven van flexibel, idiomatisch Ruby en voor het begrijpen van de dynamische, gedragsgeoriënteerde filosofie die Ruby onderscheidt van statisch getypeerde talen.

Het is een kernconceptueel onderwerp dat Ruby's flexibele ontwerp weerspiegelt en een veelvoorkomend interviewonderwerp dat aantoont dat je dynamisch, duck-typed programmeren begrijpt.