Duck typing ni nini katika Ruby?

Question

Accepted Answer

**Duck typing** ni kanuni ambapo ufaafu wa object huamuliwa na **methods anazozijibu**, si class au type yake — "kama anatembea kama bata na analia kama bata, basi ni bata." Katika Ruby, unajali kwamba object *anaweza kufanya* jambo (ana method), si type yake. Hii huwezesha code rahisi, ya polymorphic bila inheritance au interfaces.

## Kanuni: tabia kuliko 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` hufanya kazi na object **yoyote** yenye method ya `quack` — `Duck`, `Person`, chochote. Haikagui type; huita tu method. Hii ni polymorphism bila inheritance ya pamoja au interfaces dhahiri.

## Duck typing katika ulimwengu halisi

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

## Kukagua tabia (si 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
```

Ruby ya kiidiomatiki hutumia `respond_to?` (je, ana method hii?) badala ya `is_a?` (je, ni type hii?) wakati unyumbufu unahitajika — ikilenga **uwezo, si class**.

## Kwa nini ni muhimu

Duck typing ni kanuni ya msingi ya Ruby na sifa bainifu ya jinsi Ruby inavyofikia unyumbufu na polymorphism, hivyo kuielewa ni muhimu kwa kuandika Ruby ya kiidiomatiki.

Wazo kuu — kwamba ufaafu wa object huamuliwa na **anachoweza kufanya (methods zake), si class/type yake** — huwezesha code rahisi, ya polymorphic *bila* kuhitaji inheritance ya pamoja au interfaces dhahiri (tofauti na lugha zenye type tuli ambapo polymorphism inahitaji base classes au interfaces za pamoja).

Hii ni ya kukomboa na yenye nguvu: method hufanya kazi na object yoyote anayejibu methods zinazohitajika, hivyo unaweza kupitisha chochote kinachoweza "kulia kama bata" — classes tofauti, objects maalum — na inafanya kazi tu, ikifanya code iweze kutumika tena na kunyumbulika.

Kuelewa duck typing kunaelezea mtindo wa Ruby unaonyumbulika, unaolenga tabia na kwa nini code ya Ruby kwa kawaida hutegemea **uwepo wa method** (`respond_to?`) badala ya **ukaguzi wa type** (`is_a?`) — kulenga uwezo kuliko class ndiyo njia ya kiidiomatiki ya Ruby.

Kanuni hii inaunda msingi wa sehemu kubwa ya ufahari wa Ruby na unyumbufu wa libraries na frameworks zake (zinazofanya kazi na chochote kinachotoa methods sahihi, kama chochote chenye `each` au `<<`).

Kushika duck typing — kwamba Ruby hujali tabia si type, ikiwezesha polymorphism bila interface, na kwamba Ruby ya kiidiomatiki hukagua uwezo badala ya class — ni muhimu kwa kuandika Ruby inayonyumbulika, ya kiidiomatiki na kwa kuelewa falsafa yenye nguvu, inayolenga tabia inayotofautisha Ruby na lugha zenye type tuli.

Ni mada ya kimsingi ya kidhana inayonasa muundo unaonyumbulika wa Ruby na nukta ya mahojiano inayojirudia inayoonyesha uelewa wa programu yenye nguvu, yenye duck typing.