முன்குறிப்பு: கருத்தனின் பரிந்துரைப்படி, Functional programming என்பதற்கு “செயற்கூறிய நிரலாக்கம்” என்ற பதத்தையே தொடர்ந்து பயன்படுத்துவோம்.
[code lang=”javascript”]
var x = 1;
x = x + 1;
[/code]
இந்த நிரலை முதன்முதலில் பயன்படுத்தியபோது, xம், (x + 1)ம் சமமாக இருக்கமுடியாதென்ற அடிப்படை கணித சமன்பாட்டை மறந்துவிட்டிருந்தோம்.
xன் மதிப்புடன் ஒன்றைக்கூட்டி, அதன் விடையை மீண்டும் xல் சேமிக்கவேண்டும் என்பதே, பிறமுக்கிய மொழிகளில் , இதன் பொருள். ஆனால், x = x + 1 என்பது செயற்கூறிய நிரலாக்கச் சட்டங்களுக்குப் புறம்பானது. எனவே நாம் கணிதத்தில் படித்ததை மறக்கத்தேவையில்லை.
செயற்கூறிய நிரலாக்கத்தில் மாறிகளே (variables) இல்லை.
பிறமொழிகளின் தாக்கத்தின் காரணமாக, ஒரு மதிப்பைச் சேமித்துவைக்கும்போது அதனை மாறி என்ற பெயர்கொண்டு அழைக்கிறோம். ஆனால், செயற்கூறிய நிரலாக்கத்தில் மாறிகளே இல்லை. அனைத்தும் மாறிலிகளே (constants).
மாறிகளே இல்லாமல் நிரலெழுதுவதெப்படி என வியக்கவேண்டாம். மாறிகளின் மதிப்பை மாற்றவேண்டிய அவசியத்தை, இருவகைப்படுத்தலாம்:
- பன்மதிப்பு மாற்றங்கள் – multi valued changes (எ.கா: ஒரு பொருளிலுள்ள (object) மதிப்புகளை மாற்றுதல்)
- ஒற்றை மதிப்புடைய மாற்றங்கள் – single valued changes (எ.கா: மடக்கு கட்டளைகளின் சுற்றுகளின் (loop counter) எண்ணிக்கையைக் கணக்கிடுதல்)
இவ்விருவகை மாற்றங்களையும் சிறப்பு தரவுக்கட்டமைப்புகள்கொண்டு, (datastructures) செயற்கூறிய நிரலாக்கமொழிகள் திறமையாகக்கையாளுகின்றன. இதன்மூலம், ஒட்டுமொத்த பொருளையும் படியெடுக்காமல், மாற்றங்களைமட்டும் படியெடுக்கமுடியும்.
செயற்கூறிய நிரலாக்கமொழிகளில் மடக்கு கட்டளைகள் இல்லையென்பதால், ஒற்றைமதிப்புடைய மாற்றங்களையும் பெருமளவு தவிர்க்கமுடிகிறது..
மாறிகளும் இல்லை. மடக்கு கட்டளைகளும் இல்லை. எப்படித்தான் நிரலெழுதுவது?
For, while, do போன்ற மடக்கு கட்டளைகள் இல்லையென்றாலும், அதன் இடத்தை தற்சுருள் (recursion) கொண்டு இட்டுநிரப்பலாம்.
எடுத்துக்காட்டாக, கொடுக்கப்பட்டுள்ள இரு எண்களுக்கிடையேயான எண்களின் கூட்டுத்தொகையைக் கணக்கிடும் நிரலை எடுத்துக்கொள்ளலாம். ஜாவாஸ்கிரிப்ட்டில், அதனை பின்வருமாறு எழுதலாம். இதில் மடக்குக்கட்டளைகளைப் பயன்படுத்தி எழுதியிருக்கிறோம்.
[code lang=”javascript”]
var acc = 0;
for (var i = 1; i <= 10; ++i)
acc += i;
console.log(acc); // 55ஐ அச்சிடுகிறது
[/code]
இதனை, செயற்கூறிய நிரலாக்கமொழியான எலிக்சரில் எழுத முயலலாம்.
[code lang=”ruby”]
defmodule Immutability do
def sum_range(start, stop, acc) do
if start > stop do
acc
else
sum_range((start + 1), stop, (acc + start))
end
end
end
[/code]
மேற்கண்ட நிரலின் இயக்கத்தை பின்வருமாறு புரிந்துகொள்ளலாம்.
[code lang=”ruby”]
sum_range(1, 10, 0) => sum_range(2, 10, 1)
sum_range(2, 10, 1) => sum_range(3, 10, 3)
sum_range(3, 10, 3) => sum_range(4, 10, 6)
sum_range(4, 10, 6) => sum_range(5, 10, 10)
sum_range(5, 10, 10) => sum_range(6, 10, 15)
sum_range(6, 10, 15) => sum_range(7, 10, 21)
sum_range(7, 10, 21) => sum_range(8, 10, 28)
sum_range(8, 10, 28) => sum_range(9, 10, 36)
sum_range(9, 10, 36) => sum_range(10, 10, 45)
sum_range(10, 10, 45) => sum_range(11, 10, 55)
55
[/code]
மடக்குக்கட்டளைகள் புரிந்துகொள்ள எளிமையாக இருக்கின்றன, ஆனால் தற்சுருள் அப்படியில்லை என நீங்கள் வாதிடலாம். ஆனால், மடக்குக்கட்டளைகளைப்பெற நிலைமாறாத்தன்மையை (Immutability) விட்டுக்கொடுக்கவேண்டியுள்ளது.. நிலைமாறாத்தன்மையால் கிடைக்கும் நன்மைகளைக் கணக்கிட்டுப்பார்க்கும்போது, தற்சுருள்களைப் பயன்படுத்த பழக்கப்படுத்திக்கொள்வது சாலச்சிறந்தது.
நிலைமாறாத்தன்மைகொண்ட மொழிகளில், ஒரு மாறியை அணுகும்போது, நம்மால் அதன்மதிப்பைப்பெறமட்டுமே (readonly access) முடியும். தற்செயலாகக்கூட அதன்மதிப்பை மாற்றிவிடமுடியாது. எனவே, பலவிழையாக்கத்தின்போது (multi-threading), ஒரு இழையில் பயன்படுத்தப்படும் மாறியின் மதிப்பை மற்றொரு இழை மாற்றிவிடக்கூடிய அபாயம் இங்கே முற்றிலுமாக தவிர்க்கப்படுகிறது.
எளிமையான பாதுகாப்பான நிரலை நிலைமாறாத்தன்மை நமக்குத்தருகிறது.
மூலம்: Charles Scalfani எழுதிய கட்டுரைத்தொடரின் தமிழாக்கம். அவரது அனுமதியோடு மொழிபெயர்க்கப்பட்டுள்ளது.