உலகெங்குமுள்ள நிரலர்களுக்கு ஒரு பொதுப்பண்பு உண்டு. ஒருமுறை எழுதிய நிரலை மறுமுறை எழுத அவர்கள் விரும்புவதில்லை. முன்பெழுதியதுபோன்ற நிரலை மீண்டும் எழுதநேரும்போது, ஏற்கனவே உள்ள நிரலைப்பயன்படுத்தவே முயல்கிறோம்.
கொள்கையடிப்படையில், நிரலின் மறுபயன்பாடு என்பது மிகச்சிறந்த கோட்பாடு. ஆனால், அதை நடைமுறைப்படுத்துவது அவ்வளவு எளிதானதல்ல. குறிப்பிட்ட தேவைக்காக நிரலெழுதும்போது பிற இடங்களில் அதைப்பயன்படுத்துவது கடினமாகிறது. அதேநேரத்தில், மிகவும் பொதுப்படையாக நிரலெழுதினால், எந்த தேவைக்காக எழுதப்பட்டதோ, அதை நிறைவேற்றுவதே கடினமாகிவிடுகிறது.
ஆகவே, இவையிரண்டுக்குமிடையே ஒரு சமநிலையைக்கண்டறிவது அவசியம். பலமுறை பயன்படுத்தக்கூடிய சிறுசிறு தொகுதிகளைக்கொண்டு ஒரு சிக்கலான தேவையைக்கட்டமைக்க வழிகாணவேண்டும்.
செயற்கூறிய நிரலாக்கத்தின் அடிப்படை கட்டுமானத்தொகுதிகள் செயற்கூறுகளாகும்.
ஒரு குறிப்பிட்டவேலையைச் செய்யும் செயற்கூறுகளைகொண்டு சிக்கலான தேவைகளுக்குத் தீர்வுகாணும் முறைக்கு செயற்கூற்றுக்கலவை (Function Composition) என்று பெயர்.
இதைப்புரிந்துகொள்ள கீழேயுள்ள இரு செயற்கூறுகளை எடுத்துக்கொள்ளலாம். கொடுக்கப்பட்ட எண்ணுடன் பத்தைக்கூட்டுவதற்கு add10, கொடுக்கப்பட்ட எண்ணை ஐந்தால் பெருக்குவதற்கு mult5 என இரு செயற்கூறுகளை வரையறுக்கலாம்.
[code lang=”javascript”]
var add10 = function(value) {
return value + 10;
};
var mult5 = function(value) {
return value * 5;
};
[/code]
இவற்றைச்சுருக்கமாக எழுத தடித்த அம்புக்குறியீட்டைப் பயன்படுத்தலாம்.
[code lang=”javascript”]
var add10 = value => value + 10;
var mult5 = value => value * 5;
[/code]
இப்போது, ஓர் எண்ணுடன் பத்தைக்கூட்டி, அதை ஐந்தால் பெருக்கவேண்டுமென வைத்துக்கொள்வோம். இதற்கான செயற்கூற்றின் வரையறையை கீழே காணலாம்.
[code lang=”javascript”]
var mult5AfterAdd10 = value => 5 * (value + 10);
[/code]
இது மிக எளிமையானதாக இருந்தாலும், கவனக்குறைவால் தவறுநேர வாய்ப்பிருக்கிறது. கவனக்குறைவால், அடைப்புக்குறிகளை மறந்துவிட்டால், செயற்கூற்றின் வரையறையே மாறிவிடும். கொடுக்கப்பட்ட எண்ணை ஐந்தால் பெருக்கி, அதனுடன் பத்தைக்கூட்டிவிடும். மேலும், நம்மிடம் இச்செயற்கூற்றின் இருதேவைகளையும் செய்வதற்கான சிறு செயற்கூறுகள் இருப்பதால், அவற்றைப்பயன்படுத்த முயலலாம்.
[code lang=”javascript”]
var mult5AfterAdd10 = value => mult5(add10(value));
[/code]
இங்கே இருசெயற்கூறுகளைக் கலந்துகட்டி ஒருபுதிய செயற்கூற்றை உருவாக்கியிருக்கிறோம். செயற்கூறிய நிரலாக்கமொழிகளில் இதற்கென சிறப்பு செயல்பாடுகள் வழங்கப்படுகின்றன. எடுத்துக்காட்டாக, இச்செயற்கூற்றுக்கலவையை, எல்ம் மொழியில் எப்படி எழுதுவதென பார்க்கலாம்.
[code lang=”sql”]
add10 value =
value + 10
mult5 value =
value * 5
mult5AfterAdd10 value =
(mult5 << add10) value
[/code]
இங்கே << என்பதற்கு இடையமைச்செயல்பாடு என்று பெயர். கொடுக்கப்பட்ட உள்ளீட்டுமதிப்புகளின் போக்கினைக் குறிக்கும்விதமாக இச்செயல்பாடு அமைந்துள்ளது. value என்பது முதலில் add10க்கு வழங்கப்பட்டு, அதன் விடை mult5க்கு வழங்கப்படுகிறது என்பதையே இது குறிக்கிறது.
இங்கே mult5 << add10 என்பதை அடைப்புக்குறிக்குள் எழுதியிருப்பதைக் கவனிக்கவேண்டும். மதிப்புகளை உள்ளிடுவதற்குமுன் செயற்கூறுகளின் கலவையை உருவாக்கியிருக்கவேண்டும் என்பதைக்குறிக்கவே இதுபயன்படுகிறது.
இரண்டுக்குமேற்பட்ட பலசெயற்கூறுகளின் கலவையை பின்வருமாறு உருவாக்கலாம்.
[code lang=”sql”]
f x =
(g << h << s << r << t) x
[/code]
இங்கே t-இல் தொடங்கி g-வரையிலான வரிசையில் செயற்கூறுகள் இயக்கப்படுகின்றன.
புள்ளியிலாக்குறியீடு (Point-Free Notation)
உள்ளீட்டு உருபுகளைக்குறிப்பிடாமல் செயற்கூறுகளை வரையறுக்கும் பாணிக்கு புள்ளியிலாக்குறியீடு என்று பெயர். தொடக்கத்தில் சற்று விசித்திரமாக இருந்தாலும், பயன்படுத்தப்பழகியபின்பு, மிகச்சுருக்கமாக செயற்கூறுகளை எழுதமுடியும்.
mult5AfterAdd10 செயற்கூற்று வரையறையில் value என்ற மாறி இருமுறை குறிப்பிடப்பட்டுள்ளது.
[code lang=”sql”]
— இவ்வெடுத்துகாட்டிலுள்ள செயற்கூறுகளனைத்தும் ஒரேயொரு உள்ளீட்டு உருபைமட்டுமே ஏற்கின்றன.
mult5AfterAdd10 value =
(mult5 << add10) value
[/code]
add10 செயற்கூறும், mult5AfterAdd10 செயற்கூறும் ஒரே உள்ளீட்டு உருபினை ஏற்பதால், இதை வெளிப்படையாக குறிப்பது அவசியமற்றது. எனவே, மேற்கண்ட வரையறையின் புள்ளியிலாக்குறியீட்டு பாணியில் பின்வருமாறு மாற்றியெழுதலாம்.
[code lang=”sql”]
— இவ்வெடுத்துக்காட்டிலும், எல்லா செயற்கூறுகளும் ஒரேயொரு உள்ளீட்டு உருபையே ஏற்கின்றன.
mult5AfterAdd10 =
(mult5 << add10)
[/code]
இம்முறையில் பலநன்மைகள் உள்ளன.
முதலாவதாக, உள்ளீட்டு உருபுகளை மீண்டுமீண்டும் குறிப்பிடத்தேவையில்லை.
இரண்டாவதாக, வாசிப்பதற்கு மிக எளிமையானதாக உள்ளன.
ஆனால், இதில் ஒரு சிறிய சிக்கலுள்ளது. அதைப்புரிந்துகொள்ள சற்றே மாறுபட்ட எடுத்துக்காட்டைக்காணலாம். add10 என்ற செயற்கூற்றுக்குப்பதிலாக add என்ற செயற்கூற்றை வரையறுக்கலாம்.
[code lang=”sql”]
add x y =
x + y
mult5 value =
value * 5
[/code]
இப்போது, add, mult5 என்ற இரு செயற்கூறுகளை வைத்து mult5AfterAdd10 என்ற செயற்கூற்றை வரையறுக்க, என்னசெய்யவேண்டும்?
[code lang=”sql”]
— பிழையான நிரல் !!!!
mult5AfterAdd10 =
(mult5 << add) 10
[/code]
இங்கே குறிப்பிட்டுள்ளதைப்போல, பழைய வரையறையில் add10க்குப்பதிலாக add ஐப்பயன்படுத்தவேண்டும் என நினைத்தால் அது தவறு. ஏனெனில், add செயற்கூறு இரண்டு உள்ளீட்டு உருபுகளை எதிர்பார்க்கிறது. இதையே ஜாவாஸ்கிரிப்ட்டில் பின்வருமாறு எழுதலாம்.
[code lang=”javascript”]
var mult5AfterAdd10 = mult5(add(10)); // பிழையான நிரல்
[/code]
இங்கே நாம் செய்வது தவறென எளிதில் புரிந்துகொள்ளமுடிகிறது. இதனைப்பின்வருமாறு திருத்தலாம்.
[code lang=”javascript”]
var mult5AfterAdd10 = y => mult5(add(10, y)); // சரியான நிரல். ஆனால், புள்ளியிலாக்குறியீட்டைப் பயன்படுத்தவில்லை.
[/code]
ஆனால், இங்கே நாம் செயற்கூறுகளின் கலவையை உருவாக்கவில்லை. மாறாக, புதிய செயற்கூற்றையே உருவாக்கியிருக்கிறோம். இதுபோல இன்னும் சில செயற்கூறுகளை சங்கிலித்தொடர்போல பயன்படுத்தவேண்டுமெனில், அத்தகைய நிரலை எழுதுவதிலும், படித்துப்புரிந்துகொள்வதிலும் சிரமம் ஏற்படுகின்றது.
இப்படியொரு சிக்கலைத்தீர்க்க செயற்கூறிய நிரலாக்கத்தில் ஏதேனும் வழியிருக்கிறதா? அதை அடுத்தபகுதியில் தெரிந்துகொள்வோம்.
மூலம்: Charles Scalfani எழுதிய கட்டுரைத்தொடரின் தமிழாக்கம். அவரது அனுமதியோடு மொழிபெயர்க்கப்பட்டுள்ளது.