Ruby-இல் duck typing என்றால் என்ன?

Question

Accepted Answer

**Duck typing** என்பது ஒரு object-இன் பொருத்தகத்தன்மை அதன் **class அல்லது type-ஐ பொறுத்தல்ல, அது எந்த methods-ஐ செயல்படுத்தும்** என்பதைப் பொறுத்து நிர்ணயிக்கப்படும் ஒரு கொள்கையாகும் — "பாத்தை போல நடந்து, பாத்தை போல கத்தினால், அது பாத்திதான்." Ruby-இல், ஒரு object என்ன type-ஆக உள்ளது என்பது முக்கியமல்ல, அது *என்ன செய்ய முடியும்* (method உள்ளதா) என்பதுதான் முக்கியம். இது inheritance அல்லது interfaces இல்லாமலே flexible, 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-ஐ சரிபார்க்கவுமில்லை; 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
```

## Behavior-ஐ சரிபார்ப்பது (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
```

MuRuby-இல் `respond_to?` (இந்த method உள்ளதா?) என்பதை `is_a?` (இந்த type-ஆ?) விட மேலாக பயன்படுத்துகிறது flexibility முக்கியமாக இருக்கும்போது — **capability-ஐ focus செய்கிறது, class அல்ல**.

## ஏன் இது முக்கியம்

Duck typing என்பது ஒரு fundamental Ruby principle-ஆக இருக்கிறது மற்றும் Ruby-இல் flexibility மற்றும் polymorphism-ஐ அடையும் விதத்தின் ஒரு defining characteristic-ஆக இருக்கிறது, எனவே இதை புரிந்துகொள்வது idiomatic Ruby எழுத்துக்கு முக்கியம்.

மূல ধারணை — ஒரு object-இன் பொருத்தகத்தன்மை அதன் **class/type அல்ல, அது என்ன செய்ய முடியும் (அதன் methods) என்பதால்** நிர்ணயிக்கப்படுகிறது — flexible, polymorphic code-ஐ shared inheritance அல்லது explicit interfaces தேவையில்லாமல் செயல்படுத்தவுமுடியும் (statically-typed languages-இல் shared base classes அல்லது interfaces தேவை).

இது விடுதலை பெறுவதாக இருக்கிறது மற்றும் powerful-ஆக இருக்கிறது: ஒரு method தேவையான methods-ஐ செயல்படுத்தும் எந்த object-ஐயும் வேலை செய்கிறது, எனவே நீங்கள் எதையும் "quack"-ஐ செயல்படுத்தும் object-ஐ pass செய்யலாம் — வெவ்வேறு classes, custom objects — மற்றும் அது வேலை செய்யுமே, code-ஐ reusable மற்றும் adaptable-ஆக்குகிறது.

Duck typing-ஐ புரிந்துகொள்வது Ruby-இன் flexible, behavior-focused style-ஐ explain செய்கிறது மற்றும் Ruby code பொதுவாக **method presence** (`respond_to?`) பொறுத்து ஆதாரமளிக்கிறது **type checks** (`is_a?`) விட — **capability-ஐ focus செய்வது class-ஐ விட idiomatic Ruby approach ஆகும்**.

இந்த principle Ruby-இன் elegance மற்றும் அதன் libraries மற்றும் frameworks-இன் flexibility-ஐ (எதுவுமே சரியான methods-ஐ provide செய்தால் வேலை செய்கிறது, `each` அல்லது `<<` உள்ள எதுவுமே போல) அடிப்படை மாக இருக்கிறது.

Duck typing-ஐ புரிந்துகொள்வது — Ruby behavior பற்றி care செய்கிறது type அல்ல, interface-free polymorphism-ஐ enable செய்கிறது, மற்றும் idiomatic Ruby capability rather than class-ஐ check செய்கிறது — flexible, idiomatic Ruby எழுத வும் dynamic, duck-typed programming-ஐ புரிந்துகொள்ள மற்றும் statically-typed languages-ஐ விலக்கி Ruby-ஐ வேறுபடுத்தும் dynamic, behavior-oriented philosophy-ஐ புரிந்துகொள்ள முக்கியம்.

இது Ruby-இன் flexible design-ஐ capture செய்யும் மற்றும் dynamic, duck-typed programming-இல் understanding-ஐ reflect செய்யும் ஒரு frequent interview point-ஆக இருக்கும் ஒரு core conceptual topic ஆகும்.