प्रथम श्रेणी फंक्शन: Difference between revisions

From Vigyanwiki
mNo edit summary
Line 117: Line 117:


आधुनिक अनिवार्य भाषाएं अक्सर कचरा-संग्रह का समर्थन करती हैं जिससे प्रथम श्रेणी के कार्यों का कार्यान्वयन संभव हो जाता है। प्रथम श्रेणी के कार्यों को अक्सर भाषा के बाद के संशोधनों में समर्थित किया गया है, जिसमें C# 2.0 और Apple के C, C++ और Objective-C के लिए ब्लॉक एक्सटेंशन शामिल हैं। C++11 ने अनाम कार्यों और भाषा के बंद होने के लिए समर्थन जोड़ा है, लेकिन भाषा की गैर-कचरा एकत्र प्रकृति के कारण, परिणाम के रूप में लौटाए जाने वाले कार्यों में गैर-स्थानीय चर के लिए विशेष देखभाल की जानी चाहिए (नीचे देखें) ).
आधुनिक अनिवार्य भाषाएं अक्सर कचरा-संग्रह का समर्थन करती हैं जिससे प्रथम श्रेणी के कार्यों का कार्यान्वयन संभव हो जाता है। प्रथम श्रेणी के कार्यों को अक्सर भाषा के बाद के संशोधनों में समर्थित किया गया है, जिसमें C# 2.0 और Apple के C, C++ और Objective-C के लिए ब्लॉक एक्सटेंशन शामिल हैं। C++11 ने अनाम कार्यों और भाषा के बंद होने के लिए समर्थन जोड़ा है, लेकिन भाषा की गैर-कचरा एकत्र प्रकृति के कारण, परिणाम के रूप में लौटाए जाने वाले कार्यों में गैर-स्थानीय चर के लिए विशेष देखभाल की जानी चाहिए (नीचे देखें) ).
 
{| class="wikitable"
{| class=wikitable width=100% style="font-size: 85%"
! colspan=2 rowspan=2 | भाषा !! colspan="2" | [[Higher-order function]]s !! colspan=2 | [[Nested function]]s !! colspan=2 |  [[Non-local variable]]s !! rowspan=2 width=25% | Notes
|-
|-
! Arguments !! Results !! Named !! [[Anonymous function|Anonymous]] !! [[Closure (computer programming)|Closures]] !! [[Partial application]]
! colspan="2" rowspan="2" |भाषा
! colspan="2" |उच्च-क्रम के कार्य
! colspan="2" |नेस्टेड फ़ंक्शन
! colspan="2" |गैर-स्थानीय चर
! rowspan="2" |टिप्पणियाँ
|-
|-
| rowspan=6 | Algol family
!बहस
| [[ALGOL 60]] || {{yes}} || {{no}} || {{yes}} || {{no}} || {{partial|Downwards}} || {{no}} || rowspan=6 | Have [[function type]]s.
!परिणाम
!नामांकित
!अनाम
!बंद
!आंशिक आवेदन
|-
|-
| [[ALGOL 68]] || {{yes}} || {{Partial|Yes}}<ref name=compa68pascal>{{cite journal|page=319|title=A comparison of PASCAL and Algol 68|journal=The Computer Journal|volume=21|number=4|year=1977|first=A.S.|last=Tanenbaum|doi=10.1093/comjnl/21.4.316|doi-access=free}}</ref> || {{yes}} || {{yes}} || {{partial|Downwards}}<ref>{{Cite web|url=http://python-history.blogspot.nl/2009/04/origins-of-pythons-functional-features.html?showComment=1243166621952#c702829329923892023|title = The History of Python: Origins of Python's "Functional" Features|date = 21 April 2009}}</ref> || {{no}}
| rowspan="6" |अल्गोल परिवार
|एल्गोल 60
|हाँ
|नहीं
|हाँ
|नहीं
|नीचे की ओर
|नहीं
| rowspan="6" |फ़ंक्शन प्रकार हैं ।
|-
|-
| [[Pascal (programming language)|Pascal]] || {{yes}} || {{no}} || {{yes}} || {{no}} || {{partial|Downwards}} || {{no}}
|एल्गोल 68
|हाँ
|हाँ
|हाँ
|हाँ
|नीचे की ओर
|नहीं
|-
|-
| [[Ada (programming language)|Ada]] || {{yes}} || {{no}} || {{yes}} || {{no}} || {{partial|Downwards}} || {{no}}
|पास्कल
|हाँ
|नहीं
|हाँ
|नहीं
|नीचे की ओर
|नहीं
|-
|-
| [[Oberon (programming language)|Oberon]] || {{yes}} || {{partial|Non-nested only}} || {{yes}} || {{no}} || {{partial|Downwards}} || {{no}}
|एडीए
|हाँ
|नहीं
|हाँ
|नहीं
|नीचे की ओर
|नहीं
|-
|-
| [[Delphi (programming language)|Delphi]] || {{yes}} || {{yes}} || {{yes}} || {{yes|2009}} || {{yes|2009}} || {{no}}
|ओबेरोन
|हाँ
|केवल गैर-नेस्टेड
|हाँ
|नहीं
|नीचे की ओर
|नहीं
|-
|-
| rowspan=9 | C family
|डेल्फी
| [[C (programming language)|C]] || {{yes}} || {{yes}} || {{Partial|Yes in GNU C}} || {{Partial|Yes in Clang([[Blocks (C language extension)|Blocks]])}} || {{Partial|Yes in Clang([[Blocks (C language extension)|Blocks]])}} || {{no}} || Has [[function pointer]]s.
|हाँ
|हाँ
|हाँ
|2009
|2009
|नहीं
|-
|-
| [[C++]] || {{yes}} || {{yes}} || {{yes|C++11<ref>[https://stackoverflow.com/a/4324829 Nested functions using lambdas/closures]</ref>}} || {{yes|C++11}}<ref name=doc1968>Doc No. [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 1968]: V Samko; J Willcock, J Järvi, D Gregor, A Lumsdaine (February 26, 2006) ''Lambda expressions and closures for C++''</ref> || {{partial|C++11}}<ref name=doc1968/> || {{partial|C++11}} || Has function pointers, [[function object]]s. (Also, see below.)
| rowspan="9" |सी परिवार
Explicit partial application possible with <code>std::bind</code>.
|सी
|हाँ
|हाँ
|हाँ जीएनयू सी में
|हाँ क्लैंग में ( ब्लॉक )
|हाँ क्लैंग में ( ब्लॉक )
|नहीं
|फ़ंक्शन पॉइंटर्स हैं ।
|-
|-
| [[C Sharp (programming language)|C#]] || {{yes}} || {{yes}} || {{yes|7}} || {{yes|2.0 / 3.0}} || {{yes|2.0}} || {{yes|3.0}} || Has [[Delegate (CLI)|delegate]]s (2.0) and lambda expressions (3.0).
|सी++
|हाँ
|हाँ
|सी++11
|सी++11
|सी++11
|सी++11
|इसमें फ़ंक्शन पॉइंटर्स, फ़ंक्शन ऑब्जेक्ट हैं । (इसके अलावा, नीचे देखें।)
के साथ स्पष्ट आंशिक अनुप्रयोग संभव है <code>std::bind</code>।
|-
|-
| [[Objective-C]] || {{yes}} || {{yes}} || {{partial|Using anonymous}} || {{yes|2.0 + Blocks<ref>{{cite web |url=https://developer.apple.com/mac/library/documentation/Cocoa/Conceptual/Blocks/Articles/00_Introduction.html |url-status=dead |archive-url=https://web.archive.org/web/20090831133626/http://developer.apple.com/mac/library/documentation/Cocoa/Conceptual/Blocks/Articles/00_Introduction.html |archive-date=2009-08-31 |title=Mac Dev Center: Blocks Programming Topics: Introduction}}</ref>}} || {{yes|2.0 + Blocks}} || {{no}} || Has function pointers.
|सी#
|हाँ
|हाँ
|7
|2.0/3.0
|2.0
|3.0
|इसमें डेलीगेट्स (2.0) और लैम्ब्डा एक्सप्रेशन (3.0) हैं।
|-
|-
| [[Java (programming language)|Java]] || {{yes}} || {{yes}} || {{partial|Using anonymous}} || {{yes|Java 8}} || {{yes|Java 8}} || {{yes}} || Has [[anonymous inner class]]es.
|उद्देश्य सी
|हाँ
|हाँ
|अनाम का उपयोग करना
|2.0 + ब्लॉक
|2.0 + ब्लॉक
|नहीं
|फ़ंक्शन पॉइंटर्स हैं.
|-
|-
| [[Go (programming language)|Go]] || {{yes}} || {{yes}} || {{partial|Using anonymous}} || {{yes}} || {{yes}} || {{yes}}<ref>{{cite web |url=https://play.golang.org/p/lZHXrX-yR6 |title=2 examples in Go that you can have partial application }}</ref> ||
|जावा
|हाँ
|हाँ
|अनाम का उपयोग करना
|जावा 8
|जावा 8
|हाँ
|अनाम आंतरिक कक्षाएं हैं ।
|-
|-
| [[Limbo (programming language)|Limbo]] || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{no}} ||
|जाना
|हाँ
|हाँ
|अनाम का उपयोग करना
|हाँ
|हाँ
|हाँ
|
|-
|-
| [[Newsqueak]] || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{no}} ||
|लीम्बो
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|नहीं
|
|-
|-
| [[Rust (programming language)|Rust]] || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}}<ref>{{cite web |url=https://docs.rs/partial_application |title=partial_application |website=Docs.rs |access-date=2020-11-03}}</ref> ||
|न्यूज़वीक
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|नहीं
|
|-
|-
| rowspan=11 | Functional languages || [[Lisp (programming language)|Lisp]] || {{partial|Syntax}} || {{partial|Syntax}} || {{yes}} || {{yes}} || {{partial|Common Lisp}} || {{no}} || (see below)
|जंग
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|
|-
|-
| [[Scheme (programming language)|Scheme]] || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes|SRFI 26}}<ref>{{Cite web|url=http://srfi.schemers.org/srfi-26/srfi-26.html|title=SRFI 26: Notation for Specializing Parameters without Currying}}</ref> ||
| rowspan="11" |कार्यात्मक भाषाएँ
|तुतलाना
|वाक्य - विन्यास
|वाक्य - विन्यास
|हाँ
|हाँ
|सामान्य लिस्प
|नहीं
|(नीचे देखें)
|-
|-
| [[Julia (programming language)|Julia]] || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} ||
|योजना
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|एसआरएफआई 26
|
|-
|-
| [[Clojure]] || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} ||
|जूलिया
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|
|-
|-
| [[ML (programming language)|ML]] || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} ||
|क्लोजर
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|
|-
|-
| [[Haskell (programming language)|Haskell]] || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} ||
|एमएल
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|
|-
|-
| [[jq (programming language)|jq]] || {{yes}} || {{no}} || {{yes}} ||{{partial|Expressions only}} || {{partial|Downwards}} || {{no}}
|हास्केल
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|
|-
|-
| [[Scala (programming language)|Scala]] || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} ||
|jq
|हाँ
|नहीं
|हाँ
|केवल अभिव्यक्तियाँ
|नीचे की ओर
|नहीं
|-
|-
| [[Erlang (programming language)|Erlang]] || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} ||
|स्काला
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|
|-
|-
| [[F Sharp (programming language)|F#]] || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} ||
|Erlang
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|
|-
|-
| [[OCaml]] || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} ||
|एफ#
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|
|-
|-
| rowspan=7 | Scripting languages
|ओकैमल
| [[Io (programming language)|Io]] || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{no}} ||
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|
|-
|-
| [[JavaScript]] || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes|ECMAScript 5}} || Partial application possible with user-land code on ES3 <ref>{{Cite web|url=http://ejohn.org/blog/partial-functions-in-javascript/|title=John Resig - Partial Application in JavaScript}}</ref>
| rowspan="7" |स्क्रिप्टिंग भाषाएँ
|आईओ
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|नहीं
|
|-
|-
| [[Lua (programming language)|Lua]] || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}}<ref>{{cite web |last1=Katz |first1=Ian |url=http://tinylittlelife.org/?p=249 |title=Lua Code for Curry (Currying Functions) |date=2010-07-23 |df=mdy |archive-url=https://web.archive.org/web/20181106235506/http://tinylittlelife.org/?p=249 |archive-date=2018-11-06}}</ref> ||
|जावास्क्रिप्ट
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|ईसीएमएस्क्रिप्ट 5
|ES3 पर उपयोगकर्ता-भूमि कोड के साथ आंशिक आवेदन संभव है
|-
|-
| [[PHP]] || {{yes}} || {{yes}} || {{partial|Using anonymous}} || {{yes|5.3}} || {{yes|5.3}} || {{no}} || Partial application possible with user-land code.
|लुआ
 
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|
|-
|-
| [[Perl]] || {{yes}} || {{yes}} || {{yes|6}} || {{yes}} || {{yes}} || {{yes|6}}<ref>{{Cite web|url=http://perlgeek.de/blog-en/perl-5-to-6/28-currying.html|title = Blog &#124; Perlgeek.de :: Currying}}</ref> ||
|पीएचपी
|हाँ
|हाँ
|अनाम का उपयोग करना
|5.3
|5.3
|नहीं
|उपयोगकर्ता-भूमि कोड के साथ आंशिक आवेदन संभव है।
|-
|-
| [[Python (programming language)|Python]] || {{yes}} || {{yes}} || {{yes}} || {{partial|Expressions only}} || {{yes}} || {{yes|2.5}}<ref>{{Cite web|url=https://docs.python.org/whatsnew/2.5.html#pep-309-partial-function-application|title=What's New in Python 2.5 — Python 3.10.0 documentation}}</ref> || (see below)
|पर्ल
|हाँ
|हाँ
|6
|हाँ
|हाँ
|6
|
|-
|-
| [[Ruby (programming language)|Ruby]] || {{partial|Syntax}} || {{partial|Syntax}} || {{no|Unscoped}} || {{yes}} || {{yes}} || {{partial|1.9}} || (see below)
|अजगर
|हाँ
|हाँ
|हाँ
|केवल अभिव्यक्तियाँ
|हाँ
|2.5
|(नीचे देखें)
|-
|-
| rowspan=6 | Other languages
|माणिक
| [[Fortran]] || {{yes}} || {{yes}} || {{yes}} || {{no}} || {{no}} || {{no}} ||
|वाक्य - विन्यास
|वाक्य - विन्यास
|अनस्कोप्ड
|हाँ
|हाँ
|1.9
|(नीचे देखें)
|-
|-
| [[Maple (software)|Maple]] || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{no}} ||
| rowspan="6" |अन्य भाषाएं
|फोरट्रान
|हाँ
|हाँ
|हाँ
|नहीं
|नहीं
|नहीं
|
|-
|-
| [[Mathematica]] || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{no}} ||
|मेपल
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|नहीं
|
|-
|-
| [[MATLAB]] || {{yes}} || {{yes}} || {{yes}} || {{yes}}<ref>{{Cite web|url=http://www.mathworks.co.uk/help/matlab/matlab_prog/anonymous-functions.html|title=Anonymous Functions - MATLAB & Simulink - MathWorks United Kingdom}}</ref> || {{yes}} || {{yes}} || Partial application possible by automatic generation of new functions.<ref>[https://stackoverflow.com/q/9154271 Partial Function Evaluation in MATLAB]</ref>
|मेथेमेटिका
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|नहीं
|
|-
|-
| [[Smalltalk]] || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{partial}} || Partial application possible through library.
|मतलब
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|नए कार्यों की स्वचालित पीढ़ी द्वारा आंशिक अनुप्रयोग संभव।
|-
|-
| [[Swift (programming language)|Swift]] || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} ||
|गपशप
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|आंशिक
|पुस्तकालय के माध्यम से आंशिक आवेदन संभव।
|-
|तीव्र
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|हाँ
|}
|}
; सी ++: [[सी ++ 11]] समापन  कॉपी निर्माण द्वारा गैर-स्थानीय चर को संदर्भ द्वारा (उनके जीवनकाल को बढ़ाए बिना), या सी ++ 11 # रावल्यू संदर्भों द्वारा कैप्चर कर सकते हैं और कन्स्ट्रक्टर को स्थानांतरित कर सकते हैं (वैरिएबल समापन  के रूप में लंबे समय तक रहता है)। पहला विकल्प सुरक्षित है यदि समापन  लौटाया जाता है लेकिन एक प्रति की आवश्यकता होती है और मूल चर को संशोधित करने के लिए उपयोग नहीं किया जा सकता है (जो समापन  कहे जाने के समय मौजूद नहीं हो सकता है)। दूसरा विकल्प संभावित रूप से एक महंगी प्रति से बचता है और मूल चर को संशोधित करने की अनुमति देता है लेकिन बंद होने की स्थिति में असुरक्षित है (झूलते संदर्भ देखें)। तीसरा विकल्प सुरक्षित है अगर समापन  लौटाया जाता है और कॉपी की आवश्यकता नहीं होती है लेकिन मूल चर को संशोधित करने के लिए भी इसका उपयोग नहीं किया जा सकता है।
; सी ++: [[सी ++ 11]] समापन  कॉपी निर्माण द्वारा गैर-स्थानीय चर को संदर्भ द्वारा (उनके जीवनकाल को बढ़ाए बिना), या सी ++ 11 # रावल्यू संदर्भों द्वारा कैप्चर कर सकते हैं और कन्स्ट्रक्टर को स्थानांतरित कर सकते हैं (वैरिएबल समापन  के रूप में लंबे समय तक रहता है)। पहला विकल्प सुरक्षित है यदि समापन  लौटाया जाता है लेकिन एक प्रति की आवश्यकता होती है और मूल चर को संशोधित करने के लिए उपयोग नहीं किया जा सकता है (जो समापन  कहे जाने के समय मौजूद नहीं हो सकता है)। दूसरा विकल्प संभावित रूप से एक महंगी प्रति से बचता है और मूल चर को संशोधित करने की अनुमति देता है लेकिन बंद होने की स्थिति में असुरक्षित है (झूलते संदर्भ देखें)। तीसरा विकल्प सुरक्षित है अगर समापन  लौटाया जाता है और कॉपी की आवश्यकता नहीं होती है लेकिन मूल चर को संशोधित करने के लिए भी इसका उपयोग नहीं किया जा सकता है।

Revision as of 12:15, 27 June 2023

कंप्यूटर विज्ञान में, प्रोग्रामिंग भाषा को प्रथम श्रेणी के कार्यों वाला कहा जाता है यदि यह कार्य को प्रथम श्रेणी के विषय वस्तु के रूप में मानता है। इसका अर्थ यह है कि भाषा अन्य कार्यों के लिए तर्क के रूप में कार्यों को पारित करने, उन्हें अन्य कार्यों से मूल्यों के रूप में वापस करने और उन्हें चर को निर्दिष्ट करने या डेटा संरचनाओं में संग्रहीत करने का समर्थन करती है।[1] कुछ प्रोग्रामिंग भाषा सिद्धांतकारों को, अज्ञात कार्यों के लिए भी समर्थन की आवश्यकता होती है।[2] प्रथम श्रेणी के कार्यों वाली भाषाओं में, कार्यों के नाम (कंप्यूटर विज्ञान) की कोई विशेष स्थिति नहीं है; उन्हें कार्य प्रकार के साथ साधारण चर (कंप्यूटर विज्ञान) की तरह माना जाता है।[3] यह शब्द क्रिस्टोफर स्ट्रेची द्वारा 1960 के दशक के मध्य में प्रथम श्रेणी के विषय वस्तु के रूप में कार्यों के संदर्भ में बनाया गया था।[4]

कार्यात्मक प्रोग्रामिंग शैली के लिए प्रथम श्रेणी के कार्य आवश्यक हैं, जिसमें उच्च-क्रम के कार्यों का उपयोग एक मानक अभ्यास है। उच्च-क्रम वाले कार्य का एक सरल उदाहरण आलेखन कार्य है, जो इसके तर्कों, कार्यों और सूची के रूप में लेता है, और सूची के प्रत्येक सदस्य को कार्य लागू करके बनाई गई सूची देता है। एक भाषा के लिए आलेखन का समर्थन करने के लिए, उसे एक तर्क के रूप में कार्य को पारित करने का समर्थन करना चाहिए।

विशेष रूप से स्थिर कार्य और अनाम कार्य में प्रस्तुत किए गए गैर-स्थानीय चर की उपस्थिति में कार्यों को तर्कों के रूप में पारित करने या उन्हें परिणाम के रूप में वापस करने में कुछ कार्यान्वयन कठिनाइयाँ हैं। ऐतिहासिक रूप से, इन्हें फनर्ग की समस्या कहा जाता था, यह नाम कार्य तर्क से आता है।[5] प्रारंभिक अनिवार्य भाषाओं में इन समस्याओं को या तो परिणाम प्रकार (जैसे ऐल्गॉल 60, पास्कल (प्रोग्रामिंग भाषा)) के रूप में कार्यों का समर्थन न करने या स्थिर कार्यों और इस प्रकार गैर-स्थानीय चर (जैसे C ) को छोड़ कर इन समस्याओं से बचा जा सकता था। शुरुआती कार्यात्मक भाषा लिस्प (प्रोग्रामिंग भाषा) ने गतिशील कार्यक्षेत्र का दृष्टिकोण अपनाया, जहां गैर-स्थानीय चर उस चर की निकटतम परिभाषा को उस बिंदु पर संदर्भित करते हैं जहां कार्य को निष्पादित किया गया था, बजाय जहां इसे परिभाषित किया गया था। लेक्सिकली स्कोप्ड प्रथम श्रेणी के कार्यों के लिए उचित समर्थन स्कीम (प्रोग्रामिंग भाषा) में प्रस्तुत किया गया था और कार्यों के संदर्भों को अरक्षित कार्य सूचक के बजाय समापन (कंप्यूटर विज्ञान) के रूप में संभालने की आवश्यकता होती है,[4]जो बदले में अपशिष्ट संग्रह (कंप्यूटर विज्ञान) को एक आवश्यकता बनाता है।

अवधारणाएं

इस खंड में, हम तुलना करते हैं कि विशेष प्रोग्रामिंग मुहावरे एक कार्यात्मक भाषा में प्रथम श्रेणी के कार्यों (हास्केल (प्रोग्रामिंग भाषा)) की तुलना में एक अनिवार्य भाषा की तुलना में जहां कार्य द्वितीय श्रेणी के नागरिक हैं (सी (प्रोग्रामिंग भाषा))।

उच्च-क्रम के कार्य: तर्कों के रूप में कार्यों को पारित करना

उन भाषाओं में जहां कार्य प्रथम श्रेणी के नागरिक हैं, कार्यों को अन्य कार्यों के तर्कों के रूप में उसी तरह पारित किया जा सकता है जैसे अन्य मान (तर्क के रूप में किसी अन्य कार्य को लेने वाले कार्य को उच्च-क्रम कार्य कहा जाता है)। भाषा हास्केल (प्रोग्रामिंग भाषा) में: 

map :: (a -> b) -> [a] -> [b]
map f []     = []
map f (x:xs) = f x : map f xs

भाषाएं जहां कार्य प्रथम श्रेणी के नहीं होते हैं, फिर भी कार्य पॉइंटर्स या डेलिगेट (सीएलआई) जैसे सुविधाओं के उपयोग के माध्यम से उच्च-क्रम के कार्यों को लिखने की अनुमति देते हैं। भाषा सी (प्रोग्रामिंग भाषा) में: 

void map(int (*f)(int), int x[], size_t n) {
    for (int i = 0; i < n; i++)
        x[i] = f(x[i]);
}

दो दृष्टिकोणों के बीच कई अंतर हैं जो सीधे प्रथम श्रेणी के कार्यों के समर्थन से संबंधित नहीं हैं। हास्केल नमूना सूची (कंप्यूटिंग) पर काम करता है, जबकि सी नमूना सरणी डेटा संरचना पर काम करता है। दोनों संबंधित भाषाओं में सबसे प्राकृतिक यौगिक डेटा संरचनाएं हैं और सी नमूना को लिंक्ड सूचियों पर संचालित करने से यह अनावश्यक रूप से जटिल हो जाता। यह इस तथ्य के लिए भी जिम्मेदार है कि सी कार्य को एक अतिरिक्त पैरामीटर की आवश्यकता होती है (सरणी का आकार देते हुए।) सी कार्य सरणी को जगह में अद्यतन करता है, कोई मूल्य नहीं लौटाता है, जबकि हास्केल डेटा संरचनाओं में लगातार डेटा संरचना होती है (एक नई सूची वापस लौटा दिया जाता है जबकि पुराना बरकरार रहता है।) हास्केल नमूना सूची को पार करने के लिए पुनरावर्तन का उपयोग करता है, जबकि सी नमूना पुनरावृत्ति का उपयोग करता है। दोबारा, यह दोनों भाषाओं में इस कार्य को व्यक्त करने का सबसे स्वाभाविक तरीका है, लेकिन हास्केल नमूना आसानी से एक गुना (उच्च-क्रम कार्य ) और सी नमूना प्रत्यावर्तन के संदर्भ में व्यक्त किया जा सकता था। अंत में, हास्केल कार्य में एक बहुरूपता (कंप्यूटर विज्ञान) प्रकार है, क्योंकि यह सी द्वारा समर्थित नहीं है, हमने सभी प्रकार के चर को स्थिर प्रकार के लिए तय किया है int.

अनाम और स्थिर कार्य

अधिक जानकारी: अनाम फ़ंक्शन और स्थिर फ़ंक्शन

अज्ञात कार्यों का समर्थन करने वाली भाषाओं में, हम इस तरह के कार्य को उच्च-क्रम कार्य के तर्क के रूप में पास कर सकते हैं: 

main = map (\x -> 3 * x + 1) [1, 2, 3, 4, 5]

ऐसी भाषा में जो अज्ञात कार्यों का समर्थन नहीं करती है, हमें इसे इसके बजाय नाम से बांधना होगा: 

int f(int x) {
    return 3 * x + 1;
}

int main() {
    int list[] = {1, 2, 3, 4, 5};
    map(f, list, 5);
}


गैर-स्थानीय चर और समापन

एक बार जब हमारे पास गुमनाम या स्थिर कार्य होते हैं, तो उनके लिए अपने शरीर के बाहर के चरों को संदर्भित करना स्वाभाविक हो जाता है (जिन्हें गैर-स्थानीय चर कहा जाता है): 

main = let a = 3
           b = 1
        in map (\x -> a * x + b) [1, 2, 3, 4, 5]

यदि कार्य को नंगे कार्य पॉइंटर्स के साथ दर्शाया जाता है, तो हम अब यह नहीं जान सकते हैं कि कार्य के शरीर के बाहर का मान इसे कैसे पारित किया जाना चाहिए, और इसके कारण एक समापन को मैन्युअल रूप से बनाने की आवश्यकता होती है। इसलिए हम यहाँ प्रथम श्रेणी के कार्यों की बात नहीं कर सकते। 

typedef struct {
    int (*f)(int, int, int);
    int *a;
    int *b;
} closure_t;

void map(closure_t *closure, int x[], size_t n) {
    for (int i = 0; i < n; ++i)
        x[i] = (*closure->f)(*closure->a, *closure->b, x[i]);
}

int f(int a, int b, int x) {
    return a * x + b;
}

void main() {
    int l[] = {1, 2, 3, 4, 5};
    int a = 3;
    int b = 1;
    closure_t closure = {f, &a, &b};
    map(&closure, l, 5);
}

यह भी ध्यान दें कि map अब दो से संबंधित कार्यों के लिए विशिष्ट है intउनके पर्यावरण के बाहर है। इसे अधिक आम तौर पर सेट किया जा सकता है, लेकिन इसके लिए अधिक बॉयलरप्लेट कोड की आवश्यकता होती है। अगर f एक स्थिर कार्य होता हम अभी भी एक ही समस्या में भाग लेते और यही कारण है कि वे सी में समर्थित नहीं हैं।[6]


उच्च-क्रम के कार्य: परिणाम के रूप में कार्य लौटाना

किसी कार्य को वापस करते समय, हम वास्तव में उसके समापन को वापस कर रहे हैं। सी उदाहरण में समापन द्वारा कब्जा कर लिया गया कोई भी स्थानीय चर दायरे से बाहर हो जाएगा, जब हम समापन बनाने वाले कार्य से वापस आ जाएंगे। बाद के बिंदु पर बंद करने के लिए मजबूर करने से अपरिभाषित व्यवहार होगा, संभवतः ढेर को दूषित कर देगा। इसे ऊपर की ओर फनर्ग समस्या के रूप में जाना जाता है।

चरों को कार्य सौंपना

असाइनमेंट (कंप्यूटर विज्ञान) वेरिएबल (कंप्यूटर साइंस) के लिए कार्य करता है और उन्हें (वैश्विक) डेटास्ट्रक्चर के अंदर संग्रहीत करने से संभावित रूप से समान कठिनाइयों से पीड़ित होता है। 

f :: [[Integer] -> [Integer]]
f = let a = 3
        b = 1
     in [map (\x -> a * x + b), map (\x -> b * x + a)]

कार्यों की समानता

Further information: Function equality

जैसा कि कोई समानता के लिए अधिकांश शाब्दिक और मूल्यों का परीक्षण कर सकता है, यह पूछना स्वाभाविक है कि क्या कोई प्रोग्रामिंग भाषा समानता के लिए परीक्षण कार्यों का समर्थन कर सकती है। आगे के निरीक्षण पर, यह प्रश्न अधिक कठिन प्रतीत होता है और व्यक्ति को कई प्रकार की कार्य समानता के बीच अंतर करना पड़ता है:[7]

विस्तारात्मक समानता
दो कार्यों f और g को व्यापक रूप से समान माना जाता है यदि वे सभी इनपुट के लिए अपने आउटपुट पर सहमत होते हैं (∀x. f(x) = g(x))। समानता की इस परिभाषा के तहत, उदाहरण के लिए, एक स्थिर छँटाई एल्गोरिथ्म के किसी भी दो कार्यान्वयन, जैसे कि सम्मिलन छँटाई और मर्ज छँटाई, को समान माना जाएगा। विस्तृत समानता पर निर्णय लेना सामान्य रूप से अनिर्णीत समस्या है और यहां तक ​​कि परिमित डोमेन वाले कार्यों के लिए भी अक्सर अट्रैक्टिव होता है। इस कारण से कोई प्रोग्रामिंग भाषा कार्य समानता को विस्तारित समानता के रूप में लागू नहीं करती है।:गहन समानता
आकस्मिक समानता के तहत, दो कार्यों f और g को समान माना जाता है यदि उनकी आंतरिक संरचना समान हो। इस तरह की समानता व्याख्या की गई भाषाओं में कार्य निकायों के स्रोत कोड (जैसे व्याख्या किए गए लिस्प 1.5 में) या संकलित भाषाओं में वस्तु कोड की तुलना करके कार्यान्वित की जा सकती है। आकस्मिक समानता का तात्पर्य विस्तारात्मक समानता से है (यह मानते हुए कि कार्य नियतात्मक हैं और उनमें कोई छिपा हुआ इनपुट नहीं है, जैसे कि कार्यक्रम गणक या एक परिवर्तनशील वैश्विक चर।):संदर्भ समानता
विस्तारात्मक और गहन समानता को लागू करने की अव्यावहारिकता को देखते हुए, समानता के लिए परीक्षण कार्यों का समर्थन करने वाली अधिकांश भाषाएं संदर्भ समानता का उपयोग करती हैं। सभी कार्यों या समापन को एक अद्वितीय पहचानकर्ता (आमतौर पर कार्य बॉडी या समापन का पता) असाइन किया जाता है और पहचानकर्ता की समानता के आधार पर समानता तय की जाती है। दो अलग-अलग परिभाषित, लेकिन अन्यथा समान कार्य परिभाषाओं को असमान माना जाएगा। संदर्भपरक समानता का तात्पर्य गहन और विस्तारात्मक समानता से है। रेफरेंशियल समानता संदर्भित पारदर्शिता को तोड़ती है और इसलिए हास्केल जैसी शुद्धता (कंप्यूटर विज्ञान) भाषाओं में समर्थित नहीं है।

प्रकार सिद्धांत

Main article: Function type

प्रकार सिद्धांत में, प्रकार ए के मूल्यों को स्वीकार करने वाले कार्यों के प्रकार और प्रकार बी के मूल्यों को वापस करने के लिए ए → बी या बी के रूप में लिखा जा सकता हैए</सुप>। करी-हावर्ड पत्राचार में, प्रकार्य प्रकार तार्किक निहितार्थ से संबंधित हैं; लैम्ब्डा एब्स्ट्रैक्शन काल्पनिक मान्यताओं के निर्वहन से मेल खाता है और कार्य एप्लिकेशन मूड सेट करना इंट्रेंस नियम से मेल खाता है। प्रोग्रामिंग कार्य के सामान्य मामले के अलावा, टाइप थ्योरी भी सहयोगी सरणियों और समान डेटा संरचनाओं को मॉडल करने के लिए प्रथम श्रेणी के कार्य का उपयोग करती है।

श्रेणी सिद्धांत में। प्रोग्रामिंग के श्रेणी-सैद्धांतिक खाते, प्रथम श्रेणी के कार्यों की उपलब्धता बंद श्रेणी की धारणा से मेल खाती है। उदाहरण के लिए, केवल टाइप किया गया लैम्ब्डा कैलकुस कार्टेशियन बंद श्रेणी की आंतरिक भाषा से मेल खाता है।

भाषा समर्थन

एरलांग (प्रोग्रामिंग भाषा), योजना (प्रोग्रामिंग भाषा), एमएल (प्रोग्रामिंग भाषा), हास्केल (प्रोग्रामिंग भाषा), एफ शार्प (प्रोग्रामिंग भाषा)|एफ#, और स्काला (प्रोग्रामिंग भाषा) जैसी कार्यात्मक प्रोग्रामिंग भाषाएं, सभी में पहले- वर्ग कार्य। जब लिस्प (प्रोग्रामिंग लैंग्वेज), शुरुआती कार्यात्मक भाषाओं में से एक को डिजाइन किया गया था, तब प्रथम श्रेणी के कार्यों के सभी पहलुओं को ठीक से नहीं समझा गया था, जिसके परिणामस्वरूप कार्यों को गतिशील रूप से स्कॉप्ड किया गया था। बाद की स्कीम (प्रोग्रामिंग लैंग्वेज) और सामान्य लिस्प बोलियों में प्रथम श्रेणी के कार्यों को लेक्सिक रूप से स्कोप किया गया है।

पर्ल, पायथन (प्रोग्रामिंग लैंग्वेज), PHP, लुआ (प्रोग्रामिंग भाषा) , Tcl/Tk, जावास्क्रिप्ट और Io (प्रोग्रामिंग लैंग्वेज) सहित कई स्क्रिप्टिंग भाषाओं में प्रथम श्रेणी के कार्य हैं।

अनिवार्य भाषाओं के लिए, अल्गोल और उसके वंशजों जैसे पास्कल, पारंपरिक सी परिवार और आधुनिक कचरा-संग्रहित वेरिएंट के बीच अंतर करना पड़ता है। अल्गोल परिवार ने स्थिर कार्य और उच्च-क्रम लेने वाले कार्य को तर्कों के रूप में अनुमति दी है, लेकिन उच्च-क्रम वाले कार्य नहीं हैं जो परिणाम के रूप में कार्य लौटाते हैं (Algol 68 को छोड़कर, जो इसे अनुमति देता है)। इसका कारण यह था कि यह ज्ञात नहीं था कि यदि परिणाम के रूप में एक स्थिर -कार्य लौटाया जाता है तो गैर-स्थानीय चर से कैसे निपटें (और ऐसे मामलों में एल्गोल 68 रनटाइम त्रुटियाँ पैदा करता है)।

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

आधुनिक अनिवार्य भाषाएं अक्सर कचरा-संग्रह का समर्थन करती हैं जिससे प्रथम श्रेणी के कार्यों का कार्यान्वयन संभव हो जाता है। प्रथम श्रेणी के कार्यों को अक्सर भाषा के बाद के संशोधनों में समर्थित किया गया है, जिसमें C# 2.0 और Apple के C, C++ और Objective-C के लिए ब्लॉक एक्सटेंशन शामिल हैं। C++11 ने अनाम कार्यों और भाषा के बंद होने के लिए समर्थन जोड़ा है, लेकिन भाषा की गैर-कचरा एकत्र प्रकृति के कारण, परिणाम के रूप में लौटाए जाने वाले कार्यों में गैर-स्थानीय चर के लिए विशेष देखभाल की जानी चाहिए (नीचे देखें) ).

भाषा उच्च-क्रम के कार्य नेस्टेड फ़ंक्शन गैर-स्थानीय चर टिप्पणियाँ
बहस परिणाम नामांकित अनाम बंद आंशिक आवेदन
अल्गोल परिवार एल्गोल 60 हाँ नहीं हाँ नहीं नीचे की ओर नहीं फ़ंक्शन प्रकार हैं ।
एल्गोल 68 हाँ हाँ हाँ हाँ नीचे की ओर नहीं
पास्कल हाँ नहीं हाँ नहीं नीचे की ओर नहीं
एडीए हाँ नहीं हाँ नहीं नीचे की ओर नहीं
ओबेरोन हाँ केवल गैर-नेस्टेड हाँ नहीं नीचे की ओर नहीं
डेल्फी हाँ हाँ हाँ 2009 2009 नहीं
सी परिवार सी हाँ हाँ हाँ जीएनयू सी में हाँ क्लैंग में ( ब्लॉक ) हाँ क्लैंग में ( ब्लॉक ) नहीं फ़ंक्शन पॉइंटर्स हैं ।
सी++ हाँ हाँ सी++11 सी++11 सी++11 सी++11 इसमें फ़ंक्शन पॉइंटर्स, फ़ंक्शन ऑब्जेक्ट हैं । (इसके अलावा, नीचे देखें।)

के साथ स्पष्ट आंशिक अनुप्रयोग संभव है std::bind।

सी# हाँ हाँ 7 2.0/3.0 2.0 3.0 इसमें डेलीगेट्स (2.0) और लैम्ब्डा एक्सप्रेशन (3.0) हैं।
उद्देश्य सी हाँ हाँ अनाम का उपयोग करना 2.0 + ब्लॉक 2.0 + ब्लॉक नहीं फ़ंक्शन पॉइंटर्स हैं.
जावा हाँ हाँ अनाम का उपयोग करना जावा 8 जावा 8 हाँ अनाम आंतरिक कक्षाएं हैं ।
जाना हाँ हाँ अनाम का उपयोग करना हाँ हाँ हाँ
लीम्बो हाँ हाँ हाँ हाँ हाँ नहीं
न्यूज़वीक हाँ हाँ हाँ हाँ हाँ नहीं
जंग हाँ हाँ हाँ हाँ हाँ हाँ
कार्यात्मक भाषाएँ तुतलाना वाक्य - विन्यास वाक्य - विन्यास हाँ हाँ सामान्य लिस्प नहीं (नीचे देखें)
योजना हाँ हाँ हाँ हाँ हाँ एसआरएफआई 26
जूलिया हाँ हाँ हाँ हाँ हाँ हाँ
क्लोजर हाँ हाँ हाँ हाँ हाँ हाँ
एमएल हाँ हाँ हाँ हाँ हाँ हाँ
हास्केल हाँ हाँ हाँ हाँ हाँ हाँ
jq हाँ नहीं हाँ केवल अभिव्यक्तियाँ नीचे की ओर नहीं
स्काला हाँ हाँ हाँ हाँ हाँ हाँ
Erlang हाँ हाँ हाँ हाँ हाँ हाँ
एफ# हाँ हाँ हाँ हाँ हाँ हाँ
ओकैमल हाँ हाँ हाँ हाँ हाँ हाँ
स्क्रिप्टिंग भाषाएँ आईओ हाँ हाँ हाँ हाँ हाँ नहीं
जावास्क्रिप्ट हाँ हाँ हाँ हाँ हाँ ईसीएमएस्क्रिप्ट 5 ES3 पर उपयोगकर्ता-भूमि कोड के साथ आंशिक आवेदन संभव है
लुआ हाँ हाँ हाँ हाँ हाँ हाँ
पीएचपी हाँ हाँ अनाम का उपयोग करना 5.3 5.3 नहीं उपयोगकर्ता-भूमि कोड के साथ आंशिक आवेदन संभव है।
पर्ल हाँ हाँ 6 हाँ हाँ 6
अजगर हाँ हाँ हाँ केवल अभिव्यक्तियाँ हाँ 2.5 (नीचे देखें)
माणिक वाक्य - विन्यास वाक्य - विन्यास अनस्कोप्ड हाँ हाँ 1.9 (नीचे देखें)
अन्य भाषाएं फोरट्रान हाँ हाँ हाँ नहीं नहीं नहीं
मेपल हाँ हाँ हाँ हाँ हाँ नहीं
मेथेमेटिका हाँ हाँ हाँ हाँ हाँ नहीं
मतलब हाँ हाँ हाँ हाँ हाँ हाँ नए कार्यों की स्वचालित पीढ़ी द्वारा आंशिक अनुप्रयोग संभव।
गपशप हाँ हाँ हाँ हाँ हाँ आंशिक पुस्तकालय के माध्यम से आंशिक आवेदन संभव।
तीव्र हाँ हाँ हाँ हाँ हाँ हाँ
सी ++
सी ++ 11 समापन कॉपी निर्माण द्वारा गैर-स्थानीय चर को संदर्भ द्वारा (उनके जीवनकाल को बढ़ाए बिना), या सी ++ 11 # रावल्यू संदर्भों द्वारा कैप्चर कर सकते हैं और कन्स्ट्रक्टर को स्थानांतरित कर सकते हैं (वैरिएबल समापन के रूप में लंबे समय तक रहता है)। पहला विकल्प सुरक्षित है यदि समापन लौटाया जाता है लेकिन एक प्रति की आवश्यकता होती है और मूल चर को संशोधित करने के लिए उपयोग नहीं किया जा सकता है (जो समापन कहे जाने के समय मौजूद नहीं हो सकता है)। दूसरा विकल्प संभावित रूप से एक महंगी प्रति से बचता है और मूल चर को संशोधित करने की अनुमति देता है लेकिन बंद होने की स्थिति में असुरक्षित है (झूलते संदर्भ देखें)। तीसरा विकल्प सुरक्षित है अगर समापन लौटाया जाता है और कॉपी की आवश्यकता नहीं होती है लेकिन मूल चर को संशोधित करने के लिए भी इसका उपयोग नहीं किया जा सकता है।
जावा
जावा 8 समापन केवल अंतिम या प्रभावी रूप से अंतिम गैर-स्थानीय चर पर कब्जा कर सकते हैं। जावा के कार्य प्रकारों को कक्षाओं के रूप में दर्शाया जाता है। अनाम कार्य संदर्भ से अनुमानित प्रकार लेते हैं। विधि संदर्भ सीमित हैं। अधिक जानकारी के लिए देखें Anonymous function § Java limitations.
लिस्प
लेक्सिकली स्कोप्ड लिस्प वेरिएंट समापन का समर्थन करता है। डायनामिक रूप से स्कोप किए गए वेरिएंट समापन का समर्थन नहीं करते हैं या समापन बनाने के लिए एक विशेष निर्माण की आवश्यकता होती है।[8]
सामान्य लिस्प में, कार्य नेमस्पेस में कार्य के पहचानकर्ता को प्रथम श्रेणी के मान के संदर्भ के रूप में उपयोग नहीं किया जा सकता है। विशेष संचालिका function कार्य को मान के रूप में पुनर्प्राप्त करने के लिए उपयोग किया जाना चाहिए: (function foo) एक कार्य ऑब्जेक्ट का मूल्यांकन करता है। #'foo आशुलिपि संकेतन के रूप में मौजूद है। इस तरह के कार्य ऑब्जेक्ट को लागू करने के लिए, इसका उपयोग करना चाहिए funcall कार्य  : (funcall #'foo bar baz).
पाइथन
स्पष्ट आंशिक आवेदन के साथ functools.partial संस्करण 2.5 के बाद से, और operator.methodcaller संस्करण 2.6 के बाद से।
माणिक
रूबी (जो वास्तव में एक विधि है) में नियमित कार्य के पहचानकर्ता को मूल्य या पारित के रूप में उपयोग नहीं किया जा सकता है। इसे पहले एक में पुनर्प्राप्त किया जाना चाहिए Method या Proc प्रथम श्रेणी के डेटा के रूप में उपयोग की जाने वाली वस्तु। ऐसे कार्य ऑब्जेक्ट को कॉल करने का सिंटैक्स नियमित तरीकों को कॉल करने से भिन्न होता है।
स्थिर विधि परिभाषाएँ वास्तव में स्कोप को नेस्ट नहीं करती हैं।
स्पष्ट करी के साथ [1].

यह भी देखें

टिप्पणियाँ

  1. ↑ Abelson, Harold; Sussman, Gerald Jay (1984). कंप्यूटर प्रोग्राम की संरचना और व्याख्या. MIT Press. Formulating Abstractions with Higher-Order Procedures. ISBN 0-262-01077-1.
  2. ↑ Programming language pragmatics, by Michael Lee Scott, section 11.2 "Functional Programming".
  3. ↑ Roberto Ierusalimschy; Luiz Henrique de Figueiredo; Waldemar Celes (2005). "The Implementation of Lua 5.0". Journal of Universal Computer Science. 11 (7): 1159–1176. doi:10.3217/jucs-011-07-1159.
  4. ↑ 4.0 4.1 Burstall, Rod; Strachey, Christopher (2000). "प्रोग्रामिंग भाषाओं को समझना" (PDF). Higher-Order and Symbolic Computation. 13 (52): 11–49. doi:10.1023/A:1010052305354. S2CID 1989590. Archived from the original on February 16, 2010.{{cite journal}}: CS1 maint: bot: original URL status unknown (link) (also on 2010-02-16
  5. ↑ Joel Moses. "The Function of FUNCTION in LISP, or Why the FUNARG Problem Should be Called the Environment Problem". MIT AI Memo 199, 1970.
  6. ↑ "If you try to call the nested function through its address after the containing function has exited, all hell will break loose." (GNU Compiler Collection: Nested Functions)
  7. ↑ Andrew W. Appel (1995). "Intensional Equality ;=) for Continuations".
  8. ↑ Closures in ZetaLisp Archived 2012-03-19 at the Wayback Machine


संदर्भ


बाहरी संबंध

Retrieved from ‘https://www.vigyanwiki.in/index.php?title=प्रथम_श्रेणी_फंक्शन&oldid=207483’