Ruby मा duck typing के हो?

Question

Accepted Answer

**Duck typing** एक सिद्धान्त हो जहाँ कुनै पनि वस्तुको उपयुक्तता यसले **कुन-कुन methods लाई respond गर्छ** भन्ने कुरामा निर्धारण हुन्छ, यसको class वा type मा होइन — "यदि यो बत्तखको जस्तै हिँडिरहेको छ र बत्तखको जस्तै आवाज निकालिरहेको छ, त्यसो हो बत्तख।" Ruby मा, तपाईलाई यो महत्त्वपूर्ण छ कि कुनै पनि वस्तु *केही गर्न सक्छ* (method छ), यसको type के हो भन्ने कुरा होइन। यसले inheritance वा interfaces बिना नै flexible, polymorphic code लेख्न सक्षम बनाउँछ।

## The principle: behavior over 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` कुनै पनि वस्तु सँग काम गर्छ जसको `quack` method छ — एक `Duck`, एक `Person`, कुनै पनि कुरा। यो type check गर्दैन; यो सिर्फ method call गर्छ। यो inheritance वा explicit interfaces बिनाको polymorphism हो।

## Real-world 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
```

## Checking for behavior (not 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
```

Idiomatic Ruby ले flexibility महत्त्वपूर्ण हुँदा `is_a?` (यो यो type हो?) को सट्टा `respond_to?` (यसको यो method छ?) प्रयोग गर्छ — **capability** मा ध्यान केन्द्रित गरी, class मा होइन।

## यो किन महत्त्वपूर्ण छ

Duck typing एक मौलिक Ruby सिद्धान्त हो र Ruby ले flexibility र polymorphism कसरी प्राप्त गर्छ भन्नेको परिभाषित विशेषता हो, त्यसैले यो बुझ्न महत्त्वपूर्ण छ।

मुख्य विचार — कि कुनै पनि वस्तुको उपयुक्तता यसले **के गर्न सक्छ (यसका methods), यसको class/type होइन** भन्ने कुरामा निर्धारण हुन्छ — flexible, polymorphic code सक्षम बनाउँछ *बिना* shared inheritance वा explicit interfaces को आवश्यकता गरी (static-typed languages को विपरीत जहाँ polymorphism को लागि common base classes वा interfaces चाहिन्छ)।

यो मुक्त र शक्तिशाली छ: एक method कुनै पनि वस्तु सँग काम गर्छ जो आवश्यक methods लाई respond गर्छ, त्यसैले तपाई कुनै पनि कुरा पास गर्न सक्नुहुन्छ जो "quacks" गर्छ — विभिन्न classes, custom objects — र यो काम गर्छ, code लाई reusable र adaptable बनाई।

Duck typing बुझ्न Ruby को flexible, behavior-focused शैली व्याख्या गर्छ र किन Ruby code सामान्यतः **method presence** (`respond_to?`) मा आश्रय गर्छ **type checks** (`is_a?`) को सट्टा — capability मा focus गर्नु class को सट्टा idiomatic Ruby approach हो।

यो सिद्धान्त Ruby को लामो र यसको libraries र frameworks को flexibility को अन्तर्गत छ (जो कुनै पनि कुरा सँग काम गर्छ जसले सही methods प्रदान गर्छ, जस्तै कुनै पनि कुरा `each` वा `<<` सँग)।

Duck typing बुझ्न — कि Ruby behavior मा care गर्छ type मा होइन, interface-free polymorphism सक्षम गर्छ, र idiomatic Ruby capability को सट्टा class check गर्छ — flexible, idiomatic Ruby लेख्न र static-typed languages बाट Ruby लाई छुट्टिने dynamic, behavior-oriented philosophy बुझ्न महत्त्वपूर्ण छ।

यो एक मुख्य conceptual topic हो जो Ruby को flexible design लाई capture गर्छ र dynamic, duck-typed programming को समझ प्रतिबिम्बित गर्ने एक बारम्बार interview बिन्दु हो।