X'inhu duck typing f'Ruby?

Question

Accepted Answer

**Duck typing** huwa prinċipju fejn l-adattabilità ta' oġġett hija ddeterminata minn **liema metodi jirrispondi ghaliha**, mhux il-klassi jew it-tip tagħha — "jekk timxi bħala papra u tħaqqaq bħala papra, hi papra." F'Ruby, tinteressax li oġġett *jista' jagħmel* xi ħaġa (għandu l-metodu), mhux liema tip huwa. Dan jippermetti kodiċi flessibli u polymorfiku mingħajr ereditarjetà jew interfaces.

## Il-prinċipju: imġiba fuq it-tip

```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` jaħdem ma' **kwalunkwe** oġġett li għandu metodu `quack` — Duck, Person, xi ħaġa. Ma tħarrix it-tip; sempliċement tċempel il-metodu. Dan huwa polymorfism mingħajr ereditarjetà komuni jew interfaces esplċiti.

## Duck typing fir-realtà

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

## Iċċekkjar tal-imġiba (mhux it-tip)

```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 idiomatiku juża `respond_to?` (għandu dan il-metodu?) fuq `is_a?` (huwa dan it-tip?) meta l-flessibilità hija importanti — jiffoka fuq **kapaċità, mhux klassi**.

## Għaliex huwa importanti

Duck typing huwa prinċipju fundamentali ta' Ruby u karatteirstika definittiva ta' kif Ruby jilħaq il-flessibilità u l-polymorfism, allura l-fehim tiegħu huwa importanti għall-kitba ta' Ruby idiomatiku.

L-idea ċentrali — li l-adattabilità ta' oġġett hija ddeterminata minn **liema ħaġa jista' jagħmel (il-metodi tiegħu), mhux il-klassi/it-tip tiegħu** — tippermetti kodiċi flessibli u polymorfiku *mingħajr* li teħtieġ ereditarjetà komuni jew interfaces esplċiti (bħal f'lingwi miktuba statikament fejn il-polymorfism jeħtieġ klasi bażi komuni jew interfaces).

Dan huwa liberatorju u qawwi: metodu jaħdem ma' kwalunkwe oġġett li jirrispondi għall-metodi meħtieġa, allura tista' tgħoddi xi ħaġa li "taħaqqaq" — klasi differenti, oġġetti custom — u sempliċement jaħdem, u jagħmel il-kodiċi riutilizzabbli u adattabbli.

L-fehim ta' duck typing jispjega l-istil flessibli ta' Ruby ffokat fuq il-imġiba u għaliex il-kodiċi Ruby normalment jiddependi fuq **preżenza ta' metodu** (`respond_to?`) aktar minn **iċċekkjar tat-tip** (`is_a?`) — l-iffokus fuq kapaċità fuq il-klassi huwa l-approċċ idiomatiku ta' Ruby.

Il-prinċipju dan jissostitwixxi ħafna mill-eleganża ta' Ruby u l-flessibilità tal-libreriji u l-frameworks tiegħu (li jaħdmu ma' kwalunkwe ħaġa li tipprovdi l-metodi t-tajbin, bħal xi ħaġa b' `each` jew `<<`).

L-fahm ta' duck typing — li Ruby tinteressax bil-imġiba mhux it-tip, li tippermetti polymorfism mingħajr interface, u li Ruby idiomatiku tċekkja l-kapaċità aktar minn il-klassi — huwa importanti għall-kitba ta' Ruby flessibli u idiomatiku u għall-fehim tal-filosofija dinamika u imġiba-orjentata li tmiddistingwi Ruby mill-lingwi miktuba statikament.

Huwa suġġett kunċettwali essenzjali li jaqbad id-disinn flessibli ta' Ruby u punt ta' intervista frekwenti li jirrifletti l-fehim tal-programmazzjoni dinamika u duck-typed.