एक बार फिर से PHP में currying और आंशिक आवेदन के बारे में

हाल ही के एक लेख ने PHP में करी और आंशिक फ़ंक्शन अनुप्रयोग के कार्यान्वयन का सुझाव दिया। इसका मूल दोष यह है कि करी एक कार्य नहीं है, बल्कि एक वस्तु है। इसे अब कॉलबैक पैरामीटर के रूप में पारित नहीं किया जा सकता है, और आपको तर्कों को प्रतिस्थापित करने के लिए विशेष सिंटैक्स का उपयोग करना होगा। यह पाठ PHP 5.3 और उच्चतर के लिए इन निर्माणों का एक नया, पारदर्शी कार्यान्वयन प्रस्तावित करता है।

क्यूरिंग शब्द अमेरिकी गणितज्ञ हास्केल करी के नाम से आया है। करी शब्द का दूसरा अर्थ है चमड़े की ड्रेसिंग।

करी और आंशिक अनुप्रयोग की अवधारणाएं कार्यात्मक प्रोग्रामिंग भाषाओं से आती हैं, जिसके भीतर वे सबसे व्यापक अनुप्रयोग पाते हैं। आधुनिक PHP कार्यात्मक प्रोग्रामिंग के कुछ तत्वों (प्रथम श्रेणी के ऑब्जेक्ट्स, अनाम फ़ंक्शन और क्लोजर के रूप में कार्य करता है) को उधार लेती है, इसलिए चर्चा की गई अवधारणाएं अब इसके लिए पूरी तरह से विदेशी नहीं हैं।

PHP में currying और आंशिक उपयोग का अनुकरण एक उदाहरण है कि McConnell in Perfect Code (Chapter 4.3) कॉलिंग को एक भाषा का उपयोग करता है, न कि किसी भाषा का।

संक्षिप्त शैक्षिक कार्यक्रम

फ़ंक्शन कारखानों के निर्माण के लिए करी और आंशिक अनुप्रयोग का उपयोग किया जाता है। यह तकनीक विशेष रूप से उपयोगी है यदि आपको उपयोगकर्ता फ़िल्टरिंग, सॉर्टिंग, परिवर्तन आदि के लिए एक तर्क के रूप में किसी अन्य फ़ंक्शन को पारित करने के लिए दिए गए इंटरफ़ेस के साथ एक फ़ंक्शन उत्पन्न करने की आवश्यकता है, मान लीजिए कि हमारे पास कई मापदंडों के साथ एक निश्चित फ़ंक्शन है और हम बड़े पैमाने पर कार्यों का निर्माण करते हैं जो मेल खाते हैं कुछ तर्कों को ठीक करते समय दिया गया।

उदाहरण के लिए, मान लें कि हमारे पास एक "ब्लैक बॉक्स" है - हल ( f , x ₀ , supp ) फ़ंक्शन, जो सटीकता के साथ प्रारंभिक बिंदु x _{0 के} एक पड़ोस में समीकरण f ( x ) = 0 का हल ढूंढता है। फिर, आंशिक एप्लिकेशन कॉल का उपयोग करते हुए, हम फ़ंक्शन हल 1 ( x ₀ , ≡) (हल ( x - tg x , x ₀ , application) का निर्माण कर सकते हैं। या यहां तक ​​कि फ़ंक्शन हल 2 (accuracy), जो चर सटीकता के साथ एक निश्चित प्रारंभिक बिंदु के पड़ोस में एक निश्चित निश्चित समीकरण को हल करेगा।

बेशक, प्रत्येक विशेष मामले में, हम टाइप का एक आवरण फ़ंक्शन लिख सकते हैं

function solve_x_minus_tan_x($x0, $eps){ $f = function($x) { return $x - tan($x); }; return solve($f, $x0, $eps); } 

हालाँकि, यह एक सार्वभौमिक तंत्र के लिए अधिक सुविधाजनक होगा, जो आंशिक अनुप्रयोग है।

करी एक ऐसी प्रक्रिया है जो वैकल्पिक चर का प्रदर्शन करते हुए n चर के एक फ़ंक्शन को एक चर के n कार्यों की श्रृंखला में परिवर्तित करती है। उदाहरण के लिए, Add ( a , b ) = a + b , और curry_add को ऐड फंक्शन को करीने देने का परिणाम है। फिर प्रत्येक के लिए curry_add ( a ) के लिए कॉल एक तर्क के कार्यों को उत्पन्न करेगा, इसे जोड़ने के लिए, अर्थात् curry_add ( a ) ( b ) = add ( a , b )। अधिक उदाहरण नीचे दिए जाएंगे।

ई। किरपिचव के बड़े लेख " कार्यात्मक भाषाओं के तत्व " (धारा 5) में करी और आंशिक आवेदन पर अधिक विवरण पाया जा सकता है।

करी समारोह

तो, स्लाइड। हमें केवल निम्नलिखित कोड की आवश्यकता है, जो मूल फ़ंक्शन को इसके करी संस्करण के साथ बदल देता है।

 function curry($callback, $args = array()){ /* $callback -   $args -   ,     */ /*    */ $ret = function() use($callback, $args){ /*      */ $func = new ReflectionFunction($callback); $num = $func->getNumberOfParameters(); /*        */ $args = array_merge($args, func_get_args()); /*      , */ if(count($args) >= $num){ /*           */ return call_user_func_array($callback, $args); } /*    ,  , */ else { /*            */ return curry($callback, $args); } }; return $ret; } 

क्लासिक उदाहरण

हमें ऐड फंक्शन डिफाइन किया है।

 function add($a, $b) { return $a + $b; } 

हम इसका करी संस्करण बना सकते हैं।

 $add = curry("add"); 

हम सत्यापित करते हैं कि प्राप्त फ़ंक्शन मूल के समान व्यवहार करता है।

 echo $add(2, 5); //  7 

अब हम वेतन वृद्धि और वेतन वृद्धि कार्यों को उत्पन्न करने के लिए केवल पहला तर्क प्रस्तुत करते हैं।

 $inc = $add(1); $dec = $add(-1); echo $inc(6); //  7 echo $dec(8); //  7 

और उदाहरण

हम पूरी तरह से पारदर्शी तरीके से प्रारंभिक तर्कों की संख्या को प्रतिस्थापित कर सकते हैं और एक पूर्ण फ़ंक्शन प्राप्त कर सकते हैं जिसमें सभी तर्कों को फिर से प्रतिस्थापित नहीं किया जा सकता है। उदाहरण के लिए

 function add_and_mul($a, $b, $c) { return $a + $b * $c; } $add_and_mul = curry("add_and_mul"); $test1 = $add_and_mul(1, 2, 3); //    $test2 = $add_and_mul(1, 2); //    $test3 = $add_and_mul(1); //    $test4 = $test3(2); //    //     7 echo $test1; echo $test2(3); echo $test3(2, 3); echo $test4(3); 

करीकरण परिणाम को आसानी से कॉलबैक पैरामीटर के रूप में दूसरे फ़ंक्शन में पास किया जा सकता है। उदाहरण के लिए, हमें घन के द्रव्यमान की गणना घनत्व और पार्श्व लंबाई की एक सरणी से करने की आवश्यकता है। हम इस प्रकार कर सकते हैं।

 /* ,         */ function mass($density, $length){ return $density * $length * $length * $length; } /*  */ $mass = curry("mass"); /* ,     */ $steel_mass = $mass(7.9); /*     */ $lengths = array(3, 2, 5, 6, 1); /*    */ $masses = array_map($steel_mass, $lengths); /*  Array ( [0] => 213.3 [1] => 63.2 [2] => 987.5 [3] => 1706.4 [4] => 7.9 ) */ print_r($masses); 

नोट

1. PHP दुभाषिया के दृष्टिकोण से, हमारी करी का परिणाम एक फ़ंक्शन नहीं है, लेकिन क्लोजर क्लास का एक ऑब्जेक्ट है, क्योंकि यह एक अनाम क्लोजर के रूप में बनाया गया है। हालाँकि, सिंटैक्स के संदर्भ में, प्रतिस्थापन पूरी तरह से पारदर्शी है।
2. स्पष्ट कारणों के लिए, आप टाइप प्रिंटफ़ () के तर्कों की चर संख्या के साथ फ़ंक्शंस पर अंकुश नहीं लगा सकते। हमारे कार्यान्वयन में, सभी फ़ंक्शन तर्क अनिवार्य हो जाते हैं, भले ही उन्हें मूल हस्ताक्षर में वैकल्पिक के रूप में चिह्नित किया गया हो। यह भी ध्यान दिया जाना चाहिए कि जब करी समारोह के तर्कों की संख्या गिनने की कोशिश की जा रही हो, तो NumberOfParameters () 0 पर वापस आ जाएगी।
3. कड़ाई से बोलते हुए, एक क्यूरेटेड फ़ंक्शन को एक बार में तर्क देना चाहिए, यानी, $ ऐड (2, 5) के बजाय, आपको $ ऐड (2) (5) लिखना होगा। हालाँकि, PHP दुभाषिया का वर्तमान संस्करण टाइप फंक (arg1) (arg2) के सिंटैक्स त्रुटि की प्रविष्टियों पर विचार करता है, भले ही वे शब्दार्थ सही हों। इसलिए, सुविधा के लिए, हमारा कार्यान्वयन हमें कॉमा के माध्यम से एक बार में कई तर्क निर्दिष्ट करने की अनुमति देता है, जो इसे आंशिक आवेदन के करीब लाता है।

Upd। 08/01/12 से: लेख " ऑब्जेक्ट-ओरिएंटेड फंक्शनल मेटाप्रोग्रामिंग या मेथोड करी " में PHP करी के बारे में भी देखें।