ഹാസ്കൽ (പ്രോഗ്രാമിങ് ഭാഷ)

വിക്കിപീഡിയ, ഒരു സ്വതന്ത്ര വിജ്ഞാനകോശം.
ഹാസ്കൽ
Logo of Haskell
ശൈലി:functional, lazy/non-strict, modular
രൂപകൽപ്പന ചെയ്തത്:Lennart Augustsson, Dave Barton, Brian Boutel, Warren Burton, Joseph Fasel, Kevin Hammond, Ralf Hinze, Paul Hudak, John Hughes, Thomas Johnsson, Mark Jones, Simon Peyton Jones, John Launchbury, Erik Meijer, John Peterson, Alastair Reid, Colin Runciman, Philip Wadler
ഡാറ്റാടൈപ്പ് ചിട്ട:static, strong, inferred
പ്രധാന രൂപങ്ങൾ:GHC, Hugs, NHC, JHC, Yhc, UHC
വകഭേദങ്ങൾ:Helium, Gofer
സ്വാധീനിച്ചത്:Agda,[1] Bluespec,[2] C++11/Concepts,[3] C#/LINQ,[4][5][6][7] CAL,[അവലംബം ആവശ്യമാണ്] Cayenne,[4] Clean,[4] Clojure,[8] CoffeeScript,[9] Curry,[4] Elm, Epigram,[അവലംബം ആവശ്യമാണ്] Escher,[10] F#,[11] Frege,[12] Hack,[13] Idris,[14] Isabelle,[4] Java/Generics,[4] LiveScript,[15] Mercury,[4] Ωmega,[അവലംബം ആവശ്യമാണ്] Perl 6,[16] PureScript,[17] Python,[4][18] Rust,[19] Scala,[4][20] Swift,[21] Timber,[22] Visual Basic 9.0[4][5]
വെബ് വിലാസം:www.haskell.org

ഹാസ്കൽ ഉച്ചാരണം:/ˈhæskəl/[23] ഒരു സ്റ്റാൻഡേർസ്ഡ്, പൊതു-ഡവലപ്മെൻറ് കമ്പൈൽ, നോൺ സ്ട്രിറ്റ് സെമൻറിക്കുകളും ശക്തമായ സ്റ്റാറ്റിക് ടൈപ്പിംഗും മാത്രമുള്ളതാണ്. തന്ത്രജ്ഞനായ ഹാസ്കൽ കറിയാണ് ഇതിന് ഈ പേര് നൽകിയത്. ഹാസ്കലിൻറെ ഏറ്റവും പുതിയ സ്റ്റാൻഡേർഡ് ഹാസ്കൽ 2010. 2016 മേയ് മാസം മുതൽ, ഹാസ്കൽ 2020 എന്ന പുതിയ പതിപ്പിന് വേണ്ടി ഒരു ഗ്രൂപ്പ് പ്രവർത്തിക്കുന്നു.[24]

തരം അനുമാനവും[25][26] അലസമായ മൂല്യനിർണ്ണയവുമുള്ള ഒരു തരം സിസ്റ്റം ഹാസ്കലിനുണ്ട്. ഹാസ്കൽ പ്രോഗ്രാമിങ് ഭാഷയിൽ ആദ്യമായി ടൈപ്പ് ക്ലാസ്സുകൾ പ്രത്യക്ഷപ്പെട്ടു.[27]ഇതിൻറെ പ്രധാന നിർവ്വഹണം ഗ്ലാസ്ഗോ ഹാസ്കൽ കംപൈലർ ആണ്.

ഹാസ്കെൽ സെമാൻറിക്സുകളെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്, മിറാൻഡ ഭാഷയുടെ വാക്യഘടനയല്ല, ഇത് ആദ്യ ഹാസ്കൽ വർക്കിംഗ് ഗ്രൂപ്പിൻറെ പരിശ്രമങ്ങളിൽ ശ്രദ്ധ കേന്ദ്രീകരിച്ചു.[28] അക്കാമിഡിയിൽ (academia) ഹാസ്കെൽ വ്യാപകമായി ഉപയോഗിക്കുന്നു.[29][30] മാത്രമല്ല വ്യവസായത്തിലും.[31]

ചരിത്രം[തിരുത്തുക]

മിറണ്ടയുടെ ഗവേഷണ സോഫ്റ്റ് വെയർ ലിമിറ്റഡ് 1985 ൽ പുറത്തിറക്കിയതിനെ തുടർന്ന്, ഫങ്ഷണൽ ഭാഷകളോടുള്ള താത്പര്യം വളർന്നു. 1987-ൽ, ഒരു ഡസൻ നോൺ-സ്ട്രോക്ക്, മൾട്ടിപ്പിൾ ഫങ്ഷണൽ പ്രോഗ്രാമിങ് ഭാഷകളിലുമുണ്ടായിരുന്നു. മിറാൻഡ വളരെ വ്യാപകമായിരുന്നു, പക്ഷെ കുത്തക സോഫ്റ്റ്വെയറായിരുന്നു. പോളണ്ടിലെ ഓറിഗോൺ എന്ന സ്ഥലത്തെ കോൺഫ്രൻസിൽ വച്ച് ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗ് കമ്പ്യൂട്ടർ ആർക്കിടെക്ചർ (FPCA '87) ഇത്തരം ഭാഷകൾക്കുള്ള തുറന്ന മാനദണ്ഡം നിർവ്വചിക്കുന്നതിനായി ഒരു കമ്മിറ്റി രൂപം കൊള്ളുന്നതിന് ഒരു ശക്തമായ സമവായമുണ്ടായിരുന്നു. ഫംഗ്ഷണൽ-ഭാഷാ രൂപകൽപ്പനയിൽ ഭാവിയിൽ ഗവേഷണത്തിന് അടിത്തറയാകുന്നതിന് നിലവിലുള്ള പ്രവർത്തന ഭാഷകളെ ഏകീകൃതമാക്കുക എന്നതാണ് ഈ കമ്മിറ്റിയുടെ ഉദ്ദേശ്യം.[32]

ഹാസ്കൽ 1.0 മുതൽ 1.4 വരെ[തിരുത്തുക]

ഹാസ്കലിന്റെ ആദ്യപതിപ്പ് ("ഹാസ്കൽ 1.0") 1990 ൽ നിർവ്വചിക്കപ്പെട്ടു.[33]സമിതിയുടെ പരിശ്രമങ്ങൾ ഭാഷാ നിർവ്വചനങ്ങളുടെ ഒരു പരമ്പരയ്ക്ക് കാരണമായി (1.0, 1.1, 1.2, 1.3, 1.4).

ഹാസ്കൽ 98[തിരുത്തുക]

ഭാഷയുടെ സുസ്ഥിരമായ, ചുരുങ്ങിയ, പോർട്ടബിൾ പതിപ്പ്, അദ്ധ്യാപനത്തിനുള്ള അനുപമമായ ലൈബ്രറിയും, ഭാവി വിപുലീകരണത്തിനുള്ള ഒരു അടിത്തറയും ലക്ഷ്യമാക്കി 1997 ൻറെ അവസാനത്തിൽ, ഹാസ്കെൽ 98 പരമ്പര അവസാനിപ്പിച്ചു. ഹാസ്കൽ 98 ൻറെ വിപുലീകരണങ്ങളും വേരിയൻറുകളും സമിതി സ്വാഗതം ചെയ്തു.[32]

1999 ഫെബ്രുവരിയിൽ ഹാസ്കൽ 98 ഭാഷാ നിലവാരം ആദ്യം പ്രസിദ്ധീകരിച്ചത് ഹാസ്കൽ 98 റിപ്പോർട്ട് എന്നായിരുന്നു.[32] 2003 ജനുവരിയിൽ ഒരു പരിഷ്കരിച്ച പതിപ്പ് ഹാസ്കൽ 98 ലാംഗ്വേജ് ആൻഡ് ലൈബ്രറീസ് ആയി പ്രസിദ്ധീകരിച്ചു: പരിഷ്കരിച്ച ഒരു റിപ്പോർട്ട്[34] നിലവിലെ ഡേറ്റാ സ്റ്റാൻഡേർഡ് നിലവാരത്തെ പ്രതിനിധാനം ചെയ്യുന്ന ഗ്ലാസ്ഗോ ഹാസ്കൽ കംപൈലർ (ജിഎച്ച്സി) നടപ്പിലാക്കിക്കൊണ്ട് ഭാഷ അതിവേഗം വികസിച്ചുകൊണ്ടിരിക്കുന്നു.[35]

ഹാസ്കൽ 2010[തിരുത്തുക]

2006 ൻറെ തുടക്കത്തിൽ, ഹാസ്കൽ പ്രൈം എന്നറിയപ്പെട്ടിരുന്ന ഹാസ്കൽ 98 മാനകത്തിലേക്ക് ഒരു പിൻഗാമിയെ നിർവ്വചിച്ചുകൊണ്ടുള്ള ഒരു പ്രക്രിയ ആരംഭിച്ചു.[36] ഭാഷ നിർവചനം പുനഃപരിശോധിക്കുന്നതിനുള്ള തുടർ വർദ്ധന പ്രക്രിയയൊഴിച്ച്, പ്രതിവർഷം ഒരു തവണ ഒരു പുതിയ പരിഷ്ക്കരണം നടത്തുക എന്ന ലക്ഷ്യമായിരുന്നു ഇതിനുണ്ടായിരുന്നത്. 2009 നവംബറിൽ ഹാസ്കൽ 2010 എന്നു പേരുള്ള ആദ്യത്തെ പുനരവലോകനം പ്രഖ്യാപിച്ചു. 2010 ജൂലൈയിൽ ഇത് പ്രസിദ്ധീകരിച്ചു.

ഹാസ്കൽ 2010 ഭാഷക്ക് ഒരു പുരോഗമന അപ്ഡേറ്റ് ഉണ്ട്, വളരെയധികം നന്നായി ഉപയോഗപ്പെടുത്തിക്കൊണ്ടുള്ളതാണ്, കംപൈലർ നിർദ്ദിഷ്ട ഫ്ലാഗുകൾ വഴി സാധ്യമാക്കിയ വിവാദപരമല്ലാത്ത സവിശേഷതകളും ഉൾപ്പെടെ.

  • ഘടനാപരമായ മോഡൽ പേരുകൾ. മൊഡ്യൂളുകളുടെ പേരുകൾ, ഒരേപോലെ തിരിച്ചറിയുന്ന ഐഡൻറിഫയറല്ലാതെ, ക്യാപിറ്റലൈസ് ചെയ്ത ഐഡൻറിഫയറുകളുടെ ഡോട്ട് വേർതിരിച്ച സീക്വൻസുകൾ ഉൾക്കൊള്ളിക്കാൻ അനുവദിക്കുന്നു. ഒരു ഹൈറാർക്കിക്കൽ രീതിയിൽ ഘടകങ്ങളെ പേരുനൽകാൻ അനുവദിക്കുന്നു.(ഉദാ:Listഎന്നതിന് പകരമായിData.List), സാങ്കേതികമായി മൊഡ്യൂളുകൾ ഉണ്ടെങ്കിലും, എക മോണോലിതിക്ക് നെയിംസ്പേസായി തുടരുന്നു. ഈ വിപുലീകരണം ഹാസ്കൽ 98-ന് അനുബന്ധമായി നൽകിയിരുന്നു, സാർവത്രികമായി അത് ഉപയോഗിച്ചിരുന്നു.
  • വിദേശ ഫങ്ഷൻ ഇൻറർഫേസ് (FFI) മറ്റ് പ്രോഗ്രാമിങ് ഭാഷകളിൽ ബൈൻഡിങ്ങുകളെ അനുവദിക്കുന്നു. സിയിലേക്കുള്ള ബൈൻഡിങ് മാത്രമേ റിപ്പോർട്ടുചെയ്യാറുള്ളൂ, പക്ഷേ ഡിസൈൻ മറ്റ് ഭാഷാ ബൈൻഡിങ്ങുകൾ അനുവദിക്കുന്നു. ഇത് പിന്തുണയ്ക്കാൻ ഡേറ്റാ ടൈപ്പ് ഡിക്ലറേഷനുകൾക്ക് കൺസ്ട്രറ്ററുകൾ ഇല്ല, ഹാസ്കലിൽ നിർമ്മിക്കാൻ കഴിയാത്ത ഫോറിൻ ഡാറ്റയ്ക്കായി ശക്തമായ തരം വ്യത്യാസങ്ങൾ അനുവദിച്ചു. ഈ വിപുലീകരണം മുമ്പു് ഹാസ്കൽ 98 റിപ്പോർട്ടിനുള്ള ഒരു അനുബന്ധത്തിൽ നൽകിയിരിയിരിക്കുന്നു.
  • N + k പാറ്റേണുകളുടെ (എന്ന് വിളിക്കപ്പെടുന്ന ഫോം വസ്തുത (n + 1) = (n + 1) * factn)വസ്തുതാ നിർവചനങ്ങൾ അനുവദനീയമല്ല. (+) ഓപ്പറേറ്റർ കോഡ് ഉപയോഗിച്ചു, ഈ വാക്യഘടനാപരമായ ഷുഗർ സെമൻറിക്സിനെ വഴിതെറ്റിക്കുകയുണ്ടായി, എന്നാൽ വാസ്തവത്തിൽ (-),(> =) എന്നീ കോഡുകളുപയോഗിച്ച് ഡീഷുഗർ ചെയ്തു.
  • കൂടുതൽ പ്രോഗ്രാമുകളുടെ പരിശോധന തയ്യാറാക്കാൻ ടൈപ്പ് അനുമാനത്തിൻറെ ചട്ടങ്ങൾ ഇളവ് ചെയ്തു.
  • ചില വാക്യഘടന പ്രശ്നങ്ങൾ (ഔപചാരിക വ്യാകരണത്തിലെ മാറ്റങ്ങൾ) പരിഹരിക്കപ്പെട്ടു: പാറ്റേൺ ഗാർഡുകൾ ചേർക്കുകയും, ‌ആ ഗാർഡുകൾക്കുള്ളിൽ പാറ്റേൺ പൊരുത്തപ്പെടുത്തുന്നത് അനുവദിക്കുന്നു, ഓപ്പറേറ്റർ ഫിസിറ്റി ലളിതമായ രീതിയിൽ വ്യക്തമാക്കിയും അത് യഥാർത്ഥ പ്രാക്ടീസ് പ്രതിഫലിപ്പിക്കുകയും ചെയ്തു; ഓപ്പറേറ്ററുകളുടെയും കമൻറുകളുടെയും ഭാഷയുടെ ശബ്ദ സിൻറാക്സിൻറെ ഇടപെടലിൽ ഒരു അദ്വത കേസ് നടത്തുകയുണ്ടായി; ഡൂ-നൊട്ടേഷൻറെ ഇടപെടൽ അപ്രതീക്ഷിത വ്യാക്യഘടനാ പിശകുകൾ ഇല്ലാതാക്കുവാൻ if-then-else ഉപയോഗിച്ച് മെച്ചപ്പെടുത്തുന്നു.
  • LANGUAGE പ്രാഗ്മാ വ്യക്തമാക്കി. 2010 ആയപ്പോഴേക്കും ഭാഷയി ലേക്കുള്ള ഡസൻ കണക്കിന് വിപുലീകരണങ്ങൾ വ്യാപകമായി ഉപയോഗിക്കപ്പെട്ടു, ജി.എച്ച്.സി (മറ്റ് കമ്പൈലറുകൾക്കിടയിൽ) ഐഡൻറിഫയറുകളുടെ ലിസ്റ്റിനൊപ്പം വ്യക്തിഗത വിപുലീകരണങ്ങളെ വ്യക്തമാക്കാൻ LANGUAGE പ്രാഗ്മാ നൽകി. Haskell2010 എക്സ്റ്റൻഷൻ പിന്തുണയ്ക്കുന്നതിനായി ഹാസ്കൽ 2010 കമ്പൈലറുകൾ ആവശ്യമാണ്, ഹാസ്കൽ 2010 ൽ ചേർത്തിട്ടുള്ള എക്സ്റ്റെൻഷനുകൾക്ക് അനുബന്ധമായ മറ്റു അനവധി കാര്യങ്ങളെ പിന്തുണയ്ക്കാൻ പ്രോത്സാഹിപ്പിച്ചു.

സവിശേഷതകൾ[തിരുത്തുക]

അലസത മൂല്യനിർണ്ണയം, പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ, ലിസ്റ്റ് ഗ്രഹിക്കൽ, ടൈപ്പ് ക്ലാസസ്, ടൈപ്പ് പോളിമെറിസം എന്നിവയാണ് ഹാസ്ക്കലിൻറെ പ്രത്യേകതകൾ. ഇത് പൂർണ്ണമായ ഭാഷയാണ്, അതിനർത്ഥം പ്രവർത്തനം സാധാരണയായി പാർശ്വഫലങ്ങൾ ഉണ്ടാകില്ല എന്നാണ്. പാർശ്വഫലങ്ങൾ പ്രതിനിധീകരിക്കുന്നതിന് ഒരു പ്രത്യേക നിർമ്മിതി ഉണ്ട്, പ്രവർത്തനരീതികളുടെ തരം ഓർത്തോഗാനൽ ആണ്. ശുദ്ധമായ പ്രവർത്തനം ഫലപ്രദമായി നടപ്പാക്കാൻ കഴിയുന്ന പാർശ്വഫലങ്ങൾ, മറ്റ് ഭാഷകളിലെ ഇംപ്യൂവർ പ്രവർത്തനങ്ങളെ മാതൃകയാക്കാൻ കഴിയും. ഹിൽ-മിൽനർ തരത്തിലുള്ള സമ്പർക്കമുഖത്തെ ആസ്പദമാക്കിയുള്ള ശക്തമായ ഒരു സ്റ്റാറ്റിക് സംവിധാനമാണ് ഹാസ്കെലിന് ഉള്ളത്. എന്നാൽ കൂടുതൽ ഉപയോഗങ്ങൾ കണ്ടെത്തിയതിന് ശേഷം,[37] ഈ ഏരിയിലെ പ്രധാന ആധുനികവത്കരണം, ടൈപ്പ് ക്ലാസ്സുകളാണ്, യഥാർത്ഥത്തിൽ ഭാഷയിലേക്ക് ഓവർലോഡിംഗ് ചേർക്കുന്ന തത്ത്വചിന്തയായിട്ടാണ് ആദ്യം രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്.[38]

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

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

സജീവമായി വളരുന്ന ഒരു സമൂഹം ഭാഷയ്ക്കിടെയുണ്ട്, 5,400 മൂന്നാം കക്ഷി ഓപ്പൺ സോഴ്സ് ലൈബ്രറികളും ഉപകരണങ്ങളും ഓൺലൈൻ പാക്കേജ് റിപ്പോസിറ്ററിയായ ഹാക്കേജിൽ ലഭ്യമാണ്.

കോഡ് ഉദാഹരണങ്ങൾ[തിരുത്തുക]

ഹാസ്കലിൽ പ്രവർത്തിക്കുന്ന ഒരു "ഹലോ വേൾഡ്" പ്രോഗ്രാം: 

module Main where

main :: IO ()
main = putStrLn "Hello, World!"

ഹാസ്കലിൽ ഫാക്റ്റോറിയൽ ഫംഗ്ഷൻ, കുറച്ച് വ്യത്യസ്ത രീതിയിൽ നിർവചിക്കപ്പെടുന്നു. (തരം വ്യാഖ്യാനം ഓപ്ഷണലാണ്): 

-- Type annotation (optional, same for each implementation)
factorial :: (Integral a) => a -> a

-- Using recursion (with the "ifthenelse" expression)
factorial n = if n < 2
              then 1
              else n * factorial (n - 1)

-- Using recursion (with pattern matching)
factorial 0 = 1
factorial n = n * factorial (n - 1)

-- Using recursion (with guards)
factorial n
   | n < 2     = 1
   | otherwise = n * factorial (n - 1)

-- Using a list and the "product" function
factorial n = product [1..n]

-- Using fold (implements "product")
factorial n = foldl (*) 1 [1..n]

-- Point-free style
factorial = foldr (*) 1 . enumFromTo 1

ഇൻഫിനിറ്റ് ലിസ്റ്റായി ഫിബൊനാൻസി നമ്പറുകൾ ഫലപ്രദമായി നടപ്പിലാക്കുക: 

-- Type annotation (optional, same for each implementation)
fib :: Int -> Integer

-- With self-referencing data
fib n = fibs !! n
        where fibs = 0 : scanl (+) 1 fibs
        -- 0,1,1,2,3,5,...

-- Same, coded directly
fib n = fibs !! n
        where fibs = 0 : 1 : next fibs
              next (a : t@(b:_)) = (a+b) : next t

-- Similar idea, using zipWith
fib n = fibs !! n
        where fibs = 0 : 1 : zipWith (+) fibs (tail fibs)

-- Using a generator function
fib n = fibs (0,1) !! n
        where fibs (a,b) = a : fibs (b,a+b)

ഇൻറ് ടൈപ്പ് ഒരു മെഷീൻ വലിപ്പത്തിലുള്ള ഒരു പൂർണ്ണസംഖ്യയെ (ഇത് !! ഓപ്പറേറ്ററുള്ള ഒരു ലിസ്റ്റ് സബ്സ്ക്രിപ്റ്റ് ആയി ഉപയോഗിച്ചു) സൂചിപ്പിക്കുമ്പോൾ, ഇൻറിജർ ഏകപക്ഷീയമായ ഒരു പൂർണ്ണസംഖ്യയാണ്. ഉദാഹരണമായി, ഇൻറിജർ(integer) ഉപയോഗിച്ച്, മുകളിലുള്ള ഫാക്റ്റോറിയൽ കോഡ് എളുപ്പം കണക്കുകൂട്ടുന്നു factorial 100000 456,574 അക്കങ്ങളുടെ എണ്ണം, കൃത്യമായ നഷ്ടം ഇല്ലാതെ.

ദ്രുത സ്രോതസ്സുകളുൾപ്പെടെയുള്ള ഒരു അൽഗോരിതം നടപ്പിലാക്കുക, പിവറ്റ് ആകുന്ന ആദ്യത്തെ ഘടകം: 

-- Type annotation (optional, same for each implementation)
quickSort :: Ord a => [a] -> [a]

-- Using list comprehensions
quickSort []     = []                               -- The empty list is already sorted
quickSort (x:xs) = quickSort [a | a <- xs, a < x]   -- Sort the left part of the list
                   ++ [x] ++                        -- Insert pivot between two sorted parts
                   quickSort [a | a <- xs, a >= x]  -- Sort the right part of the list

-- Using filter
quickSort []     = []
quickSort (x:xs) = quickSort (filter (<x) xs)
                   ++ [x] ++
                   quickSort (filter (>=x) xs)

നടപ്പിലാക്കൽ[തിരുത്തുക]

ലിസ്റ്റുചെയ്ത നടപ്പിലാക്കൽ എല്ലാം ഓപ്പൺ സോഴ്സ് ലൈസൻസിലൂടെ വിതരണംചെയ്യുന്നു.[40]

ഹാസ്കൽ 98 സ്റ്റാൻഡേർഡുമായി പൂർണമായും യോജിക്കുന്ന നടപ്പിലാക്കൽ, താഴെ പറയുന്നവ ഉൾക്കൊള്ളുന്നു:

  • ഗ്ലാസ്ഗോ ഹാസ്കൽ കംപൈലർ (GHC) വിവിധ പ്രൊസസ്സർ ആർക്കിറ്റക്ചറു കളിൽ നേറ്റീവ് കോഡുകളായി കംപൈൽ ചെയ്യുന്നു. ആൻസി സി യ്ക്കും, രണ്ട് ഇൻറർമീഡിയറ്റ് ഭാഷകൾ ഉപയോഗിച്ച്: സി--, അല്ലെങ്കിൽ ഏറ്റവും പുതിയ പതിപ്പുകളിൽ, അല്ലെങ്കിൽ സമീപകാല പതിപ്പുകളിൽ, എൽഎൽവിഎം (മുൻപ് ലോവർ ലെവൽ വെർച്വൽ മെഷീൻ) ബിറ്റ്കോഡ്.[41][42]ഹാസ്ക്കൽ ഭാഷഭേദം യഥാർത്ഥ നിലവാരത്തിലുള്ളതായി തീർന്നു.[43] ജിഎച്ച്സിയിൽ മാത്രം പ്രവർത്തിക്കുന്ന ലൈബ്രറികൾ (ഉദാ. ഓപ്പൺജിഎല്ലിലേക്കുള്ള ബന്ധനങ്ങൾ) ഉണ്ട്. ഹാസ്കൽ പ്ലാറ്റ്ഫോമിൽ ജിഎച്ച്സി വിതരണം ചെയ്യപ്പെട്ടിട്ടുണ്ട്.
  • ഉത്രെചേത് യൂണിവേഴ്സിറ്റിയിലെ ഒരു ഹാസ്കൽ നടപ്പിലാക്കൽ ആണ് ഉത്രെചേത് ഹാസ്കൽ കംപൈലർ (UHC).[44]ഏതാണ്ട് എല്ലാ ഹാസ്കൽ 98 സവിശേഷതകളും നിരവധി പരീക്ഷണാത്മക വിപുലീകരണങ്ങളും ഇത് പിന്തുണയ്ക്കുന്നു. ആട്രിബ്യൂട്ട് ഗ്രാമറുകൾ ഉപയോഗിച്ച് ഇത് നടപ്പിലാക്കുന്നു. നിലവിൽ ജനറേറ്റഡ് ടൈപ്പ് സിസ്റ്റങ്ങളും ഭാഷാ വിപുലീകരണങ്ങളും ഗവേഷണത്തിനായി ഉപയോഗിക്കുന്നു.
  • ജോൺ മെക്കാമിൻറെ രചനയായ ഹാസ്കൽ കമ്പൈലർ ജെഎച്ച്സി(Jhc) ജനറേറ്റുചെയ്ത പ്രോഗ്രാമുകളുടെ വേഗതയും കാര്യക്ഷമതയും ഊന്നിപ്പറയുകയും പുതിയ പ്രോഗ്രാം പരിവർത്തനങ്ങൾ പരിശോധിക്കുകയും ചെയ്യുന്നു.
    • എജെഎച്ച്സി(Ajhc) ജെഎച്ച്സിയുടെ ഫോർക്ക് ആണ്.
  • അർബൻ ബോക്വിസ്റ്റിൻറെ കമ്പൈലർ ഇൻറർമീഡിയറ്റ് ഭാഷാ, ജിആർഎൻ അടിസ്ഥാനമാക്കിയുള്ള ജിഎച്ച്സി-യുടെ മുഴുവൻ പ്രോഗ്രാം ഒപ്റ്റിമൈസ് ചെയ്യുന്ന ബാക്കെൻഡാണ് എൽഎച്ച്സി.[45] എൽഎച്ചസിയുടെ പഴയ പതിപ്പുകൾ ജിഎച്ച്സിക്ക് പകരം ജെഎച്ച്സി അടിസ്ഥാനമാക്കിയുള്ളവയാണ്.

ഇനിമേൽ തുടർച്ചയായുള്ള പ്രവർത്തനങ്ങൾ ഇനി പറയുന്നവയല്ല:

  • ഹാസ്കെൽ ഉപയോക്താവിൻറെ ഗോഫർ സിസ്റ്റം (ഹഗ്സ്) ഒരു ബൈറ്റ്കോഡ് ഇൻറർപ്രെട്ടർ ആണ്. ജിഎച്ച്സി കംപൈലർക്കൊപ്പം, ഇത് ഏറ്റവും വ്യാപകമായി ഉപയോഗിക്കുന്ന നടപ്പാക്കലുകളിൽ ഒന്നായിരുന്നു,[46] എന്നാൽ ഇപ്പോൾ കൂടുതലും ജിഎച്ച്സിഐ(GHCi) വഴി മാറ്റിസ്ഥാപിക്കപ്പെട്ടിട്ടുണ്ട്. ഗ്രാഫിക്സ് ലൈബ്രറിയുമൊത്ത് ഇത് ലഭ്യമാകും.
  • എൻഎച്ച്സി98 (nhc98) എന്നത് മെമ്മറി ഉപയോഗം മിനിമൈസ് ചെയ്യുന്നതിനുള്ള ബൈറ്റ്കോഡ് കമ്പൈലർ ഫോക്കസിങ് ആണ്.
    • ഹാർലെൽ ട്രെയ്സർ എന്ന ലളിതവും, കൂടുതൽ പോർട്ടബിളും, കാര്യക്ഷമവും, ഏകീകരിക്കാനുള്ള പിന്തുണയും ഉള്ള യോർക്ക് ഹാസ്കൽ കമ്പൈലർ (Yhc) എൻഎച്ച്സി98-ൻറെ ഫോർക്ക് ആയിരുന്നു. വെബ് ബ്രൗസറുകളിൽ ഹാസ്കൽ പ്രോഗ്രാമുകൾ പ്രവർത്തിപ്പിക്കാൻ ഉപയോക്താക്കളെ അനുവദിക്കുന്ന ഒരു ജാവാസ്ക്രിപ്റ്റ് ബാക്കെൻഡും ഉണ്ടായിരുന്നു.
  • ഹാസ്കൽ 1.4 പിന്തുണയ്ക്കുന്ന ആദ്യകാല പ്രയോഗമാണ് എച്ച്ബിസി. ലെന്നാർട്ട് ആഗസ്റ്റസൺ ആണ് ഇത് നടപ്പിലാക്കിയത്. ഇത് അടിസ്ഥാനമാക്കിയുള്ളതാണ് ലേസിഎംഎൽ (Lacy ML). കുറച്ച് കാലം സജീവമായി വികസിപ്പിക്കപ്പെട്ടിട്ടില്ല.

പൂർണ്ണമായി നടപ്പിലാക്കാൻ മാത്രം ഹാസ്കെൽ 98 ഒതുക്കമുള്ളതല്ല, കൂടാതെ ഒരു വ്യത്യാസമില്ലാതെ ഒരു ഭൗതിക ഹാസ്കെൽ ഭാഷ ഉപയോഗം, ഇതിൽ ഉൾപ്പെടുന്നു:

  • ഗോഫർ ഹാസ്കലിൻറെ വിദ്യാഭ്യാസത്തിനുള്ള ഉപഭാഷ ആയിരുന്നു, മാർക്ക് ജോൺസ് വികസിപ്പിച്ചെടുത്ത കൺസ്ട്രക്ടർ ക്ലാസസ് എന്ന ഫീച്ചറോടുകൂടിയാണ്. ഇത് ഹഗ്ഗ്സ് (മുകളിൽ കാണുക) ചെയ്തു.
  • ഹീലിയം ഹാസ്കലിൻറെ പുതിയരൂപമാണ്. ലളിതമായ പിശക് സന്ദേശങ്ങളിലൂടെ പഠനം ലളിതമാക്കുന്നതിലാണ് ഊന്നൽ. ഇത് നിലവിൽ ടൈപ്പ് ക്ലാസുകളിൽ പൂർണ്ണ പിന്തുണയില്ല, ഇത് പല ഹാസ്കൽ പ്രോഗ്രാമുകളുമായി പൊരുത്തപ്പെടുന്നില്ല.
  • ഇറ്റാ, ഫ്രെജ് എന്നിവ ജാവ വിർച്ച്വൽ മെഷീൻ ലക്ഷ്യമിടുന്ന ഹാസ്കലെൻറെ വകഭേദങ്ങളാണ്.

അപ്ലിക്കേഷനുകൾ[തിരുത്തുക]

  • ഡാർക്കുകൾ ഹാസ്കലിൽ എഴുതിയ ഒരു റിവിഷൻ നിയന്ത്രണ സംവിധാനമാണ്, നിരവധി നൂതന സവിശേഷതകൾ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്, പാച്ചുകളുടെ കൂടുതൽ കൃത്യമായ നിയന്ത്രണം പോലുള്ളവ പ്രയോഗത്തിൽ ഉണ്ട്.
  • ഹാസ്കൽ ലൈബ്രറികളും പ്രോഗ്രാമുകളും നിർമ്മിക്കുന്നതിനും പാക്കേജിങ് ചെയ്യുന്നതിനുമുള്ള ഉപകരണമാണ് കാബൽ.[47]
  • ലിനസ്പർ ഗ്നു / ലിനക്സ് സിസ്റ്റം പ്രയോഗങ്ങളുടെ വികസനത്തിനായി ഹാസ്കൽ തെരഞ്ഞെടുത്തു.[48]
  • എക്സ് വിൻഡോ സിസ്റ്റത്തിനുള്ള ഒരു വിൻഡോ നടത്തിപ്പുകാരനാണ് എക്സ്മോനാഡ്(Xmonad), ഹാസ്കലിൽ പൂർണ്ണമായി എഴുതുന്നു.[49]
  • മറ്റ് പ്രോഗ്രാമിങ് ഭാഷകളിൽ വിപുലമായ ഫങ്ഷണൽ പ്രോഗ്രാമിങ് സവിശേഷതകളും ഒപ്റ്റിമൈസേഷനും വേണ്ടി പലപ്പോഴും ജിഎച്ച്സി പരീക്ഷിക്കപ്പെടുന്നു.
  • ഒരു മാർക്ക്അപ്പ് ഫോർമാറ്റിൽ നിന്ന് മറ്റൊന്നിലേക്ക് പരിവർത്തനം ചെയ്യാൻ കഴിയുന്ന ഒരു ഉപകരണമാണ് പാൻഡോക്ക്(Pandoc).
  • വിശ്വസനീയവും, കരുത്തുറ്റതും, വേഗതയുള്ളതുമായ ലക്ഷ്യത്തോടെയുള്ള സിസ്റ്റമാണ് ഷെയ്ക്ക് ബിൽഡ് സിസ്റ്റം.
  • ഷെൽ ചെക്ക്(ShellCheck) - ഷെൽ സ്ക്രിപ്റ്റ് സ്റ്റാറ്റിക് വിശകലന ഉപകരണമാണ്.[50]

വ്യവസായം[തിരുത്തുക]

  • ഹാസ്ക്കലിൽ ഓപ്പൺ സോഴ്സ് സോഫ്റ്റ് വെയർ ആയി,[51] ഫേസ്ബുക്ക് ആൻറി സ്പാം പ്രോഗ്രാമുകൾ നടപ്പിലാക്കുന്നു[52].
  • ഹാസ്കലിൻറെ ഒരു വിപുലീകരണമായ അർദ്ധചാലക (semiconductor) ഡിസൈനു വേണ്ടിയുള്ള ഒരു ഭാഷയാണ് ബ്ലൂസ്പെക് സിസ്റ്റംവെരിലോഗ്(BSV). കൂടാതെ, ബ്ലൂസ്പെക്, ഇൻകോർപ്പറേറ്റഡുകളുടെ ഉപകരണങ്ങളും ഹാസ്കലിൽ നടപ്പിലാക്കുന്നു.
  • ക്രിപ്റ്റോൾ, ക്രിപ്റ്റോഗ്രാഫി അൽഗോരിതം വികസിപ്പിക്കുന്നതിനും പരിശോധിക്കുന്നതിനും ടൂൾചെയിനുകൾ ഉപയോഗിക്കുകയും, ഹാസ്കലിൽ നടപ്പിലാക്കുകയും ചെയ്യുന്നു.
  • seL4, ആദ്യത്തെ ഔപചാരികമായി പരിശോധിച്ച മൈക്രോകേർണൽ,[53]ഒഎസ് ഡവലപ്പറിനായുള്ള ഒരു പ്രോട്ടോടൈപ്പിംഗ് ഭാഷയായി ഹാസ്കലിനെ ഉപയോഗിച്ചു.[53]:p.2അതേസമയം, ഹാസ്കൽ കോഡ് ഒരു നിർവ്വഹിക്കാവുന്ന സ്പെസിഫിക്കേഷനെ,സിദ്ധാന്തം തെളിയിക്കുന്ന ഉപകരണം ഉപയോഗിച്ച് സ്വപ്രേരിത വിവർത്തനം നടത്തി.[53]:p.2 ഫൈനൽ സി പരിഷ്കരണത്തിനു മുമ്പായി ഹാസ്കെൽ കോഡ് ഒരു ഇൻറർമീഡിയറ്റ് പ്രോട്ടോടൈപ്പായി പ്രവർത്തിച്ചു.[53]:p.3
  • ക്രിപ്റ്റോകറൻസിയായ കാർഡോണയുടെ ഔദ്യോഗിക നടപ്പാക്കൽ ഹാസ്കലിൽ ആണ് എഴുതിയിട്ടുള്ളത്.[54]

വെബ്[തിരുത്തുക]

ഹാസ്കൽ വെബ് ചട്ടക്കൂടുകൾ നിലവിലുള്ളവ, [55] താഴെ ചേർക്കുന്നു:

  • യെസോഡ്(Yesod)
  • ഹാപ്പ്സ്റ്റാക്ക്
  • സ്നാപ്പ്.[56]
  • മിസ്സോ

വിമർശനം[തിരുത്തുക]

2002 ൽ ജാൻ വില്ലം മസെൻ, സൈമൺ പേസ്റ്റൺ ജോൺസ് എന്നിവർ, അലസ വിലയിരുത്തലുകളുമായി ബന്ധപ്പെട്ട പ്രശ്നങ്ങൾ ചർച്ചചെയ്തിനുപുറമെ, അതിനെ സംബന്ധിച്ചുള്ള സൈദ്ധാന്തികമായ ഉദ്ദേശ്യങ്ങൾ അംഗീകരിക്കുമ്പോൾ,[57][58]പ്രായോഗിക പരിഗണനയ്ക്ക് പുറമെ മെച്ചപ്പെട്ട പ്രകടനം പോലുള്ളവയെ പ്പറ്റിയും ചർച്ച ചെയ്തു. അവർ ശ്രദ്ധിക്കുന്നത്, ചില പ്രവർത്തന പരിധികൾ ചേർക്കുന്നതിനൊപ്പം, അലസ മൂല്യനിർണ്ണയം മൂലം പ്രോഗ്രാമ്മർമാർ അവരുടെ കോഡിൻറെ (പ്രത്യേകിച്ച് അതിൻറെ സ്പേസ് ഉപയോഗം) പ്രവർത്തനത്തെക്കുറിച്ച് ചിന്തിക്കാൻ കൂടുതൽ പ്രയാസകരമാക്കുന്നു.

2003 ൽ ബാസ്രിയൻ ഹെരെൻ, ദാൻ ലീജീൻ, അർജൻ വാൻ ഇജെജെൻഡോൺ എന്നിവർ ഹാസ്കൽ പഠിതാക്കൾക്ക് അനുഭവപ്പെടുന്ന ചില തടസ്സങ്ങൾ കണ്ടു: "ഹാസ്കലിൻറെ നിഗൂഡമായ സിൻറാക്സും സങ്കീർണമായ തരം സിസ്റ്റവും, ഇരുവശവും മൂർച്ചയുള്ള വാളിനു തുല്യമാണ്. പരിചയസമ്പന്നരായ പ്രോഗ്രാമർമാർ അതിയായി വിലമതിക്കുന്നു എന്നാൽ തുടക്കക്കാർക്കിടയിൽ നിരാശയുടെ ഉറവിടമായാണ് അനുഭവപ്പെടുന്നത്, ഹാസ്കലിൻറെ സാമാന്യസ്വഭാവം പലപ്പോഴും ഗൂഢമായ പിശക് സന്ദേശങ്ങളിലേക്ക് നയിക്കുന്നു."[59]ഇതു പരിഹരിക്കുന്നതിനായി, ഉത്രെചത്ത് യൂണിവേഴ്സിറ്റിയിലെ ഗവേഷകർ ഹീലിയം എന്ന പേരുള്ള വിപുലമായ ഇൻറർപ്രെട്ടർ വികസിപ്പിച്ചെടുത്തു, പിശക് സന്ദേശങ്ങളുടെ ഉപയോക്തൃ-സൗഹൃദം മെച്ചപ്പെടുത്തുകയും, ചില ഹാസ്കൽ സവിശേഷതകളുടെ സാമാന്യത്വം പരിമിതപ്പെടുത്തിയെടുക്കുകയും ചെയ്തു, പ്രത്യേകിച്ച് ടൈപ്പ് ക്ലാസ്സുകൾക്കുള്ള പിന്തുണ നീക്കം ചെയ്യുക.

ബെൻ ലിപ്മീയർ ആണ് ഡിസിപ്പിൾ(Disciple) രൂപകൽപ്പന ചെയ്തത്[60]ഒരു ടൈപ് എഫക്ട് സിസ്റ്റം ഉപയോഗിച്ച് ഹാസ്കലിൻറെ ഒരു കർശനമായി നിർബന്ധമായും (അലസമായ വ്യാഖ്യാനം വഴി), അലസമായ മൂല്യനിർണ്ണയത്തെ ക്കുറിച്ചുള്ള ന്യായവാദത്തിൽ ഹാക്കസിൻറെ ബുദ്ധിമുട്ടുകൾ പരിഹരിക്കുക, മ്യൂട്ടബിൾ അറേകൾ പോലെയുള്ള പരമ്പരാഗത ഡാറ്റാഘടനകൾ ഉപയോഗിക്കുക തുടങ്ങിയവ.[61]"വിനാശകരമായ അപ്ഡേറ്റ് തയ്യാറാക്കുന്നു" (പേജ് 20) അദ്ദേഹം വാദിക്കുന്നു, പ്രോഗ്രാമർമാർക്ക് പ്രധാനപ്പെട്ട രണ്ട് ശക്തമായ ഉപകരണങ്ങൾ ഉപയോഗിച്ച് ... വസ്തുക്കളുടെ ശേഖരണം നിയന്ത്രിക്കുന്നതിനുള്ള കാര്യക്ഷമമായ അറേ-ഡാറ്റ ഡാറ്റാ സ്ട്രക്ച്ചറുകൾ, ഒപ്പം ... ഒരു പ്രോഗ്രാമിൻറെ എല്ലാ ഭാഗങ്ങളിലും ഒരു പുതിയ മൂല്യം പ്രക്ഷേപണം ചെയ്യാനുള്ള കഴിവ് മുതലായവയിൽ പ്രോഗ്രാമർമാർക്ക് കുറഞ്ഞ പ്രയത്നം മാത്രമെ ഇതിനാവശ്യമായി വരുന്നുള്ളു.

സ്റ്റാൻഡേർഡ് എംഎൽ(ML) എഴുത്തുകാരനായ റോബർട്ട് ഹാർപ്പർ, ആമുഖ പ്രോഗ്രാമിങ് പഠിപ്പിക്കുന്നതിനായി ഹാസ്കൽ ഉപയോഗിക്കാത്തതിൻറെ കാരണം ചൂണ്ടിക്കാണിക്കുന്നു. മൗലികമായ വിലയിരുത്തലുകൾ, ഡാറ്റ തരങ്ങളുടെ നിർവ്വചനം, ഇൻഡക്റ്റീവ് ന്യായവാദം, എന്നിവയിൽ ഉറവിട ഉപയോഗത്തെക്കുറിച്ച് ന്യായവാദം ചെയ്യുന്നത് ബുദ്ധിമുട്ടുള്ള കാര്യമാണ്.[62]എംഎലിൻറെ മൊഡ്യൂൾ സിസ്റ്റവുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ ഹാസ്കലിൻറെ (പഴയ) ക്ലാസ് സിസ്റ്റം "തരംതാണത്" ആണ്.[63]സ്ഥിരം ബിൽഡ്ടൂളായ കാബൽ(Cabel) ഒരു പ്രത്യേക ലൈബ്രറിയുടെ വ്യത്യസ്ത പതിപ്പുകളുടെ നല്ല മാനേജ്മെൻറ് അഭാവത്തിൽ ഡെവലപ്പർമാരുടെ ഇടയിൽ ഇത് നിരന്തരം വിമർശിക്കപ്പെട്ടു. സ്റ്റാക്കിൻറെ പ്രകാശനം വഴി ഇത് പരിഹരിക്കപ്പെട്ടിരിക്കുന്നു. എന്നാൽ സ്വതേയുള്ള ബിൽഡ് ഉപകരണമായി കാബൽ ഇപ്പോഴും ലഭ്യമാക്കുന്നു.

അനുബന്ധ ഭാഷകൾ[തിരുത്തുക]

ക്ലീൻ എന്നത് ഹാസ്കലിൻറെ ഏറ്റവും അടുത്ത ബന്ധമുള്ള ഭാഷയാണ്. I / O, സൈഡ് ഇഫക്റ്റുകൾ എന്നിവയ്ക്കായി മൊനാഡ്സിന് (monads) പകരം ഉപയോഗിക്കുന്നത് ഹാസ്കലിൽ നിന്ന് വലിയ വ്യത്യാസം വരുത്തിയ രൂപമാണ്.

ഹാസ്കൽ പ്രചോദിപ്പിച്ച നിരവധി പരമ്പര ഭാഷകൾ, വ്യത്യസ്ത തരത്തിലുള്ള സംവിധാനങ്ങൾ വികസിപ്പിച്ചെടുത്തിട്ടുണ്ട്:

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

ജാവ വെർച്ച്വൽ മെഷീൻ (ജെവിഎം) അടിസ്ഥാനമാക്കിയുള്ളവ:

  • ഫ്രെജ്ജ്(Frege), ജാവയുടെ സ്കാനർ തരങ്ങളുള്ള ഒരു ഹാസ്കൽ പോലെയുള്ള ഭാഷയും മികച്ച ജാവ സംയോജനം ഉൾപ്പെടുന്നതാണ്.[64][65][66]
  • ജാവ വെർച്ച്വൽ മെഷീനീ(ജെവിഎം)ൽ പ്രവർത്തിക്കുന്ന ഒരു ഫങ്ഷണൽ സ്ക്രിപ്റ്റിംഗ് ഭാഷായാണ് ജാസ്കെൽ.[67]
  • ജെ.വി.എം.ലിൽ ഹാസ്കൽ ആയിരിക്കാൻ ഉദ്ദേശിക്കുന്നതാണ് എതാ-ലാംഗ്(Eta-lang).


മറ്റ് ബന്ധപ്പെട്ട ഭാഷകൾ ഉൾപ്പെടുന്നവ താഴെ പറയുന്നവയാണ്:

  • കറി, എന്നത് ഹാസ്കൽ അടിസ്ഥാനമാക്കിയുള്ള ഒരു ഫംഗ്ഷണൽ / ലോജിക്കൽ പ്രോഗ്രാമിങ് ഭാഷയാണ്.

ഭാഷാ രൂപകൽപ്പനയിൽ നിരവധി പുതിയ ആശയങ്ങൾ പരീക്ഷിച്ചറിയാൻ ഹാസ്കെൽ സഹായിച്ചിട്ടുണ്ട്. നിരവധി ഹാസ്കൽ വകഭേദങ്ങൾ സൃഷ്ടിച്ചിട്ടുണ്ട്, പുതിയ ഭാഷാ ആശയങ്ങൾ പര്യവേക്ഷണം ചെയ്യൽ മുതലായവ:

  • പാരലൽ ഹാസ്കൽ
    • ഗ്ലാസ്കോ യൂണിവേഴ്സിറ്റിയിൽ നിന്നും യന്ത്രങ്ങളുടെ കൂട്ടങ്ങൾ അല്ലെങ്കിൽ ഒറ്റ മൾട്ടിപ്രൊസസറുകളെ പിന്തുണയ്ക്കുന്നു.[68][69]കൂടാതെ, സിമ്മട്രിക് മൾട്ടിപ്രോസസർ സമാന്തരവാദത്തിന് ഹാസ്കെൽ പിന്തുണ നൽകുന്നുണ്ട്.[70]
    • എംഐറ്റി(MIT)യിൽ നിന്ന്.[71]
  • ഡിസ്ട്രിബ്യൂട്ടഡ് ഹാസ്കലും (മുൻപ് ഗോഫിൻ), ഏഡനും.
  • ഊഹത്തിലധിഷ്ഠിതമായ വിലയിരുത്തൽ അടിസ്ഥാനമാക്കിയുള്ള ഈഗർ ഹാസ്കെൽ(Eager Haskell).
  • നിരവധി ഒബജക്ട്-ഓറിയെൻറഡ് പതിപ്പുകൾ ഉണ്ട്: ഹാസ്കെൽ ++, മോണ്ട്രിയൻ മുതലയാവ.
  • ജെനറിക്ക് ഹാസ്കൽ, സാധാരണ പ്രോഗ്രാമിങ്ങിനുള്ള ടൈപ്പ് സിസ്റ്റം പിന്തുണയുള്ള ഹാസ്കലിൻറെ ഒരു പതിപ്പ്.
  • ഓ'ഹാസ്കെൽ(O'Haskell), വസ്തുവിൻറെ ഓറിയൻറേഷൻ ചേർക്കുന്ന ഹാസ്കലിൻറെ ഒരു എക്സ്റ്റെൻഷൻ ആണ്. ഒപ്പം അതുമായി ബന്ധപ്പെട്ട പ്രോഗ്രാമിങ് പിന്തുണയും.
  • ഡിസിപ്പിൾ, കർശനമായ ടൈപ് ഡെഫനിഷൻ (ലേസിനെസ്സ് ഉദ്ധരണിയിൽ ലഭ്യമാണ്)ഹാസ്കലിൻറെ വകഭേദങ്ങൾ, നശീകരണ പരിഷ്കാരങ്ങൾ, കമ്പ്യൂട്ടേഷണൽ ഇഫക്റ്റുകൾ, ഡയറക്ട് ഫീൽഡ് പ്രൊജകടുകൾ ടൈപ്പുചെയ്യുക, ഒപ്പം അനുബന്ധ പ്രവർത്തനങ്ങളും.
  • മെയിൽ ബോക്സുകളിലേക്ക് ഫീഡ്ബാക്ക് സൂക്ഷിക്കുന്ന ഒരു ഘടകം മെയിൽ ബോക്സ് ചാനലുകളുടെ ട്യൂപ്പ്ലുകളിലുടനീളം സ്റ്റേറ്റലെസ് ഓട്ടോമേറ്റായി പ്രോസസ് അടിസ്ഥാനമാക്കി എംബെഡ് ചെയ്ത സിസ്റ്റങ്ങളുടെ കർശനമായ ഭാഷയായ ഹ്യൂം, ഹാസ്കൽ പോലുള്ള എക്സ്പ്രഷൻ ഭാഷയും സിൻറാക്സും ഉപയോഗിച്ച് ഔട്ട്പുട്ട് മുതൽ ചാനലുകൾ വരെയുള്ള ബോക്സ് വയറിംഗുകളിൽ മാപ്പിങ് വിവരവും നൽകുന്നു.

സമ്മേളനങ്ങളും വർക്ക്ഷോപ്പുകളും[തിരുത്തുക]

ഹാസ്കൽ സമൂഹം പതിവായി ഗവേഷണ-വികസന പ്രവർത്തനങ്ങൾ നിർവഹിക്കുന്നു. പ്രധാന സംഭവങ്ങൾ ഇവയാണ്:

  • ഇൻറർനാഷണൽ കോൺഫറൻസ് ഓൺ ഫംഗ്ഷണൽ പ്രോഗ്രാമിങ് (ഐസിഎഫ്പി).
  • ഹാസ്കൽ സിമ്പോസിയം (മുമ്പ് ഹാസ്കൽ വർക്ക്ഷോപ്പ്)
  • ഹാസ്കൽ നടപ്പിലാക്കുന്നവർക്കുള്ള വർക്ക്ഷോപ്പ്.
  • ഫങ്ഷണൽ പ്രോഗ്രാമിങ്ങിൻറെ വാണിജ്യ ഉപയോക്താക്കൾ (സി.യു.എഫ്.പി).

2006 മുതൽ പരമ്പര ഭാഷാ ഉപകരണങ്ങളും ലൈബ്രറികളും മെച്ചപ്പെടുത്തുന്നതിനായുള്ള സംഘടിപ്പിക്കുന്ന ഹാക്കത്തൺ പരമ്പരയാണ് ഹാക്ക്(HAC)പരമ്പര.[72]

ഹാസ്കൽ ബേസ് ലൈബ്രറിയും ആൾജിബ്രയും[തിരുത്തുക]

ഹാസ്കൽ ഡൊമെയ്നുകളെ (തരം) പെരുമാറ്റവും (ടൈപ്പ് ക്ലാസുകൾ) ഹാസ്കൽ അടിസ്ഥാന ലൈബ്രറിയുടെ സ്റ്റാൻഡേർഡ് ടൈപ്പ്ക്ലാസ്സുകൾക്ക് അടിവരയിടുന്ന ബീജഗണിത ലോകവുമായി നിങ്ങൾക്ക് ആശയവിനിമയം നടത്താം.

നം ക്ലാസ്സുകൾ റിംഗിനു വേണ്ടി ആവശ്യമുള്ള ഓപ്പറേഷൻ സിഗ്നേച്ചറുകളാണുള്ളത്, (+) ഉം (*) ന്യൂട്രൽ ഘടകങ്ങളും ഒഴികെ, ഇത് ലിറ്ററലുകളെ മുൻകൂട്ടി നിശ്ചയിച്ചിരിക്കുന്നു.[73]

ഓപ്പറേഷൻ നിയമങ്ങൾ (+), (*) സഹവർത്തിത്വവും കൂട്ടിച്ചേർക്കലുകളും കൂട്ടിച്ചേർത്തത് ടൈപ്പുകൾ തിരുത്തുകയല്ല, മറിച്ച് തെളിവുകൾ പരിശോധിക്കുകയാണ്. 

$ ghci
Prelude> :type 0
0 :: Num a => a         -- 0 belongs to any type that has a Num instance, a Ring
Prelude> :type 1
1 :: Num a => a         -- neutral for the product of a type that implements Num

വേഡ് ഡാറ്റ ടൈപ്പുകൾ (വേഡ്, വേഡ് എൻ(WordN)) നം ടൈപ്പ് ക്ലാസ് മോഡുലാർ അരിത്മെറ്റിക് ഉപയോഗിച്ച് നടപ്പിലാക്കുന്നു. ഡാറ്റ ടൈപ്പുകളും Int, IntN-ൻറെ ദ്വിമാന സങ്കലനങ്ങളുപയോഗിച്ച് ദശാംശ ഗണിതവുമായി പൊരുത്തപ്പെടുന്നില്ല (ഇൻറിജർ ഓവർഫ്ലോ കാണുക): 

Prelude> (signum maxBound ::Int) == signum (maxBound +1)    
False -- ??? maxBound successor doesn't obey arithmetic rule  (it doesn't throw exceptions)

Prelude> (signum maxBound ::Int) == signum (maxBound *2)    
False -- ??? Int product overflow (no exceptions either)

Prelude> (-minBound ::Int) /= minBound  -- where Int minBound == sign bit set followed by zeros
False   -- ??? Negate overflow

സാധ്യമായ കാര്യപരിവർത്തനം, അത് ക്രമീകൃതമായ അരിത്തമെറ്റിക് ഉപയോഗിച്ച് പൊരുത്തപ്പെടുത്തുന്നത് വഴി ഓവർഫ്ലോയിൽ ഒരു ഒഴിവുകഴിവ് നടത്തി.

  • ഓപ്പറൻറ് ചിഹ്നങ്ങൾ തമ്മിൽ ഒത്തുചേരുന്ന അവസരത്തിൽ സൈൻനം(signum){-1.0,1} അതേ സൂചനയ്ക്ക് കൂടുതലായുള്ള ഫലം പരിശോധിക്കുക; [74][75] അല്ലെങ്കിൽ
  • പരിമിതികളില്ലാതെ കൃത്യതയോടെ പ്രവർത്തനം നടത്തുന്നതിന്, ടൈപ്പ് കാസ്റ്റ് ചെയ്ത ഫലം പരിശോധിക്കുക.[75]

പ്രാരംഭ തരം വർഗം റസിപ്പിങ് ഫംഗ്ഷനിൽ ഗുണിത വിപരീതം ("പരോക്ഷമായ") എന്നതിനൊപ്പം അതിൻറെ അനന്തരഫലമായി ഡിവിഷൻ ചേർക്കുന്നു. അത് ഒരു ഫീൽഡിനോട് യോജിക്കുന്നു.[76]

റിയൽ ടൈപ്പ് ക്ലാസിക്ക് നമ്പരും ഓർഡും(ord) ആവശ്യമാണ്. ഓർഡഡ് റിങിന് അനുരൂപമായിരിക്കണം,[77] ഇത് പൂർണ്ണ സംഖ്യയും റാഷണലും നൽകുന്നു.[78] കൂടാതെ ഫ്ലോട്ടിംഗ് പോയിൻറ് നമ്പറുകൾ കൂടി നൽകുന്നു.[79]

യൂക്ലിഡിയൻ ഡിവിഷനിലെ പ്രവർത്തനങ്ങൾക്ക് ഇൻറഗ്രൽ ടൈപ്പ് ക്ലാസ് ഒരു യൂക്ലിഡിയൻ റിംഗുമായി യോജിക്കുന്ന റിയൽ, ഈനമും ക്ലാസുകൾക്ക് പ്രവർത്തനങ്ങൾ കൂട്ടിച്ചേർക്കുന്നു.[80]

ഫ്ലോട്ടിംഗ് ടൈപ്പ് ക്ലാസ് ഫ്ലോറാൽ ഫങ്ഷണൽ കാൽക്യുസ് ഫങ്ഷനുകൾ (sqrt, ട്രൈക്കോണിമെട്രിക് ഫംഗ്ഷനുകൾ, ലോഗരിതങ്ങൾ) ഫ്ലോട്ടിംഗ് പോയിൻറ് (ഫ്ലോട്ട്, ഡബിൾ), സങ്കീർണ്ണ സംഖ്യകൾ എന്നിവയിലേയ്ക്ക് ചേർക്കുന്നു[81][79][82] എക്സ്പോണനേഷൻ മൂന്ന് ഫ്ളേവറുകളിൽ വരുന്നു:

  • ഒരു പോസിറ്റീവ് ഇൻറിജർ എക്സ്പോണൻറിന് അടിസ്ഥാന ഡൊമെയിൻ ആവശ്യമാണ്(നം സൂചിപ്പിക്കുന്നു, കൂടാതെ റിംഗ് സിഗ്നേച്ചറും):
(^) :: (Num a, Integral ex) => a -> ex -> a    -- (^) admits non-negative exponents of an euclidean domain, throws an error if the exponent is negative
  • ഒരു നെഗറ്റീവ് ഇൻറിജർ എക്സ്പോണൻറിന് അടിസ്ഥനാന ഡൊമെയിൻ ആവശ്യമാണ്, അതിനൊപ്പം ഗുണനവിപരീതം(multiplicative inverse)(ഭിന്നസംഖ്യയെ സൂചിപ്പിക്കുന്നു, ഫീൽഡ് സിഗ്നേച്ചറും)ഉൾപ്പെടുന്നു:
(^^) :: (Fractional a, Integral ex) => a -> ex -> a   -- (^^) admits all exponents of an euclidean domain
  • ഒരു ഫ്ലോട്ടിങ് പോയിൻറ് എക്സ്പോണൻറിന് അടിസ്ഥാന ഡൊമെയിൻ ആവശ്യമാണ്, ഫ്ലോട്ടിംഗ് ടൈപ്പ് ക്ലാസ്സിൽ സൂചിപ്പിച്ചിരിക്കുന്നത് പോലെ ലോഗരിതത്തിൻറെ പ്രവർത്തനങ്ങൾ:[81]
(**) :: (Floating a, Floating ex) => a -> ex -> a

യൂക്ലിഡിയൻ തരങ്ങൾ തമ്മിലുള്ള പരിവർത്തനങ്ങൾ പ്രതിനിധാനം ചെയ്യുന്നത്, മൂല്യം അല്ല. ന്യൂമെറിക്കൽ ടൈപ്പ് ക്ലെയിമിൽ ഓവർഫ്ലോ ഒഴിവാക്കില്ല: 

$ ghci
Prelude> import Data.Int
Prelude Data.Int> fromIntegral (32767 :: Int16) :: Int8
-1
Prelude Data.Int> fromInteger (2^64 :: Integer) :: Int32
0

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

  1. ↑ Norell, Ulf (2008). "Dependently Typed Programming in Agda" (PDF). Gothenburg: Chalmers University. ശേഖരിച്ചത് 9 February 2012.
  2. ↑ Hudak et al. 2007, p. 12-38,43.
  3. ↑ Stroustrup, Bjarne; Sutton, Andrew (2011). "Design of Concept Libraries for C++" (PDF). മൂലതാളിൽ (PDF) നിന്നും 10 February 2012-ന് ആർക്കൈവ് ചെയ്തത്. {{cite journal}}: Cite journal requires |journal= (help)
  4. ↑ 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 Hudak et al. 2007, pp. 12-45–46.
  5. ↑ 5.0 5.1 Meijer, Erik. "Confessions of a Used Programming Language Salesman: Getting the Masses Hooked on Haskell". OOPSLA 2007.
  6. ↑ Meijer, Erik (1 October 2009). "C9 Lectures: Dr. Erik Meijer – Functional Programming Fundamentals, Chapter 1 of 13". Channel 9. Microsoft. മൂലതാളിൽ നിന്നും 2012-06-16-ന് ആർക്കൈവ് ചെയ്തത്. ശേഖരിച്ചത് 9 February 2012.
  7. ↑ Drobi, Sadek (4 March 2009). "Erik Meijer on LINQ". InfoQ. QCon SF 2008: C4Media Inc. ശേഖരിച്ചത് 9 February 2012.{{cite news}}: CS1 maint: location (link)
  8. ↑ Hickey, Rich. "Clojure Bookshelf". Listmania!. Amazon.com. ശേഖരിച്ചത് 9 February 2012.
  9. ↑ Heller, Martin (18 October 2011). "Turn up your nose at Dart and smell the CoffeeScript". JavaWorld. InfoWorld. മൂലതാളിൽ നിന്നും 2012-02-10-ന് ആർക്കൈവ് ചെയ്തത്. ശേഖരിച്ചത് 9 February 2012.
  10. ↑ "Declarative programming in Escher" (PDF). ശേഖരിച്ചത് 2015-10-07.
  11. ↑ Syme, Don; Granicz, Adam; Cisternino, Antonio (2007). Expert F#. Apress. പുറം. 2. F# also draws from Haskell particularly with regard to two advanced language features called sequence expressions and workflows.
  12. ↑ Wechsung, Ingo. "The Frege Programming Language" (PDF). ശേഖരിച്ചത് 26 February 2014.
  13. ↑ "Facebook Introduces 'Hack,' the Programming Language of the Future". WIRED. 20 March 2014.
  14. ↑ "Idris, a dependently typed language". ശേഖരിച്ചത് 2014-10-26.
  15. ↑ "LiveScript Inspiration". ശേഖരിച്ചത് 2014-02-04.
  16. ↑ "Glossary of Terms and Jargon". Perl Foundation Perl 6 Wiki. The Perl Foundation. മൂലതാളിൽ നിന്നും 2012-01-21-ന് ആർക്കൈവ് ചെയ്തത്. ശേഖരിച്ചത് 9 February 2012.
  17. ↑ Freeman, Phil (2016). "PureScript by Example". Leanpub. ശേഖരിച്ചത് 23 April 2017.
  18. ↑ Kuchling, A. M. "Functional Programming HOWTO". Python v2.7.2 documentation. Python Software Foundation. ശേഖരിച്ചത് 9 February 2012.
  19. ↑ "The Rust Reference: Appendix: Influences". ശേഖരിച്ചത് 2016-02-03.
  20. ↑ Fogus, Michael (6 August 2010). "MartinOdersky take(5) toList". Send More Paramedics. ശേഖരിച്ചത് 9 February 2012.
  21. ↑ Lattner, Chris (2014-06-03). "Chris Lattner's Homepage". Chris Lattner. ശേഖരിച്ചത് 2014-06-03. The Swift language is the product of tireless effort from a team of language experts, documentation gurus, compiler optimization ninjas, and an incredibly important internal dogfooding group who provided feedback to help refine and battle-test ideas. Of course, it also greatly benefited from the experiences hard-won by many other languages in the field, drawing ideas from Objective-C, Rust, Haskell, Ruby, Python, C#, CLU, and far too many others to list.
  22. ↑ "Timber/History". ശേഖരിച്ചത് 2015-10-07.
  23. ↑ Chevalier, Tim (28 January 2008). "anybody can tell me the pronunciation of "haskell"?". Haskell-cafe mailing list. ശേഖരിച്ചത് 12 March 2011.
  24. ↑ https://mail.haskell.org/pipermail/haskell-prime/2016-April/004050.html
  25. ↑ Type inference originally using Hindley-Milner type inference
  26. ↑ This allows finer control over the expression evaluation strategy
  27. ↑ "Type classes, first proposed during the design of the Haskell programming language, ..." —John Garrett Morris (2013), "Type Classes and Instance Chains: A Relational Approach" [പ്രവർത്തിക്കാത്ത കണ്ണി]
  28. ↑ Edward Kmett, Edward Kmett - Type Classes vs. the World
  29. ↑ "Haskell in education". ശേഖരിച്ചത് 15 February 2016.
  30. ↑ "Haskell in research". ശേഖരിച്ചത് 15 February 2016.
  31. ↑ "Haskell in industry". ശേഖരിച്ചത് 15 February 2016.
  32. ↑ 32.0 32.1 32.2 Peyton Jones 2003, Preface.
  33. ↑ Hudak et al. 2007.
  34. ↑ 34.0 34.1 Peyton Jones 2003.
  35. ↑ "Haskell Wiki: Implementations". ശേഖരിച്ചത് 18 December 2012.
  36. ↑ "Welcome to Haskell'". The Haskell' Wiki. മൂലതാളിൽ നിന്നും 2016-02-20-ന് ആർക്കൈവ് ചെയ്തത്. ശേഖരിച്ചത് 2018-07-24.
  37. ↑ Hallgren, T. (January 2001). "Fun with Functional Dependencies, or Types as Values in Static Computations in Haskell". Proceedings of the Joint CS/CE Winter Meeting. Varberg, Sweden.
  38. ↑ Wadler, P.; Blott, S. (1989). "How to make ad-hoc polymorphism less ad hoc". Proceedings of the 16th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages. ACM: 60–76. doi:10.1145/75277.75283. ISBN 0-89791-294-2.
  39. ↑ "Computer Language Benchmarks Game". മൂലതാളിൽ നിന്നും 2016-03-10-ന് ആർക്കൈവ് ചെയ്തത്. ശേഖരിച്ചത് 2018-08-05.
  40. ↑ "Implementations" at the Haskell Wiki
  41. ↑ "The LLVM Backend". GHC Trac.
  42. ↑ Terei, David A.; Chakravarty, Manuel M. T. (2010). "An LLVM Backend for GHC". Proceedings of ACM SIGPLAN Haskell Symposium 2010. ACM Press.
  43. ↑ C. Ryder and S. Thompson (2005). "Porting HaRe to the GHC API"
  44. ↑ Utrecht Haskell Compiler
  45. ↑ Boquist, Urban; Johnsson, Thomas (1996). "The GRIN Project: A Highly Optimising Back End for Lazy Functional Languages". LNCS. 1268: 58–84.
  46. ↑ Hudak et al. 2007, p. 12-22.
  47. ↑ "The Haskell Cabal". ശേഖരിച്ചത് 8 April 2015.
  48. ↑ "Linspire/Freespire Core OS Team and Haskell". Debian Haskell mailing list. May 2006. മൂലതാളിൽ നിന്നും 2017-12-27-ന് ആർക്കൈവ് ചെയ്തത്. ശേഖരിച്ചത് 2018-08-11.
  49. ↑ xmonad.org
  50. ↑ ShellCheck
  51. ↑ Simon Marlow (2014), Open-sourcing Haxl
  52. ↑ Metz, Cade (September 1, 2015). "Facebook's New Spam-Killer Hints at the Future of Coding". Wired. ശേഖരിച്ചത് September 1, 2015.
  53. ↑ 53.0 53.1 53.2 53.3 A formal proof of functional correctness was completed in 2009. Klein, Gerwin; Elphinstone, Kevin; Heiser, Gernot; Andronick, June; Cock, David; Derrin, Philip; Elkaduwe, Dhammika; Engelhardt, Kai; Kolanski, Rafal; Norrish, Michael; Sewell, Thomas; Tuch, Harvey; Winwood, Simon (October 2009). "seL4: Formal verification of an OS kernel" (PDF). 22nd ACM Symposium on Operating System Principles. Big Sky, MT, USA. {{cite conference}}: Unknown parameter |booktitle= ignored (|book-title= suggested) (help)
  54. ↑ "Cardano". Input Output. മൂലതാളിൽ നിന്നും 2017-12-22-ന് ആർക്കൈവ് ചെയ്തത്. ശേഖരിച്ചത് 2017-12-18.
  55. ↑ "Web/Frameworks".
  56. ↑ "Snap: A Haskell Web Framework: Home". Snapframework.com. ശേഖരിച്ചത് 2013-06-26.
  57. ↑ Jan-Willem Maessen. Eager Haskell: Resource-bounded execution yields efficient iteration. Proceedings of the 2002 Association for Computing Machinery (ACM) SIGPLAN workshop on Haskell.
  58. ↑ Simon Peyton Jones. Wearing the hair shirt: a retrospective on Haskell. Invited talk at POPL 2003.
  59. ↑ Heeren, Bastiaan; Leijen, Daan; van IJzendoorn, Arjan (2003). "Helium, for learning Haskell" (PDF). Proceedings of the 2003 ACM SIGPLAN workshop on Haskell. മൂലതാളിൽ (PDF) നിന്നും 2007-02-04-ന് ആർക്കൈവ് ചെയ്തത്. ശേഖരിച്ചത് 2018-08-13.
  60. ↑ "DDC – HaskellWiki". Haskell.org. 2010-12-03. ശേഖരിച്ചത് 2013-06-26.
  61. ↑ Ben Lippmeier, Type Inference and Optimisation for an Impure World, Australian National University (2010) PhD thesis, chapter 1
  62. ↑ "DDC – HaskellWiki". Haskell.org. 2010-12-03. ശേഖരിച്ചത് 2013-06-26.
  63. ↑ Robert Harper. "Modules matter most".
  64. ↑ "Frege Programming Language".
  65. ↑ "Google Code Archive - Long-term storage for Google Code Project Hosting".
  66. ↑ Marimuthu Madasamy. "mmhelloworld".
  67. ↑ "Codehaus". മൂലതാളിൽ നിന്നും 20 ഫെബ്രുവരി 2006-ന് ആർക്കൈവ് ചെയ്തത്.
  68. ↑ "Glasgow Parallel Haskell".
  69. ↑ "7.15. Parallel Haskell".
  70. ↑ "4.12. Using SMP parallelism".
  71. ↑ Todd Allen Amicon. "Computation Structures Group- MIT- LCS".
  72. ↑ "Hackathon – HaskellWiki".
  73. ↑ The Num type class
  74. ↑ Num typeclass signum function
  75. ↑ 75.0 75.1 SchoolOfHaskell.com - Safe Int addition and product
  76. ↑ The Fractional type class
  77. ↑ The Real type class
  78. ↑ The Rational numbers module
  79. ↑ 79.0 79.1 The Float data type
  80. ↑ The Integral type class
  81. ↑ 81.0 81.1 The Floating type class
  82. ↑ The Complex data type
"https://ml.wikipedia.org/w/index.php?title=ഹാസ്കൽ_(പ്രോഗ്രാമിങ്_ഭാഷ)&oldid=3914352" എന്ന താളിൽനിന്ന് ശേഖരിച്ചത്