ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ്
ഹാസ്കെലിൽ
പ്രഭാഷണ കുറിപ്പുകൾ
റൈബിൻസ്ക് 2010
ആമുഖം................................................ ....................................................... ............................. 3
1. ചരിത്രം ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ്.................................................... 4
2 ഫങ്ഷണൽ ഭാഷകളുടെ സവിശേഷതകൾ............................................. ...... ..................... 5
2.1 അടിസ്ഥാന ഗുണങ്ങൾ ............................................. ............................................................... ........... 5
2.2 പ്രയോജനങ്ങൾ................................................ .............................................. 9
2.3 പോരായ്മകൾ................................................ .............................................. ......... . പതിനൊന്ന്
3 നിലവിലുള്ള ഭാഷകളുടെ അവലോകനം............................................. ...... ................................. 13
4 അടിസ്ഥാന തത്വങ്ങൾഹാസ്കെൽ ഭാഷ ................................................ ... ......................... 16
4.1 സംവേദനാത്മക അന്തരീക്ഷം ............................................. ..... ................................... 16
4.2 പ്രോഗ്രാം ഘടന ............................................. ..... ................................ 18
4.3 ഫംഗ്ഷനുകളുടെ തരങ്ങൾ .............................................. ..... ................................................ 22
4.4 സോപാധിക കണക്കുകൂട്ടലുകൾ (ശാഖകൾ)........................................... ..... ............... 24
4.5 ഒരു സാമ്പിളുമായുള്ള താരതമ്യം............................................. ....................................... 27
4.6 ലിസ്റ്റുകൾ................................................ .............................................. ......... ....... 29
4.7 പ്രാദേശിക നിർവചനങ്ങൾ............................................................................. 33
4.8 സംവേദനാത്മക പരിതസ്ഥിതിയുടെ അധിക സവിശേഷതകൾ..................................... 35
4.9 പ്രവർത്തനങ്ങൾ ഉയർന്ന ആജ്ഞാപത്രം......................................................................... 36
4.10 അനന്തമായ ഡാറ്റ ഘടനകൾ........................................... ...... ............... 37
5 ഡാറ്റ തരങ്ങളും മൊഡ്യൂളുകളും............................................. ....................................................... .... 40
5.1 ഇഷ്‌ടാനുസൃത തരങ്ങൾഡാറ്റാ ഘടനകളും ............................................. .... 40
5.2 മൊഡ്യൂളുകൾ................................................ .............................................. ......... ...... 44
6 ക്ലാസുകളും മൊണാഡുകളും .............................................. ...... ............................................. ............ ... 47
6.1 ക്ലാസുകൾ........................................... .............................................. ......... ....... 47
6.2 I/O........................................... ............................................... .......... .. 49
7 ഉദാഹരണങ്ങൾ........................................... .............................................. .......................... 53
ഉപസംഹാരം .................................................. ................................................... ...... .......... 54
ഉപയോഗിച്ച സ്രോതസ്സുകളുടെ ലിസ്റ്റ് ............................................. ........... ................. 55
ആമുഖം
ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ് വിവരിക്കുന്നതിന് മുമ്പ്, നമുക്ക് പൊതുവായ പ്രോഗ്രാമിംഗിൻ്റെ ചരിത്രത്തിലേക്ക് തിരിയാം. 1940 കളിൽ ആദ്യത്തേത് ഡിജിറ്റൽ കമ്പ്യൂട്ടറുകൾ, വിവിധ തരത്തിലുള്ള ടോഗിൾ സ്വിച്ചുകൾ, വയറുകൾ, ബട്ടണുകൾ എന്നിവ മാറ്റി പ്രോഗ്രാം ചെയ്തു. അത്തരം സ്വിച്ചുകളുടെ എണ്ണം നൂറുകണക്കിന് കവിഞ്ഞു, പ്രോഗ്രാമുകൾ കൂടുതൽ സങ്കീർണ്ണമായതിനാൽ വർദ്ധിച്ചു. അതിനാൽ, പ്രോഗ്രാമിംഗിൻ്റെ വികസനത്തിൻ്റെ അടുത്ത ഘട്ടം എല്ലാത്തരം അസംബ്ലി ഭാഷകളും ലളിതമായ മെമ്മോണിക്സ് ഉപയോഗിച്ച് സൃഷ്ടിക്കുക എന്നതായിരുന്നു.
എന്നാൽ അനേകം ആളുകൾക്ക് ഉപയോഗിക്കാൻ കഴിയുന്ന ഒരു ഉപകരണമായി അസംബ്ലർമാർക്ക് പോലും മാറാൻ കഴിഞ്ഞില്ല, കാരണം മെമ്മോണിക് കോഡുകൾ ഇപ്പോഴും വളരെ സങ്കീർണ്ണമായിരുന്നു, കൂടാതെ ഓരോ അസംബ്ലറും അത് നടപ്പിലാക്കിയ വാസ്തുവിദ്യയുമായി കർശനമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു. അസംബ്ലറിന് ശേഷമുള്ള അടുത്ത ഘട്ടം നിർബന്ധിത ഭാഷകൾ എന്ന് വിളിക്കപ്പെടുന്നവയായിരുന്നു ഉയർന്ന തലം: ബേസിക്, പാസ്കൽ, സി, അഡ എന്നിവയും ഒബ്ജക്റ്റ് ഓറിയൻ്റഡ് ഉൾപ്പെടെയുള്ളവയും. അത്തരം ഭാഷകളെ നിർബന്ധിത ("പ്രിസ്‌ക്രിപ്റ്റീവ്") എന്ന് വിളിക്കുന്നു, കാരണം അവ മെമ്മറി (അതായത്, അസൈൻമെൻ്റുകൾ), ആവർത്തന ലൂപ്പുകൾ എന്നിവയിൽ പ്രവർത്തിക്കുന്ന നിർദ്ദേശങ്ങളുടെ തുടർച്ചയായ നിർവ്വഹണത്തിൽ ശ്രദ്ധ കേന്ദ്രീകരിച്ചിരിക്കുന്നു. പ്രവർത്തനവും നടപടിക്രമ കോളുകളും, ആവർത്തിച്ചുള്ളവ പോലും, അത്തരം ഭാഷകളെ വ്യക്തമായ അനിവാര്യതയിൽ നിന്ന് മോചിപ്പിച്ചില്ല.
ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ് മാതൃകയിൽ, പ്രവർത്തനമാണ് മൂലക്കല്ല്. ഗണിത പ്രവർത്തനങ്ങൾപ്രാരംഭ ഡാറ്റയും ചില പ്രക്രിയയുടെ അന്തിമ ഉൽപ്പന്നവും തമ്മിലുള്ള ബന്ധം പ്രകടിപ്പിക്കുക. കണക്കുകൂട്ടൽ പ്രക്രിയയ്ക്ക് ഒരു ഇൻപുട്ടും ഔട്ട്പുട്ടും ഉണ്ട്, അതിനാൽ ഒരു ഫംഗ്ഷൻ കണക്കുകൂട്ടലുകൾ വിവരിക്കുന്നതിന് തികച്ചും അനുയോജ്യവും മതിയായതുമായ മാർഗമാണ്. ഈ ലളിതമായ തത്വമാണ് പ്രവർത്തന മാതൃകയുടെയും ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ് ശൈലിയുടെയും അടിസ്ഥാനം. പ്രവർത്തന പരിപാടിഫംഗ്ഷൻ നിർവചനങ്ങളുടെ ഒരു കൂട്ടമാണ്. ഫംഗ്ഷനുകൾ മറ്റ് ഫംഗ്‌ഷനുകളിലൂടെയോ അല്ലെങ്കിൽ അവയിലൂടെ ആവർത്തനത്തിലൂടെയോ നിർവചിക്കപ്പെടുന്നു. ഒരു ഫങ്ഷണൽ ഭാഷയിൽ, പ്രോഗ്രാമർ ആവശ്യമുള്ള ഫലം ഫംഗ്ഷനുകളുടെ ഒരു സിസ്റ്റമായി വിവരിക്കേണ്ടതുണ്ട്.
2 ഫങ്ഷണൽ പ്രോഗ്രാമിംഗിൻ്റെ ചരിത്രം
അറിയപ്പെടുന്നതുപോലെ, സൈദ്ധാന്തിക അടിസ്ഥാനം 1930-കളിൽ അലൻ ട്യൂറിംഗും ജോൺ വോൺ ന്യൂമാനും ചേർന്നാണ് ഇംപറേറ്റീവ് പ്രോഗ്രാമിംഗ് ആരംഭിച്ചത്. പ്രവർത്തനപരമായ സമീപനത്തിൻ്റെ അടിസ്ഥാനമായ സിദ്ധാന്തവും 20-30 കളിലാണ് ജനിച്ചത്. ഫങ്ഷണൽ പ്രോഗ്രാമിംഗിൻ്റെ ഗണിതശാസ്ത്ര അടിത്തറയുടെ ഡെവലപ്പർമാരിൽ കോമ്പിനേറ്ററി ലോജിക് വികസിപ്പിച്ച മോസസ് ഷെയിൻഫിങ്കലും ഹാസ്കെൽ കറിയും അതുപോലെ തന്നെ λ-കാൽക്കുലസിൻ്റെ (ലാംഡ കാൽക്കുലസ്) സ്രഷ്ടാവായ അലോൻസോ ചർച്ചും ഉൾപ്പെടുന്നു.
1950-കളുടെ തുടക്കത്തിൽ ജോൺ മക്കാർത്തി ലിസ്പ് വികസിപ്പിക്കുന്നതുവരെ ഈ സിദ്ധാന്തം ഒരു സിദ്ധാന്തമായി തുടർന്നു, അത് പ്രവർത്തനക്ഷമമല്ലാത്ത ആദ്യത്തെ പ്രോഗ്രാമിംഗ് ഭാഷയായി മാറുകയും വർഷങ്ങളോളം ഒരേയൊരു ഭാഷയായി തുടരുകയും ചെയ്തു. ലിസ്പ് ഇപ്പോഴും ഉപയോഗത്തിലാണ്, നിരവധി വർഷത്തെ പരിണാമത്തിന് ശേഷവും അത് ആധുനിക ആവശ്യങ്ങൾ നിറവേറ്റുന്നു.
സോഫ്റ്റ്വെയറിൻ്റെ വർദ്ധിച്ചുവരുന്ന സങ്കീർണ്ണത കാരണം, ടൈപ്പിംഗ് കൂടുതൽ പ്രധാന പങ്ക് വഹിക്കാൻ തുടങ്ങിയിരിക്കുന്നു. 70-കളുടെ അവസാനത്തിലും 20-ആം നൂറ്റാണ്ടിൻ്റെ 80-കളുടെ തുടക്കത്തിലും, പ്രവർത്തനപരമായ ഭാഷകൾക്ക് അനുയോജ്യമായ ടൈപ്പിംഗ് മോഡലുകൾ തീവ്രമായി വികസിപ്പിച്ചെടുത്തു. ഈ മോഡലുകളിൽ ഭൂരിഭാഗവും ഡാറ്റ അമൂർത്തീകരണം, പോളിമോർഫിസം തുടങ്ങിയ ശക്തമായ സംവിധാനങ്ങൾക്കുള്ള പിന്തുണ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. നിരവധി ടൈപ്പ് ചെയ്ത ഫംഗ്ഷണൽ ഭാഷകൾ പ്രത്യക്ഷപ്പെടുന്നു: ML, സ്കീം, ഹോപ്പ്, മിറാൻഡ, ക്ലീൻ തുടങ്ങി നിരവധി. കൂടാതെ, പ്രാദേശിക ഭാഷകളുടെ എണ്ണം നിരന്തരം വർദ്ധിച്ചുകൊണ്ടിരിക്കുന്നു. മിക്കവാറും എല്ലാ ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ് ഗ്രൂപ്പുകളും സ്വന്തം ഭാഷ ഉപയോഗിച്ചു. ഇത് ഈ ഭാഷകളുടെ കൂടുതൽ വ്യാപനം തടയുകയും നിരവധി ചെറിയ പ്രശ്നങ്ങൾക്ക് കാരണമാവുകയും ചെയ്തു. സാഹചര്യം പരിഹരിക്കുന്നതിന്, ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗ് മേഖലയിലെ പ്രമുഖ ഗവേഷകരുടെ ഒരു സംയുക്ത സംഘം വിവിധ ഭാഷകളുടെ ശക്തികൾ ഒരു പുതിയ സാർവത്രിക പ്രവർത്തന ഭാഷയിൽ പുനർനിർമ്മിക്കാൻ തീരുമാനിച്ചു. ഹാസ്കെൽ കറിയുടെ പേരിൽ ഹാസ്കെൽ എന്ന് പേരിട്ടിരിക്കുന്ന ഈ ഭാഷയുടെ ആദ്യ പ്രയോഗം 90-കളുടെ തുടക്കത്തിൽ സൃഷ്ടിക്കപ്പെട്ടു.
3 ഫങ്ഷണൽ ഭാഷകളുടെ സവിശേഷതകൾ
പ്രോഗ്രാമിംഗ് ഭാഷകളുടെ ഏതൊരു ഗ്രൂപ്പിനെയും പോലെ, ഫംഗ്ഷണൽ ഭാഷകൾക്കും മറ്റ് ഭാഷകളിൽ നിന്ന് അവയെ വേർതിരിച്ച് പ്രവർത്തനക്ഷമമായ പ്രോഗ്രാമിംഗ് ഭാഷകളാക്കി മാറ്റുന്ന ചില സവിശേഷതകൾ ഉണ്ട്.
3.1 അടിസ്ഥാന ഗുണങ്ങൾ
പ്രവർത്തനപരമായ ഭാഷകളുടെ സവിശേഷതകളിൽ, ഇനിപ്പറയുന്നവ സാധാരണയായി വേർതിരിച്ചിരിക്കുന്നു:
- സംക്ഷിപ്തതയും ലാളിത്യവും;
- കർശനമായ ടൈപ്പിംഗ്;
- പ്രവർത്തനങ്ങൾ മൂല്യങ്ങളാണ്;
- പരിശുദ്ധി (പാർശ്വഫലങ്ങളൊന്നുമില്ല);
- മാറ്റിവെച്ച (അലസമായ) കണക്കുകൂട്ടലുകൾ;
- മോഡുലാരിറ്റി.
ഈ പ്രോപ്പർട്ടികൾ ഓരോന്നും കൂടുതൽ വിശദമായി നോക്കാം.
സംക്ഷിപ്തതയും ലാളിത്യവും
ഫങ്ഷണൽ ഭാഷകളിലെ പ്രോഗ്രാമുകൾ സാധാരണയായി നിർബന്ധിത ഭാഷകളിലെ അതേ പ്രോഗ്രാമുകളേക്കാൾ ചെറുതും ലളിതവുമാണ്. ഏറ്റവും സാധാരണമായ ഉദാഹരണങ്ങളിലൊന്നാണ് ഹോറെ ദ്രുത ക്രമം.
ഓൺ നിർബന്ധിത ഭാഷസി ക്വിക്ക്സോർട്ട് സാധാരണയായി ഇതുപോലെയാണ് നടപ്പിലാക്കുന്നത്:
ശൂന്യമായ qsort (int a, int l, int r)
int i = l, j = r, x = a[(l + r) / 2];
അതേസമയം (a[i]< x) i++;
അതേസമയം (x< a[j]) j--;
int temp = a[i];
അതേസമയം (ഐ<= j);
എങ്കിൽ (എൽ< j) qsort (a, l, j);
എനിക്ക് എങ്കിൽ< r) qsort (a, i, r);
ഹാസ്കെൽ ഫങ്ഷണൽ ഭാഷയിൽ, ഇതേ സോർട്ടിംഗ് വളരെ ചെറുതും കൂടുതൽ വ്യക്തവുമാണ്:
qsort(x:xs) = qsort
++[x]++qsort
ഈ ഉദാഹരണം ഇതുപോലെ വായിക്കണം: അടുക്കിയിരിക്കുന്ന ലിസ്റ്റ് ശൂന്യമാണെങ്കിൽ, സോർട്ടിംഗിൻ്റെ ഫലവും ഒരു ശൂന്യമായ ലിസ്റ്റായിരിക്കും, അല്ലാത്തപക്ഷം ലിസ്റ്റിൻ്റെ തലയും വാലും (ലിസ്റ്റിൻ്റെ ആദ്യ ഘടകവും ശേഷിക്കുന്ന ഘടകങ്ങളുടെ പട്ടികയും . അല്ലെങ്കിൽ തലയ്ക്ക് തുല്യമാണ്.
കോഡ് വലുപ്പത്തിലും വ്യക്തതയിലും ഒരു ഫങ്ഷണൽ ഭാഷയിലെ കോഡ് പ്രയോജനപ്പെടുന്നു. കൂടാതെ, മുകളിലുള്ള C നടപ്പിലാക്കൽ, പൂർണ്ണസംഖ്യയുടെ (int) ഘടകങ്ങളുള്ള ഒരു അറേയെ അടുക്കുന്നു, അതേസമയം ഹാസ്കെൽ നടപ്പിലാക്കലിന് ഒരു താരതമ്യ പ്രവർത്തനം നിർവചിച്ചിരിക്കുന്ന ഏത് തരത്തിലുള്ള ഘടകങ്ങളുടെയും ലിസ്റ്റുകൾ അടുക്കാൻ കഴിയും.
ശക്തമായ ടൈപ്പിംഗ്
മിക്ക ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗ് ഭാഷകളും ശക്തമായി ടൈപ്പ് ചെയ്തിരിക്കുന്നു. കർശനമായ ടൈപ്പിംഗ് ഇനിപ്പറയുന്ന നിർബന്ധിത വ്യവസ്ഥകളുടെ പൂർത്തീകരണത്തെ സൂചിപ്പിക്കുന്നു:
- പ്രോഗ്രാം ഡിസൈൻ ഘട്ടത്തിൽ ഒരു ഫംഗ്ഷൻ്റെ ഓരോ മൂല്യവും വേരിയബിളും ആർഗ്യുമെൻ്റും റിട്ടേൺ മൂല്യവും പ്രോഗ്രാം എക്സിക്യൂഷൻ സമയത്ത് മാറ്റാൻ കഴിയാത്ത ഒരു നിർദ്ദിഷ്ട ഡാറ്റാ തരവുമായി നിരുപാധികമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു;
- ഫംഗ്ഷൻ വിവരണത്തിൽ വ്യക്തമാക്കിയിരിക്കുന്ന അതേ ഡാറ്റ തരമുള്ള മൂല്യങ്ങൾ ഫംഗ്‌ഷനുകൾക്ക് സ്വീകരിക്കാനും തിരികെ നൽകാനും കഴിയും;
- ഓരോ പ്രവർത്തനത്തിനും കർശനമായി നിർവചിക്കപ്പെട്ട തരത്തിലുള്ള ആർഗ്യുമെൻ്റുകൾ ആവശ്യമാണ്;
- ഇംപ്ലിസിറ്റ് ടൈപ്പ് കൺവേർഷൻ അനുവദനീയമല്ല (അതായത്, വേരിയബിൾ, ആർഗ്യുമെൻ്റ്, ഫംഗ്ഷൻ അല്ലെങ്കിൽ ഓപ്പറേഷൻ എന്നിവയ്ക്കായി വിവരിച്ചതിൽ നിന്ന് വ്യത്യസ്തമായ ഒരു മൂല്യം ഉപയോഗിക്കാനുള്ള ഏതൊരു ശ്രമവും വിവർത്തകൻ മനസ്സിലാക്കുന്നു).
പ്രോഗ്രാമിംഗ് സിദ്ധാന്തത്തിൽ, വികസിപ്പിച്ച സോഫ്റ്റ്വെയറിൻ്റെ വിശ്വാസ്യത ഉറപ്പാക്കുന്നതിന് കർശനമായ ടൈപ്പിംഗ് ഒരു ഒഴിച്ചുകൂടാനാവാത്ത ഘടകമാണ്. ശരിയായി ഉപയോഗിക്കുമ്പോൾ (പ്രോഗ്രാം ലോജിക്കലി പൊരുത്തമില്ലാത്ത മൂല്യങ്ങൾക്കായി പ്രത്യേക ഡാറ്റ തരങ്ങൾ പ്രഖ്യാപിക്കുകയും ഉപയോഗിക്കുകയും ചെയ്യുന്നു എന്നർത്ഥം), ലോജിക്കലി പൊരുത്തമില്ലാത്ത മൂല്യങ്ങൾ പങ്കിടുന്നതുമായി ബന്ധപ്പെട്ട ലളിതവും എന്നാൽ കണ്ടെത്താൻ ബുദ്ധിമുട്ടുള്ളതുമായ പിശകുകളിൽ നിന്ന് ഇത് പ്രോഗ്രാമറെ സംരക്ഷിക്കുന്നു, ചിലപ്പോൾ ഒരു പ്രാഥമിക അക്ഷരത്തെറ്റിൽ നിന്ന് ഉണ്ടാകാം. പ്രോഗ്രാം കംപൈലേഷൻ്റെ ഘട്ടത്തിൽ പോലും അത്തരം പിശകുകൾ കണ്ടെത്തുന്നു, അതേസമയം ഏതാണ്ട് ഏത് തരത്തെയും പരസ്പരം പരസ്പരം പരിവർത്തനം ചെയ്യാൻ കഴിയുമ്പോൾ (ഉദാഹരണത്തിന്, ക്ലാസിക്കൽ സി ഭാഷയിൽ), ഈ പിശകുകൾ പരിശോധനയ്ക്കിടെ മാത്രമേ കണ്ടെത്തൂ, എല്ലാം അല്ല അവരിൽ നിന്ന് ഒറ്റയടിക്ക് അല്ല.
മൂല്യങ്ങളായി പ്രവർത്തിക്കുന്നു
ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ, ഫംഗ്ഷനുകൾ മറ്റേതൊരു ഒബ്‌ജക്‌റ്റുകളെപ്പോലെ ഉപയോഗിക്കാനും അവ മറ്റ് ഫംഗ്ഷനുകളിലേക്ക് ആർഗ്യുമെൻ്റുകളായി കൈമാറാനും മറ്റ് ഫംഗ്ഷനുകളുടെ ഫലമായി തിരികെ നൽകാനും ലിസ്റ്റുകളിലും മറ്റ് ഡാറ്റാ ഘടനകളിലും സംഭരിക്കാനും കഴിയും. മറ്റ് ഫംഗ്‌ഷനുകളെ ആർഗ്യുമെൻ്റുകളോ ഫലങ്ങൾ നൽകുന്നതോ ആയ ഫംഗ്‌ഷനുകളെ ഉയർന്ന ഓർഡർ ഫംഗ്ഷനുകൾ എന്ന് വിളിക്കുന്നു.
ഉയർന്ന ഓർഡർ ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുന്നത് കൂടുതൽ വഴക്കമുള്ള ഫംഗ്ഷനുകൾ സൃഷ്ടിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു, അതുവഴി കോഡ് പുനരുപയോഗം വർദ്ധിപ്പിക്കുന്നു. എലമെൻ്റ് താരതമ്യ ഫംഗ്ഷനെ സോർട്ട് ഫംഗ്ഷനിലേക്ക് കടത്തിവിടുന്നതാണ് സാധാരണയായി നൽകിയിരിക്കുന്ന ഒരു ഉദാഹരണം.
ശുദ്ധി
ഫംഗ്ഷൻ മൂല്യങ്ങൾ കണക്കാക്കുമ്പോൾ പാർശ്വഫലങ്ങളുടെ അഭാവമാണ് പരിശുദ്ധി. പ്രവർത്തനത്തിൻ്റെ ഒരു പാർശ്വഫലമാണ്, അതിൻ്റെ കണക്കുകൂട്ടലുകൾ കണക്കാക്കുന്ന പ്രക്രിയയിൽ, ആഗോള വേരിയബിളുകളുടെ മൂല്യങ്ങൾ വായിക്കാനും മാറ്റാനും, I/O പ്രവർത്തനങ്ങൾ നടത്താനും, ഒഴിവാക്കൽ സാഹചര്യങ്ങളോട് പ്രതികരിക്കാനും, ഇൻപുട്ട് വേരിയബിളുകളുടെ മൂല്യങ്ങൾ മാറ്റാനുമുള്ള കഴിവാണ്. . അതിനാൽ, ഒരേ സെറ്റ് ഇൻപുട്ട് ആർഗ്യുമെൻ്റ് മൂല്യങ്ങൾ ഉപയോഗിച്ച് നിങ്ങൾ അത്തരമൊരു ഫംഗ്ഷനെ രണ്ടുതവണ വിളിക്കുകയാണെങ്കിൽ, കണക്കുകൂട്ടൽ ഫലങ്ങൾ വ്യത്യാസപ്പെടാം, കൂടാതെ ചില ആഗോള ഒബ്‌ജക്റ്റുകളുടെ അവസ്ഥയും (ഉദാഹരണത്തിന്, വേരിയബിൾ മൂല്യങ്ങൾ) മാറിയേക്കാം. അത്തരം പ്രവർത്തനങ്ങളെ പാർശ്വഫലങ്ങളുള്ള നോൺഡിറ്റർമിനിസ്റ്റിക് പ്രവർത്തനങ്ങൾ എന്ന് വിളിക്കുന്നു.
ശുദ്ധമായ ഫങ്ഷണൽ പ്രോഗ്രാമിംഗിൽ, ഒരേ ആർഗ്യുമെൻ്റുകളുള്ള ഒരേ ഫംഗ്ഷൻ എല്ലായ്പ്പോഴും ഒരേ ഫലം നൽകുന്നു. സൃഷ്ടിച്ച വസ്തുക്കളെ മാറ്റാനോ നശിപ്പിക്കാനോ കഴിയില്ല; നിലവിലുള്ളവയെ അടിസ്ഥാനമാക്കി മാത്രമേ പുതിയവ സൃഷ്ടിക്കാൻ കഴിയൂ. പരിശുദ്ധിക്ക് നന്ദി, പ്രോഗ്രാമുകൾ കൂടുതൽ വ്യക്തമാകുക മാത്രമല്ല, അവയിലെ സമാന്തരതയുടെ ഓർഗനൈസേഷനും ലളിതമാക്കുകയും ചെയ്യുന്നു, കാരണം പ്രവർത്തനങ്ങൾ പരസ്പരം സ്വതന്ത്രമായി കണക്കാക്കാം. ഒരു ശുദ്ധമായ പ്രവർത്തനത്തിൻ്റെ ഫലം ഉപയോഗിക്കുന്നില്ലെങ്കിൽ, മറ്റ് പദപ്രയോഗങ്ങൾക്ക് ദോഷം വരുത്താതെ അതിൻ്റെ മൂല്യനിർണ്ണയം ഒഴിവാക്കാവുന്നതാണ്. രണ്ട് ശുദ്ധമായ ഫംഗ്ഷനുകൾക്കിടയിൽ ഡാറ്റ ആശ്രിതത്വം ഇല്ലെങ്കിൽ, നിങ്ങൾക്ക് അവയുടെ കണക്കുകൂട്ടലിൻ്റെ ക്രമം മാറ്റാം അല്ലെങ്കിൽ സമാന്തരമായി കണക്കാക്കാം. ഈ സാഹചര്യത്തിൽ, കംപൈലറിന് ഏത് മൂല്യനിർണ്ണയ നയവും ഉപയോഗിക്കാം. ഒരു പ്രോഗ്രാമിലെ എക്സ്പ്രഷനുകളുടെ മൂല്യനിർണ്ണയം സംയോജിപ്പിക്കാനും പുനഃസംഘടിപ്പിക്കാനും ഇത് കമ്പൈലറിന് സ്വാതന്ത്ര്യം നൽകുന്നു.
അലസമായ കണക്കുകൂട്ടലുകൾ
പരമ്പരാഗത ഭാഷകളിൽ, ഒരു ഫംഗ്ഷൻ വിളിക്കുന്നതിന് മുമ്പ്, അതിൻ്റെ എല്ലാ ആർഗ്യുമെൻ്റുകളുടെയും മൂല്യങ്ങൾ കണക്കാക്കുന്നു. ഫംഗ്ഷനുകൾ വിളിക്കുന്ന ഈ രീതിയെ "മൂല്യം അനുസരിച്ച് കോൾ" എന്ന് വിളിക്കുന്നു. ഏതെങ്കിലും വാദങ്ങൾ ഉപയോഗിച്ചില്ലെങ്കിൽ, കണക്കുകൂട്ടലുകൾ വെറുതെയായി. പല ഫംഗ്ഷണൽ ഭാഷകളും ഫംഗ്ഷനുകൾ വിളിക്കുന്നതിനുള്ള മറ്റൊരു രീതി ഉപയോഗിക്കുന്നു - "ആവശ്യമെങ്കിൽ വിളിക്കുക". ഈ സാഹചര്യത്തിൽ, ഓരോ ഫംഗ്ഷൻ ആർഗ്യുമെൻ്റും ഫംഗ്ഷൻ ഫലം കണക്കാക്കാൻ അതിൻ്റെ മൂല്യം ആവശ്യമാണെങ്കിൽ മാത്രമേ വിലയിരുത്തപ്പെടുകയുള്ളൂ. ഉദാഹരണത്തിന്, C++ കൺജക്ഷൻ ഓപ്പറേറ്ററിന് (&&) ആദ്യത്തേത് തെറ്റാണെങ്കിൽ രണ്ടാമത്തെ ആർഗ്യുമെൻ്റ് മൂല്യനിർണ്ണയം ആവശ്യമില്ല.
ചില സന്ദർഭങ്ങളിൽ അലസമായ വിലയിരുത്തൽ പ്രോഗ്രാം നിർവ്വഹണം വേഗത്തിലാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു, കൂടാതെ വിവിധ അനന്തമായ ഡാറ്റ ഘടനകൾ ഉപയോഗിക്കാനും നിങ്ങളെ അനുവദിക്കുന്നു.
മോഡുലാരിറ്റി
പ്രോഗ്രാമുകളെ താരതമ്യേന സ്വതന്ത്രമായ നിരവധി ഭാഗങ്ങളായി (അല്ലെങ്കിൽ മൊഡ്യൂളുകൾ) വിഭജിക്കാൻ മോഡുലാരിറ്റി മെക്കാനിസം നിങ്ങളെ അനുവദിക്കുന്നു. വലിയ സോഫ്റ്റ്വെയർ സിസ്റ്റങ്ങളുടെ രൂപകല്പനയും തുടർന്നുള്ള പിന്തുണയും ഇത് ലളിതമാക്കുന്നു. മോഡുലാരിറ്റിക്കുള്ള പിന്തുണ ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗ് ഭാഷകളുടെ സ്വത്തല്ല, എന്നാൽ അത്തരം മിക്ക ഭാഷകളും പിന്തുണയ്ക്കുന്നു.
3.2 പ്രയോജനങ്ങൾ
നിർബന്ധിത ഭാഷകളേക്കാൾ പ്രവർത്തനപരമായ പ്രോഗ്രാമിംഗ് ഭാഷകൾക്ക് നിരവധി ഗുണങ്ങളുണ്ട്. ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ് മാതൃകയുടെ ഉപയോഗം പ്രോഗ്രാമുകളുടെ വിശ്വാസ്യത, അവയുടെ എഴുത്തിൻ്റെ വേഗത, യൂണിറ്റ് പരിശോധനയുടെ സൗകര്യം, സമാഹരണ സമയത്ത് ഒപ്റ്റിമൈസേഷൻ്റെ സാധ്യത, സമാന്തരത സ്വയമേവ സംഘടിപ്പിക്കാനുള്ള സാധ്യത എന്നിവ വർദ്ധിപ്പിക്കുന്നു.
പ്രോഗ്രാമിംഗിൻ്റെ വിശ്വാസ്യത
പാർശ്വഫലങ്ങളുടെ അഭാവം ഒരു ഗ്ലോബൽ വേരിയബിളിന് ആകസ്മികമായി തെറ്റായ മൂല്യം നൽകുന്നത് പോലെയുള്ള, കണ്ടുപിടിക്കാൻ ബുദ്ധിമുട്ടുള്ള നിരവധി പിശകുകൾ ഉണ്ടാക്കുന്നു. കംപൈലേഷൻ ഘട്ടത്തിൽ ചില ഡാറ്റയുടെ തെറ്റായ ഉപയോഗവുമായി ബന്ധപ്പെട്ട ധാരാളം പിശകുകൾ കണ്ടെത്താൻ കർശനമായ സ്റ്റാറ്റിക് ടൈപ്പിംഗ് നിങ്ങളെ അനുവദിക്കുന്നു.
ഫങ്ഷണൽ ഭാഷകളുടെ രസകരമായ ഒരു സവിശേഷത അവർ ഗണിതശാസ്ത്ര വിശകലനത്തിന് സ്വയം കടം കൊടുക്കുന്നു എന്നതാണ്. ഒരു ഫങ്ഷണൽ ലാംഗ്വേജ് ഒരു ഔപചാരിക സംവിധാനത്തിൻ്റെ നടപ്പാക്കൽ മാത്രമായതിനാൽ, കടലാസിൽ ചെയ്യാവുന്ന എല്ലാ ഗണിതശാസ്ത്ര പ്രവർത്തനങ്ങളും അത്തരം ഒരു ഭാഷയിൽ എഴുതപ്പെട്ട പ്രോഗ്രാമുകൾക്കും ബാധകമാണ്. ഉദാഹരണത്തിന്, സ്‌നിപ്പെറ്റുകളുടെ തുല്യത ഗണിതശാസ്ത്രപരമായി തെളിയിക്കുന്നതിലൂടെ കോഡ് സ്‌നിപ്പെറ്റുകളെ തത്തുല്യവും എന്നാൽ കൂടുതൽ കാര്യക്ഷമവുമായ സ്‌നിപ്പെറ്റുകളായി കംപൈലറിന് പരിവർത്തനം ചെയ്യാൻ കഴിയും. മാത്രമല്ല, നിങ്ങളുടെ പ്രോഗ്രാമിൻ്റെ ചില ഭാഗങ്ങൾ ശരിയാണെന്ന് തെളിയിക്കാൻ നിങ്ങൾക്ക് ഈ സാങ്കേതികവിദ്യകൾ ഉപയോഗിക്കാം.
യൂണിറ്റ് പരിശോധനയുടെ സൗകര്യം
ഫങ്ഷണൽ പ്രോഗ്രാമിംഗിലെ ഒരു ഫംഗ്‌ഷന് പാർശ്വഫലങ്ങൾ ഉണ്ടാക്കാൻ കഴിയാത്തതിനാൽ, സ്‌കോപ്പിനുള്ളിലോ പുറത്തോ ഒബ്‌ജക്‌റ്റുകൾ മാറ്റാൻ കഴിയില്ല (ഇൻപെറേറ്റീവ് പ്രോഗ്രാമുകളിൽ നിന്ന് വ്യത്യസ്തമായി, ഒരു ഫംഗ്ഷൻ രണ്ടാമത്തെ ഫംഗ്ഷൻ വായിക്കുന്ന ചില ബാഹ്യ വേരിയബിളുകൾ മാറ്റാൻ കഴിയും). ഒരു ഫംഗ്ഷനെ വിലയിരുത്തുന്നതിൻ്റെ ഒരേയൊരു ഫലം അത് നൽകുന്ന ഫലമാണ്, ഫലത്തെ സ്വാധീനിക്കുന്ന ഒരേയൊരു ഘടകം ആർഗ്യുമെൻ്റുകളുടെ മൂല്യങ്ങളാണ്.
ഈ രീതിയിൽ, ഒരു പ്രോഗ്രാമിലെ ഓരോ ഫംഗ്ഷനും വ്യത്യസ്ത സെറ്റ് ആർഗ്യുമെൻ്റ് മൂല്യങ്ങളിൽ നിന്ന് വിലയിരുത്തി പരിശോധിക്കുന്നത് സാധ്യമാണ്. ഈ സാഹചര്യത്തിൽ, ഫംഗ്ഷനുകൾ ശരിയായ ക്രമത്തിൽ വിളിക്കുന്നതിനെക്കുറിച്ചോ അല്ലെങ്കിൽ ബാഹ്യ അവസ്ഥ ശരിയായി രൂപപ്പെടുത്തുന്നതിനെക്കുറിച്ചോ നിങ്ങൾ വിഷമിക്കേണ്ടതില്ല. ഒരു പ്രോഗ്രാമിലെ ഏതെങ്കിലും ഫംഗ്ഷൻ യൂണിറ്റ് ടെസ്റ്റുകളിൽ വിജയിക്കുകയാണെങ്കിൽ, മുഴുവൻ പ്രോഗ്രാമിൻ്റെയും ഗുണനിലവാരത്തിൽ നിങ്ങൾക്ക് ആത്മവിശ്വാസമുണ്ടാകും. നിർബന്ധിത പ്രോഗ്രാമുകളിൽ, ഒരു ഫംഗ്ഷൻ്റെ റിട്ടേൺ മൂല്യം പരിശോധിക്കുന്നത് പര്യാപ്തമല്ല: ഫംഗ്‌ഷന് ഒരു ബാഹ്യ അവസ്ഥയെ പരിഷ്‌ക്കരിക്കാൻ കഴിയും, അത് പരിശോധിക്കേണ്ടതുണ്ട്, അത് ഫംഗ്ഷണൽ പ്രോഗ്രാമുകളിൽ ചെയ്യാൻ പാടില്ല.
ഒപ്റ്റിമൈസേഷൻ ഓപ്ഷനുകൾ
ഒരു കൂട്ടം ഫംഗ്ഷനുകളുടെ രൂപത്തിലുള്ള ഒരു പ്രോഗ്രാമിൻ്റെ വിവരണം, അവയുടെ കണക്കുകൂട്ടലിൻ്റെ ക്രമവും ഫംഗ്ഷനുകളുടെ ശുദ്ധതയും വ്യക്തമായി സൂചിപ്പിക്കാതെ, ഫങ്ഷണൽ പ്രോഗ്രാമുകളിലേക്ക് ഓട്ടോമാറ്റിക് ഒപ്റ്റിമൈസേഷൻ്റെ സങ്കീർണ്ണവും ഫലപ്രദവുമായ രീതികൾ പ്രയോഗിക്കുന്നത് സാധ്യമാക്കുന്നു.
ഫങ്ഷണൽ പ്രോഗ്രാമുകളുടെ മറ്റൊരു നേട്ടം കണക്കുകൂട്ടലുകളുടെ യാന്ത്രിക സമാന്തരവൽക്കരണത്തിന് വിപുലമായ അവസരങ്ങൾ നൽകുന്നു എന്നതാണ്. പാർശ്വഫലങ്ങളുടെ അഭാവം ഉറപ്പുനൽകുന്നതിനാൽ, ഏത് ഫംഗ്ഷൻ കോളിലും രണ്ട് വ്യത്യസ്ത ആർഗ്യുമെൻ്റുകൾ സമാന്തരമായി വിലയിരുത്തുന്നത് എല്ലായ്പ്പോഴും സാധ്യമാണ് - അവ വിലയിരുത്തപ്പെടുന്ന ക്രമം കോളിൻ്റെ ഫലത്തെ ബാധിക്കില്ല.
പ്രവർത്തന ഗുണങ്ങളുടെ തെളിവ്
ഫങ്ഷണൽ പ്രോഗ്രാമിംഗിലെ ഫംഗ്ഷനുകളുടെ കണക്കുകൂട്ടൽ പാർശ്വഫലങ്ങൾ ഉണ്ടാക്കാത്തതിനാൽ, അത്തരം പ്രവർത്തനങ്ങളുടെ വിശകലനത്തിന് ഗണിതശാസ്ത്ര രീതികൾ (ഉദാഹരണത്തിന്, ഗണിതശാസ്ത്ര ഇൻഡക്ഷൻ രീതി) ബാധകമാണ്. ഫംഗ്ഷനുകളുടെ ശരിയായ പ്രവർത്തനം അല്ലെങ്കിൽ അവയുടെ മറ്റ് ചില സവിശേഷതകൾ പരിശോധിക്കാതെ തന്നെ തെളിയിക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.
3.3 ദോഷങ്ങൾ
ഫങ്ഷണൽ പ്രോഗ്രാമിംഗിൻ്റെ പോരായ്മകൾ ഒരേ സവിശേഷതകളിൽ നിന്നാണ്. അസൈൻമെൻ്റുകളുടെ അഭാവവും പുതിയ ഡാറ്റ ജനറേഷൻ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നതും മെമ്മറിയുടെ നിരന്തരമായ അലോക്കേഷൻ്റെയും യാന്ത്രിക റിലീസിൻ്റെയും ആവശ്യകതയിലേക്ക് നയിക്കുന്നു, അതിനാൽ, ഒരു ഫംഗ്ഷണൽ പ്രോഗ്രാമിൻ്റെ എക്സിക്യൂഷൻ സിസ്റ്റത്തിൽ വളരെ കാര്യക്ഷമമായ മാലിന്യ ശേഖരണം നിർബന്ധിത ഘടകമായി മാറുന്നു. മാലിന്യ ശേഖരണം ഫലപ്രദമാകണമെങ്കിൽ, ഡാറ്റ റഫറൻസുകൾ ട്രാക്ക് ചെയ്യണം, അതിന് സമയവും മെമ്മറിയും ആവശ്യമാണ്. വ്യാവസായിക പ്രോഗ്രാമുകൾക്കുള്ള ലൂപ്പുകളുടെ അഭാവം വളരെ ഗുരുതരമായ ഒരു പരിമിതിയാണ്, കാരണം പല അൽഗോരിതങ്ങൾക്കും വളരെ ദൈർഘ്യമേറിയതോ ഔപചാരികമായതോ ആയ അനന്തമായ ലൂപ്പുകൾ ആവശ്യമാണ്, അവ ആവർത്തന രൂപത്തിൽ പ്രതിനിധീകരിക്കാൻ കാര്യക്ഷമമല്ലാത്തതോ അല്ലെങ്കിൽ അസാധ്യമോ ആയ റികർഷൻ്റെ വലിയ ആഴം കാരണം. ഒരു പരിധി വരെ, ആവർത്തനത്തെ ഒരു ലൂപ്പാക്കി സ്വയമേവ പരിവർത്തനം ചെയ്യുന്നതിലൂടെ അവസാനത്തെ പോരായ്മ മറികടക്കാൻ കഴിയും, ഇത് ടെയിൽ ആവർത്തനത്തിൻ്റെ പ്രത്യേക സന്ദർഭത്തിനായി ഫംഗ്ഷണൽ ഭാഷകളുടെ ചില വിവർത്തകർ നിർവഹിക്കുന്നു, എന്നാൽ എല്ലാത്തരം ആവർത്തനങ്ങളും അത്തരം പരിവർത്തനം അനുവദിക്കുന്നില്ല (എന്നിരുന്നാലും, അത്തരം പരിവർത്തനത്തിന് വിധേയമല്ലാത്തത് ഒരു ലളിതമായ ചക്രം പോലെയും അനിവാര്യമായ ഭാഷകളിലും രൂപകൽപ്പന ചെയ്യാൻ കഴിയില്ല).
ഈ പോരായ്മകൾ മറികടക്കാൻ, പ്രവർത്തനങ്ങളും ലൂപ്പുകളും പാർശ്വഫലങ്ങളും (ഇൻപുട്ട്, ഔട്ട്പുട്ട് ഓപ്പറേഷനുകൾ പോലുള്ളവ) വ്യക്തമായി ക്രമപ്പെടുത്താൻ അനുവദിക്കുന്ന നിർബന്ധിത പ്രോഗ്രാമിംഗ് സവിശേഷതകൾ പല ഫംഗ്ഷണൽ ഭാഷകളിലും ഉൾപ്പെടുന്നു.
4 നിലവിലുള്ള ഭാഷകളുടെ അവലോകനം
നിലവിൽ, ധാരാളം ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗ് ഭാഷകൾ വികസിപ്പിച്ചെടുത്തിട്ടുണ്ട്. അവയ്‌ക്കെല്ലാം സവിശേഷമായ സവിശേഷതകളും പോസിറ്റീവ്, നെഗറ്റീവ് ഗുണങ്ങളുമുണ്ട്. ഇന്നത്തെ ഏറ്റവും സാധാരണവും ഫലപ്രദവുമായ ഭാഷകൾ ഇനിപ്പറയുന്ന ഭാഷകളോ ഭാഷകളുടെ കുടുംബങ്ങളോ ആണ്:
ഈ ഭാഷകളിൽ ഓരോന്നിൻ്റെയും സവിശേഷതകൾ നോക്കാം:
– ലിസ്പ്. ഇംഗ്ലീഷ് ലിസ്റ്റ് പ്രോസസ്സിംഗിൽ നിന്ന് അതിൻ്റെ പേര് ലഭിച്ചു - ലിസ്റ്റ് പ്രോസസ്സിംഗ്. ആദ്യകാല ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ ഒന്നാണ് ലിസ്പ്. ലിസ്‌പിലെ പ്രോഗ്രാമുകളും ഡാറ്റയും ചിഹ്നങ്ങളുടെ ലീനിയർ ലിസ്റ്റുകളുടെ സിസ്റ്റങ്ങളാൽ പ്രതിനിധീകരിക്കുന്നു. ലിസ്പ്, അഡയ്‌ക്കൊപ്പം, സൈനിക, വ്യാവസായിക ആവശ്യങ്ങൾക്കായി ഒരു അടിസ്ഥാന സ്റ്റാൻഡേർഡൈസേഷൻ പ്രക്രിയയിലൂടെ കടന്നുപോയി, അതിൻ്റെ ഫലമായി കോമൺ ലിസ്പ് സ്റ്റാൻഡേർഡ്. മിക്ക പ്ലാറ്റ്ഫോമുകൾക്കും നടപ്പിലാക്കലുകൾ നിലവിലുണ്ട്. ലിസ്‌പിൻ്റെ ആദ്യ ആപ്ലിക്കേഷനുകൾ സിംബോളിക് ഡാറ്റ പ്രോസസ്സിംഗിലും തീരുമാനമെടുക്കൽ പ്രക്രിയകളിലുമായിരുന്നു. ഇന്നത്തെ ഏറ്റവും ജനപ്രിയമായ ഭാഷാഭേദം, കോമൺ ലിസ്പ് ഒരു സാർവത്രിക പ്രോഗ്രാമിംഗ് ഭാഷയാണ്. വൈവിധ്യമാർന്ന പ്രോജക്റ്റുകളിൽ ഇത് വ്യാപകമായി ഉപയോഗിക്കുന്നു: ഇൻ്റർനെറ്റ് സെർവറുകളും സേവനങ്ങളും, ആപ്ലിക്കേഷൻ സെർവറുകളും ഡാറ്റാബേസുകളുമായി ഇടപഴകുന്ന ക്ലയൻ്റുകൾ, ശാസ്ത്രീയ കണക്കുകൂട്ടലുകൾ, ഗെയിം പ്രോഗ്രാമുകൾ.
– ഹാസ്കെൽ. ഇത് ഏറ്റവും സാധാരണമായ അലസമായ പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ ഒന്നാണ്. വളരെ വികസിതമായ ഒരു ടൈപ്പിംഗ് സംവിധാനമുണ്ട്. അടുത്തിടെ, ആപ്ലിക്കേഷൻ ലൈബ്രറികളുടെ കൂട്ടം വികസിച്ചുകൊണ്ടിരിക്കുന്നു, ഭാഷ സാധാരണ സോഫ്റ്റ്വെയർ സിസ്റ്റങ്ങളിലേക്ക് സംയോജിപ്പിക്കുന്നു, ഇത് പ്രൊഫഷണൽ പ്രോഗ്രാമർമാർക്ക് ഭാഷയെ കൂടുതൽ ആകർഷകമാക്കുന്നു. ഭാഷയുടെ പ്രധാന സവിശേഷതകൾ: ലാംഡ അമൂർത്തീകരണം ഉപയോഗിക്കാനുള്ള കഴിവ്; ഉയർന്ന ഓർഡർ പ്രവർത്തനങ്ങൾ; ഭാഗിക അപേക്ഷ; പാർശ്വഫലങ്ങളുടെ അനുവദനീയത (ഭാഷയുടെ പരിശുദ്ധി); അലസമായ വിലയിരുത്തൽ; പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ, പ്രവർത്തനപരമായ പാറ്റേണുകൾ (പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ); പാരാമെട്രിക് പോളിമോർഫിസവും ടൈപ്പ് ക്ലാസ് പോളിമോർഫിസവും; സ്റ്റാറ്റിക് ടൈപ്പിംഗ്; ഓട്ടോമാറ്റിക് തരം അനുമാനം (ഹിൻഡ്ലി-മിൽനർ ടൈപ്പിംഗ് മോഡലിനെ അടിസ്ഥാനമാക്കി); ബീജഗണിത ഡാറ്റ തരങ്ങൾ; പരാമീറ്ററുകളുള്ള ഡാറ്റ തരങ്ങൾ; ആവർത്തന ഡാറ്റ തരങ്ങൾ; അമൂർത്ത ഡാറ്റ തരങ്ങൾ (എൻക്യാപ്സുലേഷൻ); ലിസ്റ്റ് ധാരണകൾ; ഗാർഡ് എക്സ്പ്രഷനുകൾ; മൊണാഡുകൾ ഉപയോഗിച്ച് ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗ് മാതൃക ലംഘിക്കാതെ പാർശ്വഫലങ്ങൾ ഉള്ള പ്രോഗ്രാമുകൾ എഴുതാനുള്ള കഴിവ്; ഓപ്പൺ ഇൻ്റർഫേസുകളിലൂടെ നിർബന്ധിത പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ നടപ്പിലാക്കിയ പ്രോഗ്രാമുകളുമായി സംയോജിപ്പിക്കാനുള്ള കഴിവ് (വിദേശ ഫംഗ്ഷൻ ഇൻ്റർഫേസ് ഭാഷയുടെ ഒരു സാധാരണ വിപുലീകരണം).
– എം.എൽ.(മെറ്റാ ലാംഗ്വേജ്) വികസിത പോളിമോർഫിക് തരം സിസ്റ്റവും പാരാമീറ്റർ ചെയ്യാവുന്ന മൊഡ്യൂളുകളുമുള്ള കർശനമായ ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗ് ഭാഷകളുടെ ഒരു കുടുംബമാണ്. പല പാശ്ചാത്യ സർവ്വകലാശാലകളിലും ML പഠിപ്പിക്കുന്നു. സ്റ്റാറ്റിക് ടൈപ്പ് ചെക്കിംഗും ആപ്ലിക്കേഷൻ പ്രോഗ്രാം എക്സിക്യൂഷനും ഉള്ള ശക്തമായി ടൈപ്പ് ചെയ്ത ഭാഷ. ഉയർന്ന പ്രോഗ്രാം വെരിഫബിലിറ്റി, ഡീബഗ്ഗിംഗ് എളുപ്പം, ഉയർന്ന ഒപ്റ്റിമൈസേഷനുള്ള സാധ്യത, റെക്കോർഡിംഗിൻ്റെ അതുല്യമായ സംക്ഷിപ്തത എന്നിവയാണ് ML-ൻ്റെ പ്രധാന നേട്ടങ്ങൾ. വാക്യഘടനയുടെ സങ്കീർണ്ണത, അംഗീകൃത കൺവെൻഷനുകളുടെയും നിയന്ത്രണങ്ങളുടെയും അപരിചിതത്വം, മാക്രോ പരിവർത്തനങ്ങളുടെ പ്രായോഗിക അസാധ്യത എന്നിവയാണ് പ്രധാന പോരായ്മകൾ.
– എർലാങ്- വിവിധ തരം ഡിസ്ട്രിബ്യൂഡ് സിസ്റ്റങ്ങൾക്കായി പ്രോഗ്രാമുകൾ എഴുതാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ് ഭാഷ. എറിക്‌സൺ വികസിപ്പിച്ചതും പിന്തുണച്ചതും. സമാന്തര പ്രക്രിയകൾ സൃഷ്ടിക്കുന്നതിനുള്ള ഉപകരണങ്ങളും അസമന്വിത സന്ദേശങ്ങൾ അയച്ചുകൊണ്ട് അവയുടെ ആശയവിനിമയവും ഭാഷയിൽ ഉൾപ്പെടുന്നു. പോർട്ടബിലിറ്റി ഉറപ്പാക്കുന്ന വെർച്വൽ മെഷീൻ എക്സിക്യൂട്ട് ചെയ്യുന്ന പ്രോഗ്രാം ബൈറ്റ്കോഡിലേക്ക് വിവർത്തനം ചെയ്യപ്പെടുന്നു. എർലാങ്ങിൻ്റെ പ്രധാന കാര്യം അതിൻ്റെ ഭാരം കുറഞ്ഞ പ്രോസസ്സ് മോഡലാണ്. "എല്ലാം ഒരു വസ്തുവാണ്" എന്ന എർലാംഗ് മുദ്രാവാക്യം വ്യാഖ്യാനിക്കാൻ നമുക്ക് "എല്ലാം ഒരു പ്രക്രിയയാണ്" എന്ന് പറയാം. പ്രക്രിയകൾ വിലകുറഞ്ഞതാണ്; ഒരു പ്രോസസ്സ് സൃഷ്ടിക്കുന്നത് ഒരു ഫംഗ്ഷൻ വിളിക്കുന്നതിനേക്കാൾ കൂടുതൽ ഉറവിടങ്ങൾ എടുക്കുന്നില്ല. എസിൻക്രണസ് സന്ദേശ കൈമാറ്റം വഴിയാണ് പ്രക്രിയകൾക്ക് ആശയവിനിമയം നടത്താൻ കഴിയുന്ന ഏക മാർഗം.
ലിസ്റ്റുചെയ്ത ഭാഷകളിൽ, ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ് ഭാഷകളുടെ ഏറ്റവും പ്രമുഖ പ്രതിനിധിയാണ് ഹാസ്കെൽ. ഇതിന് ലളിതമായ വാക്യഘടനയും മുകളിൽ ലിസ്റ്റുചെയ്‌തിരിക്കുന്ന പ്രവർത്തന ഭാഷകളുടെ എല്ലാ സവിശേഷതകളും ഉണ്ട്.
5 ഹാസ്കെൽ ഭാഷയുടെ അടിസ്ഥാന തത്വങ്ങൾ
പറഞ്ഞതുപോലെ, ഹാസ്കെൽ പ്രോഗ്രാമിംഗ് ഭാഷ ഒരു പ്രവർത്തന ഭാഷയാണ്, അതിന് മുകളിലുള്ള എല്ലാ ഗുണങ്ങളും ഉണ്ട്
ആദ്യം, ജോലിക്ക് ആവശ്യമായ ഉപകരണങ്ങൾ നോക്കാം. ഇന്ന് ഏറ്റവും സാധാരണവും ഫലപ്രദവുമായത് കമ്പൈലറാണ് ജി.എച്ച്.സി.(ഗ്ലാസ്‌ഗോ ഹാസ്കെൽ കംപൈലർ). ഇത് ഒരു ഓപ്പൺ ലൈസൻസിന് കീഴിലാണ് വിതരണം ചെയ്യുന്നത്, ഔദ്യോഗിക വെബ്‌സൈറ്റായ http://haskell-ൽ നിന്ന് ആർക്കും അതിൻ്റെ സോഴ്‌സ് കോഡോ ജനപ്രിയ ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾക്കായി സമാഹരിച്ച പതിപ്പോ ഡൗൺലോഡ് ചെയ്യാം. org/ghc/ (കൂടാതെ, http://haskell.org/ എന്നതിൽ ഭാഷയെക്കുറിച്ച് ധാരാളം അധിക വിവരങ്ങളുണ്ട്).
കംപൈലറിന് പുറമേ, GHC-യിൽ ഇൻ്ററാക്റ്റീവ് എൻവയോൺമെൻ്റ് GHCi (GHC ഇൻ്ററാക്ടീവ്) ഉൾപ്പെടുന്നു - ഏതെങ്കിലും പദപ്രയോഗങ്ങൾ വിലയിരുത്താനും എഴുതിയ പ്രോഗ്രാമുകൾ വ്യാഖ്യാനിക്കാനും നിങ്ങളെ അനുവദിക്കുന്ന ഒരു ഹാസ്കെൽ ഇൻ്റർപ്രെറ്റർ.
നിർഭാഗ്യവശാൽ, ഹാസ്‌കെലിനായി ഒരു പൂർണ്ണ-സവിശേഷമായ വികസന അന്തരീക്ഷം ഇതുവരെ വികസിപ്പിച്ചിട്ടില്ല (ഒരുപക്ഷേ, ഹസ്‌കെല്ലിൽ എഴുതിയ ഒരു ഹാസ്കെൽ വികസന പരിസ്ഥിതിയും വിഷ്വൽ സ്റ്റുഡിയോയ്ക്കും എക്ലിപ്‌സിനും വേണ്ടിയുള്ള കുറച്ച് പ്ലഗിനുകൾ ഒഴികെ), പക്ഷേ പലപ്പോഴും ഒരു വിപുലമായ ടെക്സ്റ്റ് എഡിറ്റർ മാത്രം (ഉദാഹരണത്തിന്, സിൻ്റാക്സ് ഹൈലൈറ്റിംഗും മറ്റ് ചില സവിശേഷതകളും ഉള്ള നോട്ട്പാഡ്++, gedit, kate).
5.1 സംവേദനാത്മക പരിസ്ഥിതി
സംവേദനാത്മക പരിസ്ഥിതി GHCiഏത് Haskell പദപ്രയോഗവും വിലയിരുത്താൻ കഴിയും. ഈ പരിതസ്ഥിതിയിൽ പ്രവർത്തിക്കുന്നതിൻ്റെ അടിസ്ഥാനകാര്യങ്ങൾ നോക്കാം. ഇത് സമാരംഭിക്കുന്നതിന് (GHC അല്ലെങ്കിൽ Haskell-Platform ഇൻസ്റ്റാൾ ചെയ്തതിന് ശേഷം), കൺസോളിൽ ghci പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുക (അല്ലെങ്കിൽ എല്ലാ പ്രോഗ്രാമുകളുടെയും പട്ടികയിൽ ഉചിതമായ പ്രോഗ്രാം തിരഞ്ഞെടുക്കുക). സമാരംഭിച്ചതിന് ശേഷം, കൺസോളിൽ ഒരു പ്രോംപ്റ്റ് ദൃശ്യമാകും:
പ്രെലൂഡ് എന്നാൽ നിലവിലെ മൊഡ്യൂളിൻ്റെ പേര് എന്നാണ് അർത്ഥമാക്കുന്നത്, സ്ഥിരസ്ഥിതിയായി എല്ലാ പ്രധാന ഫംഗ്ഷനുകളും ഡാറ്റ തരങ്ങളും അടങ്ങുന്ന സ്റ്റാൻഡേർഡ് പ്രെലൂഡ് മൊഡ്യൂൾ ലോഡ് ചെയ്യുന്നു.
ഇവിടെ നമുക്ക് ഏത് പദപ്രയോഗവും വിലയിരുത്താം, ഉദാഹരണത്തിന് ഒരു സാധാരണ ഗണിത പദപ്രയോഗം:
നമുക്ക് കാണാനാകുന്നതുപോലെ, സംവേദനാത്മക അന്തരീക്ഷം എക്സ്പ്രഷൻ്റെ ഫലം കണക്കാക്കുകയും അത് ഔട്ട്പുട്ട് ചെയ്യുകയും ചെയ്തു പുതിയ വര. കൂടുതൽ സങ്കീർണ്ണമായ ഒരു പദപ്രയോഗം കണക്കാക്കാൻ ശ്രമിക്കാം:
ആമുഖം> 1-2*(4-3^2)
ഒരു ശക്തിയിലേക്ക് ഉയർത്തുന്നത് (^) ആണ് സ്റ്റാൻഡേർഡ് ഓപ്പറേറ്റർ, സങ്കലനത്തിൻ്റെയും ഗുണനത്തിൻ്റെയും പ്രവർത്തനങ്ങൾക്കൊപ്പം സ്റ്റാൻഡേർഡ് പ്രെലൂഡ് മൊഡ്യൂളിൽ നിർവചിച്ചിരിക്കുന്നു.
ഒഴികെ ഗണിത പദപ്രയോഗങ്ങൾഇൻ്ററാക്ടീവ് പരിതസ്ഥിതിയിൽ, സ്റ്റാൻഡേർഡ് മൊഡ്യൂളിൽ അല്ലെങ്കിൽ ഉപയോക്താവ് ലോഡുചെയ്ത മറ്റേതെങ്കിലും ഫംഗ്ഷനുകൾ നിർവചിച്ചിരിക്കുന്നത് വിലയിരുത്താൻ സാധിക്കും.
ഒരു ഫംഗ്ഷൻ്റെ മൂല്യം കണക്കാക്കാൻ, അതിൻ്റെ പേര് എഴുതി സ്‌പെയ്‌സുകളാൽ വേർതിരിച്ച ആർഗ്യുമെൻ്റുകൾ വ്യക്തമാക്കുക. ഉദാഹരണത്തിന്, സ്റ്റാൻഡേർഡ് മൊഡ്യൂളിൽ ഇത് നിർവചിച്ചിരിക്കുന്നു പരമാവധി പ്രവർത്തനം, തിരഞ്ഞെടുക്കുന്നു പരമാവധി മൂല്യംരണ്ട് വാദങ്ങളിൽ നിന്ന്. നിങ്ങൾക്ക് ഇത് ഇതുപോലെ ഉപയോഗിക്കാം:
ആമുഖം>പരമാവധി 7 100
IN ഈ ഉദാഹരണത്തിൽപരമാവധി രണ്ട് സംഖ്യകൾ കണക്കാക്കുന്നു - ഏഴ്, നൂറ്. നമുക്ക് കാണാനാകുന്നതുപോലെ, ഫംഗ്ഷൻ കണക്കാക്കുന്നതിൻ്റെ ഫലം നമ്പർ 100 ആണ്.
ഫംഗ്ഷൻ ആർഗ്യുമെൻ്റുകൾ ഏതെങ്കിലും എക്സ്പ്രഷനുകളാകാം (പക്ഷേ ഉചിതമായ തരത്തിൽ മാത്രം; തരങ്ങൾ മറ്റ് വിഭാഗങ്ങളിൽ കൂടുതൽ വിശദമായി ചർച്ചചെയ്യുന്നു), ഉദാഹരണത്തിന്:
ആമുഖം>പരമാവധി (2^^3)
ഈ ഉദാഹരണം നിർവചിക്കുന്നത് രണ്ട് മുതൽ പത്താം ശക്തി വരെയുള്ള പത്തിൽ നിന്ന് മൂന്നാമത്തെ ശക്തിയേക്കാൾ വലുതാണ്. പദപ്രയോഗത്തിൻ്റെ ഏത് ഭാഗമാണ് ആർഗ്യുമെൻ്റ് എന്ന് ഹൈലൈറ്റ് ചെയ്യുന്നതിന് പരാൻതീസിസിൽ ആർഗ്യുമെൻ്റുകൾ ഉൾപ്പെടുത്തേണ്ടത് ആവശ്യമാണെന്ന് ശ്രദ്ധിക്കുക. ഉദാഹരണത്തിന്, രണ്ടാമത്തെ ആർഗ്യുമെൻ്റിൻ്റെ പരാൻതീസിസ് ഒഴിവാക്കിയാൽ, നമുക്ക് അൽപ്പം അപ്രതീക്ഷിതമായ ഫലം ലഭിക്കും:
ആമുഖം> പരമാവധി (2^10) 10^3
പരാൻതീസിസ് ഇല്ലാതെ ഈ പദപ്രയോഗംമൂന്നാമത്തെ ശക്തിയിലേക്ക് ഉയർത്തിയ പരമാവധി രണ്ട് സംഖ്യകൾ (1024 ഉം 10 ഉം) ആയി വ്യാഖ്യാനിക്കുന്നു.
കൂടാതെ, GHCi ഇൻ്ററാക്ടീവ് എൻവയോൺമെൻ്റിന് നൽകിയ ഫംഗ്ഷനുകളുടെ പേരുകൾ സ്വയമേവ പൂർത്തിയാക്കാൻ കഴിയും. നിങ്ങൾ ഫംഗ്ഷൻ നാമത്തിൻ്റെ പ്രാരംഭ ഭാഗം മാത്രം ടൈപ്പുചെയ്‌ത് കീബോർഡിലെ “ടാബ്” കീ അമർത്തുകയാണെങ്കിൽ, ലഭ്യമായ നിർവചനങ്ങളിൽ (സാധാരണ മൊഡ്യൂളിൽ നിന്നോ ഉപയോക്താവ് കണക്‌റ്റുചെയ്‌തിരിക്കുന്നതോ ആയ) ഫംഗ്ഷൻ നാമം പൂർത്തിയാക്കാൻ GHCi ശ്രമിക്കും. ഉദാഹരണത്തിന്, നിങ്ങൾ “maxi” എന്ന് ടൈപ്പ് ചെയ്ത് ടാബ് അമർത്തുകയാണെങ്കിൽ, GHCi ഫംഗ്ഷൻ പേര് “പരമാവധി” ഉപയോഗിച്ച് പൂർത്തിയാക്കും. അവ്യക്തമായി സപ്ലിമെൻ്റ് ചെയ്യുന്നത് അസാധ്യമായ സാഹചര്യത്തിൽ (അനുയോജ്യമായ നിരവധി ഓപ്ഷനുകൾ ഉണ്ട്), തുടർന്ന് സാധ്യമായ എല്ലാ ഓപ്ഷനുകളും പ്രദർശിപ്പിക്കും:
max maxBound പരമാവധി
ഇപ്പോൾ നിങ്ങൾക്ക് ഫംഗ്ഷൻ്റെ പേര് വ്യക്തമാക്കാം (കുറച്ച് അക്ഷരങ്ങൾ ചേർത്ത്) "ടാബ്" കീ വീണ്ടും അമർത്തുക.
ദൈർഘ്യമേറിയ പേരുകളുള്ള ധാരാളം ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുമ്പോൾ സ്വയം പൂർത്തീകരണം വളരെ ഉപയോഗപ്രദമാണ്.
5.2 പ്രോഗ്രാം ഘടന
ഹാസ്കെൽ കംപൈലറുകളും ഇൻ്റർപ്രെറ്ററുകളും വിപുലീകരണത്തോടുകൂടിയ ഫയലുകളിൽ പ്രവർത്തിക്കുന്നു *.hsപ്രോഗ്രാമിൻ്റെ വാചകം ഉൾക്കൊള്ളുന്നു. പ്രോഗ്രാം വാചകത്തിന് ഇനിപ്പറയുന്ന ഘടനയുണ്ട്:
1. പ്രോഗ്രാമിൻ്റെ തുടക്കത്തിൽ നിലവിലെ മൊഡ്യൂളിൻ്റെ പേരും കയറ്റുമതി ചെയ്ത നിർവചനങ്ങളും സൂചിപ്പിക്കാം;
3. ബാക്കിയുള്ള പ്രോഗ്രാമുകൾ വിവിധ നിർവചനങ്ങളാൽ ഉൾക്കൊള്ളുന്നു - ഫംഗ്ഷനുകൾ, ഡാറ്റ തരങ്ങൾ, ക്ലാസുകൾ എന്നിവയുടെ നിർവചനങ്ങൾ.
ഏറ്റവും ലളിതമായ പ്രോഗ്രാമിൽ ഫംഗ്ഷൻ നിർവചനങ്ങൾ മാത്രമേ അടങ്ങിയിട്ടുള്ളൂ (ഈ സാഹചര്യത്തിൽ, സ്റ്റാൻഡേർഡ് പ്രെലൂഡ് മൊഡ്യൂൾ മാത്രമേ ഇറക്കുമതി ചെയ്തിട്ടുള്ളൂ, മിക്ക സ്റ്റാൻഡേർഡ് ഫംഗ്ഷനുകളും ഡാറ്റാ തരങ്ങളും അടങ്ങിയിരിക്കുന്നു; മൊഡ്യൂളിൻ്റെ പേര് സ്ഥിരസ്ഥിതിയായി മെയിൻ ആയി സജ്ജീകരിച്ചിരിക്കുന്നു).
ഏറ്റവും ലളിതമായ ഫംഗ്ഷൻ ആർഗ്യുമെൻ്റുകളൊന്നും എടുത്തേക്കില്ല, പക്ഷേ ഒരു മൂല്യം മാത്രം നൽകുന്നു. ഈ സാഹചര്യത്തിൽ, നിർവചനത്തിൽ ഫംഗ്ഷൻ നാമം, തുല്യ ചിഹ്നം “=”, ഈ ഫംഗ്ഷൻ്റെ മൂല്യം കണക്കാക്കുന്ന ചില പദപ്രയോഗങ്ങൾ എന്നിവ അടങ്ങിയിരിക്കുന്നു. പരമ്പരാഗതമായി, അത്തരമൊരു ഫംഗ്ഷനെ വേരിയബിൾ അല്ലെങ്കിൽ സ്ഥിരാങ്കം എന്ന് വിളിക്കാം, പക്ഷേ ഇത് പൂർണ്ണമായും ശരിയല്ല. ഫങ്ഷണൽ പ്രോഗ്രാമിംഗിൽ, ആർഗ്യുമെൻ്റുകളില്ലാത്ത പ്രവർത്തനങ്ങളെ ചിഹ്നങ്ങൾ എന്ന് വിളിക്കുന്നു. നമുക്ക് ഒരു ഉദാഹരണം നോക്കാം:
ഈ ഉദാഹരണം അഞ്ച് എന്ന് വിളിക്കുന്ന ഒരു ചിഹ്നം പ്രഖ്യാപിക്കുന്നു, അതിന് പൂർണ്ണസംഖ്യ 5 ൻ്റെ മൂല്യമുണ്ട്. ഹാസ്കെല്ലിലെ പേരുകൾ കേസ് സെൻസിറ്റീവ് ആണ്, അതായത് അഞ്ച്, അഞ്ച് എന്നിവ വ്യത്യസ്ത പേരുകളാണ്. കൂടാതെ, ഇത് അവതരിപ്പിക്കുന്നു അധിക നിയന്ത്രണംപേരിൻ്റെ ആദ്യ അക്ഷരത്തിലേക്ക് - ഫംഗ്ഷനുകളുടെ പേരുകളും അവയുടെ ആർഗ്യുമെൻ്റുകളും ആരംഭിക്കാം ചെറിയ അക്ഷരം(അഞ്ച്, പരമാവധി, മിനിറ്റ്, x, y), കൂടാതെ ഡാറ്റ തരങ്ങളുടെ പേരുകൾ (Bool, Integer, Double), മൊഡ്യൂളുകൾ (മെയിൻ, ടെസ്റ്റ്), ക്ലാസുകൾ (Eq, Ord, Num) എന്നിവ മാത്രം വലിയക്ഷരമാക്കിയിരിക്കുന്നു.
കൂടുതൽ സങ്കീർണ്ണമായ ഒരു ഉദാഹരണം നോക്കാം:
മൂന്ന് = ഒന്ന് + രണ്ട്
മൂന്ന് ചിഹ്നങ്ങൾ ഇവിടെ പ്രഖ്യാപിച്ചു - ഒന്ന്, രണ്ട്, മൂന്ന്. ഉദാഹരണത്തിൽ നിന്ന് നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഓരോ നിർവചനവും ഒരു വരി എടുക്കുന്നു, അവ വരിയുടെ അവസാനത്തിൽ മാത്രമേ വേർതിരിക്കുകയുള്ളൂ (ശൂന്യമായ വരികൾ അവഗണിക്കപ്പെടും). ഒന്നും രണ്ടും ചിഹ്നങ്ങൾ മുമ്പത്തെ ഉദാഹരണത്തിലെ അഞ്ച് ചിഹ്നത്തിൻ്റെ അതേ രീതിയിൽ നിർവചിച്ചിരിക്കുന്നു, കൂടാതെ മൂന്ന് ചിഹ്നത്തിൻ്റെ നിർവചനം നിലവിലുള്ള നിർവചനങ്ങൾ ഉപയോഗിക്കുന്നു. നിങ്ങൾ ഊഹിക്കുന്നതുപോലെ, ചിഹ്നം മൂന്നിന് മൂല്യം 3 ഉണ്ടായിരിക്കും.
നിർവചനങ്ങളുടെ ക്രമം പ്രധാനമല്ല, അതായത്, ഇനിപ്പറയുന്ന ഉദാഹരണം മുമ്പത്തേതിന് സമാനമായിരിക്കും:
മൂന്ന് = ഒന്ന് + രണ്ട്
GHCi സംവേദനാത്മക പരിതസ്ഥിതിയിലേക്ക് നമ്മുടെ ഉദാഹരണം ലോഡ് ചെയ്യാം. ഇത് ചെയ്യുന്നതിന്, ghci (OS-ൽ) ആരംഭിക്കുമ്പോൾ ഒരു കമാൻഡ് ലൈൻ പാരാമീറ്ററായി പ്രോഗ്രാം ടെക്സ്റ്റ് (ഉദാഹരണത്തിന്, ടെസ്റ്റ്. hs) ഉപയോഗിച്ച് ഫയലിൻ്റെ പേര് വ്യക്തമാക്കിയാൽ മതിയാകും. വിൻഡോസ് കുടുംബംനിങ്ങൾ ഫയൽ തുറക്കേണ്ടതുണ്ട്, ഇൻസ്റ്റാൾ ചെയ്ത GHC *.hs ഫയലുകൾ തുറക്കാൻ ghci സ്വയമേവ നിയോഗിക്കുന്നു). പ്രോഗ്രാമിൽ പിശകുകൾ ഇല്ലെങ്കിൽ, ഞങ്ങൾ ഇതിനകം പരിചിതമായ പ്രോംപ്റ്റ് കാണും:
ഇവിടെ മെയിൻ എന്നത് നിലവിലെ മൊഡ്യൂളിൻ്റെ പേരാണ് (മൊഡ്യൂളുകൾ അനുബന്ധ അധ്യായത്തിൽ കൂടുതൽ വിശദമായി ചർച്ചചെയ്യുന്നു). നിലവിലെ മൊഡ്യൂളിൽ നിന്ന് ഏത് ഫംഗ്ഷനുകളും കണക്കാക്കാൻ GHCi നിങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്, നമുക്ക് മൂന്ന് ചിഹ്നം കണക്കാക്കാം:
കൂടുതൽ സങ്കീർണ്ണമായ പദപ്രയോഗങ്ങൾഇതും സാധ്യമാണ്:
*പ്രധാന> (മൂന്ന്+രണ്ട്)^2
*പ്രധാനം> പരമാവധി ഒന്ന് രണ്ട്
അടുത്തതായി, ആർഗ്യുമെൻ്റുകളുള്ള ഫംഗ്ഷനുകൾ നോക്കാം. പരമ്പരാഗത പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ നിന്ന് വ്യത്യസ്തമായി, ആർഗ്യുമെൻ്റുകൾ പാസാക്കുന്നതിന് അവയെ പരാൻതീസിസിൽ എഴുതുകയും കോമകളാൽ വേർതിരിക്കുകയും ചെയ്യേണ്ട ആവശ്യമില്ല. ഫംഗ്ഷനെ ഇനിപ്പറയുന്ന രൂപത്തിൽ വിളിക്കുന്നു: func x1 x2 x3... xN, ഇവിടെ ഫങ്‌ഷൻ എന്നത് ഫംഗ്ഷൻ്റെ പേരാണ്, കൂടാതെ xi എന്നത് i-th ആർഗ്യുമെൻ്റ് ആണ്. ഫംഗ്ഷൻ്റെ ഫലം ചില ഒബ്ജക്റ്റ് ആയിരിക്കും, ഉദാഹരണത്തിന്, ഒരു നമ്പർ, ഒരു ലിസ്റ്റ്, ഒരു ഫംഗ്ഷൻ, ഒരു ലാംഡ എക്സ്പ്രഷൻ അല്ലെങ്കിൽ മറ്റേതെങ്കിലും ഡാറ്റ ഘടന.
ആർഗ്യുമെൻ്റുകളുള്ള ഒരു ഫംഗ്ഷൻ്റെ വിവരണം മുമ്പത്തെ ഉദാഹരണങ്ങളിലെ ചിഹ്നങ്ങളുടെ വിവരണത്തിൽ നിന്ന് പ്രായോഗികമായി വ്യത്യസ്തമല്ല. ഫംഗ്ഷൻ നിർവചനം ഒരു പ്രത്യേക വരിയിൽ സ്ഥിതിചെയ്യുന്നു അടുത്ത കാഴ്ച: func x1 x2 x3... xN = എക്സ്പ്രഷൻ, ഇവിടെ func എന്നത് പുതിയ ഫംഗ്ഷൻ്റെ പേരാണ്, xi എന്നത് i-th ആർഗ്യുമെൻ്റിൻ്റെ പേരാണ്, എക്സ്പ്രഷൻ എന്നത് എക്സ്പ്രഷൻ ആണ്.
ഉദാഹരണത്തിന്, രണ്ട് അക്കങ്ങൾ ചേർക്കുന്ന ഒരു ഫംഗ്ഷൻ ചേർക്കാം നിലവിലുള്ള ഫയൽടെസ്റ്റ്. hs.
ഇപ്പോൾ നമുക്ക് പരിഷ്‌ക്കരിച്ച മൊഡ്യൂൾ ഇൻ്ററാക്ടീവ് എൻവയോൺമെൻ്റിൽ റീലോഡ് ചെയ്യാം. ഇത് ചെയ്യുന്നതിന്, ghci പുനരാരംഭിക്കുക, അല്ലെങ്കിൽ ഉപയോഗിക്കുക സ്റ്റാൻഡേർഡ് കമാൻഡ്":r":
മെയിൻ കംപൈൽ ചെയ്യുന്നു (ടെസ്റ്റ്. hs, വ്യാഖ്യാനിച്ചു)
ശരി, മൊഡ്യൂളുകൾ ലോഡ് ചെയ്തു: പ്രധാനം.
അതിനുശേഷം പുതിയ സവിശേഷതസംവേദനാത്മക പരിതസ്ഥിതിയിൽ നിന്ന് ആക്സസ് ചെയ്യാൻ കഴിയും:
*മെയിൻ> പ്ലസ് വൺ 8
ആർഗ്യുമെൻ്റുകളുള്ള ഒരു ഫംഗ്ഷൻ്റെ മറ്റൊരു ഉദാഹരണം:
ഓരോ നിർവചനവും ഒരു വരി ഉൾക്കൊള്ളുന്നു, എന്നിരുന്നാലും, വ്യക്തതയ്ക്കായി നിർവചനത്തെ നിരവധി വരികളായി വിഭജിക്കുന്നത് കൂടുതൽ സൗകര്യപ്രദമാണെങ്കിൽ, നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന സവിശേഷത ഉപയോഗിക്കാം: മുമ്പത്തേതിനേക്കാൾ വലിയ ഇൻഡൻ്റിൽ ആരംഭിക്കുന്ന ഓരോ വരിയും അതിൻ്റെ തുടർച്ചയായി കണക്കാക്കപ്പെടുന്നു. ഉദാഹരണത്തിന്, നമുക്ക് പ്ലസ് ഫംഗ്ഷൻ ഇതുപോലെ രണ്ട് വരികളിൽ എഴുതാം:
ഹാസ്കെല്ലിലെ ഒറ്റവരി കമൻ്റുകൾ രണ്ട് ഡാഷുകളിൽ തുടങ്ങുന്നു:
പ്ലസ് x y = x+y --അഡീഷൻ ഫംഗ്ഷൻ
ഒരു ബ്ലോക്ക് കമൻ്റ് "" ൽ ആരംഭിച്ച് "" ൽ അവസാനിക്കുന്നു:
ഈ ഫംഗ്ഷൻ വലിയൊരു സംഖ്യ നൽകുന്നു
വാദമായി ലഭിച്ചതിനേക്കാൾ
5.3 പ്രവർത്തന തരങ്ങൾ
ഹാസ്കെൽ ശക്തമായി ടൈപ്പ് ചെയ്ത ഭാഷയാണ്; അതിലെ ഏതൊരു ഫംഗ്ഷനും കർശനമായി നിർവചിക്കപ്പെട്ട തരം ഉണ്ട്. എന്നിരുന്നാലും, മുമ്പത്തെ ഉദാഹരണങ്ങളിൽ ഞങ്ങൾ തരം വ്യക്തമാക്കിയിട്ടില്ല, കാരണം ഹാസ്കെൽ ഇൻ്റർപ്രെറ്ററുകളും കംപൈലറുകളും ശക്തമായ തരം അനുമാന സംവിധാനം നടപ്പിലാക്കുന്നു. ഫംഗ്ഷനുകളുടെ തരം (അവയുടെ വാദങ്ങൾ) മിക്ക കേസുകളിലും അവയുടെ നിർവചനങ്ങളിൽ നിന്ന് അനുമാനിക്കാം. ചില ഫംഗ്‌ഷനുകൾക്ക് പോളിമോർഫിക് തരങ്ങൾ ഉണ്ടാകാം (അത്തരം ഫംഗ്ഷനുകൾ വ്യത്യസ്ത തരം ആർഗ്യുമെൻ്റുകളിൽ പ്രയോഗിക്കാം), ഉദാഹരണത്തിന്, മുമ്പ് നൽകിയ പ്ലസ് ഫംഗ്‌ഷന് പൂർണ്ണസംഖ്യകളും റിയലുകളും സംഗ്രഹിക്കാം.
നേരത്തെ പറഞ്ഞതുപോലെ, ടൈപ്പ് പേരുകൾ വലിയ അക്ഷരങ്ങളിൽ തുടങ്ങുന്നു. ചില സ്റ്റാൻഡേർഡ് തരങ്ങൾ ഇതാ:
വിവരണം |
|
മുതൽ - വരെ പൂർണ്ണസംഖ്യ |
|
ദൈർഘ്യമേറിയ പൂർണ്ണസംഖ്യ, അതിരുകളില്ല (ബിൽറ്റ്-ഇൻ ലോംഗ് ഗണിതത്തിൻ്റെ ഉപയോഗം നൽകിയിട്ടുണ്ട്) |
|
യഥാർത്ഥ സംഖ്യ |
|
ഇരട്ട കൃത്യതയുള്ള യഥാർത്ഥ സംഖ്യ |
|
ചില തരം a മൂലകങ്ങളുടെ ഒരു ലിസ്റ്റ്, ഉദാഹരണത്തിന്, ഇങ്ങനെ എഴുതിയിരിക്കുന്ന പൂർണ്ണസംഖ്യകളുടെ ഒരു ലിസ്റ്റ് |
|
സ്ട്രിംഗ് (അല്ലെങ്കിൽ പ്രതീകങ്ങളുടെ ലിസ്റ്റ്), തത്തുല്യം |
|
ബൂളിയൻ തരം(അംഗീകരിക്കുന്നു യഥാർത്ഥ മൂല്യങ്ങൾഅല്ലെങ്കിൽ തെറ്റ്) |
|
ടൈപ്പ് എ, ബി എന്നീ രണ്ട് ഘടകങ്ങളുടെ ഒരു ട്യൂപ്പിൾ (ഉദാഹരണത്തിന്, (സ്ട്രിംഗ്, ബൂൾ)) |
|
ടൈപ്പ് എ, ബി, സി എന്നീ മൂന്ന് ഘടകങ്ങളുടെ ഒരു ട്യൂപ്പിൾ (ഉദാഹരണത്തിന്, (സ്ട്രിംഗ്, ബൂൾ, ഇൻ്റ്)) |
ഒരു ഫംഗ്ഷൻ്റെ തരവും അതിൻ്റെ ആർഗ്യുമെൻ്റുകളും സ്വയം സൂചിപ്പിക്കാൻ പ്രോഗ്രാമർ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, അല്ലെങ്കിൽ ഈ ഫംഗ്ഷൻ്റെ തരത്തിൻ്റെ സ്വയമേവ വ്യുൽപ്പന്നം അസാധ്യമാണെങ്കിൽ, അവൻ അത് ചെയ്യണം അധിക നിർവ്വചനം, "::" പോലുള്ള ഒരു സ്പെസിഫിക്കേഷൻ ഓപ്പറേറ്റർ ഉപയോഗിക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു യഥാർത്ഥ മൂല്യം നൽകുന്ന ഒരു ഫംഗ്ഷൻ വിവരിക്കുന്നതിന്, നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന കോഡ് എഴുതാം:
ആദ്യ വരി അർത്ഥമാക്കുന്നത് ഫംഗ്ഷൻ പൈ ഇരട്ട തരത്തിലാണെന്നാണ്, തുടർന്ന് ഫംഗ്ഷൻ ഡെഫനിഷൻ തന്നെ വരുന്നു, അതായത് ഫംഗ്ഷൻ പൈ പൈയുടെ ഏകദേശ മൂല്യം നൽകുന്നു. ഒരു ഫംഗ്‌ഷന് ഒരു ആർഗ്യുമെൻ്റ് ഉണ്ടെങ്കിൽ, അതിൻ്റെ തരം ഇനിപ്പറയുന്ന രീതിയിൽ വിവരിക്കുന്നു:
inc::Integer -> Integer
ഈ നൊട്ടേഷൻ അർത്ഥമാക്കുന്നത് inc ഫംഗ്ഷൻ ടൈപ്പ് ഇൻ്റിജറിൻ്റെ ഒരു ആർഗ്യുമെൻ്റിനെ ടൈപ്പ് ഇൻ്റിജറിൻ്റെ ഫലമാക്കി മാറ്റുന്നു എന്നാണ്.
ഒരു ഫംഗ്‌ഷന് രണ്ട് ആർഗ്യുമെൻ്റുകൾ ഉണ്ടെങ്കിൽ, അതിൻ്റെ വിവരണം ഇതുപോലെ കാണപ്പെടുന്നു:
ശക്തി:: ഇരട്ട -> പൂർണ്ണസംഖ്യ -> ഇരട്ട
പവർ ഫംഗ്ഷൻ രണ്ട് ആർഗ്യുമെൻ്റുകൾ എടുക്കുന്നു - ഒരു യഥാർത്ഥ ബേസ് x, ഒരു പൂർണ്ണ പവർ n, കൂടാതെ ഫംഗ്ഷൻ വിലയിരുത്തുന്നതിൻ്റെ ഫലം ഒരു യഥാർത്ഥ സംഖ്യയാണ്.
IN പൊതുവായ കാഴ്ചഫംഗ്ഷൻ തരം വിവരണം ഇതുപോലെ കാണപ്പെടുന്നു:
പേര്:: X1 -> X2 -> ... ->XN -> Y
ഇവിടെ പേര് ഫംഗ്ഷൻ്റെ പേരാണ്, Xi എന്നത് i-th ആർഗ്യുമെൻ്റിൻ്റെ തരമാണ്, Y എന്നത് ഫംഗ്ഷൻ്റെ തരമാണ്.
നേരത്തെ സൂചിപ്പിച്ചതുപോലെ, തരങ്ങൾ വ്യക്തമാക്കുന്നത് ഓപ്ഷണൽ ആണ്, എന്നാൽ അതിൻ്റെ സാന്നിധ്യത്തിന് ഒരു ഫംഗ്ഷൻ ഡിക്ലറേഷനിൽ നിർമ്മിച്ച എക്സ്പ്രഷനുകളുടെ കൃത്യതയ്ക്ക് മേൽ അധിക നിയന്ത്രണം നൽകാൻ കഴിയും. കൂടാതെ, പോളിമോർഫിക് തരങ്ങൾ ഉപയോഗിക്കുന്ന ചില സന്ദർഭങ്ങളിൽ, തരം വ്യക്തമായി വ്യക്തമാക്കാതെ ഒരു ഫംഗ്ഷൻ്റെ തരം നിർണ്ണയിക്കുന്നത് അസാധ്യമാണ്.
ചില സ്റ്റാൻഡേർഡ് ഫംഗ്ഷനുകൾ ലിസ്റ്റ് ചെയ്യാം.
പ്രവർത്തനങ്ങൾ | വിവരണം |
പരമ്പരാഗത ഗണിത പ്രവർത്തനങ്ങൾ |
|
യഥാർത്ഥ സംഖ്യകളുടെ വിഭജനം |
|
ഒരു സംഖ്യയെ പോസിറ്റീവ് പൂർണ്ണസംഖ്യ പവറിലേക്ക് ഉയർത്തുന്നു |
|
ഒരു സംഖ്യയെ യഥാർത്ഥ ശക്തിയിലേക്ക് ഉയർത്തുന്നു |
|
പൂർണ്ണസംഖ്യ വിഭജനംപൂർണ്ണസംഖ്യകളെ ഹരിക്കുമ്പോൾ ബാക്കിയുള്ളവയും |
|
സ്ക്വയർ റൂട്ട് |
|
അസിൻ, അക്കോസ്, അതാൻ | വിപരീത ത്രികോണമിതി പ്രവർത്തനങ്ങൾ |
സമത്വവും അസമത്വവും തമ്മിലുള്ള താരതമ്യം |
|
>, <, >=, <= | താരതമ്യം |
ലോജിക്കൽ പ്രവർത്തനങ്ങൾ |
|
ഒരു ജോഡിയുടെ ആദ്യ ഘടകം (രണ്ട് മൂലകങ്ങളുടെ ഇരട്ടി) |
|
ജോഡിയുടെ രണ്ടാമത്തെ ഘടകം |
|
പട്ടികയുടെ വാൽ (ആദ്യത്തേത് ഒഴികെയുള്ള എല്ലാ ഘടകങ്ങളും). |
5.4 സോപാധിക കണക്കുകൂട്ടലുകൾ (ശാഖകൾ)
പരമ്പരാഗത പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ, സോപാധിക പ്രസ്താവനയും (അങ്ങനെയെങ്കിൽ) തിരഞ്ഞെടുക്കൽ പ്രസ്താവനയും (കേസ് അല്ലെങ്കിൽ സ്വിച്ച്) എന്നിവയാണ് ബ്രാഞ്ചിംഗ് സംഘടിപ്പിക്കുന്നതിനുള്ള പ്രധാന വഴികൾ. അവയ്ക്ക് പുറമേ, ഫംഗ്ഷൻ നിർവചനങ്ങളിലും ഗാർഡ് എക്സ്പ്രഷനുകളിലും പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ ഹസ്‌കെൽ ഉപയോഗിക്കുന്നു. ഈ രീതികളിൽ ഓരോന്നും നമുക്ക് സൂക്ഷ്മമായി പരിശോധിക്കാം.
എങ്കിൽ-പിന്നെ-മറ്റൊരു നിർമ്മാണം
"if-then-else" വാക്യഘടന ചില വ്യവസ്ഥകളുടെ ഫലങ്ങൾ അനുസരിച്ച് വ്യത്യസ്ത പദപ്രയോഗങ്ങൾ വിലയിരുത്താൻ നിങ്ങളെ അനുവദിക്കുന്നു:
എങ്കിൽ<условие>പിന്നെ<выражение1>വേറെ<выражение2>
ഇവിടെ<условие>- ബൂൾ തരം ചില പദപ്രയോഗങ്ങൾ. നിർബന്ധിത ഭാഷകളിൽ നിന്ന് വ്യത്യസ്തമായി, ഹാസ്കെല്ലിലെ "എങ്കിൽ-അപ്പോൾ-മറ്റേത്" എന്ന നിർമ്മിതി ഒരു പദപ്രയോഗമാണ്, അതിന് എന്തെങ്കിലും ഫലം ഉണ്ടായിരിക്കണം. ഇക്കാര്യത്തിൽ, else ബ്രാഞ്ച് നിർബന്ധമാണ്, എക്സ്പ്രഷനുകളുടെ തരങ്ങൾ<выражение1>ഒപ്പം<выражение2>ചേർന്നേ പറ്റുള്ളൂ.
ഒരു ഉദാഹരണമായി, പരമാവധി രണ്ട് സംഖ്യകൾ കണക്കാക്കുന്നതിനുള്ള പ്രവർത്തനം പരിഗണിക്കുക:
max a b = a>b ആണെങ്കിൽ വേറെ a b
ഇതിനകം പറഞ്ഞതുപോലെ, if-then-else നിർമ്മിതി ഒരു ഫലമുള്ള ഒരു പദപ്രയോഗമാണ്. അതിനാൽ, ഇത് മറ്റൊരു പദപ്രയോഗത്തിൻ്റെ ഭാഗമായി ഉപയോഗിക്കാം:
*പ്രധാന> 5 + തെറ്റാണെങ്കിൽ 1 വേറെ 0
*പ്രധാന> (ശരി ആണെങ്കിൽ 1 വേറെ 0) + 5
അവസാനത്തെ ഉദാഹരണത്തിൽ, പരാൻതീസിസ് ആവശ്യമാണെന്ന് ശ്രദ്ധിക്കുക. പരാൻതീസിസില്ലാതെ, പദപ്രയോഗം വ്യത്യസ്തമായി വ്യാഖ്യാനിക്കപ്പെടും:
*പ്രധാന> ശരിയാണെങ്കിൽ 1 വേറെ 0 + 5
"മറ്റുള്ളവ" എന്ന വാക്കിന് ശേഷം എഴുതിയതെല്ലാം മറ്റൊരു ശാഖയുടെ പദപ്രയോഗത്തെ സൂചിപ്പിക്കുന്നു.
കേസ് നിർമ്മാണം
കണക്കുകൂട്ടൽ പ്രവർത്തനം ഒരു ഉദാഹരണമായി പരിഗണിക്കുക നൽകിയ നമ്പർഫിബൊനാച്ചി:
fib n = കേസ് n ൻ്റെ
_ -> fib (n-1) + fib (n-2)
ഇഫ്-തെൻ-ഇൽലെസ് സോപാധിക പദപ്രയോഗം പോലെ, ഒരു കേസ് എക്സ്പ്രഷനും ഒരു ഫലമുണ്ട്, അതിനാൽ മറ്റ് എക്സ്പ്രഷനുകളുടെ ഭാഗമാകാം.
കേസ് എക്സ്പ്രഷൻ പൊതുവായ രൂപത്തിൽ പരിഗണിക്കാം:
കേസ്<выражение0>യുടെ
<образец1> -> <выражение1>
<образец2> -> <выражение2>
<образецN> -> <выражениеN>
കണക്കുകൂട്ടലിൻ്റെ ഫലം ഇതാ<выражение0>പാറ്റേണുകളുമായി ക്രമാനുഗതമായി പൊരുത്തപ്പെടുന്നു. ഉപയോഗിച്ച് വിജയകരമായി പൊരുത്തപ്പെടുത്തുകയാണെങ്കിൽ i-th സാമ്പിൾ, മുഴുവൻ കേസിൻ്റെയും ഫലം i-th പദപ്രയോഗത്തിൻ്റെ ഫലമായിരിക്കും. പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ അനുബന്ധ വിഭാഗത്തിൽ കൂടുതൽ വിശദമായി ചർച്ചചെയ്യും, എന്നാൽ ഇപ്പോൾ ഇത് നൽകിയിരിക്കുന്ന സ്ഥിരാങ്കങ്ങളുമായുള്ള താരതമ്യമായി കണക്കാക്കാം.
ഓരോ സാമ്പിളും ഇൻഡൻ്റേഷനേക്കാൾ വലിയ ഒരു ഇൻഡൻ്റേഷൻ ഉള്ള ഒരു പുതിയ വരിയിൽ എഴുതണം എന്നത് ശ്രദ്ധിക്കുക സംവരണം ചെയ്ത വാക്ക്കേസ്. കൂടാതെ, സാമ്പിളുകൾക്ക് മുന്നിലുള്ള ഇൻഡൻ്റുകൾ പരസ്പരം തുല്യമായിരിക്കണം.
കൂടാതെ, ഇൻഡൻ്റേഷൻ ഉപയോഗിക്കാതെ കേസ് എക്സ്പ്രഷനുകൾ എഴുതുന്നതിനുള്ള ഒരു ഇതര മാർഗം സ്വീകാര്യമാണ്:
fib n = കേസ് n (1->1;2->1;_->fib (n-1) + fib (n-2))
ഈ രീതി കൂടുതൽ ഒതുക്കമുള്ളതാണ്, പക്ഷേ കാഴ്ച കുറവാണ്. പൊതുവായി:
കേസ്<выражение0>(<образец1> -> <выражение1> ; <образец2> -> <выражение2> ; ... ; <образецN> -> <выражениеN> }
ഫംഗ്ഷൻ നിർവചനങ്ങൾ
ഹാസ്കലിൽ, ഒരേ ഫംഗ്‌ഷന് നിരവധി നിർവചനങ്ങൾ ഉണ്ടാകാം, അതിൻ്റെ ആർഗ്യുമെൻ്റുകൾ എഴുതിയിരിക്കുന്ന രീതിയാൽ വേർതിരിച്ചിരിക്കുന്നു. ആർഗ്യുമെൻ്റ് റെക്കോർഡിനെ ഒരു പാറ്റേൺ എന്ന് വിളിക്കുന്നു, ഫംഗ്ഷൻ മൂല്യനിർണ്ണയം ചെയ്യുമ്പോൾ, പാസാക്കിയ ആർഗ്യുമെൻ്റുകൾ നിർവചനങ്ങളിലെ പാറ്റേണുകളുമായി പൊരുത്തപ്പെടുന്നു.
ഫിബൊനാച്ചി നമ്പർ കണക്കാക്കുന്നതിനുള്ള പ്രവർത്തനം ഒരു ഉദാഹരണമായി പരിഗണിക്കാം.
fib n = fib (n-1) + fib (n-2)
ഒരു ഫംഗ്ഷൻ്റെ മൂല്യം വിലയിരുത്തുമ്പോൾ, അതിൻ്റെ ഒറ്റ ആർഗ്യുമെൻ്റ് മുകളിൽ നിന്ന് താഴേക്കുള്ള അതിൻ്റെ നിർവചനങ്ങളുടെ പാറ്റേണുകളുമായി പൊരുത്തപ്പെടുന്നു. ആർഗ്യുമെൻ്റ് നമ്പർ 2 ആയിരുന്നെങ്കിൽ, ആദ്യ പൊരുത്തം പരാജയപ്പെടും, രണ്ടാമത്തേത് വിജയിക്കും, അതിൻ്റെ ഫലമായി ഫംഗ്ഷൻ മൂല്യം 1 എടുക്കും. ആർഗ്യുമെൻ്റ് ആദ്യത്തെ രണ്ട് നിർവചനങ്ങളിലെ പാറ്റേണുകളുമായി പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ, അത് ആർഗ്യുമെൻ്റിൻ്റെ പേരുമായി പൊരുത്തപ്പെടണം n (in ഈ സാഹചര്യത്തിൽ n പാസാക്കിയ ആർഗ്യുമെൻ്റിൻ്റെ മൂല്യം എടുക്കും), കൂടാതെ മുമ്പത്തെ രണ്ട് ഫിബൊനാച്ചി സംഖ്യകളുടെ ആകെത്തുക കണക്കാക്കും.
ഫംഗ്ഷൻ നിർവചനങ്ങൾക്കിടയിൽ അനുയോജ്യമായ ആരെയും കണ്ടെത്തിയില്ലെങ്കിൽ, ഒരു പിശക് സംഭവിക്കുകയും പ്രോഗ്രാം എക്സിക്യൂഷൻ നിർത്തുകയും ചെയ്യും.
കാവൽ ഭാവങ്ങൾ
ഫംഗ്ഷനുകളുടെ ഫലം കണക്കാക്കുമ്പോൾ ഇതരമാർഗങ്ങൾ തിരഞ്ഞെടുക്കുന്നതിനുള്ള അവസാന മാർഗം ഗാർഡ് എക്സ്പ്രഷനുകൾ എന്ന് വിളിക്കപ്പെടുന്നു. അവ (if-then-else, കേസ് എക്സ്പ്രഷനുകൾ എന്നിവയിൽ നിന്ന് വ്യത്യസ്തമായി) ഫംഗ്ഷൻ നിർവചനങ്ങളിൽ മാത്രമേ ഉപയോഗിക്കാൻ കഴിയൂ:
<имя функции> <список аргументов функции>
|<условие1> = <выражение1>
|<условие2> = <выражение2>
|<условиеN> = <выражениеN>
എല്ലാ ചിഹ്നങ്ങളും "|" സ്വന്തം ലൈനിലും ഒരു ഇൻഡൻ്റിലും തുടങ്ങണം. ഒരു ഫംഗ്ഷൻ്റെ മൂല്യം കണക്കാക്കുമ്പോൾ, Bool തരത്തിൻ്റെ പദപ്രയോഗങ്ങളായ എല്ലാ വ്യവസ്ഥകളും മുകളിൽ നിന്ന് താഴേക്ക് ആവർത്തിക്കുന്നു. എപ്പോൾ കണ്ടെത്തും i-th അവസ്ഥ, ഇതിൻ്റെ ഫലം ശരിയാണ്, i എന്ന പദപ്രയോഗം വിലയിരുത്തപ്പെടുന്നു, അതിൻ്റെ ഫലം ഫംഗ്ഷൻ്റെ ഫലമായിരിക്കും.
ഉദാഹരണത്തിന്, ഫിബൊനാച്ചി നമ്പർ കണ്ടെത്തുന്നതിനുള്ള പ്രവർത്തനം നമുക്ക് എഴുതാം:
|അല്ലെങ്കിൽ = fib (n-1) + fib (n-2)
ഇവിടെ അല്ലാത്തപക്ഷം, എല്ലായ്പ്പോഴും സത്യത്തിന് തുല്യമായ ഒരു വ്യക്തമായ യഥാർത്ഥ അവസ്ഥയുണ്ട്.
5.5 പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ
പാറ്റേൺ പൊരുത്തം ആണ് സൗകര്യപ്രദമായ വഴിചില മൂല്യങ്ങളുടെ വിവിധ ഭാഗങ്ങൾ ബന്ധപ്പെടുത്തുക ഒന്നാം പേര്(ചിഹ്നങ്ങൾ) . പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ നിർവചനങ്ങളിലും കേസ് എക്സ്പ്രഷനുകളിലും ഉപയോഗിക്കുന്നു.
ഫംഗ്ഷനുകൾ നിർവചിക്കുമ്പോൾ, ആർഗ്യുമെൻ്റുകളിൽ പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ സംഭവിക്കുന്നു. ഏറ്റവും ലളിതമായ സാഹചര്യത്തിൽ, ആർഗ്യുമെൻ്റുകൾ പേരുകൾ കൊണ്ട് മാത്രം വ്യക്തമാക്കുമ്പോൾ, ആർഗ്യുമെൻ്റുകൾ ആ പേരുകളുമായി പൂർണ്ണമായും ബന്ധപ്പെട്ടിരിക്കുന്നു. ഉദാഹരണത്തിന്:
f x = fst x + snd x
ഈ ഫംഗ്ഷൻ ഒരു ട്യൂപ്പിളിൻ്റെ മൂലകങ്ങളുടെ ആകെത്തുക കണക്കാക്കുന്നു. സ്റ്റാൻഡേർഡ് ഫംഗ്‌ഷനുകളായ fst, snd എന്നിവ യഥാക്രമം ട്യൂപ്പിളിൻ്റെ ഒന്നും രണ്ടും മൂലകങ്ങൾ നേടുന്നു.
*പ്രധാന> f (2.4)
പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ ഉപയോഗിച്ച്, ഈ ഫംഗ്ഷൻ്റെ ആർഗ്യുമെൻ്റിൻ്റെ ഉള്ളടക്കങ്ങൾ കൂടുതൽ ദൃശ്യപരമായി നമുക്ക് ഹൈലൈറ്റ് ചെയ്യാൻ കഴിയും:
(2,4) ഈ ഫംഗ്ഷൻ കണക്കാക്കുമ്പോൾ, ഈ ട്യൂപ്പിളിൻ്റെ ഘടകങ്ങൾ ഫംഗ്ഷൻ നിർവചനത്തിൽ വ്യക്തമാക്കിയ പാറ്റേണുമായി പൊരുത്തപ്പെടും, അതായത്, "a" എന്ന ചിഹ്നം 2 മൂല്യവും "b" എന്ന ചിഹ്നവും എടുക്കും. മൂല്യം 4.
ഇതുവഴി fst, snd എന്നീ ഫംഗ്ഷനുകളുടെ അനലോഗ് നമുക്ക് നിർവചിക്കാം:
ഫംഗ്ഷൻ fst1 ൻ്റെ നിർവചനം x ഉപയോഗിക്കുന്നില്ല, കൂടാതെ snd1 ഫംഗ്ഷൻ്റെ നിർവചനം y ഉപയോഗിക്കുന്നില്ല. അത്തരം സന്ദർഭങ്ങളിൽ, സാമ്പിളിൻ്റെ ഭാഗം (അല്ലെങ്കിൽ മുഴുവൻ ആർഗ്യുമെൻ്റും) ഉപയോഗിക്കാത്തപ്പോൾ, ഈ ഭാഗത്തിൻ്റെ പേര് (അല്ലെങ്കിൽ ആർഗ്യുമെൻ്റ്) വ്യക്തമാക്കേണ്ട ആവശ്യമില്ല - പേരിന് പകരം, അടിവരയിടുന്ന പ്രതീകം “_” വ്യക്തമാക്കിയാൽ മതിയാകും. ”. നമുക്ക് ഈ ഫംഗ്ഷനുകൾ പുനർനിർവചിക്കാം:
ഈ എഴുത്ത് രീതി ഉപയോഗിച്ച്, പാറ്റേണുകളുടെ അനാവശ്യ ഭാഗങ്ങൾക്കായി നിങ്ങൾ പേരുകൾ കൊണ്ടുവരേണ്ടതില്ല, കൂടാതെ ഫംഗ്ഷൻ നിർവചനം വായിക്കുമ്പോൾ, വാദത്തിൻ്റെ ഈ ഭാഗം ഉപയോഗിച്ചിട്ടില്ലെന്ന് ഉടൻ വ്യക്തമാകും.
പാറ്റേണുകൾക്ക് ഏതെങ്കിലും കൺസ്‌ട്രക്‌ടറുകളെ (മുമ്പത്തെ ഉദാഹരണങ്ങളിൽ ഒരു ട്യൂപ്പിൾ കൺസ്ട്രക്‌ടർ ഉപയോഗിച്ചിരുന്നു) വ്യക്തമാക്കാൻ കഴിയും, ഉദാഹരണത്തിന്, ഒരു ലിസ്റ്റ്, ഒരു ട്യൂപ്പിൾ അല്ലെങ്കിൽ ഏതെങ്കിലും ഇഷ്‌ടാനുസൃത ഡാറ്റാ തരങ്ങൾ, കൂടാതെ നിർദ്ദിഷ്ട ആർഗ്യുമെൻ്റ് മൂല്യങ്ങൾ (ഫിബൊനാച്ചി നമ്പറുകളെക്കുറിച്ചുള്ള ഉദാഹരണം പോലെ) . ചില സന്ദർഭങ്ങളിൽ, ഒരു പൊരുത്തം പരാജയപ്പെട്ടേക്കാം, അടുത്ത പൊരുത്തം (അടുത്ത നിർവചനത്തിൽ നിന്നോ കേസ് പാറ്റേണിൽ നിന്നോ) ശ്രമിക്കും. നമുക്ക് ഒരു ഉദാഹരണം നോക്കാം:
f_ 0 = പിശക് "പൂജ്യം കൊണ്ട് ഹരിക്കൽ"
f (a, b) c = (a+b)/c
ഇവിടെ, ഫംഗ്ഷൻ f കണക്കാക്കുമ്പോൾ, രണ്ടാമത്തെ ആർഗ്യുമെൻ്റ് 0 ന് തുല്യമായിരിക്കും, തുടർന്ന് ഫംഗ്ഷൻ വിലയിരുത്തുന്നതിന് ആദ്യ നിർവചനം തിരഞ്ഞെടുക്കും, അല്ലാത്തപക്ഷം രണ്ടാമത്തേത്, കാരണം പേരുമായുള്ള താരതമ്യം എല്ലായ്പ്പോഴും വിജയകരമാണ്. പിശക് ഫംഗ്ഷൻ പ്രോഗ്രാമിൻ്റെ എക്സിക്യൂഷൻ നിർത്തുന്നു നൽകിയ വാചകംപിശകുകൾ. വിവരിച്ച ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നതിനുള്ള ഉദാഹരണങ്ങൾ:
*പ്രധാന> f (1,2) 3
*പ്രധാന> f (3.2) 1
*പ്രധാന> f (5.5) 5
*പ്രധാന> f (5.5) 0
*** ഒഴിവാക്കൽ: പൂജ്യം കൊണ്ട് ഹരിച്ചാൽ
കൂടാതെ, ഓരോ പാറ്റേണിനും പേരിടാം, അതിലൂടെ ഘടനാപരമായ ആർഗ്യുമെൻ്റിലേക്ക് എലമെൻ്റ്-ബൈ-എലമെൻ്റ് അല്ലെങ്കിൽ മൊത്തത്തിൽ ആക്സസ് ചെയ്യാൻ കഴിയും. ഒരു പാറ്റേൺ പേരിടാൻ @ ഓപ്പറേറ്റർ ഉപയോഗിക്കുന്നു. അവൻ്റെ മുന്നിൽ പേര് പോകുന്നു, അതിലൂടെ നിങ്ങൾക്ക് ആർഗ്യുമെൻ്റ് മൊത്തത്തിൽ ആക്സസ് ചെയ്യാൻ കഴിയും, തുടർന്ന് സാമ്പിൾ തന്നെ. ഉദാഹരണത്തിന്,
func1 p@(a, b) = a + b + func2 p
func2(a, b) = a*b
5.6 പട്ടികകൾ
പട്ടിക അതിലൊന്നാണ് ഏറ്റവും പ്രധാനപ്പെട്ട ഘടനകൾഒരേ തരത്തിലുള്ള ഘടകങ്ങൾ ഉൾപ്പെടുന്ന ഡാറ്റ. ഒരു ലിസ്റ്റിൽ വ്യത്യസ്ത തരത്തിലുള്ള ഘടകങ്ങൾ അടങ്ങിയിരിക്കരുത് (ട്യൂപ്പിൾസിൽ നിന്ന് വ്യത്യസ്തമായി). ലിസ്റ്റ് തരം വിവരിക്കാൻ സ്ക്വയർ ബ്രാക്കറ്റുകൾ ഉപയോഗിക്കുന്നു. ഉദാഹരണത്തിന്, ലോജിക്കൽ തരത്തിലുള്ള ഘടകങ്ങളുടെ പട്ടികയുടെ തരത്തിൻ്റെ വിവരണമാണിത്.
ലിസ്റ്റ് കൺസ്ട്രക്റ്റർ ഉപയോഗിച്ചാണ് ലിസ്റ്റുകൾ സൃഷ്ടിക്കുന്നത് - ":" പ്രവർത്തനം. പട്ടിക ഒന്നുകിൽ ശൂന്യമായിരിക്കാം അല്ലെങ്കിൽ ഒരു തലയും (ലിസ്റ്റിൻ്റെ ആദ്യ ഘടകം) ഒരു വാലും (ബാക്കിയുള്ള മൂലകങ്ങളുടെ പട്ടിക) അടങ്ങിയിരിക്കാം. ഒരു ശൂന്യമായ ലിസ്റ്റ് ശൂന്യമായ ചതുര ബ്രാക്കറ്റുകളാൽ സൂചിപ്പിക്കുന്നു: "", കൂടാതെ ഒരു തല x ഉം ഒരു വാൽ y ഉം അടങ്ങുന്ന ഒരു ലിസ്റ്റ് ലിസ്റ്റ് കൺസ്ട്രക്റ്റർ ഉപയോഗിച്ച് എഴുതുന്നു: "x:y".
ലിസ്റ്റുകൾ എഴുതാൻ കൂടുതൽ സൗകര്യപ്രദമായ മാർഗമുണ്ട്: ചതുര ബ്രാക്കറ്റുകളിൽ ഘടകങ്ങൾ ലിസ്റ്റുചെയ്യുന്നതിലൂടെ. ഉദാഹരണത്തിന്, 1 മുതൽ 3 വരെയുള്ള പൂർണ്ണസംഖ്യകളുടെ ഒരു ലിസ്റ്റ് ഇതുപോലെ എഴുതാം:
1: = 1:2: = 1:2:3:
പാറ്റേൺ പൊരുത്തപ്പെടുത്തലിൽ ലിസ്റ്റ് കൺസ്ട്രക്റ്റർ ഉപയോഗിക്കാം. ഈ പൊരുത്തപ്പെടുത്തൽ ഉപയോഗിച്ച്, ഒരു ആർഗ്യുമെൻ്റായി പാസാക്കിയ ലിസ്റ്റ് ഒരു തലയും വാലും ആയി വിഭജിക്കപ്പെടും, അത് പാറ്റേണിൽ വ്യക്തമാക്കിയ പ്രതീകങ്ങളിലൂടെ ആക്സസ് ചെയ്യാൻ കഴിയും. ലിസ്റ്റ് ശൂന്യമാണെങ്കിൽ, താരതമ്യം ചെയ്യുക ഈ നിർവചനംപരാജയപ്പെടും.
ഉദാഹരണത്തിന്, ഒരു ലിസ്റ്റിൻ്റെ തല എടുക്കുന്നതിനുള്ള ഒരു ഫംഗ്ഷൻ നിങ്ങൾക്ക് വിവരിക്കാം:
ഹെഡ് ഫംഗ്ഷൻ്റെ മുകളിലുള്ള നിർവ്വഹണത്തിൽ, ലിസ്റ്റിൻ്റെ വാൽ ഉപയോഗിക്കില്ല; നിങ്ങൾക്ക് അതിൻ്റെ പേര് ഒരു അടിവര ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കാം:
ഒരു ലിസ്റ്റിൻ്റെ വാൽ എടുക്കുന്നതിനുള്ള പ്രവർത്തനം സമാനമായി വിവരിക്കാം.
ഈ രണ്ട് ഫംഗ്ഷനുകളും (തലയും വാലും) ഒരു ശൂന്യമായ ലിസ്റ്റ് ഉപയോഗിച്ച് അവർക്ക് കൈമാറുകയാണെങ്കിൽ ഒരു പിശക് സംഭവിക്കും, കാരണം മത്സരം വിജയിക്കില്ല.
ലിസ്റ്റുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നതിനുള്ള ഒരു ഫംഗ്ഷൻ്റെ മറ്റൊരു ഉദാഹരണം നോക്കാം: ഒരു ലിസ്റ്റിൻ്റെ ദൈർഘ്യം കണക്കാക്കുന്നതിനുള്ള ഒരു ഫംഗ്ഷൻ:
നീളം (_: t) = 1 + നീളം t
ഇൻപുട്ട് ലിസ്റ്റ് ശൂന്യമാണെങ്കിൽ, ആദ്യ നിർവചനം താരതമ്യത്തിൻ്റെ ഫലമായി പ്രവർത്തിക്കും, അല്ലാത്തപക്ഷം രണ്ടാമത്തേത് പ്രവർത്തിക്കും.
ഹാസ്കെല്ലിലെ സ്ട്രിംഗുകൾ പ്രതീകങ്ങളുടെ പട്ടികയാണ്. അക്ഷരങ്ങൾ അപ്പോസ്ട്രോഫികളിൽ എഴുതിയിരിക്കുന്നു (ഉദാഹരണത്തിന്, "സി"), സ്ട്രിംഗുകൾ ഉദ്ധരണികളിൽ എഴുതിയിരിക്കുന്നു (ഉദാഹരണത്തിന്, "സ്ട്രിംഗ്"). ഏത് സ്ട്രിംഗും പ്രതിനിധീകരിക്കാം സ്റ്റാൻഡേർഡ് നൊട്ടേഷൻലിസ്‌റ്റുകൾ, ഉദാഹരണത്തിന്, "സ്ട്രിംഗ്" എന്ന സ്ട്രിംഗ് ലിസ്റ്റിന് സമാനമാണ് ["s","t","r","i","n","g"]. സ്ട്രിംഗുകൾ ലിസ്റ്റുകൾ പോലെ തന്നെ പ്രവർത്തിക്കുന്നു.
തലയും വാലും ക്രമേണ മുറിച്ചുകൊണ്ട് പട്ടികയുടെ ഘടകങ്ങൾ തുടർച്ചയായി ആക്സസ് ചെയ്യുന്നു. ഉദാഹരണത്തിന്, ഒരു ലിസ്റ്റിൻ്റെ n-ാമത്തെ ഘടകം (0 മുതൽ ആരംഭിക്കുന്നത്) ലഭിക്കുന്നതിന്, നിങ്ങൾക്ക് ഒരു ഫംഗ്ഷൻ എഴുതാം:
getN(x:_) 0 = x
getN (_:t) n = getN t (n-1)
ഒരു ലിസ്റ്റിൻ്റെ n-ാമത്തെ ഘടകം എടുക്കുന്നത് "!!" എന്ന സ്റ്റാൻഡേർഡ് ഫംഗ്ഷനിൽ നടപ്പിലാക്കുന്നു. ഇത് ഇതുപോലെ ഉപയോഗിക്കുന്നു:
ഇവിടെ ലിസ്റ്റ് ഒരു ലിസ്റ്റ് ആണ്, n എന്നത് തിരഞ്ഞ ഘടകത്തിൻ്റെ സംഖ്യയാണ്. മൂലകങ്ങളുടെ എണ്ണം പൂജ്യത്തിൽ നിന്നാണ് ആരംഭിക്കുന്നത്. ലിസ്റ്റിൻ്റെ ദൈർഘ്യം തിരയുന്ന മൂലകത്തിൻ്റെ എണ്ണത്തേക്കാൾ കുറവോ തുല്യമോ ആണെങ്കിൽ, ഈ ഫംഗ്ഷൻ്റെ കണക്കുകൂട്ടൽ ഒരു പിശകിന് കാരണമാകും.
എണ്ണാവുന്ന ഘടകങ്ങളുടെ ലിസ്റ്റുകൾ (ഉദാഹരണത്തിന്, പൂർണ്ണസംഖ്യകൾ അല്ലെങ്കിൽ പ്രതീകങ്ങൾ) ഇനിപ്പറയുന്ന രീതിയിൽ വ്യക്തമാക്കാനും കഴിയും:
ഇവിടെ X1 എന്നത് ഗണിത പുരോഗതിയുടെ തുടക്കമാണ്, X2 അതിൻ്റെ അവസാനമാണ്. ഉദാഹരണത്തിന്, ഒരു പട്ടികയാണ്. ഈ രീതിയിൽ, ഒന്നിന് തുല്യമായ ഒരു ഘട്ടം ഉപയോഗിച്ച് മാത്രമേ നിങ്ങൾക്ക് വർദ്ധിച്ചുവരുന്ന ലിസ്റ്റുകൾ വ്യക്തമാക്കാൻ കഴിയൂ. മറ്റൊരു ഘട്ടം ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു ക്രമം വ്യക്തമാക്കണമെങ്കിൽ, നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന നൊട്ടേഷൻ ഉപയോഗിക്കാം:
ഈ പതിപ്പിൽ, X1 എന്നത് ക്രമത്തിൻ്റെ ആദ്യ ഘടകമാണ്, X2 രണ്ടാമത്തേതാണ്, X3 അവസാനത്തേത് സാധ്യമാണ്. സീക്വൻസ് സ്റ്റെപ്പ് X2-X1 ആയി തിരഞ്ഞെടുത്തു, കൂടാതെ സീക്വൻസിൽ X1 നും X3 നും ഇടയിൽ മാത്രം സ്ഥിതിചെയ്യുന്ന ഘടകങ്ങൾ അടങ്ങിയിരിക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു പട്ടികയാണ്.
നിലവിലുള്ളവയെ അടിസ്ഥാനമാക്കി ലിസ്റ്റുകൾ വ്യക്തമാക്കാനും ഒരു മാർഗമുണ്ട്. പൊതുവേ, ഈ രീതി ഇനിപ്പറയുന്ന രീതിയിൽ എഴുതാം:
[<выражение> | <образец> <- <список>, <ограничение1>, ..., <ограничениеN>]
ഒരു നിശ്ചിത ലിസ്റ്റിൽ നിന്ന്, പാറ്റേണുമായി പൊരുത്തപ്പെടുന്നതും എല്ലാ നിയന്ത്രണങ്ങളും തൃപ്തിപ്പെടുത്തുന്നതുമായ ഘടകങ്ങൾ തിരഞ്ഞെടുത്തു, കൂടാതെ ഈ പാറ്റേൺ ഉപയോഗിച്ച് എക്സ്പ്രഷൻ വിലയിരുത്തിയ ഘടകങ്ങളുടെ ഒരു ലിസ്റ്റ് രൂപീകരിക്കുന്നു. ഉദാഹരണത്തിന്,
[ x^2 | x<- ,mod x 3 == 0]
ഈ പദപ്രയോഗം 3 കൊണ്ട് ഹരിക്കാവുന്ന ഒന്ന് മുതൽ 30 വരെയുള്ള ഒറ്റ സംഖ്യകളുടെ ചതുരങ്ങളുടെ ഒരു ലിസ്റ്റ് നിർമ്മിക്കുന്നു. ഫലം:
കൂടാതെ, ലിസ്റ്റുകളുമായി പ്രവർത്തിക്കുമ്പോൾ സ്റ്റാൻഡേർഡ് മൊഡ്യൂളിൽ നിർവചിച്ചിരിക്കുന്ന മാപ്പ് ഫംഗ്ഷൻ വളരെ ഉപയോഗപ്രദമാണ്. ഇത് നൽകിയിരിക്കുന്ന ലിസ്റ്റിലേക്ക് ഒരു ഫംഗ്ഷൻ പ്രയോഗിക്കുകയും യഥാർത്ഥ ലിസ്റ്റിൻ്റെ ഘടകങ്ങളിലേക്ക് ആ ഫംഗ്ഷൻ പ്രയോഗിക്കുന്നതിൻ്റെ ഫലമായുണ്ടാകുന്ന ലിസ്റ്റ് തിരികെ നൽകുകയും ചെയ്യുന്നു. മാപ്പ് ഫംഗ്ഷൻ ഇനിപ്പറയുന്ന രീതിയിൽ നടപ്പിലാക്കാം:
ഭൂപടം:: (a -> b) -> [a] -> [b]
മാപ്പ് f xs =
അതായത്, ടൈപ്പിലെ ഒബ്‌ജക്റ്റുകളെ ടൈപ്പ് ബിയുടെ ഒബ്‌ജക്റ്റുകളാക്കി മാറ്റുന്ന ഫംഗ്ഷൻ ആദ്യ ആർഗ്യുമെൻ്റായി എടുക്കുന്നു, രണ്ടാമത്തെ ആർഗ്യുമെൻ്റായി ടൈപ്പ് എയുടെ മൂലകങ്ങളുടെ ഒരു ലിസ്റ്റ്. മാപ്പ് ഫംഗ്ഷൻ്റെ ഫലം ടൈപ്പ് ബിയുടെ മൂലകങ്ങളുടെ ഒരു പട്ടികയാണ്.
മാപ്പ് ഫംഗ്ഷൻ ഉപയോഗിക്കുമ്പോൾ, പേരില്ലാത്ത ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുന്നത് സൗകര്യപ്രദമാണ്, അവ λ- എക്സ്പ്രഷനുകളുടെ രൂപത്തിൽ വിവരിച്ചിരിക്കുന്നു (ഹയർ-ഓർഡർ ഫംഗ്ഷനുകളെക്കുറിച്ചുള്ള വിഭാഗത്തിൽ കൂടുതൽ വിശദമായി ചർച്ചചെയ്യുന്നു). ഉദാഹരണത്തിന്, 1 മുതൽ 10 വരെയുള്ള സംഖ്യകളുടെ ചതുരങ്ങളുടെ ഒരു ലിസ്റ്റ് ഇനിപ്പറയുന്ന രീതിയിൽ വിവരിക്കാം:
മാപ്പ് (\x->x*x)
ഈ പ്രവർത്തനത്തിൻ്റെ ഫലം ഒരു പട്ടികയാണ്:
ഹാസ്കലിന് ഒരു ബിൽറ്റ്-ഇൻ എക്‌സ്‌പോണൻഷ്യേഷൻ ഓപ്പറേഷൻ ഉള്ളതിനാൽ, ഈ പട്ടികഇതുപോലെ ലഭിക്കും:
മാപ്പ് (^2)
നിങ്ങൾക്ക് മറ്റേതെങ്കിലും ഫംഗ്ഷനുകളും ഉപയോഗിക്കാം, ഉദാഹരണത്തിന്:
മാപ്പ് inc
ലിസ്റ്റുകൾക്കൊപ്പം പ്രവർത്തിക്കാൻ രൂപകൽപ്പന ചെയ്ത സ്റ്റാൻഡേർഡ് മൊഡ്യൂളിൽ നിർവചിച്ചിരിക്കുന്ന നിരവധി ഫംഗ്ഷനുകൾ നോക്കാം.
പ്രവർത്തനത്തിൻ്റെ പേര് | വിവരണം |
|
ലിസ്റ്റിൻ്റെ തല (ആദ്യ ഘടകം). |
||
ലിസ്റ്റിൻ്റെ വാൽ (ആദ്യ ഘടകം ഒഴികെ എല്ലാം). |
||
പട്ടികയിലെ അവസാന ഘടകം |
||
അവസാനത്തേത് ഒഴികെ ലിസ്റ്റിലെ എല്ലാ ഘടകങ്ങളും |
||
[a] → Int → a | തന്നിരിക്കുന്ന സംഖ്യയുള്ള ഘടകം |
|
ലിസ്റ്റ് നീളം കണക്കാക്കുന്നു |
||
Int → [a] → [a] | ഒരു ലിസ്റ്റിൽ നിന്ന് ആദ്യത്തെ n ഘടകങ്ങൾ എടുക്കുക |
|
Int → [a] → [a] | ഒരു ലിസ്റ്റിൽ നിന്ന് ആദ്യത്തെ n ഘടകങ്ങൾ നിരസിക്കുക |
|
വിപരീത ലിസ്റ്റ് ക്രമം |
||
(എണ്ണം എ) => [എ] → എ | ലിസ്റ്റ് ഘടകങ്ങളുടെ ആകെത്തുക |
|
(എണ്ണം എ) => [എ] → എ | ലിസ്റ്റ് ഘടകങ്ങളുടെ ഉൽപ്പന്നം |
|
[a] → [a] → [a] | പട്ടിക കൂട്ടിച്ചേർക്കൽ |
5.7 പ്രാദേശിക നിർവചനങ്ങൾ
ഹാസ്കെൽ ഒരു ശുദ്ധമായ ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗ് ഭാഷയാണ്, അതിനാൽ ഇതിന് ആഗോള വേരിയബിളുകൾ ഉണ്ടാകില്ല, വാസ്തവത്തിൽ ഇതിന് വേരിയബിളുകളൊന്നുമില്ല. ഒരു വസ്തുവും മാറ്റാൻ കഴിയില്ല, പഴയത് ഉപയോഗിച്ച് പുതിയത് മാത്രമേ ലഭിക്കൂ. വേരിയബിളുകൾക്കുള്ള ചില "പകരം" ഫംഗ്ഷൻ പാരാമീറ്ററുകളും ലോക്കൽ ഫംഗ്ഷനുകളും ആകാം.
വിവരിക്കാൻ രണ്ട് വഴികളുണ്ട് പ്രാദേശിക പ്രവർത്തനങ്ങൾ: ഒരു റിസർവ്ഡ് വാക്ക് ഉപയോഗിക്കുന്നു എവിടെഒപ്പം അനുവദിക്കുക. ഒരു ഫംഗ്ഷൻ ഡെഫനിഷനിൽ മാത്രം ഉപയോഗിക്കാവുന്ന ലോക്കൽ ഫംഗ്ഷനുകൾ നിർവചിക്കുന്നു. മൂന്ന് സംഖ്യകളുടെ ഗണിത ശരാശരി കണക്കാക്കുന്നതിനുള്ള ഒരു ഫംഗ്ഷൻ നമുക്ക് നിർവചിക്കാം:
ശരാശരി3 x y z = s / 3
പൊതുവേ, എവിടെ എന്നതിൻ്റെ ഉപയോഗം ഇതുപോലെ എഴുതാം:
<имя функции> <аргументы> = <выражение>
<определение 1>
<определение 2>
<определение N>
എല്ലാ നിർവചനങ്ങളും ഒരേ ഇൻഡൻ്റേഷനിലായിരിക്കണം, എന്നാൽ എവിടെ അടങ്ങിയിരിക്കുന്ന വരയേക്കാൾ വലുതായിരിക്കണം. വേണമെങ്കിൽ, നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന വാക്യഘടന ഉപയോഗിക്കാം:
<имя функции> <аргументы> = <выражение>എവിടെ (<определение 1> ; <определение 2> ; ... ; <определение N> }
രണ്ടാമത്തെ രീതി (ലെറ്റ് ഉപയോഗിച്ച്) ഏത് പദപ്രയോഗത്തിലും ഉപയോഗിക്കാം (ഫംഗ്ഷനുകൾ നിർവചിക്കുമ്പോൾ മാത്രമല്ല). എവിടെ നിന്ന് വ്യത്യസ്തമായി, പ്രാദേശിക ഫംഗ്ഷനുകളുടെ നിർവചനങ്ങൾ പദപ്രയോഗത്തിന് മുമ്പായി എഴുതണം. മുമ്പത്തെ ഉദാഹരണം വീണ്ടും എഴുതാം:
ശരാശരി3 x y z =
പൊതുവേ, ഈ രീതി ഇതുപോലെ കാണപ്പെടുന്നു:
<определение 1>
<определение 2>
<определение N>
<выражение>
എല്ലാ നിർവചനങ്ങളും ഒരേ ഇൻഡൻ്റേഷനിലായിരിക്കണം, എന്നാൽ ലെറ്റ് അടങ്ങിയിരിക്കുന്ന ലൈനേക്കാൾ വലുതായിരിക്കണം. ഇൻ എന്ന വാക്ക് ലെറ്റിൽ കുറയാതെ ഇൻഡൻ്റ് ചെയ്തിരിക്കണം. വേണമെങ്കിൽ, നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന വാക്യഘടന ഉപയോഗിക്കാം:
അനുവദിക്കുക (<определение 1> ; <определение 2> ; ... ; <определение N>) ൽ<выражение>
ഈ സാഹചര്യത്തിൽ, ഇൻഡൻ്റേഷൻ അവഗണിക്കപ്പെടുന്നു.
5.8 സംവേദനാത്മക പരിസ്ഥിതിയുടെ അധിക സവിശേഷതകൾ
ഫംഗ്ഷനുകൾ അല്ലെങ്കിൽ എക്സ്പ്രഷനുകൾ വിലയിരുത്തുന്നതിന് പുറമേ, GHCi ഇൻ്ററാക്റ്റീവ് എൻവയോൺമെൻ്റിന് നിരവധി അധിക കഴിവുകളുണ്ട്. അവയിൽ പലതും ":" പ്രതീകത്തിൽ ആരംഭിക്കുന്ന കമാൻഡുകൾ വഴി ആക്സസ് ചെയ്യാവുന്നതാണ്. ഉദാഹരണത്തിന്, GHCi ലൈനിൽ ":?" എന്ന കമാൻഡ് എഴുതുക നിങ്ങൾക്ക് മറ്റെല്ലാ കമാൻഡുകളുടെയും ഒരു ലിസ്റ്റ് കാണാൻ കഴിയും (ഓട്ടോകംപ്ലീഷൻ കമാൻഡുകൾക്കും പ്രവർത്തിക്കുന്നു). ഏറ്റവും ഉപയോഗപ്രദമായ കമാൻഡുകൾ നോക്കാം.
:t - നിർദ്ദിഷ്ട പദപ്രയോഗത്തിൻ്റെ തരം ലഭിക്കുന്നു. ഉദാഹരണത്തിന്:
*മെയിൻ> :ടി റിവേഴ്സ് (ടെയിൽ "അമ്മ")
വിപരീതം (വാൽ "അമ്മ") ::
:i - ഫംഗ്ഷനെക്കുറിച്ചുള്ള വിവരങ്ങൾ നേടുന്നു (തരം, ഏത് മൊഡ്യൂളിൽ അല്ലെങ്കിൽ ക്ലാസിലാണ് ഇത് നിർവചിച്ചിരിക്കുന്നത്). ഉദാഹരണത്തിന്:
*പ്രധാന> : ഞാൻ വിപരീതമായി
വിപരീതം:: [a] -> [a] -- GHC-യിൽ നിർവചിച്ചിരിക്കുന്നത്. ലിസ്റ്റ്
:l - ലോഡ് നിർദ്ദിഷ്ട മൊഡ്യൂൾഅത് നിലവിലുള്ളതാക്കുക.
:m - നിർദ്ദിഷ്ട മൊഡ്യൂൾ ലോഡ് ചെയ്യുക അല്ലെങ്കിൽ അൺലോഡ് ചെയ്യുക.
:q - GHCi അടയ്ക്കുക.
ഒന്ന് കൂടി ഉപയോഗപ്രദമായ സവിശേഷത GHCi-ൽ നേരിട്ട് ഫംഗ്ഷൻ നിർവചനങ്ങൾ നിർവചിക്കാനുള്ള കഴിവാണ്. ലളിതവൽക്കരിച്ച ലെറ്റ് നിർമ്മാണമാണ് ഇതിനായി ഉപയോഗിക്കുന്നത്. ഉദാഹരണത്തിന്:
*പ്രധാന> f x = x+2*x എന്ന് അനുവദിക്കുക
ഫുൾ ലെറ്റ് കൺസ്ട്രക്‌റ്റ് അതിൻ്റെ എക്സ്പ്രഷൻ്റെ പരിധിക്കുള്ളിൽ മാത്രമേ പ്രവർത്തിക്കൂ:
*പ്രധാനം> z+z-ൽ z = 10 എന്ന് അനുവദിക്കുക
GHCi റിപ്പോർട്ട് ചെയ്യുന്നു പേരിന്റെ ആദ്യഭാഗംനിലവിലെ പരിധിയിൽ നിർവചിച്ചിട്ടില്ല.
5.9 ഉയർന്ന ഓർഡർ ഫംഗ്ഷനുകൾ
Haskell-ൽ, ഫംഗ്ഷനുകൾ മറ്റേതൊരു ഒബ്ജക്റ്റിനെയും പോലെ ഉപയോഗിക്കാം - അവ ലിസ്റ്റുകളിലും ട്യൂപ്പിളുകളിലും സംഭരിക്കാനും മറ്റ് ഫംഗ്ഷനുകളിലേക്ക് കൈമാറാനും മറ്റ് ഫംഗ്ഷനുകളുടെ ഫലമായി തിരികെ നൽകാനും കഴിയും.
മറ്റ് ഫംഗ്ഷനുകൾ സ്വീകരിക്കുന്നതോ തിരികെ നൽകുന്നതോ ആയ ഫംഗ്‌ഷനുകളെ ഉയർന്ന ഓർഡർ ഫംഗ്ഷനുകൾ എന്ന് വിളിക്കുന്നു. അത്തരം ഒരു ഫംഗ്ഷൻ, ഉദാഹരണത്തിന്, ഉപയോഗിക്കുന്ന മാപ്പ് ഫംഗ്ഷൻ ആണ് നൽകിയ പ്രവർത്തനംപട്ടികയിലെ എല്ലാ ഘടകങ്ങളിലേക്കും.
ഈ ഭാഗം ശരിയായി പൂർത്തിയാക്കുക
രണ്ട് സംഖ്യകൾ ചേർക്കുന്നതിൻ്റെ പ്രവർത്തനം പരിഗണിക്കുക:
പ്ലസ് x y = x + y
പ്ലസ് ഫംഗ്ഷൻ വ്യത്യസ്തമായി വിവരിക്കാം:
+ ഓപ്പറേഷൻ, പരാൻതീസിസിൽ ഘടിപ്പിച്ചിരിക്കുന്നത്, 2 വേരിയബിളുകളുടെ പ്രവർത്തനമാണ്, അതിനാൽ, അതിൽ രണ്ട് പാരാമീറ്ററുകൾ പ്രയോഗിക്കുമ്പോൾ, ഫലം അവയുടെ ആകെത്തുകയാണ്. ഈ ഫംഗ്ഷനിലേക്ക് ഞങ്ങൾ ഒരു ആർഗ്യുമെൻ്റ് മാത്രം പ്രയോഗിക്കുകയാണെങ്കിൽ, ഉദാഹരണത്തിന് നമ്പർ 3, നമുക്ക് ഒരു ആർഗ്യുമെൻ്റ് ഫംഗ്ഷൻ ലഭിക്കും, അത് ഈ ആർഗ്യുമെൻ്റ് നമ്പറിലേക്ക് ചേർക്കുന്നത് വ്യക്തമാക്കുന്നു:
ഫംഗ്‌ഷനുകളെ ഒരു പരാമീറ്റർ എടുക്കുന്ന ഒരു ഫംഗ്‌ഷനിലേക്കും മറ്റെല്ലാം കണക്കാക്കുന്ന മറ്റൊരു ഫംഗ്ഷനെ നൽകുന്ന ഫംഗ്‌ഷനെയും ഫംഗ്ഷൻ കറിയിംഗ് എന്ന് വിളിക്കുന്നു.
പ്ലസ് ഫംഗ്ഷൻ വിവരിക്കുന്നതിനുള്ള മറ്റൊരു ഓപ്ഷൻ:
പ്ലസ് ഫംഗ്ഷൻ (മുകളിലുള്ള ഏതെങ്കിലും നടപ്പിലാക്കൽ) ഉപയോഗിച്ച്, നിങ്ങൾക്ക് ഒരു ഇൻക്രിമെൻ്റ് ഫംഗ്ഷൻ എഴുതാം:
inc x = പ്ലസ് 1 x
കറിയിംഗ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് അതേ പ്രവർത്തനത്തിൻ്റെ മറ്റൊരു നിർവ്വഹണം ലഭിക്കും:
inc ഫംഗ്ഷൻ അതിൻ്റെ പാരാമീറ്ററുകളിലൊന്നിലേക്ക് 1 ചേർക്കുന്ന ഒരു ഫംഗ്ഷൻ നൽകുന്നു.
ഹാസ്കലിൽ ഫംഗ്ഷനുകൾ എഴുതുന്നതിനുള്ള ഈ രീതിക്ക് പുറമേ, λ-കാൽക്കുലസ് ഉപയോഗിച്ച് അവ വ്യക്തമാക്കുന്നതിനുള്ള ഒരു മാർഗമുണ്ട്.ഉദാഹരണത്തിന്, പ്ലസ് ഫംഗ്ഷൻ ഇനിപ്പറയുന്ന രീതിയിൽ നടപ്പിലാക്കാം:
പ്ലസ് = \x y -> x+y
ഇവിടെ “\” എന്നാൽ λ-എക്സ്പ്രഷൻ്റെ ആരംഭം എന്നാണ് അർത്ഥമാക്കുന്നത്, തുടർന്ന് പരാമീറ്ററുകൾ (x y) ലിസ്റ്റ് ചെയ്തിരിക്കുന്നു, അമ്പടയാളത്തിന് ശേഷം (->) ഒരു എക്സ്പ്രഷൻ ഉണ്ട്.
പേരില്ലാത്ത ഫംഗ്ഷനുകൾ നിർവചിക്കാൻ λ-കാൽക്കുലസ് ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്, കൂട്ടിച്ചേർക്കൽ ഫംഗ്ഷൻ പ്രത്യേകം വിവരിക്കാതെ നിങ്ങൾക്ക് ഉപയോഗിക്കാം:
ഈ പദപ്രയോഗം ഒരു പ്രവർത്തനമാണ്. അതിനാൽ, അതിൽ പരാമീറ്ററുകൾ പ്രയോഗിക്കുന്നതിലൂടെ, നമുക്ക് ഫലം ലഭിക്കും.
(\x y -> x+y) 3 6
ഫലം നമ്പർ 9 ആയിരിക്കും.
പേരിടാത്ത ഫംഗ്ഷനുകൾ ഉപയോഗപ്രദമാണ്, ഉദാഹരണത്തിന്, ഫംഗ്ഷനുകൾ മറ്റ് ഫംഗ്ഷനുകളിലേക്ക് പാരാമീറ്ററുകളായി കൈമാറുമ്പോൾ, അതിനനുസരിച്ച് ഫംഗ്ഷൻ ഫോർമാറ്റ് ചെയ്യേണ്ട ആവശ്യമില്ലാത്തപ്പോൾ.
മൂല്യം കണക്കാക്കുമ്പോൾ ഏതെങ്കിലും ഫംഗ്ഷൻ പാരാമീറ്റർ ഉപയോഗിക്കുന്നില്ലെങ്കിൽ, അതിൻ്റെ പേര് ഒഴിവാക്കാം, പകരം "_" എന്ന ചിഹ്നം നൽകാം. ഉദാഹരണത്തിന്, രണ്ട് പാരാമീറ്ററുകളിൽ ആദ്യത്തേത് നൽകുന്ന ഒരു ഫംഗ്ഷൻ ഇതുപോലെയായിരിക്കാം:
അല്ലെങ്കിൽ, സാധാരണ നൊട്ടേഷനിൽ:
firstoftwox_=x
5.10 അനന്തമായ ഡാറ്റ ഘടനകൾ
ഹാസ്കെൽ ഒരു നോൺ-സ്ട്രിക്റ്റ് ഭാഷയാണ്, അതായത്, അത് അലസമായ കണക്കുകൂട്ടലുകൾ ഉപയോഗിക്കുന്നു. മുകളിൽ സൂചിപ്പിച്ചതുപോലെ, ഫംഗ്ഷൻ്റെ ഫലം കണക്കാക്കാൻ ആവശ്യമായ പദപ്രയോഗങ്ങൾ മാത്രമേ വിലയിരുത്തപ്പെടുകയുള്ളൂ എന്നാണ് ഇതിനർത്ഥം. സ്വയം നിർവചിച്ചിരിക്കുന്ന ഒരു ഫംഗ്ഷൻ പരിഗണിക്കുക:
വ്യക്തമായും, അതിൻ്റെ മൂല്യം കണക്കാക്കാൻ കഴിയില്ല. നിങ്ങൾ ഇത് ചെയ്യാൻ ശ്രമിക്കുകയാണെങ്കിൽ, ഒരു ലൂപ്പ് സംഭവിക്കും. നമുക്ക് മറ്റൊരു ഫംഗ്ഷൻ നോക്കാം:
അതിൻ്റെ മൂല്യം x എന്ന പരാമീറ്ററിനെ ആശ്രയിക്കുന്നില്ല. അതിനാൽ അത് കണക്കാക്കേണ്ട ആവശ്യമില്ല. ഒപ്പം ആവിഷ്കാര വിലയിരുത്തലും
ഒരു ലൂപ്പിലേക്ക് നയിക്കില്ല കൂടാതെ 1 ന് തുല്യമായ ഫലം നൽകും.
അത്തരം അലസമായ വിലയിരുത്തൽ അനന്തമായ ലിസ്റ്റുകൾ പോലെയുള്ള അനന്തമായ ഡാറ്റ ഘടനകൾ സംഘടിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഏറ്റവും കൂടുതൽ ഒന്ന് ലളിതമായ വഴികൾഅനന്തമായ ലിസ്റ്റ് ടാസ്‌ക്കുകൾ ഒരു ജോലിയാണ് ഗണിത പുരോഗതികൾ. ഇത് ചെയ്യുന്നതിന്, ഇടവേളയുടെ അവസാനം നിങ്ങൾ വ്യക്തമാക്കേണ്ടതില്ല. ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന ലിസ്റ്റുകൾ അനന്തമാണ്:
പുരോഗമന ഘട്ടം കണക്കാക്കുന്ന ആദ്യത്തെ രണ്ട് ഘടകങ്ങളാൽ മാത്രമേ അവ വ്യക്തമാക്കിയിട്ടുള്ളൂ. പുരോഗതിയുടെ രണ്ടാമത്തെ ഘടകം വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ (ആദ്യ ഉദാഹരണത്തിലെന്നപോലെ), ഘട്ടം 1 ആണെന്ന് അനുമാനിക്കാം.
ഈ ലിസ്റ്റുകൾ ഉപയോഗിച്ച്, ഫലം കണക്കാക്കാൻ ലിസ്റ്റിലെ എല്ലാ ഘടകങ്ങളും ആവശ്യമില്ലാത്ത സാധാരണ ലിസ്റ്റുകൾക്ക് സമാനമായ പ്രവർത്തനങ്ങൾ നടത്താനും അതേ പ്രവർത്തനങ്ങൾ ഉപയോഗിക്കാനും സാധിക്കും. അത്തരം ഫംഗ്ഷനുകളിൽ തലയും വാലും എടുക്കൽ, ഒരു ലിസ്റ്റിൻ്റെ i-th എലമെൻ്റ് ലഭിക്കുന്നതിനുള്ള ഫംഗ്ഷനുകൾ തുടങ്ങിയവ ഉൾപ്പെടുന്നു.
ചില പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിന് അനന്തമായ ലിസ്റ്റുകൾ ഉപയോഗപ്രദമാണ്. ഉദാഹരണത്തിന്, ഫാക്‌ടോറിയൽ കണക്കുകൂട്ടൽ ഇനിപ്പറയുന്ന രീതിയിൽ നടപ്പിലാക്കാം:
വസ്തുത n = വസ്തുതാ പട്ടിക !! എൻ
വസ്തുതപട്ടിക = fl 1 1
എവിടെ fl x n = x:(fl (x*n) (n+1))
ഒരു സംഖ്യയുടെ ഫാക്‌ടോറിയൽ നിർണ്ണയിക്കുന്നതിനുള്ള ഫംഗ്ഷൻ n (fact n) ആയി നൽകുന്നു nth ഫലംഎല്ലാ സ്വാഭാവിക സംഖ്യകളുടേയും ഫാക്‌ടറിയലുകളുടെ അനന്തമായ പട്ടികയാണ് ഫാക്‌ട്‌ലിസ്റ്റിൻ്റെ ഘടകം. ഈ ലിസ്റ്റിലെ ഘടകങ്ങൾ മൂല്യനിർണ്ണയം ചെയ്യുകയും അവയുടെ മൂല്യങ്ങൾ ആവശ്യമുള്ളപ്പോൾ മാത്രം മെമ്മറി കൈവശപ്പെടുത്തുകയും ചെയ്യുന്നു.
ലിസ്റ്റുകൾ മാത്രമല്ല, പ്രോഗ്രാമർ നിർവചിച്ചിട്ടുള്ള മറ്റേതെങ്കിലും ഡാറ്റാ ഘടനകളും, ഉദാഹരണത്തിന് മരങ്ങൾ.
6 ഡാറ്റ തരങ്ങളും മൊഡ്യൂളുകളും
6.1 ഇഷ്‌ടാനുസൃത തരങ്ങളും ഡാറ്റ ഘടനകളും
ഫംഗ്ഷൻ തരങ്ങൾ വിവരിക്കുമ്പോൾ, നിങ്ങൾക്ക് ഇതിനകം ഇഷ്‌ടാനുസൃത പര്യായങ്ങൾ ആവശ്യമായി വന്നേക്കാം നിലവിലുള്ള തരങ്ങൾ. ഉദാഹരണത്തിന്, ഒരു പ്രത്യേക തരത്തിൻ്റെ നിർവചനം ബുദ്ധിമുട്ടുള്ളതാണെങ്കിൽ, അതിനെ ഒരു പേരിൽ വിളിക്കുന്നത് സൗകര്യപ്രദമാണ്. ഓരോ തവണയും [(പൂർണ്ണസംഖ്യ,) പോലെ എന്തെങ്കിലും എഴുതുന്നത് വളരെ നല്ലതല്ല; ഈ തരത്തിന് ഒരു പേര് നൽകുന്നത് കൂടുതൽ സൗകര്യപ്രദമാണ്, ഉദാഹരണത്തിന്, MyType1. ഈ നിർവചനം ഇതുപോലെ കാണപ്പെടുന്നു:
ടൈപ്പ് MyType1 = [(പൂർണ്ണസംഖ്യ,)]
ഈ തരത്തിലുള്ള നിർവചനം വിവരിക്കുന്നില്ല പുതിയ ഘടനഡാറ്റ, എന്നാൽ നിലവിലുള്ള തരങ്ങളുടെ സംയോജനത്തിൻ്റെ പേര് മാത്രം നൽകുന്നു.
നിങ്ങളുടെ സ്വന്തം ഡാറ്റ തരം നിർവചിക്കുന്നതിന്, ഇനിപ്പറയുന്ന നൊട്ടേഷൻ ഉപയോഗിക്കുക:
ഡാറ്റ<имя> = <значение1> | <значение2> | ... | <значениеN>
അങ്ങനെ, ഒരു ഡാറ്റ ഘടന വിളിക്കുന്നു<имя>, മൂല്യം 1, മൂല്യം 2, അങ്ങനെ N മൂല്യം വരെ എടുക്കാം. ഈ ഡാറ്റ തരം മൂല്യങ്ങൾ ഡാറ്റ കൺസ്ട്രക്റ്ററുകളാണ്. ഓരോ കൺസ്ട്രക്റ്റർക്കും ഒരു വലിയ അക്ഷരത്തിൽ തുടങ്ങുന്ന ഒരു തനതായ പേര് ഉണ്ടായിരിക്കണം. ഡാറ്റാ കൺസ്ട്രക്‌ടറിൻ്റെ പേരും ഡാറ്റാ തരത്തിൻ്റെ പേരിന് സമാനമാകാം. ഉദാഹരണത്തിന്, ഡാറ്റാ തരത്തിൻ്റെ വിവരണം “നിറം” ഇനിപ്പറയുന്ന രീതിയിൽ പ്രതിനിധീകരിക്കാം:
ഡാറ്റ നിറം = ചുവപ്പ് | പച്ച | നീല
കൂടാതെ, കൺസ്ട്രക്റ്റർക്ക് ചില ഡാറ്റ ഒരു ഫംഗ്‌ഷനായി സ്വീകരിക്കാൻ കഴിയും. ഉദാഹരണത്തിന്, ചുവപ്പ്, പച്ച, നീല എന്നിവയുടെ സംയോജനത്തിൽ ഒരു വർണ്ണ പ്രാതിനിധ്യം ചേർത്ത് നിങ്ങൾക്ക് കളർ ഡാറ്റ തരം വിപുലീകരിക്കാൻ കഴിയും:
ഡാറ്റ നിറം = ചുവപ്പ് | പച്ച | നീല | RGB ഡബിൾ ഡബിൾ ഡബിൾ
ഈ നൊട്ടേഷൻ അർത്ഥമാക്കുന്നത് വർണ്ണ തരം ഒബ്ജക്റ്റുകൾക്ക് ചുവപ്പ്, പച്ച, നീല അല്ലെങ്കിൽ RGB r g b മൂല്യങ്ങൾ എടുക്കാം, ഇവിടെ r g b - യഥാർത്ഥ സംഖ്യകൾ. ഉദാഹരണത്തിന്, മഞ്ഞ നിറം നൽകുന്ന ഒരു ഫംഗ്ഷൻ നിങ്ങൾക്ക് നിർവചിക്കാം:
ഫംഗ്ഷനുകൾ വ്യക്തമാക്കുന്നത് പോലെ, ഡാറ്റ തരങ്ങൾ വ്യക്തമാക്കുന്നത് പോളിമോർഫിക് ആകാം. അതായത്, നിങ്ങൾക്ക് മറ്റ് ചിലത് അടങ്ങിയിരിക്കുന്ന ഒരു ഡാറ്റ തരം വ്യക്തമാക്കാം, പക്ഷേ അല്ല നിർദ്ദിഷ്ട തരം. ഉദാഹരണത്തിന്, സ്റ്റാൻഡേർഡ് തരം ഒരുപക്ഷേ ഇനിപ്പറയുന്ന രീതിയിൽ വിവരിക്കാം:
ഡാറ്റ ഒരുപക്ഷേ a = ഒന്നുമില്ല | വെറും എ
ഇത് അർത്ഥമാക്കുന്നത് (ഒരുപക്ഷേ a) തരം ഒബ്‌ജക്റ്റിന് മൂല്യം ഒന്നും എടുക്കാം, അല്ലെങ്കിൽ ജസ്റ്റ് x, ഇവിടെ x എന്നത് ഏതെങ്കിലും തരത്തിലുള്ള ഒരു വസ്തുവാണ്. അത്തരം ഒബ്‌ജക്‌റ്റുകൾ ആക്സസ് ചെയ്യാൻ പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ ഉപയോഗിക്കുന്നു. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് അൺജസ്റ്റ് ഫംഗ്ഷൻ നടപ്പിലാക്കാൻ കഴിയും, അത് Nothing എന്നതിന് തുല്യമല്ലെങ്കിൽ Maybe കണ്ടെയ്നർ ക്ലാസിലെ ഉള്ളടക്കങ്ങൾ തിരികെ നൽകും.
അൺജസ്റ്റ് (വെറും എ) = എ
നമുക്ക് മറ്റൊരു ഉദാഹരണം നോക്കാം:
കണ്ടെത്തുക:: (Eq a) => a -> [a] -> ഒരുപക്ഷേ Int
കണ്ടെത്തുക_=ഒന്നുമില്ല
| x == a = വെറും 0
| അല്ലെങ്കിൽ = കേസ് (ഒരു xs കണ്ടെത്തുക).
(ഞാൻ മാത്രം) -> വെറും (i+1)
ഒന്നുമില്ല -> ഒന്നുമില്ല
ഈ ഫംഗ്ഷൻ രണ്ടാമത്തെ പാരാമീറ്ററായി പാസാക്കിയ ലിസ്റ്റിലെ ആദ്യ പാരാമീറ്ററായി പാസ്സാക്കിയ ഒബ്‌ജക്റ്റിൻ്റെ ആദ്യ സംഭവത്തിൻ്റെ സൂചിക നൽകുന്നു, അല്ലെങ്കിൽ അത് നഷ്‌ടമായാൽ ഒന്നുമില്ല. ഫംഗ്ഷൻ നിർവചനം ക്ലാസ് Eq ഉപയോഗിക്കുന്നു, ഇത് ഫംഗ്ഷൻ്റെ പാരാമീറ്ററുകളുടെ തരങ്ങളെ താരതമ്യപ്പെടുത്താവുന്ന തരങ്ങളിലേക്ക് പരിമിതപ്പെടുത്തുന്നു. ക്ലാസുകൾ അടുത്ത അധ്യായത്തിൽ ചർച്ച ചെയ്യും.
ഏത് ഡാറ്റാ ഘടനയെയും വിവരിക്കാൻ ഡാറ്റ കീവേഡ് ഉപയോഗിക്കാം. മറ്റൊരു ഉദാഹരണമായി ബൈനറി ട്രീയെ വിവരിക്കാം:
ഡാറ്റ ട്രീ a = Nil | നോഡ് എ (ട്രീ എ) (ട്രീ എ)
ഈ നിർവചനം പറയുന്നത്, ടൈപ്പ് എ മൂലകങ്ങളുള്ള ഒരു വൃക്ഷം ഒന്നുകിൽ ഒരു ശൂന്യമായ മരമാകാം അല്ലെങ്കിൽ ടൈപ്പ് എയുടെ ഒരു മൂലകവും അതുപോലെ തന്നെ നിർവചിച്ചിരിക്കുന്ന 2 മരങ്ങളും അടങ്ങിയിരിക്കാം.
ഒരു ബൈനറി സെർച്ച് ട്രീയിലേക്ക് ഒരു ഘടകം ചേർക്കുന്നതിൻ്റെ പ്രവർത്തനം നമുക്ക് വിവരിക്കാം.
addtotree Nil x = നോഡ് x Nil Nil
addtotree (നോഡ് y ഇടത് വലത്) x
|x |x>y = നോഡ് y ഇടത് (addtotree വലത് x) |അല്ലാതെ = നോഡ് y ഇടത് വലത് ഒരു ശൂന്യമായ ട്രീയിൽ ചേർക്കുമ്പോൾ, മൂലകം ചേർത്തിരിക്കുന്ന ഒരു നോഡുള്ള ഒരു വൃക്ഷമാണ് ഫലം. ട്രീ ശൂന്യമല്ലെങ്കിൽ, ട്രീയുടെ വേരിലുള്ള മൂലകവുമായി ചേർത്ത മൂലകത്തിൻ്റെ ബന്ധത്തെ ആശ്രയിച്ച്, തുടർന്നുള്ള കണക്കുകൂട്ടൽ തന്ത്രം തിരഞ്ഞെടുക്കുന്നു. ചേർക്കുന്ന ഘടകം ചെറുതാണെങ്കിൽ, അത് ഇടത് സബ്ട്രീയിലേക്ക് ചേർക്കണം, അതിനാൽ ഫലം ഒരേ കീയും വലത് സബ്ട്രീയും ഉള്ള ഒരു ട്രീ ആയിരിക്കും, എന്നാൽ പഴയതിലേക്ക് ഘടകം ചേർത്തുകൊണ്ട് ഒരു പുതിയ ഇടത് സബ്ട്രീ ലഭിക്കും. ചേർത്ത മൂലകം റൂട്ട് മൂലകത്തേക്കാൾ വലുതാണെങ്കിൽ, മാറ്റം വരുത്തിയ വലത് സബ്ട്രീ ഉള്ള ഒരു ട്രീ ആയിരിക്കും ഫലം. ചേർത്ത മൂലകം റൂട്ട് എലമെൻ്റുമായി പൊരുത്തപ്പെടുന്നെങ്കിൽ, ഫലം ഒരു ആർഗ്യുമെൻ്റായി പാസ്സാക്കിയ ട്രീയുമായി പൊരുത്തപ്പെടും. ട്രീയെ (വൃക്ഷത്തെ) ഒരു സ്ട്രിംഗാക്കി മാറ്റുന്നതിനുള്ള ഒരു ഫംഗ്ഷൻ നിർവചിച്ച് ലെഡ്ജുകളുള്ള ഒരു രൂപത്തിൽ ഞങ്ങൾ സ്ക്രീനിൽ ട്രീയുടെ ഡിസ്‌പ്ലേ ഓർഗനൈസ് ചെയ്യുന്നു. showtree tree = showtr tree 0 എവിടെ showtr (Nil) n = പകർപ്പ് n "\t" ++ "-\n" showtr (നോഡ് x ഇടത് വലത്) n = ഷോറ്റർ വലത് (n+1) ++ replicate n "\t" ++ കാണിക്കുക x ++ "\n" ++ ഷോറ്റർ ഇടത് (n+1) പ്രാദേശിക ഫംഗ്ഷൻ showtr രണ്ട് ആർഗ്യുമെൻ്റുകൾ എടുക്കുന്നു - വൃക്ഷവും ആഴവും നില. ഉപയോഗിച്ചിരിക്കുന്ന ഷോ ഫംഗ്ഷൻ, ഹാസ്കെല്ലിലെ മിക്കവാറും എല്ലാ ഒബ്ജക്റ്റിനെയും സ്ട്രിംഗ് രൂപത്തിലേക്ക് പരിവർത്തനം ചെയ്യുന്നതിനുള്ള ഒരു സ്റ്റാൻഡേർഡ് ഫംഗ്‌ഷനാണ്. ഇപ്പോൾ, എക്സ്പ്രഷൻ കണക്കാക്കുന്നതിൻ്റെ ഫലമായി addtotree (addtotree (addtotree (addtotree (addtotree (addtotree (addtotree Nil അതായത് 5, 3, 8, 1, 4, 6, 9 എന്നീ പൂർണ്ണസംഖ്യകൾ തുടർച്ചയായി ട്രീയിൽ ചേർക്കുമ്പോൾ, നമുക്ക് ട്രീ തരത്തിലുള്ള ചില ഒബ്ജക്റ്റ് ലഭിക്കും. ഇത് ഞങ്ങളുടെ ഷോട്രീ ഫംഗ്ഷനിലേക്ക് കൈമാറുന്നതിലൂടെ, ഈ ട്രീയുടെ ഒരു സ്ട്രിംഗ് പ്രാതിനിധ്യം നമുക്ക് ലഭിക്കും. ഉപയോക്തൃ ഡാറ്റ നിർവചിക്കാൻ മറ്റൊരു വഴിയുണ്ട് - കീവേഡ്പുതിയ തരം. ഇതിൻ്റെ ഉപയോഗം ഏതാണ്ട് ഡാറ്റയ്ക്ക് സമാനമാണ്, ഒരു അപവാദം: ന്യൂടൈപ്പിൽ വിവരിച്ചിരിക്കുന്ന ഡാറ്റ തരങ്ങൾക്ക് കൃത്യമായി ഒരു ഫീൽഡ് ഉള്ള ഒരു ഡാറ്റ കൺസ്ട്രക്റ്റർ മാത്രമേയുള്ളൂ. നിലവിലുള്ള ഒന്നിനെ അടിസ്ഥാനമാക്കി ഒരു പുതിയ ഡാറ്റ തരം സൃഷ്ടിക്കാൻ ഈ രീതി ഉപയോഗിക്കുന്നു: പുതിയ തരം MyInt = MyInt Int കൂടാതെ, പേരുള്ള ഫീൽഡുകളുള്ള റെക്കോർഡുകൾ പോലുള്ള ഡാറ്റാ ഘടനകളെ നിർവചിക്കാൻ കഴിയും. ഒബ്‌ജക്‌റ്റുകൾ ഉപയോഗിക്കുമ്പോൾ സാധാരണ ട്യൂപ്പിളുകളോ ഡാറ്റാ ഘടനകളോ ഉപയോഗിക്കുന്നു വലിയ തുകവ്യത്യസ്ത ഗുണങ്ങൾ എല്ലായ്പ്പോഴും സൗകര്യപ്രദമല്ല. അവ ദൃശ്യമാകുന്ന ക്രമം നിങ്ങൾ ഓർക്കണം, അതിലൂടെ മാത്രം നാവിഗേറ്റ് ചെയ്യുക, അല്ലെങ്കിൽ ഓരോ പ്രോപ്പർട്ടിക്കും അനുയോജ്യമായ ഒരു ഫംഗ്ഷൻ സൃഷ്ടിക്കുക. പേരുനൽകിയ ഫീൽഡുകളുള്ള ഒരു റെക്കോർഡ് ഈ പ്രക്രിയ ഓട്ടോമേറ്റ് ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു, കൂടാതെ പേരുകളിലൂടെ അതിൻ്റെ ഘടകങ്ങളിലേക്ക് പ്രവേശനം നൽകുന്നു, ഇത് ജോലിയെ വളരെയധികം ലളിതമാക്കുന്നു. അവ ഇനിപ്പറയുന്ന രീതിയിൽ വിവരിച്ചിരിക്കുന്നു: <имя записи> { <имя поля 1> :: <тип поля 1>, <имя поля 2> :: <тип поля 2>, <имя поля N> :: <тип поля N>} ഉദാഹരണത്തിന്: ഡാറ്റ മനുഷ്യൻ = മനുഷ്യൻ ( ഉയരം::ഇരട്ട, ഒരു വസ്തുവിനെ വ്യക്തമാക്കാൻ ഈ തരത്തിലുള്ളഎഴുതാം: മൈക്ക് = മനുഷ്യൻ (പേര് = "മൈക്ക്", ഉയരം = 173.4, ഭാരം = 81.3) അത്തരമൊരു ഒബ്ജക്റ്റ് മാറ്റുന്നതിന്, അല്ലെങ്കിൽ പുതിയൊരെണ്ണം നേടുന്നതിന്, എന്നാൽ ചില ഫീൽഡുകൾ മാറിയതിനാൽ, നിങ്ങൾക്ക് ഇതുപോലെ എഴുതാം: ജോൺ = മൈക്ക് (പേര് = "ജോൺ") ഹാസ്കെൽ പിന്തുണയ്ക്കുന്നു മോഡുലാർ പ്രോഗ്രാമിംഗ്, അതായത്, ഒരു പ്രോഗ്രാമിനെ മൊഡ്യൂളുകളായി വിഭജിക്കാം, കൂടാതെ ഓരോ മൊഡ്യൂളും നിരവധി പ്രോഗ്രാമുകളിൽ ഉപയോഗിക്കാം. ഓരോ മൊഡ്യൂളും ഇതുപോലെ ആയിരിക്കണം: ഓപ്ഷണൽ ഭാഗം ഒഴിവാക്കിയാൽ, മറ്റ് മൊഡ്യൂളുകളിൽ നിന്ന് ഈ മൊഡ്യൂൾ ഉപയോഗിക്കാൻ കഴിയില്ല. ഡാറ്റാ തരങ്ങൾ പോലെ മൊഡ്യൂളിൻ്റെ പേരും ഒരു വലിയ അക്ഷരത്തിൽ ആരംഭിക്കുകയും ഫയലിൻ്റെ പേരുമായി പൊരുത്തപ്പെടുകയും വേണം. ബാഹ്യ മൊഡ്യൂളുകളിലെ നിർവചനങ്ങളിലേക്ക് (ഫംഗ്ഷനുകൾ, ഡാറ്റ തരങ്ങൾ, ക്ലാസുകൾ) പ്രവേശനം നേടുന്നതിന്, പ്രോഗ്രാമിൻ്റെ തുടക്കത്തിൽ തന്നെ നിങ്ങൾ അവ ഇനിപ്പറയുന്ന രീതിയിൽ വിവരിക്കണം: ഇറക്കുമതി<модуль1> ഇറക്കുമതി<модульN> <остальной код> ഇതിനുശേഷം, ഈ മൊഡ്യൂളുകളിൽ നിന്നുള്ള എല്ലാ നിർവചനങ്ങളും നിലവിലെ മൊഡ്യൂളിൽ ലഭ്യമാകും. എന്നാൽ നിലവിലെ മൊഡ്യൂൾ ഫംഗ്ഷനുകൾ അല്ലെങ്കിൽ ഇംപോർട്ട് ചെയ്യുന്ന അതേ പേരിലുള്ള ഡാറ്റാ തരങ്ങൾ നിർവചിക്കുന്നുവെങ്കിൽ, അല്ലെങ്കിൽ വ്യത്യസ്ത പ്ലഗ്-ഇൻ മൊഡ്യൂളുകളിൽ ഒരേ പേരിലുള്ള ഫംഗ്‌ഷനുകളോ ഡാറ്റാ തരങ്ങളോ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, ഒരു പിശക് സംഭവിക്കും. ഇത് ഒഴിവാക്കാൻ, അനുബന്ധ മൊഡ്യൂളുകളിൽ നിന്ന് അത്തരം നിർവചനങ്ങൾ ഉപയോഗിക്കുന്നത് നിരോധിക്കേണ്ടത് ആവശ്യമാണ്. ഇത് ഇനിപ്പറയുന്ന രീതിയിൽ ചെയ്യുന്നു: ഇറക്കുമതി<модуль>ഒളിഞ്ഞിരിക്കുന്നത് (<скрываемые определения>) കൂടാതെ, ഇറക്കുമതി ചെയ്ത മൊഡ്യൂൾ തന്നെ വിവരിക്കുമ്പോൾ, നിർവചനങ്ങളിലേക്കുള്ള ആക്സസ് നിയന്ത്രിക്കാൻ സാധിക്കും. ഇത് ചെയ്യുന്നതിന്, മൊഡ്യൂളിൻ്റെ പേരിന് ശേഷം പരാൻതീസിസിൽ ലഭ്യമായ നിർവചനങ്ങൾ നിങ്ങൾ പട്ടികപ്പെടുത്തേണ്ടതുണ്ട്: മൊഡ്യൂൾ<Имя>(<определения>) എവിടെ<код> എല്ലാ വിവരണങ്ങളുടെയും ബാഹ്യ മൊഡ്യൂളുകൾബ്രാക്കറ്റിൽ ലിസ്റ്റുചെയ്തിരിക്കുന്നവ മാത്രമേ ലഭ്യമാകൂ. ഉദാഹരണമായി, നമുക്ക് 3 മൊഡ്യൂളുകളുടെ ഒരു പ്രോഗ്രാം നൽകാം: --
പ്രോഗ്.
hs മൊഡ്യൂൾ പ്രോഗ് എവിടെ ഇറക്കുമതി Mod2 മറയ്ക്കൽ (modfun) മോഡ്യൂൾ Mod1(modfun) എവിടെ മോഡ്ഫൺ = അഞ്ച് * 2 മോഡ്യൂൾ Mod2 എവിടെ Mod1 മൊഡ്യൂളിൽ നിർവചിച്ചിരിക്കുന്ന modfun ഫംഗ്ഷൻ പ്രോഗ് മൊഡ്യൂളിൽ നിന്ന് ലഭ്യമാണ്, എന്നാൽ അഞ്ച് ഫംഗ്ഷൻ ലഭ്യമല്ല. ഹാസ്കെൽ ഒബ്ജക്റ്റ് ഓറിയൻ്റഡ് മാതൃകയെ പിന്തുണയ്ക്കുന്നു.എന്നാൽ ഇത് മറ്റ് ഭാഷകളിൽ സ്വീകരിക്കുന്ന പതിവിൽ നിന്ന് അൽപ്പം വ്യത്യസ്തമാണ്. ഒരു ക്ലാസിൻ്റെ ഒരു ഉദാഹരണം ഒരു ഡാറ്റാ ഘടനയാണ്. ഓരോ ക്ലാസിലും ഡാറ്റാ തരങ്ങളുമായി പ്രവർത്തിക്കുന്നതിനുള്ള ചില പ്രവർത്തനങ്ങളുടെ വിവരണം ഉൾപ്പെടുന്നു. ക്ലാസ്. ഒരു ക്ലാസ് നിർവചിക്കാൻ ഇനിപ്പറയുന്ന നൊട്ടേഷൻ ഉപയോഗിക്കുന്നു: ക്ലാസ് [(<ограничения>) =>] <имя> <переменная типов>എവിടെ<функции> ഒരു ടൈപ്പ് വേരിയബിൾ ഒരു തരത്തിന് പേരിടുന്നു, അത് ഈ ക്ലാസിൻ്റെ ഉദാഹരണമായിരിക്കണം. ഫംഗ്ഷനുകളുടെ തരങ്ങളെക്കുറിച്ചുള്ള വിവരണങ്ങളും അതുപോലെ തന്നെ ഈ ഫംഗ്ഷനുകളിൽ ചിലത് പരസ്പരം പ്രകടിപ്പിക്കുന്നതും ആയ വാക്കിന് ശേഷം. ഈ പദപ്രയോഗങ്ങൾ ഉപയോഗിച്ച്, മറ്റൊരു ഭാഗം നൽകിയാൽ, ഒരു ക്ലാസ് ഉദാഹരണത്തിൻ്റെ ഫംഗ്ഷനുകളുടെ ഒരു ഭാഗം നിർണ്ണയിക്കാൻ വ്യാഖ്യാതാവിന് തന്നെ കഴിയും. ഞങ്ങളുടെ ക്ലാസിലെ ഒരു ഉദാഹരണം ഇവിടെ ലിസ്റ്റ് ചെയ്‌തിരിക്കുന്ന ക്ലാസുകളുടെ ഒരു ഉദാഹരണമായിരിക്കണം എന്നതിൻ്റെ നിർവചനമാണ് നിയന്ത്രണങ്ങൾ. ഇത് ഒരുതരം അനന്തരാവകാശമാണ്. നമുക്ക് ഒരു ഉദാഹരണം നോക്കാം: ക്ലാസ് Eq എവിടെ (==), (/=) :: a -> a -> Bool x == y = അല്ല (x/=y) x /= y = അല്ല (x==y) ക്ലാസ് Eq എന്നത് താരതമ്യപ്പെടുത്താവുന്ന തരങ്ങളുടെ ഒരു ക്ലാസാണ്. ഈ വർഗ്ഗത്തിൻ്റെ ഓരോ ഉദാഹരണത്തിനും, സമത്വത്തിൻ്റെയും അസമത്വത്തിൻ്റെയും പ്രവർത്തനങ്ങൾ നിർവചിക്കേണ്ടതുണ്ട്. രണ്ടാമത്തെ വരി അർത്ഥമാക്കുന്നത് (==) ഉം (/=) ഫംഗ്ഷനുകളും ടൈപ്പ് എയുടെ രണ്ട് ആർഗ്യുമെൻ്റുകൾ എടുക്കുകയും ബൂൾ ടൈപ്പിൻ്റെ ഒരു ഒബ്ജക്റ്റ് നൽകുകയും വേണം, അതായത് ട്രൂ അല്ലെങ്കിൽ ഫാൾസ്. ക്ലാസ് നിർവചനത്തിലെ ഇനിപ്പറയുന്ന വരികൾ ഒരു ഫംഗ്ഷൻ (/=) നിർവചിച്ചാൽ, അതിലൂടെ ഫംഗ്ഷൻ (==) നിർവചിക്കപ്പെടുന്നു, തിരിച്ചും. ഇതിന് നന്ദി, പ്രോഗ്രാമർ സമത്വത്തിന് (അല്ലെങ്കിൽ അസമത്വത്തിന്) താരതമ്യ ഫംഗ്ഷൻ നിർവചിക്കേണ്ടതുണ്ട്, കൂടാതെ വ്യാഖ്യാതാവ് മറ്റ് ഫംഗ്ഷൻ തന്നെ നിർവചിക്കും. ഒരു ക്ലാസ് നിർവചനത്തിൻ്റെ മറ്റൊരു ഉദാഹരണം, എന്നാൽ അനന്തരാവകാശത്തോടെ: ക്ലാസ് Eq a => MyClass a where myFunc:: [a] -> a -> Int ഒരു ക്ലാസ് നിർവചിച്ചുകഴിഞ്ഞാൽ, ഏത് ഡാറ്റ തരവും ആ ക്ലാസിൻ്റെ ഉദാഹരണമായി നിങ്ങൾക്ക് പ്രഖ്യാപിക്കാം: ഉദാഹരണം MyClass Double എവിടെ |x==z = 1 + myFunc xs z |otherwise = myFunc xs z അതിനാൽ ഞങ്ങൾ സ്റ്റാൻഡേർഡ് ടൈപ്പ് ഡബിൾ എന്നത് ഞങ്ങളുടെ ക്ലാസ്സ് MyClass-ൻ്റെ ഒരു ഉദാഹരണമായി പ്രഖ്യാപിക്കുകയും ഫംഗ്ഷൻ്റെ രണ്ടാമത്തെ ആർഗ്യുമെൻ്റിന് തുല്യമായ ആദ്യ ആർഗ്യുമെൻ്റിലെ ഘടകങ്ങളുടെ എണ്ണം കണക്കാക്കുന്ന ഒരു ഫംഗ്‌ഷനായി myFunc ഫംഗ്ഷനെ നിർവചിക്കുകയും ചെയ്യുന്നു. ഒരു ക്ലാസിൻ്റെ ഉദാഹരണമായി ഒരു തരം നിർവചിക്കുന്നതിലൂടെ, ആ തരത്തിലുള്ള ഒബ്‌ജക്റ്റുകളിൽ അത് വിവരിക്കുന്ന പ്രവർത്തനങ്ങൾ നിങ്ങൾക്ക് പ്രയോഗിക്കാൻ കഴിയും. test = myFunc x 2 എവിടെ പോളിമോർഫിക് പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് ഫംഗ്ഷനുകൾ വിവരിക്കാൻ ക്ലാസുകൾ പലപ്പോഴും ഉപയോഗിക്കുന്നു. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് നിരവധി ഡാറ്റ തരങ്ങൾക്കായി ഒരു താരതമ്യ പ്രവർത്തനം ഉപയോഗിക്കുന്ന ഒരു ഫംഗ്ഷൻ വിവരിക്കണമെങ്കിൽ, താരതമ്യത്തിൽ പങ്കെടുക്കുന്ന അതിൻ്റെ പാരാമീറ്ററുകൾ ക്ലാസ് തരം Eq ആയിരിക്കണം, അത് അനുബന്ധ ഫംഗ്ഷൻ നടപ്പിലാക്കുന്നതിന് ഉറപ്പ് നൽകുന്നു. ഒരു പ്രോഗ്രാമർ തൻ്റെ ഡാറ്റാ ഘടന വിവരിക്കുമ്പോൾ, അത് ഒരു ക്ലാസിലും ഉൾപ്പെടുന്നില്ല. ആവശ്യമെങ്കിൽ, പ്രോഗ്രാമർ തൻ്റെ ഘടനയ്ക്ക് അനുയോജ്യമായ പ്രവർത്തനങ്ങൾ നടപ്പിലാക്കുകയും അതിൻ്റെ ക്ലാസ് അംഗത്വം സൂചിപ്പിക്കുകയും വേണം. ഉദാഹരണത്തിന്, മുമ്പ് വിവരിച്ച ട്രീ ഡാറ്റാ ഘടന ഷോ ക്ലാസിൻ്റെ ഒരു ഉദാഹരണമായി പ്രഖ്യാപിക്കാൻ കഴിയും, അതുവഴി ഷോട്രീ ഫംഗ്‌ഷനിലേക്കുള്ള ഒരു മാനുവൽ കോൾ അവലംബിക്കാതെ വ്യാഖ്യാതാവിന് അത് സ്ക്രീനിൽ പ്രദർശിപ്പിക്കാൻ കഴിയും. ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾ എഴുതുന്നു: ഉദാഹരണം കാണിക്കുക a => കാണിക്കുക (മരം a) എവിടെ ഇതിനുശേഷം, വ്യാഖ്യാതാവിന് ടൈപ്പ് ട്രീയുടെ ഫലം ലഭിക്കുമ്പോൾ, അത് സ്ക്രീനിൽ പ്രദർശിപ്പിക്കാൻ കഴിയും, കൂടാതെ മറ്റേതൊരു ഫംഗ്ഷനും ഷോ ഫംഗ്ഷൻ ഉപയോഗിച്ച് ടൈപ്പ് ട്രീയുടെ ഒരു വസ്തുവിനെ സ്ട്രിംഗ് രൂപത്തിലേക്ക് പരിവർത്തനം ചെയ്യാൻ കഴിയും. കൂടാതെ, ഒരു തരം ഒരു ക്ലാസിൽ പെട്ടതാണെന്ന് പ്രഖ്യാപിക്കാൻ മറ്റൊരു മാർഗമുണ്ട്. ഇത് ലളിതമാണ്, പക്ഷേ പ്രോഗ്രാമറുടെ ആവശ്യങ്ങൾ എല്ലായ്പ്പോഴും തൃപ്തിപ്പെടുത്താൻ കഴിയില്ല. ഘടന പ്രഖ്യാപിക്കുമ്പോൾ ആവശ്യമായ ക്ലാസുകൾ ഉടനടി ലിസ്റ്റുചെയ്യുന്നത് ഇതിൽ അടങ്ങിയിരിക്കുന്നു: ഡാറ്റ<имя> = <значение1> | <значение2> | ... | <значениеN>ഉരുത്തിരിഞ്ഞത് (<класс1>,<класс2>,...,<классM>) ഇവിടെ ആവശ്യമായ പ്രവർത്തനങ്ങൾസാധ്യമെങ്കിൽ സ്വയമേവ പ്രദർശിപ്പിക്കും. ഉദാഹരണത്തിന്, മരങ്ങൾ പരസ്പരം താരതമ്യപ്പെടുത്താവുന്ന തരത്തിൽ Eq ക്ലാസിൻ്റെ ഉദാഹരണങ്ങളിലേക്ക് നമ്മുടെ ട്രീ തരം നിർവചിക്കാം. ഡാറ്റ ട്രീ a = Nil | മരം a (മരം a) (മരം a) “==” ഓപ്പറേഷൻ ഉപയോഗിച്ച് മരങ്ങളെ താരതമ്യം ചെയ്യാൻ ഇപ്പോൾ സാധ്യമാണ്, അവ ആവശ്യമുള്ള ഫംഗ്ഷനുകളിൽ ഉപയോഗിക്കാൻ അനുവദിക്കുന്നു. ഒരുപക്ഷേ മൊണാഡുകളെക്കുറിച്ച് കൂടുതൽ എഴുതാം മുകളിൽ പ്രസ്താവിച്ചതുപോലെ, ഹാസ്കെൽ ഒരു ശുദ്ധമായ ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ് ഭാഷയാണ്, അതായത്, അതിലെ പ്രവർത്തനങ്ങൾക്ക് പാർശ്വഫലങ്ങൾ ഉണ്ടാകില്ല, കൂടാതെ ഫംഗ്ഷനുകൾ മൂല്യനിർണ്ണയം ചെയ്യുന്ന ക്രമം നിർവചിച്ചിട്ടില്ല. എന്നാൽ ചില സന്ദർഭങ്ങളിൽ ഇത് ഒഴിവാക്കാനാവില്ല. അത്തരം കേസുകളിൽ ഉപയോക്താവിനൊപ്പം പ്രവർത്തിക്കുക, ഫയലുകൾ, ഡാറ്റാബേസുകൾ തുടങ്ങിയവ ഉൾപ്പെടുന്നു. മൊണാഡുകൾ - പ്രത്യേക കണ്ടെയ്നർ ക്ലാസുകൾ ഉപയോഗിച്ച് അത്തരം പ്രവർത്തനങ്ങൾ വ്യക്തമാക്കുന്നതിന് ഹാസ്കെൽ ഭാഷ നൽകുന്നു. ഹാസ്കെൽ പഠിക്കുമ്പോൾ, മൊണാഡുകൾ ഏറ്റവും ബുദ്ധിമുട്ടുള്ള ഭാഗമായി കണക്കാക്കപ്പെടുന്നു, അതിനാൽ നമുക്ക് ഉദാഹരണങ്ങൾ ഉപയോഗിച്ച് ഉടൻ ആരംഭിക്കാം. വായനക്കാരനെ ആശയക്കുഴപ്പത്തിലാക്കാതിരിക്കാൻ ചില കാര്യങ്ങളുടെ വിശദീകരണങ്ങൾ ഒഴിവാക്കും. ഇനിപ്പറയുന്ന ഉദാഹരണം പരിഗണിക്കുക: putStrLn "ഹലോ വേൾഡ്!" putStrLn "ഗുഡ് ബൈ വേൾഡ്!" ഈ ഉദാഹരണത്തിൽ, പ്രധാന പ്രവർത്തനത്തിന് പാർശ്വഫലങ്ങൾ ഉണ്ട് - അതിൻ്റെ മൂല്യനിർണ്ണയത്തിൻ്റെ ഫലമായി, വാചകം സ്ക്രീനിൽ പ്രദർശിപ്പിക്കും, അത് മൂല്യനിർണ്ണയ ക്രമം നിർവചിക്കുന്നു - ആദ്യം ആദ്യ വരി സ്ക്രീനിൽ പ്രദർശിപ്പിക്കും, രണ്ടാമത്തേത്. ഡോ നൊട്ടേഷൻ ഉപയോഗിക്കുമ്പോൾ, മൊണാഡുകൾ ഉപയോഗിച്ച് "അശുദ്ധമായ" ഫംഗ്ഷനുകൾ പ്രോഗ്രാമിംഗ് ചെയ്യുന്നത് മിക്കവാറും പരിചിതമായ നിർബന്ധിത പ്രോഗ്രാമിംഗായി ചുരുക്കിയിരിക്കുന്നു. ഓരോ അടുത്ത വരിയും ഒരു പ്രത്യേക തരം ഫംഗ്ഷൻ ആയിരിക്കണം - ഒരു മൊണാഡിക് തരം. I/O ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്ന കാര്യത്തിൽ, ഇതാണ് തരം (IO a). കൂടെ പ്രവർത്തിക്കാൻ കമാൻഡ് ലൈൻഇനിപ്പറയുന്ന പ്രവർത്തനങ്ങൾ ഉപയോഗിക്കുന്നു: putChar::Char -> IOcharacter ഔട്ട്പുട്ട് putStr::String -> IOoutput സ്ട്രിംഗ് putStrLn::String -> IOoutput ഒരു പുതിയ വരിയുള്ള ഒരു സ്ട്രിംഗ് IO a എന്നത് ഒരു മൊണാഡിക് I/O തരമാണ്, അത് പാർശ്വഫലങ്ങളെ അതിൽ തന്നെ മറയ്ക്കുന്നു. IO സ്ട്രിംഗ് എന്ന തരം അർത്ഥമാക്കുന്നത് ഫംഗ്ഷൻ ഒരു സ്ട്രിംഗ് അടങ്ങിയ ഒരു ഫലം നൽകുന്നു എന്നാണ്, കൂടാതെ IO() എന്നാൽ ഫംഗ്ഷൻ ഒന്നും അടങ്ങിയ ഫലം നൽകില്ല എന്നാണ് അർത്ഥമാക്കുന്നത്, അതിനെ വിളിക്കുന്ന പോയിൻ്റ് പാർശ്വഫലങ്ങൾക്ക് മാത്രമാണ് (ഉദാഹരണത്തിന്, ഔട്ട്പുട്ട്). ഉദാഹരണം: putStrLn "നിങ്ങളുടെ പേരെന്താണ്?" പേര്<- getLine ഇവിടെയാണ് "വിനിയോഗം" വരുന്നത്. നിർബന്ധിത ഭാഷകളുമായുള്ള സാമ്യം ഉപയോഗിച്ച്, നമുക്ക് അത് ഒരു വരിയിൽ പറയാം പേര്<- getLine getLine ഫംഗ്ഷൻ്റെ ഫലം നെയിം വേരിയബിളിന് നൽകി. പക്ഷേ, നമുക്കറിയാവുന്നതുപോലെ, Haskell-ൽ വേരിയബിളുകളൊന്നുമില്ല, അതിനാൽ അസൈൻമെൻ്റുകളൊന്നുമില്ല. ഈ സാഹചര്യത്തിൽ, പേരുള്ള ചില ഒബ്‌ജക്‌റ്റുകൾ സൃഷ്ടിക്കപ്പെട്ടു, അതിൻ്റെ മൂല്യം getLine ഫംഗ്ഷൻ കണക്കാക്കുന്നതിൻ്റെ ഫലത്തിന് തുല്യമാണ്. അതായത്, അതിനുശേഷം ഇത് നിങ്ങൾ വീണ്ടും എഴുതുന്നു പേര്<- getLine അപ്പോൾ ഒരു പുതിയ ഒബ്ജക്റ്റ് സൃഷ്ടിക്കപ്പെടും, അതിൻ്റെ പേര് മുമ്പത്തേതിനെ ഓവർലാപ്പ് ചെയ്യും. മൊണാഡിക് ഫംഗ്ഷനുകളുടെ ഫലങ്ങൾ എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യുന്നത് ഇങ്ങനെയാണ്. സാധാരണ ഫംഗ്ഷനുകളുടെ മൂല്യങ്ങൾ ഉപയോഗിച്ച് “വേരിയബിളുകൾ” ഈ രീതിയിൽ നിർവചിക്കുന്നതിന്, ലളിതമായ ലെറ്റ് നൊട്ടേഷൻ ഉപയോഗിക്കുന്നു: പേര് = "ജോൺ" കംപ്യൂട്ടേഷണൽ പ്രക്രിയയുടെ ശാഖകൾ ഇതുതന്നെ ഉപയോഗിച്ചാണ് നടപ്പിലാക്കുന്നത്. putStrLn "നിങ്ങളുടെ പേരെന്താണ്?" പേര്<- getLine "GHC" -> putStrLn "ഇല്ല! ഞാൻ GHC ആണ്!" _ -> putStrLn("ഹായ്, "++പേര്++"!") ശാഖയിൽ നിരവധി ഫംഗ്ഷനുകൾ ഉണ്ടായിരിക്കണം എങ്കിൽ, do കീവേഡ് ഉപയോഗിക്കുന്നു: putStrLn "നിങ്ങളുടെ പേരെന്താണ്?" പേര്<- getLine putStrLn "ഇല്ല! ഞാൻ GHC ആണ്!" _ -> putStrLn("ഹായ്, "++പേര്++"!") മുകളിൽ കാണിച്ചിരിക്കുന്നതുപോലെ റിക്കർഷൻ ഉപയോഗിച്ചോ പ്രത്യേക ഫംഗ്ഷനുകൾ ഉപയോഗിച്ചോ ലൂപ്പുകൾ നടപ്പിലാക്കുന്നു (ആവർത്തനമായും നടപ്പിലാക്കുന്നു). ഈ ഫംഗ്ഷനുകളിൽ mapM_ ഫംഗ്ഷൻ ഉൾപ്പെടുന്നു. അതിൻ്റെ പ്രവർത്തനത്തിൻ്റെ തത്വം ലിസ്റ്റുകൾക്കായുള്ള മാപ്പ് പ്രവർത്തനത്തിന് സമാനമാണ് - ഇത് ലിസ്റ്റിലെ എല്ലാ ഘടകങ്ങളിലും ഒരു മൊണാഡിക് ഫംഗ്ഷൻ പ്രയോഗിക്കുകയും അവ തുടർച്ചയായി നടപ്പിലാക്കുകയും ചെയ്യുന്നു. ഉദാഹരണം: writeDigit x = do putStr "അക്കങ്ങൾ:" മാപ്പ്M_writeDigit വിവിധ ഉദാഹരണങ്ങൾ നൽകുക (തിരയൽ മരങ്ങൾ, AVL ട്രീ, മറ്റെന്തെങ്കിലും) ഉപസംഹാരം 1 http://ru. വിക്കിബുക്കുകൾ. org/wiki/ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗിൻ്റെ അടിസ്ഥാനങ്ങൾ 2 http://www. *****/ലേഖനം/funcprog/fp. xml 3 ഡഷ്കിൻ പ്രോഗ്രാമിംഗ് ഇൻ ഹാസ്കെൽ - ഡിഎംകെ പ്രസ്സ്, 2007 - 608 പേ. 4 http://en. വിക്കിബുക്കുകൾ. org/wiki/Haskell/Pattern_matching 5 http://www. ഹാസ്കെൽ. org/tutorial/ 20-ാം നൂറ്റാണ്ടിൻ്റെ 30-കളിൽ അലൻ ട്യൂറിംഗും ജോൺ വോൺ ന്യൂമാനും ചേർന്നാണ് നിർബന്ധിത പ്രോഗ്രാമിംഗിൻ്റെ സൈദ്ധാന്തിക അടിത്തറ സ്ഥാപിച്ചത്. 20-കളിലും 30-കളിലും ഫങ്ഷണൽ സമീപനത്തിൻ്റെ അടിസ്ഥാനമായ സിദ്ധാന്തം രൂപപ്പെട്ടു. ഫങ്ഷണൽ പ്രോഗ്രാമിംഗിൻ്റെ ഗണിതശാസ്ത്ര അടിത്തറയുടെ ഡെവലപ്പർമാരിൽ മോസസ് ഷോൺഫിങ്കൽ (ജർമ്മനി, റഷ്യ), ഹാസ്കെൽ കറി (ഇംഗ്ലണ്ട്), അലോൺസോ ചർച്ച് (യുഎസ്എ) എന്നിവരും ഉൾപ്പെടുന്നു. ഷോൺഫിങ്കലും കറിയും കോമ്പിനേറ്ററി ലോജിക്കിൻ്റെ അടിത്തറയിട്ടു, ലാംഡ കാൽക്കുലസിൻ്റെ സ്രഷ്ടാവാണ് ചർച്ച്. കോമ്പിനേറ്റോറിയൽ ലോജിക്, ലാംഡ കാൽക്കുലസ് എന്നിവയിൽ നിന്നുള്ള ആശയങ്ങളെ അടിസ്ഥാനമാക്കിയുള്ളതാണ് ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗ്. എന്നാൽ കഴിഞ്ഞ നൂറ്റാണ്ടിൻ്റെ 50-കളുടെ തുടക്കത്തിൽ ജോൺ മക്കാർത്തി ലിസ്പ് ഭാഷ (1958) വികസിപ്പിച്ചെടുക്കുന്നതുവരെ ഈ സിദ്ധാന്തം ഒരു സിദ്ധാന്തമായി തുടർന്നു, അത് ഏതാണ്ട് പ്രവർത്തനക്ഷമമായ ആദ്യത്തെ പ്രോഗ്രാമിംഗ് ഭാഷയായി. വർഷങ്ങളോളം, ലിസ്പിന് എതിരാളികളില്ല. പിന്നീട്, ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗ് ഭാഷകളായ APL (1964), ISWIM (1966), FP (1977) എന്നിവ പ്രത്യക്ഷപ്പെട്ടു, അവ അത്ര വ്യാപകമായി ഉപയോഗിച്ചിരുന്നില്ല. കാലക്രമേണ, സോഫ്റ്റ്വെയർ ഡെവലപ്പർമാരുടെ ചില ആവശ്യങ്ങൾ Lisp തൃപ്തിപ്പെടുത്തിയില്ല, പ്രത്യേകിച്ചും പ്രോഗ്രാം കോഡിൻ്റെ വോളിയവും സങ്കീർണ്ണതയും വർദ്ധിച്ചതിനാൽ. ഈ സാഹചര്യവുമായി ബന്ധപ്പെട്ട്, ടൈപ്പിഫിക്കേഷൻ കൂടുതൽ പ്രധാന പങ്ക് വഹിക്കാൻ തുടങ്ങി. 1970 കളുടെ അവസാനത്തിലും 1980 കളുടെ തുടക്കത്തിലും, പ്രവർത്തനപരമായ ഭാഷകൾക്ക് അനുയോജ്യമായ ടൈപ്പിംഗ് മോഡലുകൾ തീവ്രമായി വികസിപ്പിച്ചെടുത്തു. ഈ മോഡലുകളിൽ ഭൂരിഭാഗവും ഡാറ്റ അബ്‌സ്‌ട്രാക്ഷൻ, പോളിമോർഫിസം പോലുള്ള ശക്തമായ മെക്കാനിസങ്ങൾക്കുള്ള പിന്തുണ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. നിരവധി ടൈപ്പ് ചെയ്ത ഫംഗ്ഷണൽ ഭാഷകൾ പ്രത്യക്ഷപ്പെട്ടു: ML, സ്കീം, ഹോപ്പ്, മിറാൻഡ, ക്ലീൻ തുടങ്ങി നിരവധി. കൂടാതെ, പ്രാദേശിക ഭാഷകളുടെ എണ്ണം നിരന്തരം വർദ്ധിച്ചുകൊണ്ടിരിക്കുന്നു. ഫലത്തിൽ എല്ലാ ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ് ഗ്രൂപ്പുകളും സ്വന്തം ഭാഷ ഉപയോഗിച്ചു എന്നതായിരുന്നു ഫലം. ഇത് ഈ ഭാഷകളുടെ കൂടുതൽ വ്യാപനം തടയുകയും നിരവധി പ്രശ്നങ്ങൾക്ക് കാരണമാവുകയും ചെയ്തു. 1987 ലാണ് ഹാസ്കലിൻ്റെ ചരിത്രം ആരംഭിക്കുന്നത്. പുതിയ ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗ് ഭാഷകൾ ഒന്നിനുപുറകെ ഒന്നായി പ്രത്യക്ഷപ്പെട്ടു. മിറാൻഡയുടെ (റിസർച്ച് സോഫ്റ്റ്വെയർ ലിമിറ്റഡ്, 1985) പുറത്തിറങ്ങിയതിനുശേഷം, അലസമായ കമ്പ്യൂട്ടിംഗിലുള്ള താൽപ്പര്യം വർദ്ധിച്ചു: 1987 ആയപ്പോഴേക്കും, ഒരു ഡസനിലധികം അയഞ്ഞ, പൂർണ്ണമായും പ്രവർത്തനക്ഷമമായ പ്രോഗ്രാമിംഗ് ഭാഷകൾ ഉയർന്നുവന്നു. മിറാൻഡയാണ് ഏറ്റവും കൂടുതൽ ഉപയോഗിച്ചത്, എന്നാൽ അത് കുത്തക സോഫ്റ്റ്വെയർ ആയിരുന്നു. 1987-ൽ ഒറിഗോണിലെ പോർട്ട്‌ലാൻഡിൽ നടന്ന ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ് ലാംഗ്വേജുകളും കമ്പ്യൂട്ടർ ആർക്കിടെക്ചറും (എഫ്‌പിസിഎ) കോൺഫറൻസിൽ, അത്തരം ഭാഷകൾക്കായി ഒരു ഓപ്പൺ സ്റ്റാൻഡേർഡ് നിർവചിക്കുന്നതിന് ഒരു കമ്മിറ്റി രൂപീകരിക്കണമെന്ന് പങ്കാളികൾ സമ്മതിച്ചു. ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗ് ഭാഷകളുടെ വികസനത്തിൽ ഭാവിയിലെ ഗവേഷണത്തിന് അടിസ്ഥാനം നൽകുന്ന ഒരു പൊതു ഭാഷയിലേക്ക് നിലവിലുള്ള ഫംഗ്ഷണൽ ഭാഷകളെ സംയോജിപ്പിക്കുക എന്നതായിരുന്നു കമ്മിറ്റിയുടെ ലക്ഷ്യം. അങ്ങനെയാണ് ഹാസ്കെൽ ജനിച്ചത്. കോമ്പിനേറ്റോറിയൽ ലോജിക്കിൻ്റെ സ്ഥാപകരിലൊരാളായ ഹാസ്കെൽ കറിയുടെ പേരിലാണ് ഇതിന് പേര് ലഭിച്ചത്. 1980 കളുടെ അവസാനത്തോടെ, നിരവധി പ്രവർത്തന ഭാഷകൾ സൃഷ്ടിക്കപ്പെട്ടു. അവയിൽ ചിലത് ഹാസ്കലിൽ കാര്യമായ സ്വാധീനം ചെലുത്തി: പുതിയ ഭാഷ ഗവേഷണത്തിനും പ്രായോഗിക പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിനും അനുയോജ്യമായ ഒരു സ്വതന്ത്ര ഭാഷയായി മാറേണ്ടതായിരുന്നു. ഡവലപ്പർമാരുടെ ഒരു കമ്മിറ്റി രൂപപ്പെടുത്തിയ ഒരു മാനദണ്ഡത്തെ അടിസ്ഥാനമാക്കിയുള്ളതാണ് സ്വതന്ത്ര ഭാഷകൾ. അപ്പോൾ ആർക്കും സ്റ്റാൻഡേർഡ് നടപ്പിലാക്കാനും ഒരു ഭാഷാ കമ്പൈലർ എഴുതാനും കഴിയും. ഹാസ്കെൽ സ്റ്റാൻഡേർഡിൻ്റെ ആദ്യ പതിപ്പ് 1990 ഏപ്രിൽ 1 ന് പ്രസിദ്ധീകരിച്ചു. 1999 ഫെബ്രുവരിയിൽ, ഹാസ്കെൽ 98 ഭാഷാ നിലവാരം ആദ്യമായി "ദ ഹാസ്കെൽ 98 റിപ്പോർട്ട്" എന്ന പേരിൽ പ്രസിദ്ധീകരിച്ചു. 2003 ജനുവരിയിൽ, ഹാസ്കെൽ 98 ലാംഗ്വേജ് ആൻഡ് ലൈബ്രറികൾ: ദി റിവൈസ്ഡ് റിപ്പോർട്ട് എന്ന പേരിൽ ഒരു പരിഷ്കരിച്ച പതിപ്പ് പ്രസിദ്ധീകരിച്ചു. ഭാഷയുടെ യഥാർത്ഥ നിലവാരത്തെ പ്രതിനിധീകരിക്കുന്ന ഗ്ലാസ്‌ഗോ ഹാസ്കെൽ കംപൈലർ (ജിഎച്ച്‌സി) നടപ്പാക്കലിനൊപ്പം ഭാഷ അതിവേഗം വികസിച്ചുകൊണ്ടിരിക്കുകയാണ്. ഹാസ്കെൽ "98 മായി താരതമ്യപ്പെടുത്തുമ്പോൾ, അതിൽ ഇനിപ്പറയുന്ന മാറ്റങ്ങൾ അടങ്ങിയിരിക്കുന്നു: ചെയ്യുക, എങ്കിൽ വേറെ ഡാറ്റ തരം സന്ദർഭത്തിൻ്റെ അഭാവം ഹാസ്കെൽ ഇന്നും പരിണമിച്ചുകൊണ്ടിരിക്കുകയാണ്. എന്നാൽ സ്ഥിരതയുള്ള പതിപ്പുകൾ യഥാക്രമം 1998, 2010 എന്നിവയുടെ മാനദണ്ഡങ്ങളെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്. എന്നാൽ അവ കൂടാതെ, ഹാസ്കെൽ നിരവധി വിപുലീകരണങ്ങൾ ഉൾക്കൊള്ളുന്നു, പുതിയ ആശയങ്ങൾ നിരന്തരം അവതരിപ്പിക്കപ്പെടുന്നു. ലോകമെമ്പാടുമുള്ള നിരവധി രാജ്യങ്ങൾ ഭാഷയിൽ പ്രവർത്തിക്കുന്നു - ഇംഗ്ലണ്ട്, നെതർലാൻഡ്‌സ്, അമേരിക്ക, ഓസ്‌ട്രേലിയ. മൾട്ടിപ്രൊസസർ സാങ്കേതികവിദ്യകളുടെ ജനപ്രീതിയാണ് ഹാസ്‌കെലിനോടുള്ള താൽപര്യം. ഹാസ്കെൽ മോഡൽ സമാന്തര കമ്പ്യൂട്ടിംഗിന് അനുയോജ്യമാണ്. കൂടാതെ, ശുദ്ധമായ പ്രോഗ്രാമിംഗ് ഭാഷകളുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ കറി ഭാഷ അധിക സംവിധാനങ്ങൾ നൽകുന്നു (ഫംഗ്ഷണൽ ഭാഷകളുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ - അപൂർണ്ണമായ ഡാറ്റയിൽ തിരയലും കമ്പ്യൂട്ടിംഗും, ലോജിക്കൽ ഭാഷകളുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ - ഡിറ്റർമിനിസം കാരണം കൂടുതൽ കാര്യക്ഷമമായ കണക്കുകൂട്ടൽ സംവിധാനം, ആവശ്യാനുസരണം കോളിംഗ് ഫംഗ്ഷനുകൾ. ). പേൾ 6-നുള്ള പഗ്സ് ഇൻ്റർപ്രെറ്റർ/കംപൈലർ. ലാവ ഹാർഡ്‌വെയർ വിവരണ ഭാഷ. സ്വാഭാവിക ഭാഷാ സംസ്കരണ സംവിധാനം ലോലിറ്റ. സിദ്ധാന്തം തെളിയിക്കുന്ന സംവിധാനങ്ങൾ Equinox/Paradox, Agda. ചെറുപ്പവും പരീക്ഷണാത്മക നിലയും താരതമ്യേന കുറഞ്ഞ ജനപ്രീതിയും ഉണ്ടായിരുന്നിട്ടും, ഒരു പ്രധാന മൊഡ്യൂൾ സൃഷ്ടിക്കാൻ Facebook Haskell തിരഞ്ഞെടുത്തു. പുതിയ ആൻ്റി-സ്പാം ഫിൽട്ടർ വികസിപ്പിക്കുന്ന ടീമിൻ്റെ ഭാഗമായ എഞ്ചിനീയർമാരിൽ ഒരാളായ ലൂയിസ് ബ്രാണ്ടി തൻ്റെ സഹപ്രവർത്തകർക്കൊപ്പം ഈ പ്രോജക്റ്റിനായി രണ്ട് വർഷം ചെലവഴിച്ചു. വയർഡുമായുള്ള അഭിമുഖത്തിൽ, എന്താണ് അവരെ പ്രേരിപ്പിച്ചതെന്ന് അദ്ദേഹം വിശദീകരിച്ചു. ലൂയിസ് ബ്രാണ്ടി, തൻ്റെ വാക്കുകൾ ശ്രദ്ധാപൂർവ്വം തിരഞ്ഞെടുത്ത്, Facebook-ൻ്റെ സ്പാം ഫിൽട്ടർ നടപ്പിലാക്കുന്നതിന് Haskell അനുയോജ്യമെന്ന് വിളിക്കുന്നു, കാരണം അത് സമാന്തര ടാസ്‌ക്കുകൾ നന്നായി കൈകാര്യം ചെയ്യുകയും ഡെവലപ്പർമാരെ ഈ ടാസ്‌ക്കുകൾ എളുപ്പത്തിൽ സജ്ജീകരിക്കാൻ അനുവദിക്കുകയും ചെയ്യുന്നു. Facebook ഒരു വലിയ പദ്ധതിയാണ്, സ്പാമർമാർ വളരെ വേഗത്തിൽ തന്ത്രങ്ങൾ മാറ്റുന്നു, അത് ഉടനടി പ്രാബല്യത്തിൽ വരുന്ന സ്പാം ഫിൽട്ടറുകൾ വികസിപ്പിക്കുന്നതിനും തുടർച്ചയായി പരിഷ്കരിക്കുന്നതിനും ഒരു ഉപകരണം ആവശ്യമാണ്. ആധുനിക ഇൻറർനെറ്റിൻ്റെ വികസനം നിങ്ങൾ നോക്കുകയാണെങ്കിൽ, സ്കേലബിളിറ്റിയും തത്സമയ പ്രതികരണവും പ്രധാനമായ നിരവധി ഇൻ്റർനെറ്റ് പ്രോജക്ടുകൾ ഈ പാത പിന്തുടരേണ്ടതാണ്. ഫേസ്ബുക്ക് ഡെവലപ്പർമാരുടെ അഭിപ്രായത്തിൽ, ഹാസ്കെൽ ഭാഷയ്ക്ക് വ്യാപകമായി പ്രചാരം നേടാനുള്ള എല്ലാ സാധ്യതകളും ഉണ്ട്. ഹാസ്കെൽ മറ്റ് ഭാഷകളിൽ നിന്ന് തികച്ചും വ്യത്യസ്തമാണ് എന്നതാണ് ഒരേയൊരു തടസ്സം - ഇത് അതിലേക്കുള്ള കൂട്ട കുടിയേറ്റം ബുദ്ധിമുട്ടാക്കുന്നു. എന്നിരുന്നാലും, വ്യവസായം തീർച്ചയായും ശരിയായ ദിശയിലാണ് നീങ്ങുന്നത്, ഗൂഗിളിൻ്റെ ഗോ, മോസില്ലയുടെ റസ്റ്റ് പോലുള്ള പുതിയ സമാന്തര പ്രോഗ്രാമിംഗ് ഭാഷകൾ തെളിയിക്കുന്നു. അവർ ഹാസ്കെലിനെപ്പോലെ കാര്യക്ഷമമായിരിക്കില്ല, പക്ഷേ അവ പഠിക്കാൻ എളുപ്പമാണ്. ഏത് സാഹചര്യത്തിലും, മറ്റ് പ്രോഗ്രാമിംഗ് ഭാഷകളുടെ വികസനം പ്രോത്സാഹിപ്പിക്കുന്നതിനും പുതിയ വാഗ്ദാന പ്രോജക്റ്റുകൾ സമാരംഭിക്കുന്നതിന് സംഭാവന നൽകിയതിനും ഹാസ്കലിന് നന്ദി പറയാം. രണ്ടാമതായി, പ്രൊഡക്റ്റീവ് കോഡ് എഴുതുന്നത് ബുദ്ധിമുട്ടാണ്. ഹാസ്കെല്ലിലെ എല്ലാ കോഡുകളും അലസമായതിനാൽ, ജിഗാബൈറ്റ് ശേഷിക്കുന്ന കണക്കുകൂട്ടലുകൾ മെമ്മറിയിൽ അടിഞ്ഞുകൂടിയ സാഹചര്യത്തിൽ നിങ്ങൾക്ക് എളുപ്പത്തിൽ എത്തിച്ചേരാനാകും, എന്നാൽ അവ ഇതുവരെ അഭ്യർത്ഥിച്ചിട്ടില്ലാത്തതിനാൽ അവ കണക്കാക്കില്ല. കോഡ് എഴുതിക്കഴിഞ്ഞാൽ, രണ്ട് തരത്തിൽ വ്യാഖ്യാനിക്കാൻ പ്രയാസമാണ്. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് ഒരു ഫംഗ്ഷൻ റഫറൻസുമായി ഒരു ഫംഗ്ഷൻ ആപ്ലിക്കേഷനെ ആശയക്കുഴപ്പത്തിലാക്കാൻ കഴിയില്ല, സ്‌കാലയിലെ പോലെ, ഫംഗ്ഷനുകൾ ഹാസ്കെല്ലിലെ ഫസ്റ്റ്-ക്ലാസ് ഒബ്‌ജക്റ്റുകളാണ്. അല്ലെങ്കിൽ, ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് ഒരു ഫംഗ്ഷനെ ഒരു തരം അല്ലെങ്കിൽ ക്ലാസുമായി ആശയക്കുഴപ്പത്തിലാക്കാൻ കഴിയില്ല, കാരണം എല്ലാ ഫംഗ്ഷനുകളും ഒരു ചെറിയ അക്ഷരത്തിൽ ആരംഭിക്കണം, കൂടാതെ തരങ്ങൾ/ക്ലാസുകൾ ഒരു വലിയ അക്ഷരത്തിൽ ആരംഭിക്കണം. ഒരു ഭാഷാ സ്വത്ത് ഇല്ലെങ്കിൽ ഹാസ്കലിനെ കുറിച്ച് സംസാരിക്കുന്നത് അർത്ഥശൂന്യമാകും, പോളിമോർഫിസം. പരമാവധി പുനരുപയോഗിച്ച കോഡ് ഉള്ള ഭാഷയാണ് ഹാസ്കെൽ എന്ന് ഞാൻ പറഞ്ഞാൽ അത് അതിശയോക്തിയാകില്ല. അൽപ്പം പോലും ആവർത്തിക്കുന്ന ഏതൊരു പ്രവർത്തനവും അമൂർത്തതയിലേക്ക് മാറ്റുന്നു. ഇത് നിങ്ങളുടെ വലിയ മാനദണ്ഡങ്ങളിലൊന്ന് (സ്റ്റാറ്റിക്* ഇൻപുട്ട്) പാലിക്കുന്നില്ലെങ്കിലും, ഞാൻ പൈത്തണിൻ്റെ കേസ് ഉണ്ടാക്കാൻ പോകുന്നു. നിങ്ങൾ അത് പരിശോധിക്കണമെന്ന് ഞാൻ കരുതുന്ന ചില കാരണങ്ങൾ ഇതാ: നിങ്ങൾ മറ്റെന്തെങ്കിലും അന്വേഷിക്കുകയാണെങ്കിൽ ഞാൻ മനസ്സിലാക്കുന്നു. ലോജിക് പ്രോഗ്രാമിംഗ്, ഉദാഹരണത്തിന്, മറ്റുള്ളവരെപ്പോലെ നിങ്ങളുടെ ഇടവഴിയിൽ ശരിയായിരിക്കാം. *നിങ്ങൾക്ക് തരങ്ങൾ പ്രഖ്യാപിക്കാൻ താൽപ്പര്യമുള്ളതിനാൽ നിങ്ങൾ ഇവിടെ സ്റ്റാറ്റിക് ടൈപ്പിംഗ് ആണ് ഉദ്ദേശിക്കുന്നതെന്ന് ഞാൻ അനുമാനിക്കുന്നു. സാങ്കേതികമായി, പൈത്തൺ -
ഇത് ശക്തമായി ടൈപ്പ് ചെയ്ത ഭാഷയാണ്, കാരണം നിങ്ങൾക്ക് ഒരു സ്ട്രിംഗിനെ ഒരു സംഖ്യയായി ഏകപക്ഷീയമായി വ്യാഖ്യാനിക്കാൻ കഴിയില്ല. രസകരമെന്നു പറയട്ടെ, ബൂ പോലെയുള്ള സ്റ്റാറ്റിക് ടൈപ്പിംഗ് അനുവദിക്കുന്ന പൈത്തൺ ഡെറിവേറ്റീവുകൾ ഉണ്ട്. 2018-12-04T00:00Z നിങ്ങൾക്ക് ശക്തമായ (എർ) വ്യക്തിഗത ആമുഖം വേണമെങ്കിൽ, ബുധൻ രസകരമായ ഒരു തിരഞ്ഞെടുപ്പാണ്. ഞാൻ ഇത് മുമ്പ് ചെയ്തിട്ടുണ്ട്, അത് എനിക്ക് നൽകിയ വ്യത്യസ്ത വീക്ഷണം ഇഷ്ടപ്പെട്ടു. ടൈപ്പ് സിസ്റ്റത്തിൽ മോഡഡ്-നെസ് (ഏത് പരാമീറ്ററുകൾ ഫ്രീ/ഫിക്സ്ഡ് ആയിരിക്കണം) ഡിറ്റർമിനിസം (എത്ര ഫലങ്ങളുണ്ട്?) എന്നിവയും ഇതിന് ഉണ്ട്. ക്ലീൻ ഹാസ്കെല്ലിനോട് വളരെ സാമ്യമുള്ളതാണ്, എന്നാൽ മൊണാഡുകൾക്ക് (കൂടുതൽ വ്യക്തമായി പറഞ്ഞാൽ, ഐഒ മൊണാഡ്) ബദലായി ഉപയോഗിക്കുന്ന ഒരു അതുല്യമായ ടൈപ്പിംഗ് ഉണ്ട്. ഇൻപുട്ടിൻ്റെ പ്രത്യേകത അറേകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നതും രസകരമാക്കുന്നു. 2018-12-11T00:00Z നിങ്ങളുടെ ആത്മനിഷ്ഠ താൽപ്പര്യങ്ങളല്ലാതെ പരിമിതികളൊന്നും നിങ്ങൾ വ്യക്തമാക്കിയിട്ടില്ലാത്തതിനാൽ, നിങ്ങൾ "പഠനത്തിൻ്റെ പ്രതിഫലം" (ശരി, ശരി, സ്റ്റാറ്റിക് ടൈപ്പിംഗ് പരിമിതി ഞാൻ അവഗണിക്കും) ഊന്നിപ്പറയുന്നതിനാൽ, വ്യത്യസ്ത മാതൃകകളുള്ള നിരവധി ഭാഷകൾ പഠിക്കാൻ ഞാൻ നിർദ്ദേശിക്കുന്നു. അവയിൽ ഓരോന്നിനും "മാതൃക" ആയിരിക്കുന്നതാണ് നല്ലത്. പ്രത്യേകിച്ച് ലിസ്‌പ്‌സും (സിഎൽ സ്കീമിൻ്റെ അത്രയും അല്ല) പ്രോലോഗും (ഹാസ്‌കെല്ലും) കവർ റിക്കർഷനും. ഈ ഭാഷകളിലൊന്നും ഞാൻ ഗുരു അല്ലെങ്കിലും, എർലാംഗും ഫോർത്തും ഒഴികെ ഓരോരുത്തർക്കും ഒപ്പം ഞാൻ കുറച്ച് സമയം ചിലവഴിച്ചു, ഓരോരുത്തർക്കും ഓരോ കോണിൽ നിന്ന് പ്രശ്‌നങ്ങളെ സമീപിക്കുമ്പോൾ അവരെല്ലാം എനിക്ക് കണ്ണ് തുറപ്പിക്കുന്നതും രസകരവുമായ പഠനാനുഭവങ്ങൾ നൽകി. . അതിനാൽ ഒന്നിലധികം ഭാഷകൾ പരീക്ഷിക്കാൻ സമയമില്ല എന്ന ഭാഗം ഞാൻ അവഗണിച്ചതായി തോന്നുമെങ്കിലും, അവയിലൊന്നിലും ചിലവഴിച്ച സമയം പാഴാകില്ലെന്ന് ഞാൻ കരുതുന്നു, നിങ്ങൾ അവയെല്ലാം നോക്കണം. 2018-12-18T00:00Z നിങ്ങളുടെ മേജറിന് അനുയോജ്യമായത് എന്താണെന്നതിൻ്റെ അടിസ്ഥാനത്തിൽ, വ്യക്തമായ ചോയ്‌സ് പ്രോലോഗ് അല്ലെങ്കിൽ അതിൻ്റെ ഡെറിവേറ്റീവുകൾ പോലെയുള്ള ഒരു ലോജിക്കൽ ഭാഷയാണെന്ന് തോന്നുന്നു. ഒരു ഫങ്ഷണൽ ഭാഷയിൽ ലോജിക് പ്രോഗ്രാമിംഗ് വളരെ ഭംഗിയായി ചെയ്യാൻ കഴിയും (ഉദാഹരണത്തിന്, ദി റീസൺഡ് സ്കീമർ കാണുക), എന്നാൽ നിങ്ങൾക്ക് ലോജിക് മാതൃകയിൽ നേരിട്ട് പ്രവർത്തിക്കാൻ ഇഷ്ടപ്പെട്ടേക്കാം. പന്ത്രണ്ട് അല്ലെങ്കിൽ കോക്ക് പോലെയുള്ള ഒരു സംവേദനാത്മക സൈദ്ധാന്തിക തെളിവ് സംവിധാനവും നിങ്ങളുടെ ഭാവനയെ ജ്വലിപ്പിച്ചേക്കാം. 2018-12-25T00:00Z പ്രോഗ്രാമിംഗിൽ എൻ്റെ അറിവ് വികസിപ്പിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. (...) ഞാൻ ഇവിടെ ഒരു ചോദ്യവും അതുപോലെ ഞാൻ തിരയുന്ന ഭാഷയെക്കുറിച്ചുള്ള കുറച്ച് പോയിൻ്റുകളും ഉന്നയിക്കുമെന്ന് ഞാൻ കരുതി. അവയിൽ ചിലത് ആത്മനിഷ്ഠമാണ്, അവയിൽ ചിലത് ഹാസ്കലിൽ നിന്നുള്ള മാറ്റം എളുപ്പമാക്കാൻ ഉദ്ദേശിച്ചുള്ളതാണ്. ശക്തമായ തരം സിസ്റ്റം. (...) ഇത് എൻ്റെ പ്രോഗ്രാമിൻ്റെ കൃത്യതയെക്കുറിച്ചുള്ള അനൗപചാരിക ന്യായവാദം എളുപ്പമാക്കുന്നു. കാര്യക്ഷമതയല്ല, കൃത്യതയെക്കുറിച്ചാണ് എനിക്ക് ആശങ്ക. ആവർത്തനത്തേക്കാൾ ആവർത്തനത്തിന് ഊന്നൽ നൽകുക. (...) നിങ്ങൾക്ക് ഇവിടെ മാറ്റം കുറച്ച് എളുപ്പമാക്കാൻ കഴിയുമെന്ന് ഞാൻ ഭയപ്പെടുന്നു. വളരെ കർശനമായ രീതിയിലുള്ള സംവിധാനവും പൂർണ്ണമായും പ്രവർത്തനക്ഷമമായ ശൈലിയും ഹാസ്കെലിനെ വിശേഷിപ്പിക്കുന്നു, കൂടാതെ മുഖ്യധാരാ പ്രോഗ്രാമിംഗ് ഭാഷയോട് സാമ്യമുള്ള ഏതൊരു കാര്യത്തിനും അവയിലൊന്നിലെങ്കിലും വിട്ടുവീഴ്ച ആവശ്യമായി വരും. അതിനാൽ, അത് മനസ്സിൽ വെച്ചുകൊണ്ട്, സംരക്ഷിക്കാൻ ലക്ഷ്യമിട്ടുള്ള ചില വിശാലമായ നിർദ്ദേശങ്ങൾ ഇതാ വലിയഹാസ്കെലിനെ കുറിച്ച് നിങ്ങൾ ഇഷ്ടപ്പെടുന്ന ചിലത്, എന്നാൽ ചില കാര്യമായ മാറ്റങ്ങളോടെ. പ്രായോഗികത അവഗണിച്ച് "ഹാസ്കെലിനേക്കാൾ കൂടുതൽ ഹാസ്കൽ" എന്നതിലേക്ക് പോകുക: ഒരു ഹാസ്കെൽ-ടൈപ്പ് സിസ്റ്റം ദ്വാരങ്ങൾ നിറഞ്ഞതാണ്, അവസാനിപ്പിക്കലും മറ്റ് കുഴപ്പങ്ങളുള്ള വിട്ടുവീഴ്ചകളും കാരണം. അലങ്കോലങ്ങൾ വൃത്തിയാക്കി കൂടുതൽ ശക്തമായ ഫീച്ചറുകൾ ചേർക്കുക, നിങ്ങൾക്ക് ഭാഷകൾ ലഭിക്കും കോക്ഒപ്പം അഗ്ദ, ഫംഗ്ഷൻ തരത്തിൽ അതിൻ്റെ കൃത്യതയുടെ തെളിവ് അടങ്ങിയിരിക്കുന്നു (നിങ്ങൾക്ക് അമ്പടയാളം പോലും വായിക്കാം -> ഫംഗ്ഷൻ ഒരു ലോജിക്കൽ ഇംപാക്‌ഷനായി!). ഈ ഭാഷകൾ ഗണിതശാസ്ത്ര തെളിവുകൾക്കും പ്രോഗ്രാമുകൾക്കും ഉപയോഗിച്ചിരുന്നു ഉയർന്ന ആവശ്യകതകൾകൃത്യതയിലേക്ക്. കോക്ക് ഒരുപക്ഷേ ഏറ്റവും കൂടുതൽ മികച്ച ഭാഷശൈലി, എന്നാൽ അഗ്‌ഡയ്ക്ക് കൂടുതൽ ഹാസ്കെൽ-വൈ ഫീൽ ഉണ്ട് (ഹാസ്‌കെല്ലിലും എഴുതിയിരിക്കുന്നു). തരങ്ങൾ പരിഗണിക്കരുത്, കൂടുതൽ മാജിക് ചേർക്കുക: ഹാസ്കെൽ മന്ത്രവാദം ആണെങ്കിൽ, ലിസ്പ്സൃഷ്ടിയുടെ അസംസ്കൃതവും പ്രാഥമികവുമായ മാന്ത്രികതയാണ്. ലിസ്പ് കുടുംബത്തിൻ്റെ ഭാഷകൾ (ഉൾപ്പെടെ സ്കീംഒപ്പം ക്ലോജർ) അങ്ങേയറ്റത്തെ മിനിമലിസത്തിനൊപ്പം ഏതാണ്ട് അഭൂതപൂർവമായ വഴക്കമുണ്ട്. ഭാഷകൾ അടിസ്ഥാനപരമായി വാക്യഘടന രഹിതമാണ്, ഒരു ട്രീ ഡാറ്റാ ഘടനയായി നേരിട്ട് കോഡ് എഴുതുന്നു; ചില ഭാഷകളിൽ മെറ്റാപ്രോഗ്രാമിംഗ് അല്ലാത്തതിനേക്കാൾ എളുപ്പമാണ് Lisp-ലെ മെറ്റാപ്രോഗ്രാമിംഗ്. അല്പം വിട്ടുവീഴ്ച ചെയ്ത് മുഖ്യധാരയിലേക്ക് അടുക്കുക: ഹാസ്കെൽ ML-ൻ്റെ സ്വാധീനമുള്ള ഒരു വിശാലമായ ഭാഷാ കുടുംബത്തിലേക്ക് വരുന്നു, അവയിലേതെങ്കിലും നിങ്ങൾക്ക് വളരെയധികം ബുദ്ധിമുട്ടില്ലാതെ മാറാം. മറ്റുള്ളവ പലപ്പോഴും ഹൈബ്രിഡ് ശൈലികൾ കൂടാതെ/അല്ലെങ്കിൽ പ്രായോഗികമായ വിട്ടുവീഴ്ചകൾ ചെയ്യുന്ന തരത്തിൽ നിന്നും ഫങ്ഷണൽ ശൈലിയുടെ ഉപയോഗത്തിൽ നിന്നും കൃത്യത ഉറപ്പുവരുത്തുന്ന കാര്യത്തിൽ ഹാസ്കെൽ കർശനമായ ഒന്നാണ്. വിവിധ കാരണങ്ങൾ. OOP-ലേക്ക് സ്വയം തുറന്നുകാട്ടാനും വിവിധ പ്രധാന സാങ്കേതിക പ്ലാറ്റ്‌ഫോമുകൾ ആക്സസ് ചെയ്യാനും നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, ഒന്നുകിൽ സ്കാല JVM-ൽ, അല്ലെങ്കിൽ F#.NET-ന് ഹാസ്‌കെല്ലുമായി വളരെ സാമ്യമുണ്ട്, ഇത് എളുപ്പമുള്ള അനുയോജ്യത നൽകുന്നു ജാവ പ്ലാറ്റ്ഫോമുകൾകൂടാതെ .NET. F# നെ മൈക്രോസോഫ്റ്റ് നേരിട്ട് പിന്തുണയ്ക്കുന്നു, പക്ഷേ ഹാസ്‌കെല്ലുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ ചില ശല്യപ്പെടുത്തുന്ന പരിമിതികളും നോൺ-വിൻഡോസ് പ്ലാറ്റ്‌ഫോമുകളിലെ പോർട്ടബിലിറ്റി പ്രശ്നങ്ങളും ഉണ്ട്. ഹാസ്‌കെല്ലിൻ്റെ ടൈപ്പ് സിസ്റ്റത്തിനും ജാവയുടെ ക്രോസ്-പ്ലാറ്റ്ഫോം സാധ്യതകൾക്കും സ്‌കാലയ്ക്ക് നേരിട്ടുള്ള അനലോഗുകൾ ഉണ്ട്, എന്നാൽ ഇതിന് കനത്ത വാക്യഘടനയുണ്ട്, കൂടാതെ F# ആസ്വദിക്കുന്ന ശക്തമായ മൂന്നാം കക്ഷി പിന്തുണയും ഇതിനില്ല. റീഫാക്‌ടറിംഗ്, ടിഡിഡി, ബഗ് ട്രാക്കറുകൾ, പിന്നെ (അവസാനം!) എൻ്റെ പ്രിയപ്പെട്ട ഹാസ്‌കെല്ലിനെക്കുറിച്ച്. നിർഭാഗ്യവശാൽ, "നിങ്ങളുടെ ഈ ഹാസ്കെല്ലിൽ എന്താണ് നല്ലത്" എന്ന വിഷയം വേണ്ടത്ര അഭിസംബോധന ചെയ്തില്ല. മിക്ക ഐടി ആൾക്കാർക്കും തോന്നും ശരിക്കുംഫങ്ഷണൽ പ്രോഗ്രാമിംഗിൻ്റെ പ്രയോജനങ്ങൾ മനസ്സിലാകുന്നില്ല. ഈ കുറിപ്പിൽ, എന്തുകൊണ്ടാണ് ഞാൻ വ്യക്തിപരമായി ഹാസ്കലിനെ ഇഷ്ടപ്പെടുന്നതെന്ന് വിശദമായി വിവരിക്കാൻ ശ്രമിച്ചു. പതിവുപോലെ, ആരെയും എന്തെങ്കിലും ബോധ്യപ്പെടുത്തുക അല്ലെങ്കിൽ എന്തെങ്കിലും തെളിയിക്കുക എന്ന ലക്ഷ്യം ഞാൻ സ്വയം നിശ്ചയിച്ചിട്ടില്ല. കൂടാതെ, ഞാൻ സത്യം അറിയുന്നതായി നടിക്കുന്നില്ല, ചില പോയിൻ്റുകളിൽ ഞാൻ തെറ്റിദ്ധരിച്ചേക്കാം. എഴുതിയതിനോട് നിങ്ങൾ യോജിക്കുന്നുണ്ടോ ഇല്ലയോ എന്നത് നിങ്ങളുടേതാണ്. ഇനങ്ങൾക്ക് നമ്പറിട്ടിട്ടുണ്ടെങ്കിലും, അവ ഒരു തരത്തിലും അടുക്കിയിട്ടില്ല. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, അഞ്ചാമത്തേതിനേക്കാൾ അല്ലെങ്കിൽ അത്തരത്തിലുള്ള മറ്റെന്തിനെക്കാളും ആദ്യത്തെ പോയിൻ്റ് പ്രധാനമാണ്. ഒരു ആത്മനിഷ്ഠമായ കാര്യമായതിനാലും കർശനമായ നിർവചനം ഇല്ലാത്തതിനാലും "ഒരു പ്രോഗ്രാമിംഗ് ഭാഷയുടെ ഭംഗി" ഹോളിവാറുകൾക്ക് ഒരു മികച്ച വിഷയമാണ്. അതുകൊണ്ട് ഞാൻ ഇത് പറയും - ഞാൻ വ്യക്തിപരമായിഹാസ്കെൽ വളരെ മനോഹരമായ ഭാഷയാണെന്ന് തോന്നുന്നു. ഹാസ്കെൽ ബുദ്ധിമുട്ടാണെന്ന് ചിലർ കരുതുന്നു, പക്ഷേ അത് അങ്ങനെയല്ല. എനിക്ക് ഹാസ്കലിനെ ഇഷ്ടപ്പെടാനുള്ള ഒരു കാരണം ഭാഷയുടെ ലളിതവും യുക്തിസഹവുമായ കാതലാണ്. എല്ലാത്തരം സ്വകാര്യവും എഴുതാൻ നിർബന്ധിതനായ ഒരു ദുഃഖിതനും അസന്തുഷ്ടനുമായ ജാവ പ്രോഗ്രാമർ സ്റ്റാറ്റിക് ഫൈനൽ ക്ഷണികമായ അസ്ഥിരമായലിസ്റ്റ് ഞാൻ കുറച്ച് നമ്പറുകൾ തരാം. റോമൻ ഡഷ്‌കിൻ്റെ ഹാസ്കെൽ ലാംഗ്വേജ് റഫറൻസിലെ ഭാഷയുടെ വിവരണം 100 പേജുകൾ മാത്രമാണ്. ശേഷിക്കുന്ന 430 പേജുകൾ മൊഡ്യൂൾ വിവരണങ്ങളാൽ ഉൾക്കൊള്ളുന്നു, അത് എനിക്ക് ഇതുവരെ ആവശ്യമില്ല. ലേൺ യു എ ഹാസ്കൽ ഫോർ ഗ്രേറ്റ് ഗുഡ് എന്ന പുസ്തകത്തിൻ്റെ വോളിയം! (വഴിയിൽ, ഒരു റഷ്യൻ വിവർത്തനം ഉടൻ പ്രസിദ്ധീകരിക്കും) 400 പേജാണ്. വ്യക്തിപരമായി, നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, ഒന്നും നഷ്ടപ്പെടാതെ പകുതിയായി ചുരുക്കാൻ കഴിയുമെന്ന് എനിക്ക് തോന്നുന്നു. താരതമ്യപ്പെടുത്തുമ്പോൾ, കെർനിഗൻ്റെയും റിച്ചിയുടെയും സി പ്രോഗ്രാമിംഗ് ഭാഷ 300 പേജുകളും സ്ട്രോസ്‌ട്രപ്പിൻ്റെ സി++ പ്രോഗ്രാമിംഗ് ലാംഗ്വേജ് ഏകദേശം 1,100 പേജുകളുമാണ്. നിങ്ങൾ ശരിക്കും ചിന്തിക്കുന്നുണ്ടോ ബുദ്ധിമുട്ടുള്ള ഭാഷ, ഏത് വിവരണത്തിന്, ഏറ്റവും യാഥാസ്ഥിതിക കണക്കുകൾ പ്രകാരം പോലും, സി ഭാഷയുടെ വിവരണത്തിന് ഏകദേശം ഒരേ വോള്യം ഉണ്ട്, അത് C ++ ഭാഷയുടെ വിവരണത്തേക്കാൾ 3-4 മടങ്ങ് ചെറുതാണ്? ചില പ്രോഗ്രാമർമാർ ഭാഷയുടെ "ഉയർന്ന പ്രഖ്യാപന സ്വഭാവം" പ്രകടിപ്പിക്കാൻ ഇഷ്ടപ്പെടുന്നതുപോലെ, കുറച്ച് കോഡ് നൽകാനുള്ള സമയമാണിത്. ഉദാഹരണത്തിന്, ഒരു ഫംഗ്ഷൻ നിർവചിക്കുന്നത് ഇങ്ങനെയാണ്, അത് ഒരു നിശ്ചിത സംഖ്യയുടെ വിഭജനങ്ങളുടെ ലിസ്റ്റ് നൽകുന്നു: getDivisors സംഖ്യ ഒരു നിർവചനം എഴുതുന്നതുപോലെ! n എന്ന സംഖ്യയുടെ വിഭജനങ്ങളുടെ കൂട്ടത്തെ D(n) ആയി സൂചിപ്പിക്കുകയും മുകളിൽ എഴുതിയത് ഗണിതശാസ്ത്രത്തിൻ്റെ ഭാഷയിലേക്ക് വിവർത്തനം ചെയ്യുകയും ചെയ്താൽ, നമുക്ക് ലഭിക്കും D(n) = ( x | x ∈ ℤ + , x ≤ n, mod(n, x) = 0 ), എവിടെ n ∈ ℤ + . പ്രാഥമികതയ്ക്കായി ഒരു സംഖ്യ പരിശോധിക്കാൻ ഇപ്പോൾ നമുക്ക് ഒരു ഫംഗ്ഷൻ എഴുതാം: പ്രൈം നമ്പർ വീണ്ടും, നിങ്ങൾ ഒരു ഗണിത സൂത്രവാക്യം എഴുതുന്നത് പോലെയാണ്. ഇപ്പോൾ നമുക്ക് പട്ടിക ലഭിക്കും എല്ലാവരുംപ്രധാന സംഖ്യകൾ: allPrimeNumbers = [ 2 ] ++ ഫിൽട്ടർ isPrime [ 3 , 5 .. ] അതെ, ഹാസ്കെല്ലിനൊപ്പം പ്രവർത്തിക്കാൻ കഴിയും അനന്തമായപട്ടികകൾ. അലസമായ മൂല്യനിർണ്ണയ സംവിധാനത്തിന് നന്ദി ഇത് സാധ്യമാണ്. അതായത്, പ്രൈം നമ്പറുകളുടെ പട്ടികയിലെ മൂലകങ്ങളൊന്നും യഥാർത്ഥത്തിൽ എവിടെയെങ്കിലും ഉപയോഗിക്കുന്നതുവരെ മൂല്യനിർണ്ണയം ചെയ്യപ്പെടില്ല. സൗകര്യത്തിന് പുറമേ, അലസമായ മൂല്യനിർണ്ണയം വേഗത്തിലുള്ള പ്രോഗ്രാമുകൾ എഴുതാൻ നിങ്ങളെ അനുവദിക്കുന്നു, അത് അനുബന്ധ ഖണ്ഡികയിൽ ചർച്ചചെയ്യും. ഹാസ്കലിൻ്റെ "ഉയർന്ന പ്രഖ്യാപന സ്വഭാവം" ഗണിതശാസ്ത്ര പ്രശ്നങ്ങൾക്ക് മാത്രമേ ബാധകമാകൂ എന്ന് നിങ്ങൾ കരുതുന്നുവെങ്കിൽ, നിങ്ങൾ തെറ്റിദ്ധരിക്കപ്പെടുന്നു. ഉദാഹരണത്തിന്, ഹാസ്കലിൽ GUI ആപ്ലിക്കേഷൻ കോഡ് എങ്ങനെയുണ്ടെന്ന് നോക്കുക. അല്ലെങ്കിൽ HaskellDB ലൈബ്രറി ഉപയോഗിച്ച് ഒരു ഡാറ്റാബേസ് എങ്ങനെ ആക്സസ് ചെയ്യാം. വാസ്തവത്തിൽ, ചോദ്യം സാധാരണ റിലേഷണൽ ബീജഗണിതം ഉപയോഗിക്കുന്നു. പ്രോഗ്രാമിൻ്റെ സമാഹാര ഘട്ടത്തിൽ ചോദ്യത്തിൻ്റെ കൃത്യത പരിശോധിക്കുന്നു എന്നതാണ് ഇവിടെ SQL-നെക്കാൾ നേട്ടം. എന്നിരുന്നാലും, നിങ്ങൾ സാധാരണ SQL-ൽ ചോദ്യങ്ങൾ എഴുതാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, ആരും നിങ്ങളെ തടയില്ല. ഗോട്ടോ ഓപ്പറേറ്ററിനെതിരെ പോരാടുന്നവർ ഹാസ്കലിന് ഇല്ലെന്നറിയുമ്പോൾ സന്തോഷിക്കും. മെമ്മറി മാനേജ്മെൻ്റിൻ്റെ പൂർണ്ണ നിയന്ത്രണം ഹാസ്കെൽ ഏറ്റെടുക്കുന്നു. വിക്കിബുക്കിൽ നിന്നുള്ള ഉദ്ധരണി: പ്രവർത്തനപരമായ ഭാഷകൾ ഈ പ്രയാസകരമായ ഉത്തരവാദിത്തത്തിൽ നിന്ന് പ്രോഗ്രാമറെ മോചിപ്പിക്കുന്നു. മെമ്മറി പരോക്ഷമായി, സ്വയമേവ അലോക്കേറ്റ് ചെയ്യപ്പെടുന്നു, കൂടാതെ ഒരു പ്രത്യേക ഗാർബേജ് കളക്ടർ (ഗാർബേജ് കളക്ടർ) ഉപയോഗിക്കാത്ത മെമ്മറി കഷണങ്ങൾ സിസ്റ്റത്തിലേക്ക് തിരികെ നൽകുന്നു. ഒപ്റ്റിമൽ മെമ്മറി മാനേജ്മെൻ്റ് അൽഗോരിതങ്ങൾ സങ്കീർണ്ണമാണ്, എന്നാൽ ഇന്ന് അവ ഇതിനകം നന്നായി വികസിപ്പിച്ചെടുത്തിട്ടുണ്ട്. ഈ അൽഗോരിതങ്ങളുടെ ഉപയോഗം പ്രോഗ്രാമിൻ്റെ പ്രവർത്തന സമയം മൊത്തത്തിൽ വർദ്ധിപ്പിക്കില്ല (പ്രോഗ്രാമർ തന്നെ മികച്ച രീതിയിൽ മെമ്മറി അനുവദിക്കുകയും സ്വതന്ത്രമാക്കുകയും ചെയ്യുന്നതുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ). ബഫർ ഓവർഫ്ലോകൾ, നൾ പോയിൻ്ററുകൾ, അൺഇനീഷ്യലൈസ്ഡ് ഡാറ്റ, മെമ്മറി ലീക്കുകൾ എന്നിവ പോലുള്ള കണ്ടുപിടിക്കാൻ ബുദ്ധിമുട്ടുള്ള പിശകുകളിൽ നിന്ന് ഹാസ്കൽ പ്രോഗ്രാമുകൾ മുക്തമാണെന്ന് ഇത് ഉറപ്പാക്കുന്നു. പലർക്കും പോയിൻ്ററുകളുമായി പ്രവർത്തിക്കാൻ ബുദ്ധിമുട്ടുണ്ടെന്ന് വിശ്വസിക്കപ്പെടുന്നു, അതിനാൽ അവ പൂർണ്ണമായും ഒഴിവാക്കുന്നത് നല്ല ആശയമാണെന്ന് തോന്നുന്നു. വഴിയിൽ, ജാവ, പേൾ, പൈത്തൺ തുടങ്ങിയ ഉയർന്ന തലത്തിലുള്ള ഭാഷകളിൽ ലിസ്റ്റുചെയ്ത എല്ലാ പ്രശ്നങ്ങളും യഥാർത്ഥത്തിൽ പരിഹരിച്ചിട്ടില്ല (സി ++ ൻ്റെ പ്രശ്നങ്ങളെക്കുറിച്ച് ഞാൻ പൊതുവെ നിശബ്ദനാണ്). ഉദാഹരണത്തിന്, ഡേവിഡ് ബീസ്ലിയുടെ പുസ്തകം ഒരു പ്രോഗ്രാമിൻ്റെ ഒരു ഉദാഹരണം നൽകുന്നു (എൻ്റെ പകർപ്പ് പേജ് 174-ൽ ഉണ്ട്) അത് നിരീക്ഷക പാറ്റേൺ ഉപയോഗിക്കുന്നു, അതിൽ മാലിന്യ ശേഖരണത്തിന് വീക്ക്‌പ്റ്റർ ഉപയോഗിച്ചില്ലെങ്കിൽ മെമ്മറി സ്വതന്ത്രമാക്കാൻ കഴിയില്ല. ജനങ്ങളേ, 21-ാം നൂറ്റാണ്ട് ഇതാ! റഫറൻസ് കൗണ്ടറുകൾ, വീക്ക്‌പ്‌റ്റിആർ തുടങ്ങിയ ഊന്നുവടികൾ ഉപയോഗിച്ചോ അല്ലെങ്കിൽ സ്വമേധയാ പോലും ഞങ്ങൾ 90 വർഷത്തേക്ക് മെമ്മറി നിയന്ത്രിക്കുമോ? അതോ ഒടുവിൽ ഒരു ദുർസ്വപ്നം പോലെ മറന്ന് മുന്നോട്ട് പോകുമോ? ചടങ്ങിനെ വിളിക്കുന്നു നിർണ്ണായകമായ, അത് നൽകുന്ന മൂല്യം ആർഗ്യുമെൻ്റുകളെ മാത്രം ആശ്രയിച്ചിരിക്കുന്നു. അവർ ഫംഗ്ഷൻ പറയുന്നു പാർശ്വഫലങ്ങൾ ഇല്ല, വിളിക്കുന്നത് ഒരു ഫയലിലേക്ക് എഴുതുന്നില്ലെങ്കിൽ, ഒരു സോക്കറ്റിൽ നിന്ന് വായിക്കുക, ആഗോള വേരിയബിളുകൾ മാറ്റുക തുടങ്ങിയവ. ചടങ്ങിനെ വിളിക്കുന്നു ശുദ്ധമായ, അത് നിർണ്ണായകമാണെങ്കിൽ ഒപ്പംപാർശ്വഫലങ്ങൾ ഇല്ല. ശുദ്ധമായ പ്രവർത്തനങ്ങൾ എഴുതാൻ ഹാസ്കൽ ശക്തമായി പ്രോത്സാഹിപ്പിക്കുന്നു. നമ്മൾ ഒരേ ആർഗ്യുമെൻ്റുകൾ ഫംഗ്ഷനിലേക്ക് എത്ര തവണ കൈമാറിയാലും, അത് എല്ലായ്പ്പോഴും ഒരേ ഫലം നൽകും. കൂടാതെ, ഒരു പ്യുവർ ഫംഗ്ഷൻ വിളിക്കുമ്പോൾ, ഒരു ഫയലിലേക്ക് ഡാറ്റയൊന്നും എഴുതുകയോ നെറ്റ്‌വർക്കിലൂടെ കൈമാറ്റം ചെയ്യുകയോ ചെയ്യുന്നില്ലെന്ന് ഞങ്ങൾക്ക് ഉറപ്പിക്കാം. ഇത് പ്രോഗ്രാം വികസനം വളരെ ലളിതമാക്കുന്നു. റോബർട്ട് മാർട്ടിൻ്റെ ക്ലീൻ കോഡ്-ക്രിയേറ്റിംഗ്, അനലൈസിംഗ്, റീഫാക്റ്ററിംഗ് ഫോർ സൈഡ് ഇഫക്റ്റുകൾ എന്ന പുസ്തകത്തിൽ പറയുന്നത് ഇതാണ്: പാർശ്വഫലങ്ങൾ നുണയാണ്. നിങ്ങളുടെ പ്രവർത്തനം ഒരു കാര്യം ചെയ്യാൻ വാഗ്ദാനം ചെയ്യുന്നു, എന്നാൽ മറ്റെന്തെങ്കിലും ചെയ്യുന്നു, ഉപയോക്താവിൽ നിന്ന് മറച്ചിരിക്കുന്നു. ചിലപ്പോൾ അത് അതിൻ്റെ ക്ലാസിലെ വേരിയബിളുകളിൽ അപ്രതീക്ഷിത മാറ്റങ്ങൾ വരുത്തുന്നു - ഉദാഹരണത്തിന്, ഒരു ഫംഗ്ഷനിലേക്ക് കൈമാറിയ പാരാമീറ്ററുകളുടെ മൂല്യങ്ങൾ അല്ലെങ്കിൽ ആഗോള സിസ്റ്റം വേരിയബിളുകൾ അവയ്ക്ക് നൽകുന്നു. ഏത് സാഹചര്യത്തിലും, അത്തരമൊരു പ്രവർത്തനം വഞ്ചനാപരവും ദോഷകരവുമായ ഒരു നുണയാണ്, ഇത് പലപ്പോഴും പ്രകൃതിവിരുദ്ധമായ സമയവും മറ്റ് ആശ്രിതത്വങ്ങളും സൃഷ്ടിക്കുന്നതിലേക്ക് നയിക്കുന്നു. എന്നാൽ ഫയലുകളിൽ നിന്ന് വായിക്കാതെയും നെറ്റ്‌വർക്കിൽ പ്രവർത്തിക്കാതെയും ഉപയോക്തൃ ഇൻപുട്ടില്ലാതെയും ഹാസ്‌കെലിന് ശരിക്കും ചെയ്യാൻ കഴിയുമോ? എല്ലാത്തിനുമുപരി, ഇതെല്ലാം പാർശ്വഫലങ്ങളാണ്. തൽഫലമായി, ശുദ്ധമായ പ്രവർത്തനങ്ങളിൽ അനുബന്ധ പ്രവർത്തനങ്ങൾ നടത്താൻ കഴിയില്ല. ഹാസ്കെൽ ഫംഗ്‌ഷനുകളെ ശുദ്ധവും “വൃത്തികെട്ടതും” ആയി തിരിച്ചിരിക്കുന്നു, അതായത്, നിർണ്ണായകമല്ലാത്തതും പാർശ്വഫലങ്ങളുള്ളതുമാണ്. ഡാറ്റ ഇൻപുട്ട് ചെയ്യുന്നതിനും ക്ലീൻ ഫംഗ്ഷനുകളിലേക്ക് കൈമാറുന്നതിനും ഫലം ഔട്ട്പുട്ട് ചെയ്യുന്നതിനും ഡേർട്ടി ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുന്നു. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ഒരു ശുദ്ധമായ പ്രവർത്തന ഭാഷയ്ക്കുള്ളിൽ ഒരു ചെറിയ നടപടിക്രമ ലോകമുണ്ട്. അല്ലെങ്കിൽ തിരിച്ചും, നിങ്ങൾ എങ്ങനെ നോക്കുന്നു എന്നതിനെ ആശ്രയിച്ച്. സമർത്ഥമായ എല്ലാം ലളിതമാണ്! അലസമായ കണക്കുകൂട്ടലുകളെക്കുറിച്ച് ഞാൻ ആവർത്തിക്കും. ഹാസ്കെലിൽ, യഥാർത്ഥത്തിൽ ആവശ്യമുള്ളപ്പോൾ മാത്രമേ എന്തെങ്കിലും കണക്കാക്കാൻ തുടങ്ങുകയുള്ളൂ. നിങ്ങൾക്ക് 9000 ഘടകങ്ങളുടെ ഒരു ലിസ്റ്റ് പ്രഖ്യാപിക്കാൻ കഴിയും, എന്നാൽ നിങ്ങൾക്ക് അവയിലൊന്ന് ആവശ്യമുണ്ടെങ്കിൽ (അത് ലിസ്റ്റിലെ മറ്റ് ഘടകങ്ങളെ ആശ്രയിക്കുന്നില്ല), അപ്പോൾ ആ ഒരു ഘടകത്തിൻ്റെ മാത്രം മൂല്യം കണക്കാക്കും. കൂടാതെ ഈ തത്വം പ്രവർത്തിക്കുന്നു എല്ലായിടത്തും, ലിസ്റ്റുകളിൽ മാത്രമല്ല. ചില C++ ൽ, ഇതും ചെയ്യാൻ കഴിയും, എന്നാൽ നിങ്ങൾ അനുബന്ധ കോഡ് സ്വയം എഴുതുകയോ അല്ലെങ്കിൽ കുറച്ച് ലൈബ്രറി കണക്റ്റുചെയ്യുകയോ ചെയ്യേണ്ടിവരും, എന്നാൽ ഹാസ്കലിൽ എല്ലാം ഇതിനകം തന്നെ "ബോക്സിന് പുറത്ത്" ഉണ്ട്. Haskell-ലെ മിക്ക ഫംഗ്ഷനുകളും ശുദ്ധമായതിനാൽ, നൽകിയിരിക്കുന്ന ആർഗ്യുമെൻ്റുകൾക്കായി ഒരു ഫംഗ്ഷൻ്റെ റിട്ടേൺ മൂല്യം നമുക്ക് എളുപ്പത്തിൽ കാഷെ ചെയ്യാൻ കഴിയും. ഒരേ ആർഗ്യുമെൻ്റുകൾ ഉപയോഗിച്ച് ഒരു ഫംഗ്ഷൻ ഒന്നിലധികം തവണ വിളിക്കുകയാണെങ്കിൽ, യഥാർത്ഥ ജോലി ഒരു തവണ മാത്രമേ ചെയ്യൂ. രണ്ടാമത്തെ അല്ലെങ്കിൽ മൂന്നാമത്തെ കോളിൽ, ഇതിനകം കണക്കാക്കിയ മൂല്യം കാഷെയിൽ നിന്ന് എടുക്കുന്നു. മറ്റൊരു ഉദാഹരണം നോക്കാം. നമുക്ക് ഒരു നിശ്ചിത ഫംഗ്ഷൻ f(a, b) ഉണ്ടെന്ന് പറയാം. a, b എന്നീ ആർഗ്യുമെൻ്റുകൾ സന്തോഷകരമായ യാദൃശ്ചികതയാൽ ശുദ്ധമായ മറ്റ് ചില പ്രവർത്തനങ്ങളുടെ കണക്കുകൂട്ടലുകളുടെ ഫലമായിരിക്കട്ടെ. ഈ സാഹചര്യത്തിൽ, a, b എന്നിവ സമാന്തരമായി കണക്കാക്കാം! സമ്മതിക്കുക, മൾട്ടി-കോർ പ്രോസസ്സറുകളുടെ കാലഘട്ടത്തിൽ ഇത് പ്രധാനമാണ്. OOP ഭാഷകളിൽ, അത്തരം ഒപ്റ്റിമൈസേഷൻ നടപ്പിലാക്കാൻ വളരെ ബുദ്ധിമുട്ടാണ്. പ്രകടന നേട്ടത്തിന് പുറമേ, ഞങ്ങൾ പ്രോഗ്രാമിനെ യാന്ത്രികമായി സമാന്തരമാക്കുകയും എക്സിക്യൂഷൻ ത്രെഡുകൾ സമന്വയിപ്പിക്കുകയും ചെയ്യുന്നു! എന്നാൽ മാനുവൽ മെമ്മറി മാനേജ്മെൻ്റ് കഴിഞ്ഞാൽ ആധുനിക പ്രോഗ്രാമിംഗിൻ്റെ ഏറ്റവും പ്രധാനപ്പെട്ട രണ്ടാമത്തെ പ്രശ്‌നമാണ് ഡെഡ്‌ലോക്കുകളുള്ള മൾട്ടിത്രെഡ് പ്രോഗ്രാമിംഗ്. മേൽപ്പറഞ്ഞത് വെറും സിദ്ധാന്തമാണെന്ന് നിങ്ങൾ കരുതുന്നുവെങ്കിൽ, GHC കംപൈലർ വിപുലീകരണങ്ങളുടെ പട്ടികയും ഡാറ്റ പാരലൽ ഹാസ്കെൽ പ്രോജക്‌റ്റും പരിശോധിക്കുക. എല്ലാം ഇതിനകം നടപ്പിലാക്കി! കൂട്ടിച്ചേർക്കൽ: Haskell STM പദ്ധതിയും കാണുക. ട്രാൻസാക്ഷണൽ മെമ്മറി രസകരമാണ്, കാരണം മൾട്ടി-ത്രെഡഡ് ആപ്ലിക്കേഷനുകളിൽ ലോക്കുകൾ ഒഴിവാക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു. നിർഭാഗ്യവശാൽ, shootout.alioth.debian.org ഒഴികെയുള്ള ഒരു മാനദണ്ഡം പോലും ഹാസ്കെൽ പ്രോഗ്രാമുകൾക്കായി എനിക്ക് കണ്ടെത്താൻ കഴിഞ്ഞില്ല. “നിർഭാഗ്യവശാൽ” - കാരണം ഈ മാനദണ്ഡത്തെക്കുറിച്ച് എനിക്ക് ധാരാളം ചോദ്യങ്ങളുണ്ട്. സി പ്രോഗ്രാമുകളേക്കാൾ 2 മടങ്ങ് വേഗത കുറവാണ് പാസ്കൽ പ്രോഗ്രാമുകൾ പ്രവർത്തിക്കുന്നതെന്ന് വിശ്വസിക്കാൻ ഞാൻ വിസമ്മതിക്കുന്നു. സ്ക്രിപ്റ്റിംഗ് ഭാഷകൾക്കായുള്ള ±100% ശൈലിയിലുള്ള പിശകുകളും സംശയാസ്പദമാണ്. എന്നിരുന്നാലും, ഈ മാനദണ്ഡമനുസരിച്ച്, ഏറ്റവും വേഗതയേറിയ ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗ് ഭാഷയാണ് ഹാസ്കെൽ. വേഗതയുടെ കാര്യത്തിൽ, ഇത് ജാവ, സി# ഭാഷകളുമായി താരതമ്യപ്പെടുത്താവുന്നതാണ്. റീഫാക്‌ടറിംഗ് - ഇംപ്രൂവിംഗ് ഫൗളേഴ്‌സ് എക്‌സിസ്റ്റിംഗ് കോഡ് എന്ന പുസ്തകത്തിൻ്റെ ഉള്ളടക്ക പട്ടിക തുറന്ന് ഏതൊക്കെ തരം റീഫാക്‌ടറിംഗ് ഉണ്ടെന്ന് നോക്കാം. ഒരു രീതി എക്‌സ്‌ട്രാക്റ്റുചെയ്യൽ, ഒരു രീതി ഇൻലൈൻ ചെയ്യുക, ഒരു രീതി നീക്കുക, ഒരു താൽക്കാലിക വേരിയബിൾ കുത്തിവയ്ക്കുക, ഒരു മെത്തേഡ് കോൾ ഉപയോഗിച്ച് താൽക്കാലിക വേരിയബിളിനെ മാറ്റിസ്ഥാപിക്കുക, ഒരു വിശദീകരണ വേരിയബിൾ അവതരിപ്പിക്കുക, ഒരു താൽക്കാലിക വേരിയബിൾ വിഭജിക്കുക, ഒരു റഫറൻസ് ഉപയോഗിച്ച് ഒരു മൂല്യം ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുക, ഒരു മൂല്യത്തെ ഒരു റഫറൻസ് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുക. .. ഈ ഭാഷയിൽ റഫറൻസുകളോ വേരിയബിളുകളോ ഇല്ലെങ്കിൽ, മുകളിൽ പറഞ്ഞവയിൽ ഭൂരിഭാഗവും ഹാസ്കെലിൽ ബാധകമാണെന്ന് നിങ്ങൾ കരുതുന്നുണ്ടോ (എവിടെ കണക്കാക്കരുത്)? ഞാൻ അടുത്തിടെ ഹാബ്രെയിൽ രണ്ട് സർവേകൾ നടത്തി, ഒന്ന് ജാവ ബ്ലോഗിൽ, രണ്ടാമത്തേത് ഹാസ്കെൽ ബ്ലോഗിൽ. ചോദ്യം ഇതുതന്നെയായിരുന്നു - “നിങ്ങൾ എത്ര തവണ കോഡ് %PROGRAMMING_LANGUAGE% എന്നതിലേക്ക് റീഫാക്റ്റർ ചെയ്യണം?” ഈ സർവേകളിൽ എനിക്ക് എൻ്റെ മിക്കവാറും എല്ലാ കർമ്മങ്ങളും നഷ്ടപ്പെട്ടു (ഇത് ആരുടെയെങ്കിലും കണ്ണുകളെ ശരിക്കും വേദനിപ്പിക്കുന്നുണ്ടോ?), പക്ഷേ അത് വിലമതിക്കുന്നു: പ്രതികരിച്ചവരിൽ ചിലർക്ക് ഹാസ്കലിൽ എഴുതാത്തതിനാൽ അതിൽ റീഫാക്റ്റർ ചെയ്യുന്നില്ലെന്ന് ഉത്തരം നൽകാമെന്ന് ഞാൻ സമ്മതിക്കാൻ തയ്യാറാണ്, പക്ഷേ ഇത് ചിത്രത്തെ വളരെയധികം വളച്ചൊടിക്കാൻ സാധ്യതയില്ല. ഒന്നാമതായി, വോട്ടെടുപ്പിൽ ഒരു "ഒഴിവാക്കുക" ബട്ടൺ ഉണ്ട്, രണ്ടാമതായി, ജാവ ബ്ലോഗിൻ്റെ വായനക്കാർക്കിടയിൽ, എല്ലാവരും ജാവയിൽ എഴുതുന്നില്ല. രസകരമെന്നു പറയട്ടെ, ഹാസ്കലിൻ്റെ വാക്യഘടന തന്നെ ധാരാളം ലളിതമായ ഫംഗ്ഷനുകൾ അടങ്ങിയ കോഡ് എഴുതാൻ പ്രോത്സാഹിപ്പിക്കുന്നു. OOP ഭാഷകളിലെ പോലെ ഉയരത്തിലല്ല, സ്‌ക്രീനിൻ്റെ വീതിയിൽ വളരാൻ Haskell കോഡ് ശരിക്കും ഇഷ്ടപ്പെടുന്നു എന്നതാണ് ഇതിന് കാരണം. കൂടാതെ, if-then-else കൺസ്ട്രക്‌റ്റിനുള്ളിൽ ഒരു മൂല്യം തിരികെ നൽകുന്നതിനേക്കാൾ കൂടുതൽ എന്തെങ്കിലും ആവശ്യമുണ്ടെങ്കിൽ, if-then-else വളരെ കൂടുതലാണ് സൗകര്യപ്രദമായഒരു പുതിയ ഫംഗ്ഷൻ നിർവ്വചിക്കുക. വാസ്തവത്തിൽ, പാറ്റേൺ പൊരുത്തപ്പെടുത്തലിനും ഗാർഡിംഗിനും നന്ദി, if-then-else ഉപയോഗിക്കാതെ തന്നെ Haskell എഴുതാൻ കഴിയും. അത്തരം സന്ദർഭങ്ങളിൽ, റീഫാക്‌ടറിംഗ് ഇപ്പോഴും ആവശ്യമായി വരുമ്പോൾ, ഭാഷയുടെ കർശനമായ സ്റ്റാറ്റിക് ടൈപ്പിംഗിന് നന്ദി, ഇത് ലളിതവും എളുപ്പവുമാണ്. പൈത്തണിലോ ജാവയിലോ ഉള്ള ഏതൊരു പാഠപുസ്തകവും നമ്മെ പഠിപ്പിക്കുന്നത് ഓർക്കുക. എല്ലാം ഒരു വസ്തുവാണ്. ഒബ്‌ജക്‌റ്റുകൾ ഉപയോഗിക്കുക, നിങ്ങളുടെ കോഡ് പരിപാലിക്കാനും വിപുലീകരിക്കാനും വീണ്ടും ഉപയോഗിക്കാനും വളരെ എളുപ്പമാകും. വിശ്വസിക്കുകയും അനുതപിക്കുകയും ചെയ്യുക! എന്നിരുന്നാലും, കോഡിനൊപ്പം, ക്ലാസ് ഡയഗ്രമുകൾ ഉണ്ടാക്കുക, അല്ലാത്തപക്ഷം അത് മനസ്സിലാക്കാൻ കഴിയില്ല. കൂടാതെ പലതും ഉൾക്കൊള്ളുന്ന പരീക്ഷകൾ എഴുതുന്നത് ഉറപ്പാക്കുക ഒകോഡിൻ്റെ ഭൂരിഭാഗവും, അല്ലാത്തപക്ഷം അതിലെ ഏത് മാറ്റവും നിങ്ങളുടെ പ്രോഗ്രാമിനെ പ്രവർത്തനരഹിതമാക്കും. ചോദ്യങ്ങൾ ദയവായി. അതെ, ദയവായി. എന്ത്, എന്ത്, ക്ഷമിക്കണം? ഏത് അർത്ഥത്തിലാണ് ഇത് "പ്രോസീജറൽ പ്രോഗ്രാമിംഗിലേക്കുള്ള ഒരു ആഡ്-ഓൺ"?! നിങ്ങൾ കേൾക്കുന്നില്ലേ? എൻക്യാപ്സുലേഷൻ, പൈതൃകം, പോളിമോർഫിസം! ഇല്ല, ശരിക്കും, OOP പ്രവർത്തിക്കാൻ എത്ര ഊന്നുവടികൾ ഉപയോഗിക്കണമെന്ന് നിങ്ങൾ എപ്പോഴെങ്കിലും ചിന്തിച്ചിട്ടുണ്ടോ? റേഡിയോ-ടിയുടെ ഇതിനകം സൂചിപ്പിച്ച 253-ാം ലക്കമെങ്കിലും ഡൗൺലോഡ് ചെയ്ത് ടിഡിഡിയെക്കുറിച്ച് അവർ പറയുന്നത് ശ്രദ്ധിക്കുക. വാസ്തവത്തിൽ, ഞങ്ങളോട് രണ്ടോ മൂന്നോ തവണ (UML കണക്കാക്കുന്നത്) കൂടുതൽ ജോലി ചെയ്യാൻ ആവശ്യപ്പെടുന്നു! ആളുകൾ ചിലപ്പോൾ ചോദിക്കും, "ഹാസ്കെല്ലിന് തുല്യമായ UML എന്താണ്?" 10 വർഷം മുമ്പ് എന്നോട് ഇതിനെക്കുറിച്ച് ആദ്യമായി ചോദിച്ചപ്പോൾ, ഞാൻ ചിന്തിച്ചു, “എനിക്ക് ഒന്നും അറിയില്ല. ഒരുപക്ഷേ നമ്മൾ നമ്മുടെ സ്വന്തം UML കൊണ്ട് വന്നേക്കാം." ഇപ്പോൾ ഞാൻ ചിന്തിക്കുന്നു, "അവർ വെറും തരം മാത്രമാണ്!" // സൈമൺ പെയ്റ്റൺ ജോൺസ് അതേ സമയം, എല്ലാ ജോലികളും OOP യുടെ ചട്ടക്കൂടിലേക്ക് എളുപ്പത്തിൽ യോജിക്കുന്നില്ല എന്നത് സാധാരണയായി നിശബ്ദമാണ്. വാസ്തവത്തിൽ, ഗെയിം വികസനം, GUI-കൾ, ഗ്രാഫിക് എഡിറ്റർമാരുടെ സൃഷ്ടി എന്നിവയിൽ മാത്രമാണ് OOP സ്വയം നന്നായി തെളിയിച്ചത്. ഉദാഹരണത്തിന്, CPAN-ലേക്ക് പോകുക. 10 റാൻഡം മൊഡ്യൂളുകൾ എടുത്ത് അവയിൽ എത്രയെന്ന് കാണുക ശരിക്കുംമൊഡ്യൂളിനെ ഒരു ക്ലാസായി പാക്ക് ചെയ്യുന്നതിനുപകരം OOP (അതെ, പേളിന് OOP ഉണ്ട്) ഉപയോഗിക്കുക. അല്ലെങ്കിൽ ഹാക്കേജ് നോക്കുക, OOP യുടെ ഒരു സൂചന പോലും ഇല്ലാതെ എത്ര മൊഡ്യൂളുകൾ പ്രായോഗിക പ്രശ്നങ്ങൾ വിജയകരമായി പരിഹരിക്കുന്നുവെന്ന് എണ്ണുക. കുറിപ്പ്:വാസ്തവത്തിൽ, പ്രവർത്തനപരമായ ഭാഷകൾ എൻക്യാപ്സുലേഷൻ, പാരമ്പര്യം, പോളിമോർഫിസം എന്നിവയ്ക്ക് അന്യമല്ല. ഉദാഹരണത്തിന്, ഹാസ്കെലിൽ, മൊഡ്യൂൾ തലത്തിലാണ് എൻക്യാപ്സുലേഷൻ നടത്തുന്നത്, പോളിമോർഫിസം ടൈപ്പ് ക്ലാസുകളിലൂടെയാണ് നൽകുന്നത്, അനന്തരാവകാശം അതിൻ്റെ ശുദ്ധമായ രൂപത്തിൽ നിലനിൽക്കുന്നു. ഹാസ്‌കെല്ലിലും ഫങ്ഷണൽ പ്രോഗ്രാമിംഗിലും ഉള്ള 14 വിനോദ ഉപന്യാസങ്ങൾ എന്ന പുസ്തകത്തിൻ്റെ നാലാം അധ്യായത്തിൽ ഹാസ്കെല്ലിലെ OOP ഭാഷകളുടെ ഉപയോഗത്തെക്കുറിച്ച് നിങ്ങൾക്ക് വായിക്കാം. ഹാസ്കെൽ ഉപയോഗിക്കുമ്പോൾ "ക്രച്ചുകൾ" കുറവായിരിക്കണമെന്ന് എനിക്ക് തോന്നുന്നത് എന്തുകൊണ്ട്? ശരി, ഒന്നാമതായി, ക്ലാസുകളില്ലാത്തതിനാൽ (ആശയക്കുഴപ്പത്തിലാകരുത് തരം ക്ലാസുകൾ) — നിങ്ങൾ അവരുടെ ഡയഗ്രമുകൾ വരയ്‌ക്കേണ്ടതില്ല :) സൈദ്ധാന്തികമായി, ടൈപ്പ് ക്ലാസ് ഡയഗ്രമുകൾ വരയ്ക്കുന്നതിൽ നിന്ന് നിങ്ങളെ ഒന്നും തടയുന്നില്ല, എന്നാൽ വ്യക്തിപരമായി ഞാൻ ഇതുപോലൊന്ന് കണ്ടിട്ടില്ല. രണ്ടാമതായി, ഞങ്ങൾ ഇതിനകം കണ്ടെത്തിയതുപോലെ, ഹാസ്കെൽ ഒരു "വളരെ പ്രഖ്യാപന" ഭാഷയാണ്. അതായത്, ഞങ്ങൾ സാധാരണയായി അതിൽ എഴുതുന്നു, എന്ത്ഞങ്ങൾ സ്വീകരിക്കാൻ ആഗ്രഹിക്കുന്നു, അല്ല എങ്ങനെ. ഈ രീതിയിൽ, പ്രോഗ്രാം സ്വയം രേഖപ്പെടുത്തുന്നു. മൂന്നാമതായി, ഭാഷയുടെ കർശനമായ സ്റ്റാറ്റിക് ടൈപ്പിംഗ് പ്രോഗ്രാം കംപൈലേഷൻ്റെ ഘട്ടത്തിൽ മുഴുവൻ പിശകുകളും ഇല്ലാതാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഇത് കാലാകാലങ്ങളിൽ പരീക്ഷകൾ എഴുതേണ്ടതിൻ്റെ ആവശ്യകത ഇല്ലാതാക്കുന്നില്ല, പക്ഷേ ഇത് അവരുടെ എണ്ണം ഗണ്യമായി കുറയ്ക്കുന്നു. വഴിയിൽ, പാർശ്വഫലങ്ങളുടെ അഭാവവും ഭാഷയുടെ ക്രോസ്-പ്ലാറ്റ്ഫോം സ്വഭാവവുമാണ് ഹാസ്കലിൻ്റെ പ്രധാന സവിശേഷതകൾ. യഥാർത്ഥമായ C++ പോലെയല്ല, ക്രോസ്-പ്ലാറ്റ്ഫോം. ഒരിക്കൽ എഴുതിയ ഒരു പ്രോഗ്രാം, മാക്രോകളോ മറ്റോ എഴുതേണ്ട ആവശ്യമില്ലാതെ, ഏത് OS-ലും ഏത് പ്രോസസ്സർ ആർക്കിടെക്ചറിലും ഒരുപോലെ നന്നായി പ്രവർത്തിക്കുന്നു. ഇത് ഹാസ്കെൽ പ്രോഗ്രാമർമാർ പലപ്പോഴും (!) അവരുടെ പ്രോഗ്രാമുകൾ സമാഹരിക്കുന്നില്ല. അത് പരിഹാസ്യമാണെന്ന് എനിക്കറിയാം. ഞാൻ അത് പരീക്ഷിക്കുന്നതുവരെ ഞാൻ സ്വയം വിശ്വസിച്ചില്ല. ഇത് ഇതുപോലെ തോന്നുന്നു. നമുക്ക് ഒരു പുതിയ മൊഡ്യൂൾ ഉണ്ടാക്കാം. ഞങ്ങൾ കുറച്ച് പുതിയ തരങ്ങൾ അവതരിപ്പിക്കുകയും ആദ്യ ഫംഗ്ഷൻ പ്രഖ്യാപിക്കുകയും ചെയ്യുന്നു. ഞങ്ങൾ ghci ഇൻ്റർപ്രെറ്റർ സമാരംഭിക്കുകയും സാധാരണ ഡാറ്റയിലും രണ്ട് എഡ്ജ് കേസുകളിലും ഫംഗ്ഷൻ പരിശോധിക്കുകയും ചെയ്യുന്നു. ഇത് പ്രവർത്തിക്കുന്നുവെങ്കിൽ, ഞങ്ങൾ ഇപ്പോൾ എഴുതിയ ഫംഗ്ഷനെ കുറിച്ച് മറക്കുകയും അടുത്തത് എഴുതുകയും ചെയ്യും. ആവശ്യമായ എല്ലാ പ്രവർത്തനങ്ങളും നടപ്പിലാക്കുമ്പോൾ, മൊഡ്യൂളിൽ നിന്ന് ഏതൊക്കെ എൻ്റിറ്റികളാണ് കയറ്റുമതി ചെയ്യേണ്ടതെന്ന് ഞങ്ങൾ നോക്കുകയും ഉചിതമായ മാറ്റങ്ങൾ വരുത്തുകയും ചെയ്യുന്നു. അത്രയേയുള്ളൂ, ജോലി കഴിഞ്ഞു! ഒരൊറ്റ സമാഹാരം ഇല്ലാതെ.പ്രോഗ്രാം ghci-ൽ പ്രവർത്തിക്കുന്നുണ്ടെങ്കിൽ, ഏത് ഹാസ്കെൽ കംപൈലറും ഏത് പ്ലാറ്റ്‌ഫോമിലേക്കും അത് ശരിയായി കംപൈൽ ചെയ്യും. ഇതാണ് യഥാർത്ഥ ക്രോസ് പ്ലാറ്റ്ഫോം. ഹാസ്കെലിനെക്കുറിച്ചുള്ള പൊതുവായ ഒരു തെറ്റിദ്ധാരണ, സങ്കീർണ്ണമായ ഗണിതശാസ്ത്ര പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിന് മാത്രമേ ഭാഷ അനുയോജ്യമാകൂ എന്നതാണ്. ശരിക്കും, ഞങ്ങൾക്ക് സൈക്കിളുകൾ പോലും ഇല്ലെങ്കിൽ നിങ്ങൾ എങ്ങനെയാണ് "സാധാരണ" പ്രശ്നങ്ങൾ പരിഹരിക്കേണ്ടത്? വാസ്തവത്തിൽ, ആവർത്തനം ലൂപ്പുകളേക്കാൾ മോശമല്ല. ആവർത്തനങ്ങളിൽ ചിന്തിക്കുകയോ ആവർത്തനങ്ങളിൽ ചിന്തിക്കുകയോ ചെയ്യുന്നത് ഒരു ശീലം മാത്രമാണ്. അല്ല, ആവർത്തനത്തിന് ഏതെങ്കിലും മെമ്മറി ഉപയോഗിക്കണമെന്നില്ല. വാസ്തവത്തിൽ, OOP യുടെ ദുരുപയോഗമാണ് ആത്യന്തികമായി ടെംപ്ലേറ്റ് അനുസരിച്ച് ചിന്തിക്കുന്നതിലേക്ക് നയിക്കുന്നത്, കൂടാതെ "പ്രത്യക്ഷമായും, ഈ പ്രശ്നം സ്പോർട്സ് പ്രോഗ്രാമിംഗ് ഒളിമ്പ്യാഡിൽ നിന്നുള്ളതാണ്, കാരണം ഇത് എങ്ങനെ പരിഹരിക്കണമെന്ന് എനിക്കറിയില്ല." എന്നിരുന്നാലും, നമുക്ക് സ്കോപ്പിലേക്ക് മടങ്ങാം. ഞാൻ ഇതിനകം സൂചിപ്പിച്ചതുപോലെ, GUI ആപ്ലിക്കേഷനുകൾ എഴുതുന്നതിന് ഹാസ്കൽ മികച്ചതാണ്. ഞാൻ ഇതുവരെ വെബിൽ ഇത് എഴുതാൻ ശ്രമിച്ചിട്ടില്ല, പക്ഷേ അവലോകനങ്ങൾ അനുസരിച്ച്, ഹാസ്കെൽ ഇവിടെ PHP-യെക്കാൾ മോശമല്ല: ഞാൻ ഹാസ്കെലിൽ ഒരു ലളിതമായ FastCGI പ്രോഗ്രാം എഴുതി പൂർത്തിയാക്കി. ഹാസ്കെൽ വെബ് ആപ്ലിക്കേഷനുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്നും ഭാഷാ പഠനത്തിനായി സമർപ്പിച്ചിരിക്കുന്ന ഒരു വെബ്‌സൈറ്റ് സൃഷ്ടിക്കുന്നതിന് ഈ ഭാഷ അനുയോജ്യമാണോ എന്നും മനസിലാക്കാൻ ഞാൻ ആഗ്രഹിച്ചു. ഹാസ്കെല്ലിന് ജോലി മാത്രമല്ല ലഭിച്ചത്. അതിൽ എഴുതുന്നത് PHP // jekor.com എന്നതിനേക്കാൾ രസകരമാണെന്ന് മനസ്സിലായി. നിങ്ങൾക്ക് ഹാസ്കലിൽ പോലും എഴുതാം. ഒടുവിൽ, ഈ കുറിപ്പ് എഴുതാൻ സഹായിച്ചതിന് റോമൻ ദുഷ്കിന് നന്ദി പറയാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. അദ്ദേഹത്തിന് നന്ദി, വാചകം ഗണ്യമായി മെച്ചപ്പെടുത്തുകയും ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗിൻ്റെ ലോകത്തെക്കുറിച്ചുള്ള രസകരമായ വസ്തുതകളാൽ സമ്പുഷ്ടമാക്കുകയും ചെയ്തു. നിങ്ങൾക്ക് പോസ്റ്റ് രസകരമായി തോന്നിയെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു. എല്ലായ്പ്പോഴും എന്നപോലെ, വായനക്കാരിൽ നിന്നുള്ള ഏതെങ്കിലും അഭിപ്രായങ്ങളോ ചോദ്യങ്ങളോ ഞാൻ സ്വാഗതം ചെയ്യുന്നു. കൂട്ടിച്ചേർക്കൽ:"മഹത്തായ നന്മയ്ക്കായി നിങ്ങൾക്ക് ഒരു ഹാസ്കെൽ പഠിക്കൂ!" എന്ന പുസ്തകം റഷ്യൻ വിവർത്തനം ഇതിനകം ഓർഡർ ചെയ്യാവുന്നതാണ് ഓൺലൈൻ സ്റ്റോറുകൾ. കൂടാതെ, ആൻ്റൺ ഖോലോമിയേവിൻ്റെ ഉപയോഗപ്രദമായ ഒരു പുസ്തകം, "ഹാസ്കൽ പാഠപുസ്തകം", ഇൻ്റർനെറ്റിൽ കണ്ടെത്തി. നിങ്ങൾക്ക് ഹാസ്കെൽ പഠിക്കാൻ "സമയമില്ലെങ്കിൽ", ഗ്രിഗറി മേക്കീവിൻ്റെ പാഠപുസ്തകം വായിക്കാൻ ശ്രമിക്കുക, അതിൽ 114 പേജുകൾ മാത്രമേയുള്ളൂ. എൻ്റെ ബ്ലോഗിൻ്റെ എല്ലാ സ്ഥിരം വായനക്കാർക്കും ഞാൻ ഒരു മിതമായ തീവ്ര അനുയായിയാണെന്ന് അറിയാമെന്ന് ഞാൻ കരുതുന്നു. മറ്റെല്ലാ കാര്യങ്ങളെക്കുറിച്ചും ഒന്നും കേൾക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നില്ല എന്നല്ല - അല്ല, തിരഞ്ഞെടുക്കാനുള്ള സാധ്യതയ്ക്കും ചർച്ചയ്ക്കും മികച്ചതിനായുള്ള നിരന്തരമായ തിരയലിനും വേണ്ടി ഞാൻ എപ്പോഴും വാദിക്കുന്നു, അതിനാൽ, ആത്യന്തികമായി, വികസന രീതികളുടെ ഒരു നിശ്ചിത പരിണാമത്തിനായി. വ്യക്തിത്വത്തിൻ്റെ ആരാധന ഒരു പ്രത്യേക പ്രോഗ്രാമിംഗ് രീതിശാസ്ത്രത്തിൻ്റെ ആരാധന പോലെ എനിക്ക് അരോചകമാണ്, കാരണം ദീർഘകാലാടിസ്ഥാനത്തിൽ ഇത് സ്തംഭനത്തിലേക്കും ഭ്രാന്തിലേക്കും ഉള്ള വ്യക്തമായ പാതയാണ്. ഈ വിദ്യാഭ്യാസ പ്രവർത്തനം തുടരുന്നതിലൂടെ, ഒരു അത്ഭുതകരമായ ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗ് ഭാഷയിൽ ഇന്ന് താമസിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. ഇതേ ചോദ്യം എനിക്ക് ഇതിനകം മൂന്ന് തവണ അയച്ചിട്ടുണ്ട്: ഹാസ്കെൽ പഠിക്കുന്നത് എവിടെ തുടങ്ങണം (തുടരുക)? ഒരു ചെറിയ ഉത്തരവും ഉപദേശവും നൽകാനുള്ള സമയമാണിത്. എന്നിൽ നിന്ന് ഈ വിഷയത്തിലേക്ക് പ്രവേശിക്കുന്നതിനുള്ള പൊതു അൽഗോരിതം ഇതാ. പ്രോഗ്രാമർ റിക്രൂട്ടർമാർക്കിടയിൽ അറിയപ്പെടുന്ന ഒരു വിരോധാഭാസം, പലപ്പോഴും "" എന്ന് വിളിക്കപ്പെടുന്നു, ഇത് ഇതുപോലെയാണ് രൂപപ്പെടുത്തിയിരിക്കുന്നത്: ഒരു കമ്പനി അതിൻ്റെ പ്രധാന പ്രോഗ്രാമിംഗ് ഭാഷയായി കുറച്ച് ഉപയോഗിക്കാത്ത നിഗൂഢ പ്രോഗ്രാമിംഗ് ഭാഷ തിരഞ്ഞെടുക്കുകയാണെങ്കിൽ, ആ കമ്പനിക്ക് വിപണിയിൽ മികച്ച പ്രോഗ്രാമർമാരെ ലഭിക്കാനുള്ള ഏറ്റവും വലിയ അവസരമുണ്ട്. എന്തുകൊണ്ട്? പുതിയ കാര്യങ്ങൾ പഠിക്കുന്നത് ഒരു പ്രശ്നമല്ലാത്ത പ്രോഗ്രാമർമാർ ആദ്യം അത്തരമൊരു "വിചിത്രമായ കമ്പനി" വാടകയ്ക്ക് എടുക്കാൻ ആഗ്രഹിക്കുന്നു എന്നതാണ് വസ്തുത; അധികം അറിയപ്പെടാത്തവരും ആക്സസ് ചെയ്യാൻ പ്രയാസമുള്ളവരുമായവർക്ക് ഒരു തടസ്സമല്ല; അവസാനമായി, അത്തരം കഠിനമായ സാഹചര്യങ്ങളിൽ സ്വയം സമർപ്പിക്കാൻ മതിയായ ആത്മാഭിമാനമുള്ളവർ. ഏറ്റവും പ്രധാനമായി: രണ്ട് തരം പ്രോഗ്രാമർമാർ ഉണ്ട്: നല്ല ജോലി ലഭിക്കാൻ പഠിക്കുന്നവർ, അവർ എപ്പോഴും തിരഞ്ഞെടുക്കുന്നു മുഖ്യധാര, കാരണം ഇത് അവരുടെ ജോലി കണ്ടെത്താനുള്ള സാധ്യത ഗണ്യമായി വർദ്ധിപ്പിക്കുന്നു; പുതിയ എന്തെങ്കിലും പഠിക്കാനും വികസിപ്പിക്കാനും അവർ എപ്പോഴും തിരഞ്ഞെടുക്കാനും ഇഷ്ടപ്പെടുന്നവർ മികച്ചത്, അത് പലപ്പോഴും അകലെയാണ് ഏറ്റവും ലാഭകരമായത്, അവരുടെ സഹപ്രവർത്തകർ ചെയ്യുന്നതുപോലെ. അതിനാൽ, പൈത്തൺ വിരോധാഭാസംഅത്യാധുനിക വിചിത്രമായ വികസനം ആരംഭിക്കുന്നതിലൂടെ, നിങ്ങൾ, ഒരു വാക്വം ക്ലീനർ പോലെ, രണ്ടാമത്തെ വിഭാഗം പ്രോഗ്രാമർമാരെ ആകർഷിക്കുമെന്ന് അവകാശപ്പെടുന്നു (ജോലി വാഗ്ദാനം ചെയ്യുന്ന കമ്പനികളുടെ കാര്യത്തിലും വിപരീതമാണ് ശരി). ഒരു അമൂർത്ത ഉദാഹരണമെന്ന നിലയിൽ, തന്നിരിക്കുന്ന പ്രോപ്പർട്ടികൾ ഉള്ള ഫോക്കസ് ഗ്രൂപ്പുകളെ പൂർണ്ണമായും സമാനമായ ഒരു രഹസ്യ ടാർഗെറ്റിംഗ് എനിക്ക് നൽകാൻ കഴിയും, എൻ്റെ സമീപകാല ചെറുപ്പത്തിൽ നിന്നുള്ള ഒരു കഥ. ഞാൻ ഇപ്പോഴും പഠിക്കുമ്പോൾ, ഞങ്ങൾക്ക് ഒരു "വിചിത്രമായ" പോഡ്‌പോഡ് ഉണ്ടായിരുന്നു, അത് അവതരിപ്പിക്കുമ്പോൾ അത് പ്രകടമായിരുന്നു ഗണിത വിശകലനംപ്രേക്ഷകരുടെ വലതു വശത്തേക്ക് ഒരിക്കലും ശ്രദ്ധിച്ചില്ല. അതായത്, സദസ്സിൽ രണ്ട് വരികൾ ഉണ്ടായിരുന്നു - ഇടത്തും വലത്തും - ഇവിടെ അദ്ദേഹം ഒരു പ്രഭാഷണം നടത്തുന്നു, എന്തെങ്കിലും വിശദീകരിക്കുന്നു, എന്നാൽ അതേ സമയം വലത് വരിയിലേക്ക് ഒരിക്കലും നോക്കില്ല - അവൻ്റെ ശ്രദ്ധ മുഴുവൻ ഇടത് നിരയിൽ നിന്നുള്ള വിദ്യാർത്ഥികളിൽ മാത്രമാണ്. . ചോദ്യങ്ങൾക്കുള്ള ഉത്തരങ്ങളോടൊപ്പം - ശരിയായ പാത അദ്ദേഹത്തിന് നിലവിലില്ല. അവന് അവിടെ നിന്ന് ഒന്നും കേൾക്കുന്നില്ല. തൽഫലമായി, വളരെക്കാലമായി ഞാൻ രസകരമായ ഒരു കാര്യം ശ്രദ്ധിച്ചു: ഞങ്ങളുടെ ഗ്രൂപ്പിൽ ഒരു യാന്ത്രിക സ്വയം തിരിച്ചറിയലും വിഘടനവും ഉണ്ടായിരുന്നു. ഗണിത വിശകലനംആവശ്യമുള്ളതും രസകരവുമാണ് (ഈ വിചിത്രമായ ഗെയിമിൻ്റെ നിയമങ്ങൾ അംഗീകരിച്ച് അവർ ഉടൻ തന്നെ ഇടത് നിരയിലെ സീറ്റുകൾ എടുത്തു), ആവശ്യമില്ലാത്തവരും, വലതുവശത്തുള്ള സീറ്റുകൾ എടുക്കാൻ അവർ തിടുക്കപ്പെട്ടു, കാരണം അവർ ഇവിടെ അവശേഷിക്കുന്നു അവരുടെ സ്വന്തം ആവശ്യങ്ങൾക്ക്. പുറത്തുനിന്നുള്ള അസാധാരണമായ ശ്രമങ്ങളൊന്നും കൂടാതെ തന്നെ ഈ തരംതിരിക്കൽ സംഭവിച്ചു. അധ്യാപകനെ സംബന്ധിച്ചിടത്തോളം, അദ്ദേഹത്തിൻ്റെ പ്രചോദനം ഞാൻ മനസ്സിലാക്കിയതുപോലെ, ഇത് വളരെ സൗകര്യപ്രദമായിരുന്നു - അടിസ്ഥാനപരമായി അപരിചിതർക്കായി അദ്ദേഹം തൻ്റെ ഊർജ്ജം പാഴാക്കിയില്ല, എന്നാൽ തൻ്റെ അറിവ് ആവശ്യമുള്ളവരിൽ തൻ്റെ ഊർജ്ജവും ശ്രദ്ധയും കേന്ദ്രീകരിക്കുന്നതിനുള്ള സാഹചര്യങ്ങൾ ഉടനടി സൃഷ്ടിച്ചു. സി വിദ്യാർത്ഥികൾക്കും ഇത് വിജയകരമായ സാഹചര്യമായിരുന്നു. മൂന്നാം ഘട്ടം ഇതിനകം ആഴത്തിൽ കുഴിക്കുന്നു. പരമ്പരാഗത പാറ്റേണുകൾ അൽപ്പം തകർക്കാൻ ഞാൻ ഇവിടെ നിർദ്ദേശിക്കുന്നു (ഓ, ഞാൻ ഇത് എങ്ങനെ ചെയ്യാൻ ഇഷ്ടപ്പെടുന്നു) കൂടാതെ വിവരങ്ങൾ അവതരിപ്പിക്കുന്നതിന് അടിസ്ഥാനപരമായി വ്യത്യസ്തമായ ഒരു ഫോർമാറ്റിലേക്ക് നീങ്ങുക: ഇത് ഒരു ഭാഷ പഠിക്കാനുള്ള ചുമതലയെ വൈവിധ്യവത്കരിക്കുക മാത്രമല്ല, പുതിയതും ഉൾക്കൊള്ളുകയും ചെയ്യും, നിങ്ങളുടെ മസ്തിഷ്കത്തിൻ്റെ ഇതുവരെ സജീവമല്ലാത്ത ഭാഗങ്ങൾ (ഞങ്ങൾ നിങ്ങളുടെ തളർന്നുപോയ പ്രോഗ്രാമറുടെ ഇടത് മസ്തിഷ്കത്തെ പ്രത്യേകിച്ച് ബുദ്ധിമുട്ടിക്കും). ഇംഗ്ലീഷ് വേരുകളുള്ള വളരെ മിടുക്കനായ ഒരാളിൽ നിന്നുള്ള ഹാസ്കെലിനെക്കുറിച്ചുള്ള മികച്ച വീഡിയോ പ്രഭാഷണമാണ് ഞാൻ ഉദ്ദേശിക്കുന്നത്. അതിൻ്റെ ഔട്ട്പുട്ട് ഇതാ: ഹാസ്കെൽ കോഴ്‌സ് ഉപയോഗിച്ചുള്ള പ്രവർത്തനപരമായ പ്രോഗ്രാമിംഗ് നിങ്ങൾക്ക് ഈ വലിയ വീഡിയോ പ്രഭാഷണം ഡൗൺലോഡ് ചെയ്യാം. രോഷാകുലരായ പകർപ്പവകാശ ഉടമകൾ ഓടിയെത്തി ഈ അപൂർവ ആർക്കൈവ് വെറുതെ നശിപ്പിക്കുന്നതിന് മുമ്പ് വേഗത്തിൽ പോകാൻ ഞാൻ നിങ്ങളെ ഉപദേശിക്കുന്നു ( അപ്ഡേറ്റ് ചെയ്യുക: അതെ, അവർ അവനെ ആണിയടിച്ചു: ആമേൻ. ഈ മെഗാ ലിങ്ക് ഉപയോഗിക്കാൻ താൽപ്പര്യമുള്ള എല്ലാവരെയും ഞാൻ ക്ഷണിക്കുന്നു). ഏറ്റവും അനുയോജ്യവും പ്രചോദനാത്മകവുമായ പ്രായോഗിക ജോലി കണ്ടെത്തുന്നത് ഒരു പ്രത്യേക പോസ്റ്റിൻ്റെ വിഷയമാണ്, അവിടെ പ്രശസ്തരുടെ ജീവിതത്തിൽ നിന്ന് ശ്രദ്ധേയമായ ചില ഉദാഹരണങ്ങൾ നൽകാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. ഗോണർ പ്രോഗ്രാമർമാർ, അതിനാൽ ഈ അവസാന ഘട്ടത്തെക്കുറിച്ചുള്ള എൻ്റെ വിശദീകരണങ്ങൾ ഇപ്പോൾ മാറ്റിവയ്ക്കാം. അതിനാൽ, ഇതുപോലുള്ള ഒന്ന്, പലർക്കും ഭാഗികമായി വ്യക്തമാണ്, അൽഗോരിതം, ഹാസ്കെൽ പഠിക്കാൻ ആഗ്രഹിക്കുന്ന എല്ലാവർക്കും നൽകാൻ ഞാൻ ആഗ്രഹിച്ചു, മാത്രമല്ല. അതിനായി ശ്രമിക്കൂ! അവസാനമായി, മറ്റ് പ്രോഗ്രാമിംഗ് ഭാഷകളുടെ ആരാധകർക്കായി: ജമാന്മാർക്ക് നൽകുന്ന ഒരു വിശുദ്ധ പ്രോഗ്രാമിംഗ് ഭാഷയാണ് ഹാസ്കെൽ ഡയമണ്ട്ലാൻഡ്അവരുടെ പരമോന്നത ദേവത കൊമോനാഡആശയവിനിമയത്തിനും ആത്മീയ ശുദ്ധീകരണത്തിനുമുള്ള ഒരു സാർവത്രിക ഉപാധി എന്ന നിലയിൽ, ദൈവിക മനുഷ്യർക്കും (ചിലർ) ബുദ്ധിയുടെ കഠിനമായ ഘട്ടങ്ങളാൽ കഷ്ടപ്പെടുന്ന മനുഷ്യർക്കും അനുയോജ്യമാണ്. അതിൻ്റെ ഉത്ഭവം കാരണം, ഭാഷ എല്ലായ്പ്പോഴും പ്രവർത്തനപരമായി ശുദ്ധമാണ്. ശരാശരി, 10-12 വയസ്സിൽ ഹാസ്കെൽ പഠിക്കാൻ തുടങ്ങുന്നു. നിങ്ങളുടെ പരിശീലനം നേരത്തെ ആരംഭിക്കുന്നത് 75 വയസ്സ് ആകുമ്പോഴേക്കും ശക്തിയുടെ മൂന്നാം തലത്തിൽ എത്തുമെന്ന് ഉറപ്പാക്കും. ഈ ജീവിതത്തിലെങ്കിലും ആരംഭിക്കാൻ കഴിയുന്നത് നിങ്ങളുടെ അടുത്ത ജീവിതം വരെ മാറ്റിവെക്കരുത്.6.2 മൊഡ്യൂളുകൾ
7 ക്ലാസുകളും മൊണാഡുകളും
7.1 ക്ലാസുകൾ
7.2 I/O
8 ഉദാഹരണങ്ങൾ
ഉപസംഹാരം
ഉപയോഗിച്ച ഉറവിടങ്ങളുടെ പട്ടിക
ML (1973) - ഹിൻഡ്ലി-മിൽനർ ടൈപ്പിംഗ് ഉള്ള ആദ്യ ഭാഷ;
സ്കീം (1975) ലിസ്പ് ഭാഷയിലെ ഏറ്റവും ജനപ്രിയമായ രണ്ട് ഭാഷകളിൽ ഒന്നാണ്;
SASL, KRC, Miranda (1972–1985) എന്നിവയാണ് ആദ്യ അലസ ഭാഷകളിൽ ചിലത്;
ഹോപ്പ് (1980) - ബീജഗണിത ഡാറ്റ തരങ്ങളുള്ള ആദ്യ ഭാഷകളിൽ ഒന്ന്.
ഹാസ്കെൽ കറി
ഹാസ്കെൽ 1.0 - 1.4
ഹാസ്കലിൻ്റെ ആദ്യ പതിപ്പ് (ഹാസ്കൽ 1.0) 1990-ൽ പുറത്തിറങ്ങി. സമിതിയുടെ ശ്രമങ്ങൾ ഭാഷാ പ്രയോഗങ്ങളുടെ ഒരു പരമ്പരയിൽ കലാശിച്ചു (1.0, 1.1, 1.2, 1.3, 1.4). 
ഹാസ്കെൽ 98
1997-ൻ്റെ അവസാനത്തിൽ, ഹാസ്കെൽ 98-ൻ്റെ പതിപ്പുകൾ ഭാഷയുടെ ഒരു സ്ഥിരതയുള്ളതും ചുരുങ്ങിയതും പോർട്ടബിൾ ആയതുമായ ഒരു പതിപ്പായും പഠനത്തിനായുള്ള ഒരു സ്റ്റാൻഡേർഡ് ലൈബ്രറിയായും ഭാവി വികസനത്തിൻ്റെ അടിസ്ഥാനമായി വ്യക്തമാക്കേണ്ടതുണ്ട്. ഹാസ്കെൽ 98-ൻ്റെ എക്‌സ്‌റ്റൻഷനുകളും വ്യതിയാനങ്ങളും പരീക്ഷണാത്മക സവിശേഷതകൾ ചേർത്ത് നടപ്പിലാക്കിയതിനെ കമ്മിറ്റി സ്വാഗതം ചെയ്തു. ഹാസ്കെൽ 2010
ആധുനിക ഹാസ്കെൽ സ്റ്റാൻഡേർഡ്, ഹാസ്കെൽ 2010, നവംബർ 24, 2009-ന് പ്രഖ്യാപിച്ചു; പതിപ്പ് 7.0.1 മുതൽ GHC ഇതിനെ പിന്തുണയ്ക്കുന്നു.
ശ്രേണിപരമായ മൊഡ്യൂളുകൾ
ശൂന്യമായ വേരിയബിൾ പ്രഖ്യാപനങ്ങൾ
സ്ഥിരത പരിഹാരം
മൂന്നാം കക്ഷി ഫംഗ്ഷൻ ഇൻ്റർഫേസ്
ലീനിയർ കമൻ്റ് സിൻ്റാക്സ്
ഗാർഡിയൻ പാറ്റേണുകൾ
ഭാരം കുറഞ്ഞ ആശ്രിതത്വ വിശകലനം
ഭാഷാ മാർഗ്ഗനിർദ്ദേശങ്ങൾ (പ്രാഗ്മ)
n+k പാറ്റേണുകളുടെ അഭാവം
വേരിയബിളുകളുടെ ബുള്ളറ്റ് ലിസ്റ്റുകൾഹാസ്കലിൻ്റെ സ്രഷ്ടാവിൽ നിന്ന്
ഹാസ്കെല്ലിന് മുകളിൽ നടപ്പിലാക്കിയ ഒരു പൊതു-ഉദ്ദേശ്യ എംബഡഡ് പ്രോഗ്രാമിംഗ് ഭാഷയാണ് കറി. കറി ഭാഷ ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ് (നെസ്റ്റഡ് എക്സ്പ്രഷനുകൾ, ഉയർന്ന ഓർഡർ ഫംഗ്ഷനുകൾ, അലസമായ മൂല്യനിർണ്ണയം), ലോജിക് പ്രോഗ്രാമിംഗ് (ബൂളിയൻ വേരിയബിളുകൾ, ഭാഗിക ഡാറ്റ ഘടനകൾ, ബിൽറ്റ്-ഇൻ സെർച്ച് സിസ്റ്റം), സമാന്തര സിസ്റ്റങ്ങൾക്കായുള്ള പ്രോഗ്രാമിംഗ് രീതികൾ (സമാന്തര എക്സ്പ്രഷൻ മൂല്യനിർണ്ണയം) എന്നിവയുടെ കഴിവുകൾ തടസ്സമില്ലാതെ സംയോജിപ്പിക്കുന്നു. ബൂളിയൻ വേരിയബിളുകളിൽ സിൻക്രൊണൈസേഷൻ ).
ജനപ്രീതി
Github വെബ്‌സൈറ്റിൽ ഇത് നിലവിൽ പ്രോഗ്രാമിംഗ് ഭാഷകൾക്കിടയിൽ ജനപ്രീതിയിൽ 23-ാം സ്ഥാനത്താണ്. ഫേസ്ബുക്ക്
Facebook എഞ്ചിനീയർമാർ പരിഹരിക്കുന്ന ഏറ്റവും പ്രധാനപ്പെട്ട ജോലികളിലൊന്നാണ് സ്പാം ഫിൽട്ടറിംഗ്. ഏറ്റവും വലിയ സോഷ്യൽ നെറ്റ്‌വർക്ക് 1.5 ബില്യണിലധികം ആളുകളിൽ നിന്നുള്ള സന്ദേശങ്ങൾ പ്രോസസ്സ് ചെയ്യുന്നു, അതിനാൽ നിങ്ങൾക്ക് പ്രശ്നത്തിൻ്റെ തോത് മനസ്സിലാക്കാൻ കഴിയും. 2015-ൽ, കമ്പനി പുതിയ ആൻ്റി-സ്പാം ഫിൽട്ടറുകൾ അവതരിപ്പിച്ചു, അവ ഹാസ്കെൽ പ്രോഗ്രാമിംഗ് ഭാഷ ഉപയോഗിച്ച് വികസിപ്പിച്ചെടുത്തു. 
എവ്ജെനി കോസ്ലോവ് തൻ്റെ ബ്ലോഗിൽ ഹാസ്കെലിനൊപ്പം പ്രവർത്തിക്കുന്നതിൻ്റെ മതിപ്പിനെക്കുറിച്ച് സംസാരിച്ചു:
കുറവുകൾ
ഒന്നാമതായി, ഭാഷയിലേക്കുള്ള പ്രവേശനത്തിന് ഉയർന്ന തടസ്സമുണ്ട്. അതെ, ഹാസ്കെൽ മനോഹരവും വൃത്തിയുള്ളതും സംക്ഷിപ്തവുമാണ്, എന്നാൽ ഇത് സൗജന്യമായി നേടിയെടുത്തതല്ല, മറിച്ച് മസ്തിഷ്കത്തിൻ്റെ ഒരു നീണ്ട പുനർനിർമ്മാണത്തിലൂടെയും മൊണാഡുകൾ, മോണാഡ് ട്രാൻസ്ഫോർമറുകൾ, ലെൻസുകൾ, മെഷീനുകൾ എന്നിവ പോലുള്ള സങ്കീർണ്ണമായ അമൂർത്തതകളെക്കുറിച്ചുള്ള പഠനത്തിലൂടെയുമാണ്.
പോസിറ്റീവ് വശങ്ങൾ
ഒന്നാമതായി, തീർച്ചയായും, ഭാഷയുടെ വിശുദ്ധി. രണ്ട് ഇന്ദ്രിയങ്ങളിലും പരിശുദ്ധി: പ്രവർത്തനങ്ങളുടെ ശുദ്ധതയും OOP മാതൃകയുടെ പൂർണ്ണമായ അഭാവവും. നിങ്ങൾക്ക് ഒരു ഫംഗ്ഷൻ്റെ ഒപ്പ് നോക്കാനും അത് പാർശ്വഫലങ്ങൾ ഉണ്ടാക്കുമോ ഇല്ലയോ എന്ന് കണ്ടെത്താനും കഴിയുന്നത് വളരെ രസകരമാണ്. OOP യുടെ അഭാവം അർത്ഥമാക്കുന്നത് ഒരു അടിസ്ഥാന ക്ലാസ്സിൽ നിന്ന് ഒരു സബ്ക്ലാസ്സിലേക്ക് പരിശോധിക്കാത്ത കാസ്റ്റുകൾ പോലെയുള്ള ഭയാനകമായ കാര്യങ്ങൾ ചെയ്യാൻ ഒരു മാർഗവുമില്ല എന്നാണ്.
1. ഭാഷയുടെ സൗന്ദര്യവും പ്രഖ്യാപനവും
| സംഖ്യ<
1
=
| അല്ലാത്തപക്ഷം = [ x | x<-
[
1
..
num]
,
num `mod
` x ==
0
]
-- ^ വ്യക്തമായ ഒപ്റ്റിമൈസേഷൻ -
| സംഖ്യ<=
1
=
False
| അല്ലാത്തപക്ഷം = getDivisors സംഖ്യ == [ 1 , സംഖ്യ]2. ഓട്ടോമാറ്റിക് മെമ്മറി മാനേജ്മെൻ്റ്
3. ശുദ്ധമായ പ്രവർത്തനങ്ങൾ
4. പ്രകടനം
5. റീഫാക്റ്ററിംഗ് കുറവ്
6. TDD ഉം UML ഉം ആവശ്യമാണോ?
7. ആപ്ലിക്കേഷൻ്റെ വിശാലമായ വ്യാപ്തി
ഘട്ടം 0 - ആമുഖം. ഹാസ്കെൽ? എന്തൊരു നരകമാണ്?
3. ഘട്ടം - ഒരു പുതിയ ഭാഷയുടെ ആഴവും വികാരവും തിരയുന്നു
(ഭാഷ: ഇംഗ്ലീഷ്)
35 മണിക്കൂർ | 1280x720 | XviD - 1326Kbps
25.00fps | Mp3 - 96Kbps | 20.06 ജിബി 
4. അവസാന ഘട്ടം പരിശീലനമാണ്
