Higher order

Higher order functions என்பவை பிற செயல்பாடுகளை கையாளும் செயல்பாடுகளாகும். எடுத்துக்காட்டாக, ஒரு செயல்பாடு பிற செயல்பாடுகளை வாதங்களாக எடுத்துக் கொள்ளலாம் மற்றும்/அல்லது அதன் திரும்பப் பெறும் மதிப்பாக ஒரு செயல்பாட்டை உருவாக்கலாம். இத்தகைய ஆடம்பரமான செயல்பாட்டு நுட்பங்கள் ஜாவாஸ்கிரிப்ட் மற்றும் python, lisp போன்ற பிற உயர்மட்ட மொழிகளில் உங்களுக்கு கிடைக்கும் சக்திவாய்ந்த கட்டமைப்புகளாகும்.

இப்போது நாம் add_2 மற்றும் double என்ற இரண்டு எளிய செயல்பாடுகளையும், map எனப்படும் higher order function ஒன்றையும் உருவாக்குவோம். map ஆனது func மற்றும் list என்ற இரண்டு வாதங்களை ஏற்றுக்கொள்ளும் (எனவே அதன் அறிவிப்பு map(func,list) எனத் தொடங்கும்), மற்றும் ஒரு வரிசையை (array) திரும்பப் பெறும். func (முதல் வாதம்) என்பது list (இரண்டாவது வாதம்) வரிசையில் உள்ள ஒவ்வொரு உறுப்புக்கும் பயன்படுத்தப்படும் ஒரு செயல்பாடாக இருக்கும்.

// இரண்டு எளிய செயல்பாடுகளை வரையறுக்கவும்
let add_2 = function (x) {
  return x + 2;
};
let double = function (x) {
  return 2 * x;
};

// map என்பது 2 வாதங்களை ஏற்கும் ஒரு அருமையான செயல்பாடு:
//  func    அழைக்க வேண்டிய செயல்பாடு
//  list    func ஐ அழைக்க வேண்டிய மதிப்புகளின் வரிசை
let map = function (func, list) {
  let output = []; // வெளியீட்டு பட்டியல்
  for (idx in list) {
    output.push(func(list[idx]));
  }
  return output;
};

// ஒரு முழு உள்ளீட்டு பட்டியலுக்கும் ஒரு செயல்பாட்டைப் பயன்படுத்த map ஐப் பயன்படுத்துகிறோம்
// அவற்றை தொடர்புடைய வெளியீடுகளின் பட்டியலுக்கு "வரைபடமாக்க"
map(add_2, [5, 6, 7]); // => [7, 8, 9]
map(double, [5, 6, 7]); // => [10, 12, 14]

மேலே உள்ள எடுத்துக்காட்டில் உள்ள செயல்பாடுகள் எளிமையானவை. இருப்பினும், பிற செயல்பாடுகளுக்கு வாதங்களாக அனுப்பப்படும்போது, ​​அவை மிகவும் சிக்கலான செயல்பாடுகளை உருவாக்க எதிர்பாராத வழிகளில் தொகுக்கப்படலாம்.

எடுத்துக்காட்டாக, எங்கள் குறியீட்டில் map(add_2, ...) மற்றும் map(double, ...) ஆகிய அழைப்புகளை நாம் அடிக்கடி பயன்படுத்துவதை கவனித்தால், விரும்பிய செயல்பாட்டை தங்களுக்குள்ளேயே கொண்டுள்ள இரண்டு சிறப்பு நோக்கத்திற்கான பட்டியல் செயலாக்க செயல்பாடுகளை உருவாக்க நாம் முடிவு செய்யலாம். செயல்பாட்டு கலவையைப் (function composition) பயன்படுத்தி, நாம் இதை பின்வருமாறு செய்யலாம்:

process_add_2 = function (list) {
  return map(add_2, list);
};
process_double = function (list) {
  return map(double, list);
};
process_add_2([5, 6, 7]); // => [7, 8, 9]
process_double([5, 6, 7]); // => [10, 12, 14]

இப்போது உள்ளீடாக func என்ற செயல்பாட்டை எடுத்து ஒரு func-processor ஐ திரும்பப் பெறும் buildProcessor எனப்படும் ஒரு செயல்பாட்டை உருவாக்குவோம், அதாவது, பட்டியலில் உள்ள ஒவ்வொரு உள்ளீட்டிற்கும் func ஐப் பயன்படுத்தும் ஒரு செயல்பாடு.

// ஒரு பட்டியல் செயலியை உருவாக்கும் ஒரு செயல்பாடு
let buildProcessor = function (func) {
  let process_func = function (list) {
    return map(func, list);
  };
  return process_func;
};
// buildProcessor ஐ அழைப்பது ஒரு செயல்பாட்டைத் திரும்பப் பெறுகிறது, அது ஒரு பட்டியல் உள்ளீட்டுடன் அழைக்கப்படுகிறது

// buildProcessor ஐப் பயன்படுத்தி நாம் add_2 மற்றும் double பட்டியல் செயலிகளை பின்வருமாறு உருவாக்கலாம்:
process_add_2 = buildProcessor(add_2);
process_double = buildProcessor(double);

process_add_2([5, 6, 7]); // => [7, 8, 9]
process_double([5, 6, 7]); // => [10, 12, 14]

மற்றொரு உதாரணத்தைப் பார்ப்போம். உள்ளீடாக ஒரு எண் x ஐ எடுத்து அதன் வாதத்தை x ஆல் பெருக்கும் ஒரு செயல்பாட்டைத் திரும்பப் பெறும் buildMultiplier எனப்படும் ஒரு செயல்பாட்டை உருவாக்குவோம்:

let buildMultiplier = function (x) {
  return function (y) {
    return x * y;
  };
};

let double = buildMultiplier(2);
let triple = buildMultiplier(3);

double(3); // => 6
triple(3); // => 9