ഡക്ക് ടൈപ്പിംഗ്

വിക്കിപീഡിയ, ഒരു സ്വതന്ത്ര വിജ്ഞാനകോശം.
(Duck typing എന്ന താളിൽ നിന്നും തിരിച്ചുവിട്ടതു പ്രകാരം)
Jump to navigation Jump to search

കമ്പ്യൂട്ടർ പ്രോഗ്രാമിംഗിൽ ഡക്ക് ടൈപ്പിംഗ് എന്നു പറയുന്നത് ഡക്ക് ടെസ്റ്റിന്റെ ഒരു പ്രയോഗം പോലെയാണ്. അതായത് "ഇത് ഒരു താറാവിനെ പോലെ നടക്കുകയും അതിൻറെ ശബ്ദം ഒരു താറാവിന്റെ കരച്ചിൽ പോലെയും ആയതിനാൽ അത് തീർച്ചയായും ഒരു താറാവായിരിക്കണം"-എന്നത് പോലെ ഒരു പ്രത്യേക ഉദ്ദേശ്യത്തിനായി ഒരു വസ്തു ഉപയോഗിക്കുവാൻ സാധിക്കുമോ എന്ന് നിർണ്ണയിക്കുന്നതിനെയാണ് ഇവിടെ ഇതുകൊണ്ടുദ്ദേശിക്കുന്നത്. സാധാരണ ടൈപ്പുചെയ്യൽ ഉപയോഗിച്ച്, ഒരു വസ്തുവിന്റെ രീതി ഇവിടെ യോജിച്ചതാണോ എന്ന് നിർണ്ണയിക്കുന്നു. ഡക്ക് ടൈപ്പിംഗിൽ ഒരു വസ്തുവിന്റെ അനുയോജ്യത നിശ്ചയിക്കുന്നത് ചില മെത്തേഡുകളും അതിന്റെ സാന്നിദ്ധ്യവുമാണ്.[1]

ഉദാഹരണം[തിരുത്തുക]

ഏതൊക്കെ വസ്തുക്കളിൽ എതൊക്കെ ഉപയോഗിക്കാം എന്നു കാണിക്കുന്ന പൈത്തൺ 3-ൽ ഉള്ള പ്രോഗ്രാം ചുവടെ ചേർക്കുന്നു ഇത് ഒരു ലളിതമായ ഉദാഹരണമാണ്.

class Duck:
    def fly(self):
        print("Duck flying")

class Airplane:
    def fly(self):
        print("Airplane flying")

class Whale:
    def swim(self):
        print("Whale swimming")

def fly(entity):
    entity.fly()

duck = Duck()
airplane = Airplane()
whale = Whale()

fly(duck) # prints `Duck flying`
fly(airplane) # prints `Airplane flying`
fly(whale) # Throws the error `'Whale' object has no attribute 'fly'`

സ്റ്റാറ്റിസ്റ്റിക്കൽ ടൈപ്പ് ചെയ്ത ഭാഷകൾ[തിരുത്തുക]

സാധാരണയായി സ്റ്റാറ്റിക്ക് ടൈപ്പ് ചെയ്ത ഭാഷയായ ബൂ പോലുള്ളവ, സി# പതിപ്പിന്റെ 4-ാം ലക്കത്തിൽ കൂടുതൽ തരത്തിലുള്ള വ്യാഖ്യാനങ്ങളുണ്ട്(annotations)[2] [3] കംപൈൽ ടൈമിന് പകരമായി, റൺ-ടൈമിൽ ക്ലാസുകളുടെ ടൈപ്പ് പരിശോധനയ്ക്കായി ക്രമീകരിക്കാൻ കമ്പൈലർക്ക് നിർദ്ദേശം നൽകുക, മാത്രമല്ല സമാഹരിച്ച ഔട്ട്പുട്ടിൽ റൺ ടൈം തര പരിശോധനയും ഉൾപ്പെടുന്നു.

മറ്റ് തരത്തിലുള്ള സംവിധാനങ്ങളുമായുള്ള താരതമ്യം[തിരുത്തുക]

സ്ട്രക്ചറൽ ടൈപ്പ് സിസ്റ്റങ്ങൾ[തിരുത്തുക]

ഡക്ക് ടൈപ്പിംഗിന് സമാനമാണ്, എന്നാൽ ഘടനാപരമായ ടൈപ്പിംഗ് (structural typing) ഇതിൽ നിന്ന് വ്യത്യസ്തമാണ്. ടൈപ്പുകളുടെ ഘടനയിൽ തരത്തിന്റെ അനുയോജ്യതയും തുല്യതയും നിർണ്ണയിക്കുന്ന സ്റ്റാറ്റിക് ടൈപ്പിങ് സംവിധാനമാണ് സ്ട്രക്ചറൽ ടൈപ്പിംഗ്, ഡക്ക് ടൈപ്പിംഗ് എന്നത് ചലനാത്മകമാണ്, റൺ ടൈം സമയത്ത് ആക്സസ് ചെയ്യപ്പെടുന്ന തരത്തിലുള്ള ഘടനയിൽ കൂടി മാത്രമേ അനുയോജ്യത നിർണ്ണയിക്കുകയുള്ളൂ.

ഒകാമൽ, സ്കാല, ഗോ , എൽമ്, [4], ഗോസു(Gosu), പ്യൂർസ്ക്രിപ്റ്റ്(PureScript) എന്നീ ഭാഷകൾ വിവിധ തലങ്ങളിൽ ഘടനാപരമായ ടൈപ്പിംഗ് പിന്തുണയ്ക്കുന്നു.

പ്രോട്ടോക്കോളുകളും ഇൻറർഫെയ്സുകളും[തിരുത്തുക]

പ്രോട്ടോക്കോളുകൾക്കും ഇൻറർഫെയിസുകൾക്കും ഡക്ക് ടൈപ്പിങിന്റെ ചില പ്രയോജനങ്ങൾ നൽകാം, എന്നാൽ സ്പഷ്ടമായ ഇന്റർഫേസ് നിർവചിച്ചിട്ടില്ലെങ്കിൽ ഡക്ക് ടൈപ്പിംഗ് വ്യത്യസ്തമായിരിക്കും. ഉദാഹരണത്തിന്, ഒരു മൂന്നാം കക്ഷി ലൈബ്രറി പരിഷ്കരിക്കാൻ കഴിയാത്ത ഒരു ക്ലാസ് നടപ്പിലാക്കുകയാണെങ്കിൽ, ഒരു ക്ലയന്റിന് ആ ലൈബ്രറിയിൽ അജ്ഞാതമായ ഒരു ഇന്റർഫേസ് ഉപയോഗിക്കാനാവില്ല , ക്ലാസ്സ് വാസ്തവത്തിൽ ഇന്റർഫേസ് ആവശ്യകതകൾ നിറവേറ്റുന്നുണ്ടെങ്കിൽ പോലും.(ഈ പ്രശ്നത്തിന്റെ ഒരു പൊതു പരിഹാരം അഡാപ്റ്റർ പാറ്റേൺ ആണ്) ഡക്ക് ടൈപ്പിംഗ് ഇത് അനുവദിക്കും. വീണ്ടും, എല്ലാ ഇന്റർഫേസുകളും അനുയോജ്യമായ ആവശ്യങ്ങൾ നിർവഹിക്കാൻ സാധിക്കണം.

അവലംബം[തിരുത്തുക]

  1. "Glossary — Python 3.7.1 documentation". docs.python.org. ശേഖരിച്ചത്: 2018-11-08.
  2. Boo: Duck Typing Archived October 6, 2008, at the Wayback Machine.
  3. "Anders Hejlsberg Introduces C# 4.0 at PDC 2008". ശേഖരിച്ചത്: 30 January 2017.
  4. Czaplicki, Evan. "Core Language · An Introduction to Elm". ശേഖരിച്ചത്: 30 January 2017.
"https://ml.wikipedia.org/w/index.php?title=ഡക്ക്_ടൈപ്പിംഗ്&oldid=3105878" എന്ന താളിൽനിന്ന് ശേഖരിച്ചത്