प्योर फंक्शन: Difference between revisions

From Vigyanwiki
No edit summary
m (11 revisions imported from alpha:प्योर_फंक्शन)
 
(3 intermediate revisions by 2 users not shown)
Line 1: Line 1:
{{Short description|Program function without side effects and which returns identical values for identical arguments}}
{{Short description|Program function without side effects and which returns identical values for identical arguments}}
[[कंप्यूटर प्रोग्रामिंग]] में, एक शुद्ध फ़ंक्शन एक [[सबरूटीन]] होता है जिसमें निम्नलिखित गुण होते हैं:<ref>{{cite web |url=https://www.schoolofhaskell.com/school/starting-with-haskell/basics-of-haskell/3-pure-functions-laziness-io |title=हास्केल की मूल बातें|author=Bartosz Milewski |date=2013 |website=School of Haskell |publisher=FP Complete |access-date=2018-07-13 |quote=Here are the fundamental properties of a pure function: 1. A function returns exactly the same result every time it's called with the same set of arguments. In other words a function has no state, nor can it access any external state. Every time you call it, it behaves like a newborn baby with blank memory and no knowledge of the external world. 2. A function has no side effects. Calling a function once is the same as calling it twice and discarding the result of the first call. |archive-url=https://web.archive.org/web/20161027145455/https://www.schoolofhaskell.com/school/starting-with-haskell/basics-of-haskell/3-pure-functions-laziness-io |archive-date=2016-10-27 |url-status=dead }}</ref><ref>{{cite web |url=https://github.com/MostlyAdequate/mostly-adequate-guide/blob/master/ch03.md |title=कार्यात्मक प्रोग्रामिंग के लिए प्रोफेसर फ्रिसबी की अधिकतर पर्याप्त मार्गदर्शिका|author=Brian Lonsdorf |date=2015 |website=GitHub |publisher= |access-date=2020-03-20 |quote=A pure function is a function that, given the same input, will always return the same output and does not have any observable side effect.}}</ref>
[[कंप्यूटर प्रोग्रामिंग]] में, एक प्योर फ़ंक्शन एक [[सबरूटीन]] होता है जिसमें निम्नलिखित गुण होते हैं:<ref>{{cite web |url=https://www.schoolofhaskell.com/school/starting-with-haskell/basics-of-haskell/3-pure-functions-laziness-io |title=हास्केल की मूल बातें|author=Bartosz Milewski |date=2013 |website=School of Haskell |publisher=FP Complete |access-date=2018-07-13 |quote=Here are the fundamental properties of a pure function: 1. A function returns exactly the same result every time it's called with the same set of arguments. In other words a function has no state, nor can it access any external state. Every time you call it, it behaves like a newborn baby with blank memory and no knowledge of the external world. 2. A function has no side effects. Calling a function once is the same as calling it twice and discarding the result of the first call. |archive-url=https://web.archive.org/web/20161027145455/https://www.schoolofhaskell.com/school/starting-with-haskell/basics-of-haskell/3-pure-functions-laziness-io |archive-date=2016-10-27 |url-status=dead }}</ref><ref>{{cite web |url=https://github.com/MostlyAdequate/mostly-adequate-guide/blob/master/ch03.md |title=कार्यात्मक प्रोग्रामिंग के लिए प्रोफेसर फ्रिसबी की अधिकतर पर्याप्त मार्गदर्शिका|author=Brian Lonsdorf |date=2015 |website=GitHub |publisher= |access-date=2020-03-20 |quote=A pure function is a function that, given the same input, will always return the same output and does not have any observable side effect.}}</ref>
# फ़ंक्शन [[ वापसी विवरण |वापसी विवरण]] रिलेशनल ऑपरेटर हैं या किसी फ़ंक्शन के समान तर्क के लिए स्थान समानता बनाम सामग्री समानता (स्थानीय [[स्थैतिक चर]], [[गैर-स्थानीय चर]], परिवर्तनीय [[मान प्रकार और संदर्भ प्रकार]] या इनपुट/आउटपुट के साथ कोई भिन्नता नहीं), और
# फ़ंक्शन [[ वापसी विवरण |वापसी विवरण]] रिलेशनल ऑपरेटर हैं या किसी फ़ंक्शन के समान तर्क के लिए स्थान समानता बनाम सामग्री समानता (स्थानीय [[स्थैतिक चर|स्थैतिक वैरीएबल]], [[गैर-स्थानीय चर|गैर-स्थानीय वैरीएबल]], परिवर्तनीय [[मान प्रकार और संदर्भ प्रकार]] या इनपुट/आउटपुट के साथ कोई भिन्नता नहीं), और
# फ़ंक्शन का कोई साइड इफेक्ट नहीं है (कंप्यूटर विज्ञान) (स्थानीय स्थैतिक चर, गैर-स्थानीय चर, परिवर्तनशील संदर्भ तर्क या इनपुट/आउटपुट स्ट्रीम का कोई उत्परिवर्तन नहीं)।
# फ़ंक्शन का कोई साइड इफेक्ट नहीं है (कंप्यूटर विज्ञान) (स्थानीय स्थैतिक वैरीएबल, गैर-स्थानीय वैरीएबल, परिवर्तनशील संदर्भ तर्क या इनपुट/आउटपुट स्ट्रीम का कोई उत्परिवर्तन नहीं)।


कुछ लेखक विशेष रूप से [[अनिवार्य भाषा]] समुदाय से उन सभी कार्यों के लिए शुद्ध शब्द का उपयोग करते हैं जिनमें उपरोक्त संपत्ति 2 होती है<ref>{{Cite web |title=सामान्य फ़ंक्शन विशेषताएँ - जीएनयू कंपाइलर संग्रह (जीसीसी) का उपयोग करना|url=https://gcc.gnu.org/onlinedocs/gcc-6.1.0/gcc/Common-Function-Attributes.html#index-functions-that-have-no-side-effects-3202 |access-date=2018-06-28 |website=gcc.gnu.org, the GNU Compiler Collection |publisher=Free Software Foundation, Inc.}}</ref><ref>[[Fortran 95 language features#Pure Procedures]]</ref> (नीचे चर्चा की गई है)।
कुछ लेखक विशेष रूप से [[अनिवार्य भाषा|अनिवार्य लैंग्वेज]] समुदाय से उन सभी कार्यों के लिए प्योर शब्द का उपयोग करते हैं जिनमें उपरोक्त प्रोपर्टी 2 होती है<ref>{{Cite web |title=सामान्य फ़ंक्शन विशेषताएँ - जीएनयू कंपाइलर संग्रह (जीसीसी) का उपयोग करना|url=https://gcc.gnu.org/onlinedocs/gcc-6.1.0/gcc/Common-Function-Attributes.html#index-functions-that-have-no-side-effects-3202 |access-date=2018-06-28 |website=gcc.gnu.org, the GNU Compiler Collection |publisher=Free Software Foundation, Inc.}}</ref><ref>[[Fortran 95 language features#Pure Procedures]]</ref> (नीचे चर्चा की गई है)।


== उदाहरण ==
== उदाहरण ==


=== शुद्ध कार्य ===
=== प्योर कार्य ===
[[C++]] फ़ंक्शंस के निम्नलिखित उदाहरण शुद्ध हैं:
[[C++]] फ़ंक्शंस के निम्नलिखित उदाहरण प्योर हैं:
{{ulist
{{ulist
|1=<code>floor</code>, returning the [[Floor and ceiling functions|floor]] of a number;
|1=<code>floor</code>, किसी संख्या का [[फर्श और छत कार्य|फर्श]] लौटाना;
|2=<code>max</code>, returning the [[Maxima and minima|maximum]] of two values.
|2=<code>max</code>, दो मानों का [[मैक्सिमा और मिनिमा|मैक्सिमम]] लौटाना.
|3=the function ''f'', defined as
|3=फ़ंक्शन ''f'', के रूप में परिभाषित किया गया है
<syntaxhighlight lang="c++">
<syntaxhighlight lang="c++">
void f() {
void f() {
Line 20: Line 20:
}
}
</syntaxhighlight>
</syntaxhighlight>
The value of <code>x</code> can be only observed inside other invocations of <code>f()</code>, and as <code>f()</code> does not communicate the value of <code>x</code> to its environment, it is indistinguishable from function <code>void f() {}</code> that does nothing. Note that <code>x</code> is <code>std::atomic</code> so that modifications from multiple threads executing <code>f()</code> concurrently do not result in a [[Race_condition#Data_race|data race]], which has [[undefined behavior]] in C and C++.
का मान <code>x</code> के अन्य आह्वानों के अंदर ही देखा जा सकता है <code>f()</code>, और जैसे <code>f()</code> का मूल्य संप्रेषित नहीं करता <code>x</code> अपने वातावरण में, यह कार्य से अप्रभेद्य है <code>void f() {}</code> वह कुछ नहीं करता. ध्यान दें कि <code>x</code> है <code>std::atomic</code> जिससे एकाधिक थ्रेड से संशोधन क्रियान्वित हो सकें <code>f()</code> समवर्ती रूप से [[रेस_कंडिशन#डेटा_रेस|डेटा रेस]] का परिणाम नहीं होता है, जिसमें C और C++ में [[अपरिभाषित व्यवहार]] होता है.
}}
}}


=== अशुद्ध कार्य ===
=== अप्योर कार्य ===
निम्नलिखित C++ फ़ंक्शंस अशुद्ध हैं क्योंकि उनमें उपरोक्त गुण 1 का अभाव है:
निम्नलिखित C++ फ़ंक्शंस अप्योर हैं क्योंकि उनमें उपरोक्त गुण 1 का अभाव है:
{{ulist
{{ulist
|1=because of return value variation with a static variable
|1=स्थिर वैरिएबल के साथ वापसी मूल्य भिन्नता के कारण
<syntaxhighlight lang="c++">
<syntaxhighlight lang="c++">
int f() {
int f() {
Line 34: Line 34:
}
}
</syntaxhighlight>
</syntaxhighlight>
|2=because of return value variation with a non-local variable
|2=गैर-स्थानीय वैरिएबल के साथ रिटर्न वैल्यू भिन्नता के कारण
<syntaxhighlight lang="c++">
<syntaxhighlight lang="c++">
int f() {
int f() {
Line 40: Line 40:
}
}
</syntaxhighlight>
</syntaxhighlight>
For the same reason, e.g. the C++ library function <code>sin()</code> is not pure, since its result depends on the [[IEEE rounding mode]] which can be changed at runtime.
इसी कारण से, उदा. C++ लाइब्रेरी फ़ंक्शन <code>sin()</code> शुद्ध नहीं है, क्योंकि इसका परिणाम [[आईईईई राउंडिंग मोड]] पर निर्भर करता है जिसे रनटाइम पर परिवर्तित किया जा सकता है.
|3=because of return value variation with a mutable reference argument
|3=एक परिवर्तनशील संदर्भ तर्क के साथ वापसी मूल्य भिन्नता के कारण
  <syntaxhighlight lang="c++">
  <syntaxhighlight lang="c++">
int f(int* x) {
int f(int* x) {
Line 47: Line 47:
}
}
</syntaxhighlight>
</syntaxhighlight>
|4=because of return value variation with an input stream
|4=इनपुट स्ट्रीम के साथ रिटर्न वैल्यू भिन्नता के कारण
<syntaxhighlight lang="c++">
<syntaxhighlight lang="c++">
int f() {
int f() {
Line 57: Line 57:
}}
}}


निम्नलिखित C++ फ़ंक्शंस अशुद्ध हैं क्योंकि उनमें उपरोक्त गुण 2 का अभाव है:
निम्नलिखित C++ फ़ंक्शंस अप्योर हैं क्योंकि उनमें उपरोक्त गुण 2 का अभाव है:
{{ulist
{{ulist
|1=because of mutation of a local static variable
|1=स्थानीय स्थैतिक वैरिएबल के उत्परिवर्तन के कारण
<syntaxhighlight lang="c++">
<syntaxhighlight lang="c++">
void f() {
void f() {
Line 66: Line 66:
}
}
</syntaxhighlight>
</syntaxhighlight>
|2=because of mutation of a non-local variable
|2=एक गैर-स्थानीय वैरिएबल के उत्परिवर्तन के कारण
<syntaxhighlight lang="c++">
<syntaxhighlight lang="c++">
void f() {
void f() {
Line 72: Line 72:
}
}
</syntaxhighlight>
</syntaxhighlight>
|3=because of mutation of a mutable reference argument
|3=एक परिवर्तनशील संदर्भ तर्क के उत्परिवर्तन के कारण
<syntaxhighlight lang="c++">
<syntaxhighlight lang="c++">
void f(int* x) {
void f(int* x) {
Line 78: Line 78:
}
}
</syntaxhighlight>
</syntaxhighlight>
|4=because of mutation of an output stream
|4=किसी आउटपुट स्ट्रीम में उत्परिवर्तन के कारण
<syntaxhighlight lang="c++">
<syntaxhighlight lang="c++">
void f() {
void f() {
Line 86: Line 86:
}}
}}


निम्नलिखित C++ फ़ंक्शंस अशुद्ध हैं क्योंकि उनमें उपरोक्त दोनों गुणों 1 और 2 का अभाव है:
निम्नलिखित C++ फ़ंक्शंस अप्योर हैं क्योंकि उनमें उपरोक्त दोनों गुणों 1 और 2 का अभाव है:
{{ulist
{{ulist
|1=because of return value variation with a local static variable and mutation of a local static variable
|1=स्थानीय स्थैतिक वैरीएबल के साथ वापसी मूल्य भिन्नता और स्थानीय स्थैतिक चर के उत्परिवर्तन के कारण
<syntaxhighlight lang="c++">
<syntaxhighlight lang="c++">
int f() {
int f() {
Line 96: Line 96:
}
}
</syntaxhighlight>
</syntaxhighlight>
|2=because of return value variation with an input stream and mutation of an input stream
|2=इनपुट स्ट्रीम के साथ रिटर्न वैल्यू भिन्नता और इनपुट स्ट्रीम के उत्परिवर्तन के कारण
<syntaxhighlight lang="c++">
<syntaxhighlight lang="c++">
int f() {
int f() {
Line 106: Line 106:
}}
}}


== शुद्ध कार्यों में I/O ==
== प्योर कार्यों में I/O ==
I/O स्वाभाविक रूप से अशुद्ध है: इनपुट ऑपरेशंस [[संदर्भात्मक पारदर्शिता]] को अशक्त करते हैं, और आउटपुट ऑपरेशंस दुष्प्रभाव उत्पन्न करते हैं। फिर भी एक ऐसा अर्थ है जिसमें एक फ़ंक्शन इनपुट या आउटपुट निष्पादित कर सकता है और फिर भी शुद्ध हो सकता है, यदि प्रासंगिक I/O उपकरणों पर संचालन के अनुक्रम को तर्क और परिणाम दोनों के रूप में स्पष्ट रूप से मॉडलिंग किया जाता है, और I/O संचालन लिया जाता है विफल होना जब इनपुट अनुक्रम प्रोग्राम के निष्पादन प्रारंभिक होने के बाद से वास्तव में किए गए संचालन का वर्णन नहीं करता है।
I/O स्वाभाविक रूप से अप्योर है: इनपुट ऑपरेशंस [[संदर्भात्मक पारदर्शिता]] को अशक्त करते हैं, और आउटपुट ऑपरेशंस दुष्प्रभाव उत्पन्न करते हैं। फिर भी एक ऐसा अर्थ है जिसमें एक फ़ंक्शन इनपुट या आउटपुट निष्पादित कर सकता है और फिर भी प्योर हो सकता है, यदि प्रासंगिक I/O उपकरणों पर संचालन के अनुक्रम को तर्क और परिणाम दोनों के रूप में स्पष्ट रूप से मॉडलिंग किया जाता है, और I/O संचालन लिया जाता है विफल होना जब इनपुट अनुक्रम प्रोग्राम के निष्पादन प्रारंभिक होने के बाद से वास्तव में किए गए संचालन का वर्णन नहीं करता है।


दूसरा बिंदु यह सुनिश्चित करता है कि तर्क के रूप में प्रयोग करने योग्य एकमात्र अनुक्रम प्रत्येक I/O कार्रवाई के साथ बदलना चाहिए; पहला, अनुक्रम तर्कों में बदलाव के कारण अलग-अलग परिणाम देने के लिए I/O-प्रदर्शन फ़ंक्शन में अलग-अलग कॉल की अनुमति देता है।<ref>{{cite book|last1=Peyton Jones|first1=Simon L.|title=Haskell 98 Language and Libraries: The Revised Report|page=95|date=2003|publisher=Cambridge University Press|location=Cambridge, United Kingdom|isbn=0-521 826144|url=http://it.bmc.uu.se/andlov/dev/books/haskell98-report.pdf|accessdate=17 July 2014|ref=haskell98}}</ref><ref>{{cite web|last1=Hanus|first1=Michael|title=Curry: An Integrated Functional Logic Language|page=33|url=http://www.informatik.uni-kiel.de/~curry/papers/report.pdf|website=www-ps.informatik.uni-kiel.de|publisher=Institut für Informatik, Christian-Albrechts-Universität zu Kiel|accessdate=17 July 2014|ref=curry14|archive-url=https://web.archive.org/web/20140725231927/http://www.informatik.uni-kiel.de/~curry/papers/report.pdf|archive-date=25 July 2014|url-status=dead}}</ref>
दूसरा बिंदु यह सुनिश्चित करता है कि तर्क के रूप में प्रयोग करने योग्य एकमात्र अनुक्रम प्रत्येक I/O कार्रवाई के साथ बदलना चाहिए; पहला, अनुक्रम तर्कों में बदलाव के कारण अलग-अलग परिणाम देने के लिए I/O-प्रदर्शन फ़ंक्शन में अलग-अलग कॉल की अनुमति देता है।<ref>{{cite book|last1=Peyton Jones|first1=Simon L.|title=Haskell 98 Language and Libraries: The Revised Report|page=95|date=2003|publisher=Cambridge University Press|location=Cambridge, United Kingdom|isbn=0-521 826144|url=http://it.bmc.uu.se/andlov/dev/books/haskell98-report.pdf|accessdate=17 July 2014|ref=haskell98}}</ref><ref>{{cite web|last1=Hanus|first1=Michael|title=Curry: An Integrated Functional Logic Language|page=33|url=http://www.informatik.uni-kiel.de/~curry/papers/report.pdf|website=www-ps.informatik.uni-kiel.de|publisher=Institut für Informatik, Christian-Albrechts-Universität zu Kiel|accessdate=17 July 2014|ref=curry14|archive-url=https://web.archive.org/web/20140725231927/http://www.informatik.uni-kiel.de/~curry/papers/report.pdf|archive-date=25 July 2014|url-status=dead}}</ref>


I/O मोनैड एक [[प्रोग्रामिंग मुहावरा]] है जिसका उपयोग सामान्यतः शुद्ध कार्यात्मक भाषाओं में I/O करने के लिए किया जाता है।  
I/O मोनैड एक [[प्रोग्रामिंग मुहावरा]] है जिसका उपयोग सामान्यतः प्योर कार्यात्मक लैंग्वेज में I/O करने के लिए किया जाता है।  


== कंपाइलर अनुकूलन ==
== कंपाइलर अनुकूलन ==
उपरोक्त संपत्ति 2 वाले फ़ंक्शंस कंपाइलर ऑप्टिमाइज़ेशन विधिों के लिए अनुमति देते हैं जैसे कि [[सामान्य उपअभिव्यक्ति उन्मूलन]] और अंकगणितीय ऑपरेटरों के समान [[लूप अनुकूलन]]<ref>{{Cite web |title=सामान्य फ़ंक्शन विशेषताएँ - जीएनयू कंपाइलर संग्रह (जीसीसी) का उपयोग करना|url=https://gcc.gnu.org/onlinedocs/gcc-6.1.0/gcc/Common-Function-Attributes.html#index-functions-that-have-no-side-effects-3246 |access-date=2018-06-28 |website=gcc.gnu.org, the GNU Compiler Collection |publisher=Free Software Foundation, Inc.}}</ref> C++ उदाहरण (<code>length</code> ) विधि है, एक स्ट्रिंग का आकार लौटाती है, जो उस मेमोरी सामग्री पर निर्भर करती है जहां स्ट्रिंग इंगित करती है, इसलिए उपरोक्त संपत्ति 1 का अभाव है। फिर भी, एक [[थ्रेड (कंप्यूटिंग)]] | एकल-थ्रेडेड वातावरण में, निम्नलिखित C++ कोड होता है<syntaxhighlight>
उपरोक्त प्रोपर्टी 2 वाले फ़ंक्शंस कंपाइलर ऑप्टिमाइज़ेशन विधिों के लिए अनुमति देते हैं जैसे कि [[सामान्य उपअभिव्यक्ति उन्मूलन]] और अंकगणितीय ऑपरेटरों के समान [[लूप अनुकूलन]] <ref>{{Cite web |title=सामान्य फ़ंक्शन विशेषताएँ - जीएनयू कंपाइलर संग्रह (जीसीसी) का उपयोग करना|url=https://gcc.gnu.org/onlinedocs/gcc-6.1.0/gcc/Common-Function-Attributes.html#index-functions-that-have-no-side-effects-3246 |access-date=2018-06-28 |website=gcc.gnu.org, the GNU Compiler Collection |publisher=Free Software Foundation, Inc.}}</ref> C++ उदाहरण (<code>length</code> ) विधि है, एक स्ट्रिंग का आकार लौटाती है, जो उस मेमोरी सामग्री पर निर्भर करती है जहां स्ट्रिंग इंगित करती है, इसलिए उपरोक्त प्रोपर्टी 1 का अभाव है। फिर भी, एक [[थ्रेड (कंप्यूटिंग)]] एकल-थ्रेडेड वातावरण में, निम्नलिखित C++ कोड होता है<syntaxhighlight>
std::string s = "Hello, world!";
std::string s = "Hello, world!";
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
Line 123: Line 123:
}
}
</syntaxhighlight>
</syntaxhighlight>




इस प्रकार अनुकूलित किया जा सकता है कि का मान <code>s.length()</code> लूप से पहले केवल एक बार गणना की जाती है।
इस प्रकार अनुकूलित किया जा सकता है कि का मान <code>s.length()</code> लूप से पहले केवल एक बार गणना की जाती है।


कुछ प्रोग्रामिंग भाषाएँ किसी फ़ंक्शन के लिए शुद्ध गुण घोषित करने की अनुमति देती हैं:
कुछ प्रोग्रामिंग लैंग्वेज किसी फ़ंक्शन के लिए प्योर गुण घोषित करने की अनुमति देती हैं:
* [[फोरट्रान]] और डी में, <code>pure</code> कीवर्ड का उपयोग किसी फ़ंक्शन को केवल साइड-इफेक्ट मुक्त घोषित करने के लिए किया जा सकता है (अर्थात केवल उपरोक्त संपत्ति 2 है)।<ref>[https://archive.today/20130103042647/http://publib.boulder.ibm.com/infocenter/comphelp/v111v131/index.jsp?topic=/com.ibm.xlf131.aix.doc/language_ref/pure.html Pure attribute in Fortran]</ref> संकलक घोषणा के शीर्ष पर संपत्ति 1 निकालने में सक्षम हो सकता है।<ref>[https://web.archive.org/web/20190202194918/https://digitalmars.com/d/2.0/function.html#pure-functions Pure attribute in D language]</ref>
* [[फोरट्रान]] और डी में, <code>pure</code> कीवर्ड का उपयोग किसी फ़ंक्शन को केवल साइड-इफेक्ट मुक्त घोषित करने के लिए किया जा सकता है (अर्थात केवल उपरोक्त प्रोपर्टी 2 है)।<ref>[https://archive.today/20130103042647/http://publib.boulder.ibm.com/infocenter/comphelp/v111v131/index.jsp?topic=/com.ibm.xlf131.aix.doc/language_ref/pure.html Pure attribute in Fortran]</ref> संकलक घोषणा के शीर्ष पर प्रोपर्टी 1 निकालने में सक्षम हो सकता है।<ref>[https://web.archive.org/web/20190202194918/https://digitalmars.com/d/2.0/function.html#pure-functions Pure attribute in D language]</ref>
* [[जीएनयू कंपाइलर संग्रह]] में, <code>pure</code> विशेषता संपत्ति 2 निर्दिष्ट करती है, जबकि <code>const</code> विशेषता दोनों गुणों के साथ वास्तव में शुद्ध फ़ंक्शन निर्दिष्ट करती है।<ref>{{cite web |title=सामान्य कार्य विशेषताएँ|url=https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html |website=Using the GNU Compiler Collection (GCC |access-date=22 July 2021}}</ref>
* [[जीएनयू कंपाइलर संग्रह]] में, <code>pure</code> विशेषता प्रोपर्टी 2 निर्दिष्ट करती है, जबकि <code>const</code> विशेषता दोनों गुणों के साथ वास्तव में प्योर फ़ंक्शन निर्दिष्ट करती है।<ref>{{cite web |title=सामान्य कार्य विशेषताएँ|url=https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html |website=Using the GNU Compiler Collection (GCC |access-date=22 July 2021}}</ref>
* [[संकलन-समय फ़ंक्शन निष्पादन]] की प्रस्तुति करने वाली भाषाओं को फ़ंक्शन को शुद्ध करने की आवश्यकता हो सकती है, कभी-कभी कुछ अन्य बाधाओं के साथ। उदाहरणों में सम्मिलित <code>constexpr</code> C++ की (दोनों गुण) सम्मिलित हैं।।<ref>[https://web.archive.org/web/20190325075719/https://en.cppreference.com/w/cpp/language/constexpr constexpr attribute in C++]</ref>
* [[संकलन-समय फ़ंक्शन निष्पादन]] की प्रस्तुति करने वाली लैंग्वेज को फ़ंक्शन को प्योर करने की आवश्यकता हो सकती है, कभी-कभी कुछ अन्य बाधाओं के साथ। उदाहरणों में सम्मिलित <code>constexpr</code> C++ की (दोनों गुण) सम्मिलित हैं।।<ref>[https://web.archive.org/web/20190325075719/https://en.cppreference.com/w/cpp/language/constexpr constexpr attribute in C++]</ref>
== इकाई परीक्षण ==
== इकाई परीक्षण ==
चूँकि शुद्ध फ़ंक्शंस में किसी फ़ंक्शन के समान तर्क के लिए समान रिटर्न स्टेटमेंट होता है, इसलिए वे इकाई परीक्षण के लिए उपयुक्त होते हैं।
चूँकि प्योर फ़ंक्शंस में किसी फ़ंक्शन के समान तर्क के लिए समान रिटर्न स्टेटमेंट होता है, इसलिए वे इकाई परीक्षण के लिए उपयुक्त होते हैं।


== यह भी देखें              ==
== यह भी देखें              ==
* संकलन-समय फ़ंक्शन निष्पादन: संकलन समय पर शुद्ध कार्यों का मूल्यांकन
* संकलन-समय फ़ंक्शन निष्पादन: संकलन समय पर प्योर कार्यों का मूल्यांकन
* [[नियतात्मक एल्गोरिथ्म]]
* [[नियतात्मक एल्गोरिथ्म]]
* [[विशुद्ध रूप से कार्यात्मक डेटा संरचना]]
* [[विशुद्ध रूप से कार्यात्मक डेटा संरचना|विप्योर रूप से कार्यात्मक डेटा संरचना]]
* [[लैम्ब्डा कैलकुलस]]
* [[लैम्ब्डा कैलकुलस]]
* दुष्प्रभाव (कंप्यूटर विज्ञान)
* दुष्प्रभाव (कंप्यूटर विज्ञान)
* [[पुनर्प्रवेश (कंप्यूटिंग)]]
* [[पुनर्प्रवेश (कंप्यूटिंग)]]
* [[नपुंसकता]]
* [[नपुंसकता]]
* फोरट्रान 95 भाषा की विशेषताएँ या फोरट्रान में शुद्ध प्रक्रियाएँ कीवर्ड शुद्ध कार्यों की व्याख्या करते हैं
* फोरट्रान 95 लैंग्वेज की विशेषताएँ या फोरट्रान में प्योर प्रक्रियाएँ कीवर्ड प्योर कार्यों की व्याख्या करते हैं
* C++11 या कॉन्स्टेक्सपीआर- C++ में सामान्यीकृत स्थिर अभिव्यक्ति कीवर्ड, संकलन-समय पर प्रयोग करने योग्य शुद्ध कार्यों को एनोटेट करता है
* C++11 या कॉन्स्टेक्सपीआर- C++ में सामान्यीकृत स्थिर अभिव्यक्ति कीवर्ड, संकलन-समय पर प्रयोग करने योग्य प्योर कार्यों को एनोटेट करता है


== संदर्भ ==
== संदर्भ ==
Line 153: Line 154:
[[Category: Machine Translated Page]]
[[Category: Machine Translated Page]]
[[Category:Created On 22/06/2023]]
[[Category:Created On 22/06/2023]]
[[Category:Vigyan Ready]]

Latest revision as of 07:05, 8 October 2023

कंप्यूटर प्रोग्रामिंग में, एक प्योर फ़ंक्शन एक सबरूटीन होता है जिसमें निम्नलिखित गुण होते हैं:[1][2]

  1. फ़ंक्शन वापसी विवरण रिलेशनल ऑपरेटर हैं या किसी फ़ंक्शन के समान तर्क के लिए स्थान समानता बनाम सामग्री समानता (स्थानीय स्थैतिक वैरीएबल, गैर-स्थानीय वैरीएबल, परिवर्तनीय मान प्रकार और संदर्भ प्रकार या इनपुट/आउटपुट के साथ कोई भिन्नता नहीं), और
  2. फ़ंक्शन का कोई साइड इफेक्ट नहीं है (कंप्यूटर विज्ञान) (स्थानीय स्थैतिक वैरीएबल, गैर-स्थानीय वैरीएबल, परिवर्तनशील संदर्भ तर्क या इनपुट/आउटपुट स्ट्रीम का कोई उत्परिवर्तन नहीं)।

कुछ लेखक विशेष रूप से अनिवार्य लैंग्वेज समुदाय से उन सभी कार्यों के लिए प्योर शब्द का उपयोग करते हैं जिनमें उपरोक्त प्रोपर्टी 2 होती है[3][4] (नीचे चर्चा की गई है)।

उदाहरण

प्योर कार्य

C++ फ़ंक्शंस के निम्नलिखित उदाहरण प्योर हैं:

  • floor, किसी संख्या का फर्श लौटाना;
  • max, दो मानों का मैक्सिमम लौटाना.
  • फ़ंक्शन f, के रूप में परिभाषित किया गया है 
    void f() {
  static std::atomic<unsigned int> x = 0;
  ++x;
}
    का मान x के अन्य आह्वानों के अंदर ही देखा जा सकता है f(), और जैसे f() का मूल्य संप्रेषित नहीं करता x अपने वातावरण में, यह कार्य से अप्रभेद्य है void f() {} वह कुछ नहीं करता. ध्यान दें कि x है std::atomic जिससे एकाधिक थ्रेड से संशोधन क्रियान्वित हो सकें f() समवर्ती रूप से डेटा रेस का परिणाम नहीं होता है, जिसमें C और C++ में अपरिभाषित व्यवहार होता है.

अप्योर कार्य

निम्नलिखित C++ फ़ंक्शंस अप्योर हैं क्योंकि उनमें उपरोक्त गुण 1 का अभाव है:

  • स्थिर वैरिएबल के साथ वापसी मूल्य भिन्नता के कारण 
    int f() {
  static int x = 0;
  ++x;
  return x;
}
  • गैर-स्थानीय वैरिएबल के साथ रिटर्न वैल्यू भिन्नता के कारण 
    int f() {
  return x;
}
    इसी कारण से, उदा. C++ लाइब्रेरी फ़ंक्शन sin() शुद्ध नहीं है, क्योंकि इसका परिणाम आईईईई राउंडिंग मोड पर निर्भर करता है जिसे रनटाइम पर परिवर्तित किया जा सकता है.
  • एक परिवर्तनशील संदर्भ तर्क के साथ वापसी मूल्य भिन्नता के कारण 
    int f(int* x) {
  return *x;
}
  • इनपुट स्ट्रीम के साथ रिटर्न वैल्यू भिन्नता के कारण 
    int f() {
  int x = 0;
  std::cin >> x;
  return x;
}

निम्नलिखित C++ फ़ंक्शंस अप्योर हैं क्योंकि उनमें उपरोक्त गुण 2 का अभाव है:

  • स्थानीय स्थैतिक वैरिएबल के उत्परिवर्तन के कारण 
    void f() {
  static int x = 0;
  ++x;
}
  • एक गैर-स्थानीय वैरिएबल के उत्परिवर्तन के कारण 
    void f() {
  ++x;
}
  • एक परिवर्तनशील संदर्भ तर्क के उत्परिवर्तन के कारण 
    void f(int* x) {
  ++*x;
}
  • किसी आउटपुट स्ट्रीम में उत्परिवर्तन के कारण 
    void f() {
  std::cout << "Hello, world!" << std::endl;
}

निम्नलिखित C++ फ़ंक्शंस अप्योर हैं क्योंकि उनमें उपरोक्त दोनों गुणों 1 और 2 का अभाव है:

  • स्थानीय स्थैतिक वैरीएबल के साथ वापसी मूल्य भिन्नता और स्थानीय स्थैतिक चर के उत्परिवर्तन के कारण 
    int f() {
  static int x = 0;
  ++x;
  return x;
}
  • इनपुट स्ट्रीम के साथ रिटर्न वैल्यू भिन्नता और इनपुट स्ट्रीम के उत्परिवर्तन के कारण 
    int f() {
  int x = 0;
  std::cin >> x;
  return x;
}

प्योर कार्यों में I/O

I/O स्वाभाविक रूप से अप्योर है: इनपुट ऑपरेशंस संदर्भात्मक पारदर्शिता को अशक्त करते हैं, और आउटपुट ऑपरेशंस दुष्प्रभाव उत्पन्न करते हैं। फिर भी एक ऐसा अर्थ है जिसमें एक फ़ंक्शन इनपुट या आउटपुट निष्पादित कर सकता है और फिर भी प्योर हो सकता है, यदि प्रासंगिक I/O उपकरणों पर संचालन के अनुक्रम को तर्क और परिणाम दोनों के रूप में स्पष्ट रूप से मॉडलिंग किया जाता है, और I/O संचालन लिया जाता है विफल होना जब इनपुट अनुक्रम प्रोग्राम के निष्पादन प्रारंभिक होने के बाद से वास्तव में किए गए संचालन का वर्णन नहीं करता है।

दूसरा बिंदु यह सुनिश्चित करता है कि तर्क के रूप में प्रयोग करने योग्य एकमात्र अनुक्रम प्रत्येक I/O कार्रवाई के साथ बदलना चाहिए; पहला, अनुक्रम तर्कों में बदलाव के कारण अलग-अलग परिणाम देने के लिए I/O-प्रदर्शन फ़ंक्शन में अलग-अलग कॉल की अनुमति देता है।[5][6]

I/O मोनैड एक प्रोग्रामिंग मुहावरा है जिसका उपयोग सामान्यतः प्योर कार्यात्मक लैंग्वेज में I/O करने के लिए किया जाता है।

कंपाइलर अनुकूलन

उपरोक्त प्रोपर्टी 2 वाले फ़ंक्शंस कंपाइलर ऑप्टिमाइज़ेशन विधिों के लिए अनुमति देते हैं जैसे कि सामान्य उपअभिव्यक्ति उन्मूलन और अंकगणितीय ऑपरेटरों के समान लूप अनुकूलन [7] C++ उदाहरण (length ) विधि है, एक स्ट्रिंग का आकार लौटाती है, जो उस मेमोरी सामग्री पर निर्भर करती है जहां स्ट्रिंग इंगित करती है, इसलिए उपरोक्त प्रोपर्टी 1 का अभाव है। फिर भी, एक थ्रेड (कंप्यूटिंग) एकल-थ्रेडेड वातावरण में, निम्नलिखित C++ कोड होता है

std::string s = "Hello, world!";
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int l = 0;

for (int i = 0; i < 10; ++i) {
  l += s.length() + a[i];
}


इस प्रकार अनुकूलित किया जा सकता है कि का मान s.length() लूप से पहले केवल एक बार गणना की जाती है।

कुछ प्रोग्रामिंग लैंग्वेज किसी फ़ंक्शन के लिए प्योर गुण घोषित करने की अनुमति देती हैं:

  • फोरट्रान और डी में, pure कीवर्ड का उपयोग किसी फ़ंक्शन को केवल साइड-इफेक्ट मुक्त घोषित करने के लिए किया जा सकता है (अर्थात केवल उपरोक्त प्रोपर्टी 2 है)।[8] संकलक घोषणा के शीर्ष पर प्रोपर्टी 1 निकालने में सक्षम हो सकता है।[9]
  • जीएनयू कंपाइलर संग्रह में, pure विशेषता प्रोपर्टी 2 निर्दिष्ट करती है, जबकि const विशेषता दोनों गुणों के साथ वास्तव में प्योर फ़ंक्शन निर्दिष्ट करती है।[10]
  • संकलन-समय फ़ंक्शन निष्पादन की प्रस्तुति करने वाली लैंग्वेज को फ़ंक्शन को प्योर करने की आवश्यकता हो सकती है, कभी-कभी कुछ अन्य बाधाओं के साथ। उदाहरणों में सम्मिलित constexpr C++ की (दोनों गुण) सम्मिलित हैं।।[11]

इकाई परीक्षण

चूँकि प्योर फ़ंक्शंस में किसी फ़ंक्शन के समान तर्क के लिए समान रिटर्न स्टेटमेंट होता है, इसलिए वे इकाई परीक्षण के लिए उपयुक्त होते हैं।

यह भी देखें

संदर्भ

  1. ↑ Bartosz Milewski (2013). "हास्केल की मूल बातें". School of Haskell. FP Complete. Archived from the original on 2016-10-27. Retrieved 2018-07-13. Here are the fundamental properties of a pure function: 1. A function returns exactly the same result every time it's called with the same set of arguments. In other words a function has no state, nor can it access any external state. Every time you call it, it behaves like a newborn baby with blank memory and no knowledge of the external world. 2. A function has no side effects. Calling a function once is the same as calling it twice and discarding the result of the first call.
  2. ↑ Brian Lonsdorf (2015). "कार्यात्मक प्रोग्रामिंग के लिए प्रोफेसर फ्रिसबी की अधिकतर पर्याप्त मार्गदर्शिका". GitHub. Retrieved 2020-03-20. A pure function is a function that, given the same input, will always return the same output and does not have any observable side effect.
  3. ↑ "सामान्य फ़ंक्शन विशेषताएँ - जीएनयू कंपाइलर संग्रह (जीसीसी) का उपयोग करना". gcc.gnu.org, the GNU Compiler Collection. Free Software Foundation, Inc. Retrieved 2018-06-28.
  4. ↑ Fortran 95 language features#Pure Procedures
  5. ↑ Peyton Jones, Simon L. (2003). Haskell 98 Language and Libraries: The Revised Report (PDF). Cambridge, United Kingdom: Cambridge University Press. p. 95. ISBN 0-521 826144. Retrieved 17 July 2014.
  6. ↑ Hanus, Michael. "Curry: An Integrated Functional Logic Language" (PDF). www-ps.informatik.uni-kiel.de. Institut für Informatik, Christian-Albrechts-Universität zu Kiel. p. 33. Archived from the original (PDF) on 25 July 2014. Retrieved 17 July 2014.
  7. ↑ "सामान्य फ़ंक्शन विशेषताएँ - जीएनयू कंपाइलर संग्रह (जीसीसी) का उपयोग करना". gcc.gnu.org, the GNU Compiler Collection. Free Software Foundation, Inc. Retrieved 2018-06-28.
  8. ↑ Pure attribute in Fortran
  9. ↑ Pure attribute in D language
  10. ↑ "सामान्य कार्य विशेषताएँ". Using the GNU Compiler Collection (GCC. Retrieved 22 July 2021.
  11. ↑ constexpr attribute in C++
Retrieved from ‘https://www.vigyanwiki.in/index.php?title=प्योर_फंक्शन&oldid=263617’