Duck typing a nini a Ruby?

Question

Accepted Answer

**Duck typing** shine dokarin inda ba'a lura da nawa ne wani abu (class ko type), sai kuma a lura da **abubuwan da shi ke iya yi** — "idan yana tafiya kamar gara kuma yana ita kamar gara, to shi gara ne." A Ruby, ba ka bukatar sanin nawa ne wani abu, sai kuma ka lura da kwatance kusan shi ke iya yi (yana da hanya), ba haka da nawa ne. Wannan yana ba da damar su yi flexible, polymorphic code ba tare da inheritance ko interfaces ba.

## Dokarin: aikin da ba klasin

```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` yana aiki da **kome** wani abu wanda yana da `quack` hanya — `Duck`, `Person`, ko abin da. Ba a bada lura da nawa ne; kawai ana kirowa hanya. Wannan shine polymorphism ba tare da inheritance ko explicit interfaces ba.

## Aiki na gida duck typing

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

## Duba aiki (ba nawa ba)

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

Idiomatic Ruby yana bukatarwa `respond_to?` (akwai shi da hanya?) fiye da `is_a?` (shi ne nawa?) lokacin da saukewar take yana bukatar — tunawar kan **iya gwaba, ba klasin ba**.

## Me ya makada

Duck typing shine marakaci mai mahimmanci na Ruby kuma babbar sifa ta yadda Ruby ke samun flexibility da polymorphism, don haka fahimta yana muhimmi.

Rahotun da ke tsaya — cewa su kwatancen wani abu yana tabbatarwa da **abin da shi ke iya yi (hanyoyin sa), ba da klasin/nawa** — yana ba da damar flexible, polymorphic code *ba tare da* bukatan wadatacciyar inheritance ko explicit interfaces ba (kaida a statically-typed languages inda polymorphism bukatar shared base classes ko interfaces).

Wannan yana ba kamfi kuma yana da iko: hanya ke aiki da kome wani abu wanda ke amsa bukatan hanyoyi, saboda haka za ka iya shigar da abin da ya "quack" — sundansu classai, custom objects — kuma ya yi kawai, yana ba da aiki kuma yana daidaita.

Fahimtar duck typing ta bayyana style na Ruby na flexible, behavior-focused kuma me yasa Ruby code galibi yana dogara da **kasancewar hanya** (`respond_to?`) kaida ga **checks nawa** (`is_a?`) — tunawar kan **iya gwaba da ba klasin ba** shine idiomatic Ruby tsari.

Dokarin nan yana taya wurin Ruby's elegance kuma flexibility na yajagandai da frameworks nanta (wanda ke aiki da kome da ke ba da hanyoyi daidai, kaida abin da yana da `each` ko `<<`).

Fahimtar duck typing — cewa Ruby ba ta duba nawa sai aikin, yana ba da damar interface-free polymorphism, da cewa idiomatic Ruby yana duba iya gwaba da ba klasin ba — shine muhimmi don rubuta flexible, idiomatic Ruby kuma don fahimtar dynamic, behavior-oriented philosophy wanda ke bambanta Ruby daga statically-typed languages.

Ishi shine ainihin dokarin aiki wanda ke kama Ruby's flexible design kuma matakin jawabin sharuwa da yafi walwala na fahimtar dynamic, duck-typed programming.