செயற்கூறிய நிரலாக்கம் – ஒற்றைஉள்ளீட்டாக்கம் – பகுதி 6

முந்தைய பகுதியில் mult மற்றும் add என்ற இருசெயற்கூறுகளைகளின் உள்ளீட்டுஉருபுகளின் எண்ணிக்கையின் வேறுபாட்டால், அவற்றைக்கொண்டு செயற்கூற்றுக்கலவையை உருவாக்கமுடியாமல் போனது.

var add = (x, y) => x + y;
var mult5 = value => value * 5;
var mult5AfterAdd10 = y => mult5(add(10, y));

இங்கே add செயற்கூறு இரண்டு உள்ளீட்டுஉருபுகளை ஏற்கிறது. எனவே அதனை ஒற்றை உள்ளீட்டுஉருபை ஏற்கும் mult என்ற செயற்கூறோடு கலந்து புதிய செயற்கூற்றை வரையறுக்கமுடியாது.

நமது mult5AfterAdd10 செயற்கூற்றுக்குத்தேவையான add10 செயற்கூற்றை add செயற்கூற்றிலிருந்து பின்வருமாறு தருவிக்கலாம்.

var add10 = y => add(10,y);

பிறகு add10ஐயும், mult5ஐயும் கலந்து mult5AfterAdd10 செயற்கூற்றை உருவாக்கமுடியும்.

இங்கே நாம் ஒருவகையான செயலுருபுக்குறுக்கத்தைக் (partial application) கையாண்டுள்ளோம். அதாவது, முதல்படியாக add செயற்கூற்றுக்கு ஒரேயொரு உள்ளீட்டுஉருபை (x = 10) மட்டும் அளித்துள்ளோம். அதன் இரண்டாவது உள்ளீட்டுஉருபை (y), காலந்தாழ்த்தி வழங்குகிறோம்.

இவ்வாறாக ஒரு செயற்கூறுக்கான உள்ளீட்டு உருபுகளை ஒன்றன்பின் ஒன்றாக வழங்குவதை ஒற்றைஉள்ளீட்டாக்கம் (Currying) என்கிறோம்.

ஜாவாஸ்கிரிப்ட்டில், இதனை பின்வருமாறு எழுதலாம்.

var add = x => y => x + y

இந்த add செயற்கூறு முதலில் x என்ற ஒற்றைஉள்ளீட்டுஉருபை ஏற்று, ஒரு பெயரில்லா செயற்கூற்றை (anonymous function) அளிக்கிறது. இப்பெயரில்லா செயற்கூறு, y என்ற ஒற்றைஉள்ளீட்டுஉருபை ஏற்று, இவ்விரு எண்களின் கூட்டுத்தொகையை அளிக்கிறது.

இதனைப்பயன்படுத்தி, mult5AfterAdd10 செயற்கூற்றை வரையறுக்கலாம்.

var compose = (f, g) => x => f(g(x));
var mult5AfterAdd10 = compose(mult5, add(10));

இதனை எல்ம் என்ற செயற்கூறிய நிரலாக்கமொழியில் எழுதமுயலலாம்.

add x y =
    x + y
mult5AfterAdd10 =
    (mult5 << add 10)

ஒற்றைஉள்ளீட்டாக்கத்திற்காக, add செயற்கூற்றை திருத்தியெழுதத்தேவையில்லை. ஏனெனில், பெரும்பாலான செயற்கூறியநிரலாக்கமொழிகளில், எல்லா செயற்கூறுகளுமே, இயல்பாகவே ஒற்றைஉள்ளீட்டாக்கத்திற்கு ஏற்றதாக உள்ளன.

ஒற்றைஉள்ளீட்டாக்கமும் மறுபகுப்பும்

மறுபகுப்பின்போது (Refactoring), பல உருபுகளை ஏற்கக்கூடிய பொதுவான செயற்கூறொன்றை உருவாக்கி, அதன்பின் ஒவ்வொரு உருபாக உள்ளிடுவதன்மூலம், குறிப்பிட்ட பணியைச்செய்யக்கூடிய செயற்கூறுகளை உருவாக்குவதில், ஒற்றைஉள்ளீட்டாக்கம் பெருமளவில் உதவுகிறது.

எடுத்துக்காட்டாக, கொடுக்கப்பட்ட சரத்தை (String) அடைப்புக்குறிக்குள் எழுதக்கூடிய இருவேறு செயற்கூறுகளை எழுதலாம்.

bracket str =
	"{" ++ str ++ "}"
doubleBracket str =
    "{{" ++ str ++ "}}"

இதனைக்கீழ்கண்டவாறு பயன்படுத்தலாம்:

bracketedJoe =
    bracket "Joe"
doubleBracketedJoe =
    doubleBracket "Joe"

bracket, doubleBracket என்ற இரு செயற்கூறுகளுக்கும் பொதுவான செயற்கூறொன்றை வரையறுக்கலாம்:

generalBracket prefix str suffix =
    prefix ++ str ++ suffix

generalBracket என்ற செயற்கூறு prefix, str, suffix என்ற உருபுகளை ஏற்றுக்கொண்டு, கொடுக்கப்பட்ட சரத்துடன், முன்னொட்டையும், பின்னொட்டையும் இணைத்து அளிக்கிறது. மேற்கண்ட இருசெயற்கூறுகளுக்குப்பதிலாக பொதுவான செயற்கூற்றைப்பயன்படுத்த முற்பட்டால், ஒவ்வொருமுறையும் முன்னொட்டையும், பின்னொட்டையும் அளிக்கவேண்டியிருக்கும்.

பொதுவான செயற்கூற்றையும் பயன்படுத்தவேண்டும், ஆனால், முன்னொட்டு, பின்னொட்டுகளை மீண்டுமீண்டும் வழங்காமலிருக்கவேண்டும். என்ன செய்யலாம்?

ஒற்றைஉள்ளீட்டாக்கத்தைப் பயன்படுத்தி, இதனை மறுபகுப்பு செய்யமுயலலாம்.

ஒற்றைஉள்ளீட்டாக்கத்திற்காக, generalBracket செயற்கூற்றின் உருபுகளின் வரிசையை மாற்றியமைக்கலாம்.

generalBracket prefix suffix str =
    prefix ++ str ++ suffix

இதனைப்பயன்படுத்தி, bracket, doubleBracket செயற்கூறுகளை வரையறுக்கலாம்.

bracket =
    generalBracket "{" "}"
doubleBracket =
    generalBracket "{{" "}}"

பெருமளவில் மாறாத உருபுகளை முதலிலும், ஒவ்வொருபயன்பாட்டின்போதும் மாறக்கூடிய சாத்தியமுள்ள உருபுகளை கடைசியாகவும் ஏற்றுக்கொள்ளுமாறு பொதுவான செயற்கூற்றை வரையறுப்பதன்மூலம், அதிலிருந்து, குறிப்பிட்ட பணியைச்செய்யும் செயற்கூறுகளைத் தருவிக்கமுடிகிறது.

ஒற்றைஉள்ளீட்டாக்கத்தை முழுமையாகப் பயன்படுத்துவதில் உள்ளீட்டுஉருபுகளின் வரிசை முக்கியபங்குவகிக்கிறது.

மேலும், இங்கே bracket, doubleBracket செயற்கூறுகள் புள்ளியிலாக்குறியீட்டில் எழுதப்பட்டிருப்பதையும் கவனிக்கவேண்டும்.

bracketedJoe =
    bracket "Joe"
doubleBracketedJoe =
    doubleBracket "Joe"

மூலம்: Charles Scalfani எழுதிய கட்டுரைத்தொடரின் தமிழாக்கம். அவரது அனுமதியோடு மொழிபெயர்க்கப்பட்டுள்ளது.

%d bloggers like this: