Ruby میں duck typing کیا ہے؟

Question

Accepted Answer

**Duck typing** ایک اصول ہے جہاں کسی object کی موزوں ہونے کا تعین **وہ methods کے لحاظ سے کیا جاتا ہے جن کا وہ جواب دیتا ہے**، نہ کہ اس کی class یا type سے — "اگر یہ بتخ کی طرح چلتا ہے اور بتخ کی طرح ڈاکتا ہے، تو یہ بتخ ہے۔" Ruby میں، آپ کو یہ پرواہ ہے کہ ایک object *کر سکتا ہے* (method ہے)، نہ کہ یہ کیا type ہے۔ یہ وراثت یا interfaces کے بغیر لچکدار، polymorphic code کو ممکن بناتا ہے۔

## اصول: رویہ 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` **کسی بھی** object کے ساتھ کام کرتا ہے جس کے پاس `quack` method ہو — `Duck`، `Person`، کچھ بھی۔ یہ type کو check نہیں کرتا؛ یہ صرف method کو call کرتا ہے۔ یہ shared inheritance یا explicit interfaces کے بغیر polymorphism ہے۔

## حقیقی دنیا میں 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
```

## رویہ کو check کرنا (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 لچک اہم ہو تو `respond_to?` (کیا اس کے پاس یہ method ہے؟) کو `is_a?` (کیا یہ یہ type ہے؟) سے زیادہ استعمال کرتا ہے — **صلاحیت، نہ کہ class** پر توجہ مرکوز کرتے ہوئے۔

## یہ اہم کیوں ہے

Duck typing Ruby کا ایک بنیادی اصول ہے اور Ruby کی لچک اور polymorphism حاصل کرنے کی طریقہ کاری کی ایک خصوصیت ہے، اس لیے اسے سمجھنا Ruby لکھنے کے لیے اہم ہے۔

بنیادی خیال — کہ کسی object کی موزوں ہونے کا تعین **یہ سے ہوتا ہے کہ یہ کیا کر سکتا ہے (اس کے methods)، نہ کہ اس کی class/type**— لچکدار، polymorphic code کو ممکن بناتا ہے *بغیر* shared inheritance یا explicit interfaces (static-typed languages کے برعکس جہاں polymorphism کو common base classes یا interfaces کی ضرورت ہے)۔

یہ آزادی بخش اور طاقتور ہے: ایک method کسی بھی object کے ساتھ کام کرتا ہے جو مطلوبہ methods کا جواب دیتا ہے، تو آپ کچھ بھی pass کر سکتے ہیں جو "ڈاکتا" ہے — مختلف classes، custom objects — اور یہ بس کام کرتا ہے، code کو دوبارہ استعمال اور موافق بناتا ہے۔

Duck typing سمجھنا Ruby کی لچکدار، رویہ پر مرکوز انداز کو سمجھاتا ہے اور Ruby code عام طور پر **method موجودگی** (`respond_to?`) کے بجائے **type checks** (`is_a?`) پر کیوں انحصار کرتا ہے — صلاحیت پر توجہ مرکوز کرنا class سے idiomatic Ruby رویہ ہے۔

یہ اصول Ruby کی خوبصورتی اور اس کی libraries اور frameworks کی لچک کو نیچے کی بنیاد فراہم کرتا ہے (جو کسی بھی چیز کے ساتھ کام کرتے ہیں جو صحیح methods فراہم کرتی ہے، جیسے `each` یا `<<` والی کوئی چیز)۔

Duck typing کو سمجھنا — کہ Ruby رویہ کو type سے نہیں پرواہ کرتا، interface-free polymorphism کو ممکن بناتا ہے، اور idiomatic Ruby صلاحیت کو check کرتا ہے نہ کہ class — لچکدار، idiomatic Ruby لکھنے اور dynamic، رویہ پر مرکوز فلسفہ کو سمجھنے کے لیے اہم ہے جو Ruby کو static-typed languages سے الگ کرتی ہے۔

یہ ایک بنیادی conceptual موضوع ہے جو Ruby کی لچکدار ڈیزائن کو ظاہر کرتا ہے اور dynamic، duck-typed programming کی سمجھ کو ظاہر کرتے ہوئے ایک متکرر انٹرویو نقطہ ہے۔