लिस्ट कॉम्प्रिहेंशन: Difference between revisions

From Vigyanwiki
(Created page with "{{Short description|Syntactic construct for creating a list based on existing lists}} सूची समझ मौजूदा सूची (कंप्यूटिंग)...")
 
No edit summary
 
(9 intermediate revisions by 4 users not shown)
Line 1: Line 1:
{{Short description|Syntactic construct for creating a list based on existing lists}}
{{Short description|Syntactic construct for creating a list based on existing lists}}
सूची समझ मौजूदा [[सूची (कंप्यूटिंग)]] के आधार पर सूची बनाने के लिए कुछ [[प्रोग्रामिंग भाषा]]ओं में उपलब्ध प्रोग्रामिंग भाषाओं का एक सिंटैक्स है। यह गणितीय ''[[सेट-बिल्डर नोटेशन]]'' (''सेट कॉम्प्रिहेंशन'') के रूप का अनुसरण करता है जो मैप (उच्च-क्रम फ़ंक्शन) और फ़िल्टर (उच्च-ऑर्डर फ़ंक्शन) फ़ंक्शंस के उपयोग से अलग है।
'''लिस्ट कॉम्प्रिहेंशन''' उपस्थित लिस्ट के आधार पर लिस्ट बनाने के लिए कुछ [[प्रोग्रामिंग भाषा|प्रोग्रामिंग भाषाओं]] में उपलब्ध एक वाक्यात्मक संरचना है। यह गणितीय [[सेट-बिल्डर नोटेशन|''सेट-बिल्डर संकेतन'']] (सेट कॉम्प्रिहेंशन) के रूप का अनुसरण करता है जो मानचित्र और फ़िल्टर फ़ंक्शंस के उपयोग से अलग है।


==अवलोकन==
==अवलोकन==
सेट-बिल्डर नोटेशन में निम्नलिखित उदाहरण पर विचार करें।
सेट-बिल्डर संकेतन में निम्नलिखित उदाहरण पर विचार करें।


:<math>S=\{2\cdot x\mid x \in \mathbb{N},\ x^2>3\}</math>
:<math>S=\{2\cdot x\mid x \in \mathbb{N},\ x^2>3\}</math>
या अक्सर
या प्रायः
:<math>S=\{2\cdot x : x \in \mathbb{N},\ x^2>3\}</math>
:<math>S=\{2\cdot x : x \in \mathbb{N},\ x^2>3\}</math>
इसे पढ़ा जा सकता है,<math>S</math> सभी संख्याओं का 2 बार समुच्चय है <math>x</math>ऐसा है कि <math>x</math> [[प्राकृतिक संख्या]]ओं के समुच्चय का एक तत्व या सदस्य है (<math>\mathbb{N}</math>), और <math>x</math> चुकता से बड़ा है <math>3</math>.
इसे रीड किया जा सकता है, "<math>S</math> सभी संख्याओं का सेट है "2 गुना <math>x</math>" सच दैट <math>x</math> [[प्राकृतिक संख्या|प्राकृतिक संख्याओं]] (<math>\mathbb{N}</math>) के सेट का एलिमेंट या मेंमबर है, एंड <math>x</math> का वर्ग <math>3</math> से बड़ा है।"


सबसे छोटी प्राकृतिक संख्या, x = 1, शर्त x को संतुष्ट करने में विफल रहती है<sup>2</sup>>3 (शर्त 1<sup>2</sup>>3 गलत है) इसलिए 2·1 को एस में शामिल नहीं किया गया है। अगली प्राकृतिक संख्या, 2, शर्त को पूरा करती है (2<sup>2</sup>>3) जैसा कि हर अन्य प्राकृतिक संख्या करती है। इस प्रकार x में 2, 3, 4, 5... समुच्चय है {{var|S}} सभी संख्याओं से 2 गुना x से मिलकर बना है, यह S = {4, 6, 8, 10,...} द्वारा दिया गया है। दूसरे शब्दों में, S, 2 से बड़ी सभी सम संख्याओं का समुच्चय है।
सबसे छोटी प्राकृतिक संख्या, x = 1, स्थिति x<sup>2</sup>>3 को संतुष्ट करने में विफल रहती है (स्थिति 1<sup>2</sup>>3 गलत है) इसलिए 2 ·1 को S में सम्मिलित नहीं किया गया है। अगली प्राकृतिक संख्या, 2, प्रत्येक अन्य प्राकृतिक संख्या की तरह स्थिति (2<sup>2</sup>>3) को संतुष्ट करती है। इस प्रकार x में 2, 3, 4, 5... होते हैं चूँकि सेट S में सभी संख्याएँ "2 गुना x" होती हैं, इसलिए इसे S = {4, 6, 8, 10,...} द्वारा दिया जाता है। दूसरे शब्दों में, S, 2 से बड़ी सभी सम संख्याओं का सेट है।


उदाहरण के इस एनोटेटेड संस्करण में:
उदाहरण के इस एनोटेटेड संस्करण में-
:<math>S=\{\underbrace{2\cdot x}_{\color{Violet}{\text{output expression}}}\mid \underbrace{x}_{\color{Violet}{\text{variable}}} \in \underbrace{\mathbb{N}}_{\color{Violet}{\text{input set}}},\ \underbrace{x^2>3}_{\color{Violet}{\text{predicate}}}\}</math>
:<math>S=\{\underbrace{2\cdot x}_{\color{Violet}{\text{output expression}}}\mid \underbrace{x}_{\color{Violet}{\text{variable}}} \in \underbrace{\mathbb{N}}_{\color{Violet}{\text{input set}}},\ \underbrace{x^2>3}_{\color{Violet}{\text{predicate}}}\}</math>
* <math>x</math> एक इनपुट सेट के सदस्यों का प्रतिनिधित्व करने वाला वेरिएबल है।
* <math>x</math> एक इनपुट सेट के सदस्यों का प्रतिनिधित्व करने वाला चर है।
* <math>\mathbb{N}</math> इनपुट सेट का प्रतिनिधित्व करता है, जो इस उदाहरण में प्राकृतिक संख्याओं का सेट है
* <math>\mathbb{N}</math> इनपुट सेट का प्रतिनिधित्व करता है, जो इस उदाहरण में प्राकृतिक संख्याओं का सेट है
* <math>x^2>3</math> एक [[विधेय (तर्क)]] अभिव्यक्ति है जो इनपुट सेट के सदस्यों पर फ़िल्टर के रूप में कार्य करती है।
* <math>x^2>3</math> इनपुट सेट के सदस्यों पर फ़िल्टर के रूप में कार्य करने वाली [[विधेय (तर्क)|निर्धारक]] अभिव्यक्ति है।
* <math>2\cdot x</math> एक आउटपुट एक्सप्रेशन है जो इनपुट सेट के सदस्यों से नए सेट के सदस्यों का निर्माण करता है जो विधेय अभिव्यक्ति को संतुष्ट करते हैं।
* <math>2\cdot x</math> आउटपुट अभिव्यक्ति है जो इनपुट सेट के सदस्यों से नए सेट के सदस्यों का उत्पादन करती है जो विधेय अभिव्यक्ति को संतुष्ट करते हैं।
* <math>\{\}</math> ब्रेसिज़ इंगित करते हैं कि परिणाम एक सेट है
* <math>\{\}</math> ब्रेसिज़ इंगित करते हैं कि परिणाम एक सेट है
* <math>\mid</math> <math>,</math> ऊर्ध्वाधर पट्टी को इस प्रकार पढ़ा जाता है। बार और कोलन : का उपयोग परस्पर विनिमय के लिए किया जाता है।
* <math>\mid</math> <math>,</math> ऊर्ध्वाधर पट्टी को "सच दैट" के रूप में रीड किया जाता है। बार और कोलन ":" का प्रयोग एक दूसरे के स्थान पर किया जाता है।
* अल्पविराम विधेय को अलग करते हैं और इन्हें AND के रूप में पढ़ा जा सकता है।
* अल्पविराम निर्धारक को अलग करते हैं और इसे "एंड" के रूप में रीड किया जा सकता है।


एक सूची समझ में एक इनपुट सूची (कंप्यूटिंग) या पुनरावर्तक के क्रम में एक सूची की पीढ़ी का प्रतिनिधित्व करने के लिए समान वाक्यात्मक घटक होते हैं:
लिस्ट कॉम्प्रिहेंशन में इनपुट लिस्ट या पुनरावर्तक के क्रम में लिस्ट की पीढ़ी का प्रतिनिधित्व करने के लिए समान वाक्यात्मक घटक होते हैं-
* एक इनपुट सूची के सदस्यों का प्रतिनिधित्व करने वाला एक चर।
* इनपुट लिस्ट के सदस्यों का प्रतिनिधित्व करने वाला चर।
* एक इनपुट सूची (या पुनरावर्तक)।
* इनपुट लिस्ट (या पुनरावर्तक)।
* एक वैकल्पिक विधेय अभिव्यक्ति.
* वैकल्पिक निर्धारक अभिव्यक्ति।
* और एक आउटपुट एक्सप्रेशन, इनपुट पुनरावर्तनीय के सदस्यों से आउटपुट सूची के सदस्यों का उत्पादन करता है जो विधेय को संतुष्ट करते हैं।
* और आउटपुट अभिव्यक्ति, इनपुट पुनरावर्तनीय के सदस्यों से आउटपुट लिस्ट के सदस्यों का उत्पादन करती है जो निर्धारक को संतुष्ट करते हैं।
आउटपुट सूची के सदस्यों की पीढ़ी का क्रम इनपुट में वस्तुओं के क्रम पर आधारित है।
आउटपुट लिस्ट के सदस्यों की पीढ़ी का क्रम इनपुट में वस्तुओं के क्रम पर आधारित है।


हास्केल (प्रोग्रामिंग भाषा)|हास्केल की सूची समझ वाक्यविन्यास में, यह सेट-बिल्डर निर्माण इसी तरह लिखा जाएगा, जैसे:
हास्केल के लिस्ट कॉम्प्रिहेंशन सिंटैक्स में, यह सेट-बिल्डर निर्माण इसी तरह लिखा जाएगा, जैसे-
<syntaxhighlight lang="haskell">
<syntaxhighlight lang="haskell">
s = [ 2*x | x <- [0..], x^2 > 3 ]
s = [ 2*x | x <- [0..], x^2 > 3 ]
</syntaxhighlight>
</syntaxhighlight>
यहाँ, सूची <code>[0..]</code> का प्रतिनिधित्व करता है <math>\mathbb{N}</math>, <code>x^2>3</code> विधेय का प्रतिनिधित्व करता है, और <code>2*x</code> आउटपुट अभिव्यक्ति का प्रतिनिधित्व करता है।
यहां, लिस्ट <code>[0..]</code> <math>\mathbb{N}</math> का प्रतिनिधित्व करती है, <code>x^2>3</code> निर्धारक का प्रतिनिधित्व करती है, और <code>2*x</code> आउटपुट अभिव्यक्ति का प्रतिनिधित्व करती है।


सूची समझ एक परिभाषित क्रम में परिणाम देती है (सेट के सदस्यों के विपरीत); और सूची समझ [[जनरेटर (कंप्यूटर विज्ञान)]] किसी सूची के सदस्यों को क्रम में ला सकता है, न कि पूरी सूची तैयार कर सकता है, उदाहरण के लिए, एक अनंत सूची के सदस्यों की पिछली हास्केल परिभाषा की अनुमति देता है।
लिस्ट कॉम्प्रिहेंशन एक परिभाषित क्रम (सेट के सदस्यों के विपरीत) में परिणाम देता है और लिस्ट का कॉम्प्रिहेंशन किसी लिस्ट के सदस्यों को क्रम में [[जनरेटर (कंप्यूटर विज्ञान)|उत्पन्न]] कर सकता है, न कि संपूर्ण लिस्ट तैयार करने से, उदाहरण के लिए, अनंत लिस्ट के सदस्यों को पिछली हास्केल परिभाषा की अनुमति मिलती है।


==इतिहास==
==इतिहास==


संबंधित निर्माणों का अस्तित्व सूची समझ शब्द के उपयोग से पहले का है। [[SETL]] प्रोग्रामिंग भाषा (1969) में एक सेट निर्माण संरचना है जो सूची समझ के समान है। उदाहरण के लिए, यह कोड 2 से लेकर सभी अभाज्य संख्याओं को प्रिंट करता है {{var|N}}:
संबंधित निर्माणों का अस्तित्व "लिस्ट कॉम्प्रिहेंशन" शब्द के उपयोग से पहले का है। [[SETL|एसईटीएल (SETL)]] प्रोग्रामिंग भाषा (1969) में एक सेट निर्माण संरचना है जो लिस्ट कॉम्प्रिहेंशन के समान है। उदाहरण के लिए, यह कोड 2 से {{var|N}} तक सभी अभाज्य संख्याओं को प्रिंट करता है-
  प्रिंट([n in [2..N] | forall m in {2..n - 1} | n mod m > 0]);
  print([n in [2..N] | forall m in {2..n - 1} | n mod m > 0]);
[[कंप्यूटर बीजगणित प्रणाली]] Axiom (कंप्यूटर बीजगणित प्रणाली) (1973) में एक समान संरचना है जो [[स्ट्रीम (कंप्यूटिंग)]] को संसाधित करती है।
[[कंप्यूटर बीजगणित प्रणाली]] एएक्सआईओएम (AXIOM) (1973) में समान निर्माण होता है जो [[स्ट्रीम (कंप्यूटिंग)|स्ट्रीम]] को प्रोसेस करता है।


ऐसे निर्माणों के लिए समझ शब्द का पहला उपयोग [[रॉड बर्स्टल]] और [[जॉन डार्लिंगटन]] द्वारा 1977 से उनकी कार्यात्मक प्रोग्रामिंग भाषा [[एनपीएल प्रोग्रामिंग भाषा]] के विवरण में किया गया था। उनके पूर्वव्यापी कार्यात्मक प्रोग्रामिंग भाषाओं के कुछ इतिहास में,<ref>{{cite conference | first = David | last = Turner | url = https://www.cs.kent.ac.uk/people/staff/dat/tfp12/tfp12.pdf | title = कार्यात्मक प्रोग्रामिंग भाषाओं का कुछ इतिहास| book-title = International Symposium on Trends in Functional Programming, Springer, Berlin, Heidelberg | pages = 1–20 | year = 2012}}</ref> डेविड_टर्नर_(कंप्यूटर_वैज्ञानिक) याद करते हैं:
ऐसे निर्माणों के लिए "कॉम्प्रिहेंशन" शब्द का प्रथम उपयोग [[रॉड बर्स्टल]] और [[जॉन डार्लिंगटन]] द्वारा 1977 से उनकी कार्यात्मक प्रोग्रामिंग भाषा [[एनपीएल प्रोग्रामिंग भाषा|एनपीएल (NPL)]] के विवरण में किया गया था। डेविड टर्नर अपने पूर्वव्यापी "कार्यात्मक प्रोग्रामिंग भाषाओं के कुछ इतिहास" में<ref>{{cite conference | first = David | last = Turner | url = https://www.cs.kent.ac.uk/people/staff/dat/tfp12/tfp12.pdf | title = कार्यात्मक प्रोग्रामिंग भाषाओं का कुछ इतिहास| book-title = International Symposium on Trends in Functional Programming, Springer, Berlin, Heidelberg | pages = 1–20 | year = 2012}}</ref> याद करते हैं-


{{quote|text=NPL was implemented in POP2 by Burstall and used for Darlington’s work on program transformation (Burstall & Darlington 1977). The language was first order, strongly (but not polymorphically) typed, purely functional, call-by-value. It also had “set expressions” e.g.
{{quote|text=एनपीएल को बर्स्टॉल द्वारा पीओपी2 (POP2) में कार्यान्वित किया गया था और प्रोग्राम ट्रांसफॉर्मेशन (बर्स्टल और डार्लिंगटन 1977) पर डार्लिंगटन के काम के लिए उपयोग किया गया था। भाषा प्रथम क्रम की थी, दृढ़ता से (लेकिन बहुरूपी रूप से नहीं) टाइप की गई, पूरी तरह कार्यात्मक, कॉल-बाय-वैल्यू थी। इसमें "सेट अभिव्यक्तियाँ" भी थे जैसे
:<pre>setofeven (X)  <=  <:x : x in X & even(x):>}}</pre>
:<pre>setofeven (X)  <=  <:x : x in X & even(x):>}}</pre>
}}
}}


शब्द सूची समझ से जुड़े एक फ़ुटनोट में, टर्नर यह भी नोट करता है
"लिस्ट कॉम्प्रिहेंशन" शब्द से जुड़े फ़ुटनोट में, टर्नर यह भी नोट करते है


{{quote|text=I initially called these ''ZF expressions'', a reference to Zermelo-Frankel set theory — it was [[Philip_Wadler|Phil Wadler]] who coined the better term ''list comprehension''.}}
{{quote|text=मैंने प्रारम्भ में इन जेडएफ (ZF) अभिव्यक्तियों को ज़र्मेलो-फ्रैंकल सेट सिद्धांत का संदर्भ कहा था - यह [[फिल वाडलर|फिल वाडलर]] थे जिन्होंने बेहतर शब्द लिस्ट कॉम्प्रिहेंशन को गढ़ा था।}}
 
एनपीएल के साथ बर्स्टॉल और डार्लिंगटन के काम ने 1980 के दशक के दौरान कई कार्यात्मक प्रोग्रामिंग भाषाओं को प्रभावित किया, लेकिन सभी में सूची समझ शामिल नहीं थी। 1985 में जारी टर्नर की प्रभावशाली, शुद्ध, आलसी, कार्यात्मक प्रोग्रामिंग भाषा [[मिरांडा प्रोग्रामिंग भाषा]] एक अपवाद थी। बाद में विकसित मानक शुद्ध आलसी कार्यात्मक भाषा [[हास्केल प्रोग्रामिंग भाषा]] में सूची समझ सहित मिरांडा की कई विशेषताएं शामिल हैं।
 
समझ को डेटाबेस के लिए क्वेरी नोटेशन के रूप में प्रस्तावित किया गया था<ref>[http://portal.acm.org/citation.cfm?coll=GUIDE&dl=GUIDE&id=135271 Comprehensions, a query notation for DBPLs<!-- Bot generated title -->]</ref> और [[हेनरिक क्लिस्ली]] डेटाबेस क्वेरी भाषा में कार्यान्वित किए गए थे।<ref>[http://portal.acm.org/citation.cfm?id=351241&dl=ACM&coll=portal The functional guts of the Kleisli query system<!-- Bot generated title -->]</ref>


एनपीएल के साथ बर्स्टॉल और डार्लिंगटन के काम ने 1980 के दशक के दौरान कई कार्यात्मक प्रोग्रामिंग भाषाओं को प्रभावित किया, लेकिन सभी में लिस्ट कॉम्प्रिहेंशन सम्मिलित नहीं था। 1985 में जारी टर्नर की प्रभावशाली, शुद्ध, स्लो, कार्यात्मक प्रोग्रामिंग भाषा [[मिरांडा प्रोग्रामिंग भाषा|मिरांडा]] एक अपवाद थी। बाद में विकसित मानक शुद्ध स्लो कार्यात्मक भाषा [[हास्केल प्रोग्रामिंग भाषा|हास्केल]] में लिस्ट कॉम्प्रिहेंशन सहित मिरांडा की कई विशेषताएं सम्मिलित हैं।


कॉम्प्रिहेंशन को डेटाबेस के लिए क्वेरी संकेतन के रूप में प्रस्तावित किया गया था<ref>[http://portal.acm.org/citation.cfm?coll=GUIDE&dl=GUIDE&id=135271 Comprehensions, a query notation for DBPLs<!-- Bot generated title -->]</ref> और इसे [[हेनरिक क्लिस्ली|क्लेस्ली]] डेटाबेस क्वेरी भाषा में लागू किया गया था।<ref>[http://portal.acm.org/citation.cfm?id=351241&dl=ACM&coll=portal The functional guts of the Kleisli query system<!-- Bot generated title -->]</ref>
== विभिन्न प्रोग्रामिंग भाषाओं में उदाहरण ==
== विभिन्न प्रोग्रामिंग भाषाओं में उदाहरण ==


{{main|Comparison of programming languages (list comprehension)}}<syntaxhighlight lang="julia">
{{main|प्रोग्रामिंग भाषाओं की तुलना (लिस्ट कॉम्प्रिहेंशन)}}
 
==समान निर्माण==
</syntaxhighlight>
 


==समान रचनाएँ==
===मोनाड कॉम्प्रिहेंशन===
हास्केल में, मोनैड कॉम्प्रिहेंशन कार्यात्मक प्रोग्रामिंग में अन्य मोनैड के लिए लिस्ट कॉम्प्रिहेंशन का सामान्यीकरण है।


===मोनाड समझ===
===सेट कॉम्प्रिहेंशन===
हास्केल में, कार्यात्मक प्रोग्रामिंग में एक सन्यासी #do-नोटेशन कार्यात्मक प्रोग्रामिंग में अन्य सन्यासियों के लिए सूची समझ का एक सामान्यीकरण है।
पायथन भाषा का संस्करण 3.x और 2.7 सेट कॉम्प्रिहेंशन के लिए सिंटैक्स का परिचय देता है। लिस्ट कॉम्प्रिहेंशन के समान, [[सेट (कंप्यूटर विज्ञान)|सेट]] कॉम्प्रिहेंशन लिस्ट के स्थान पर पायथन सेट उत्पन्न करते हैं।
 
===समझ सेट करें===
पायथन भाषा का संस्करण 3.x और 2.7 [[सेट (कंप्यूटर विज्ञान)]] समझ के लिए वाक्यविन्यास का परिचय देता है। सूची समझ के रूप में समान, सेट समझ सूचियों के बजाय पायथन सेट उत्पन्न करती है।
<syntaxhighlight lang="python">
<syntaxhighlight lang="python">
>>> s = {v for v in 'ABCDABCD' if v not in 'CB'}
>>> s = {v for v in 'ABCDABCD' if v not in 'CB'}
Line 80: Line 74:
>>>
>>>
</syntaxhighlight>
</syntaxhighlight>
[[रैकेट (प्रोग्रामिंग भाषा)]] सेट समझ सूचियों के बजाय रैकेट सेट उत्पन्न करती है।
[[रैकेट (प्रोग्रामिंग भाषा)|रैकेट]] सेट कॉम्प्रिहेंशन लिस्ट के स्थान पर रैकेट सेट उत्पन्न करता है।
<syntaxhighlight lang="scheme">
<syntaxhighlight lang="scheme">
(for/set ([v "ABCDABCD"] #:unless (member v (string->list "CB")))
(for/set ([v "ABCDABCD"] #:unless (member v (string->list "CB")))
         v))
         v))
</syntaxhighlight>
</syntaxhighlight>
 
===शब्दकोश कॉम्प्रिहेंशन===
 
पायथन भाषा के संस्करण 3.x और 2.7 ने [[साहचर्य सरणी|शब्दकोश]] कॉम्प्रिहेंशन के लिए एक नया सिंटैक्स पेश किया, जो लिस्ट कॉम्प्रिहेंशन के रूप में समान था लेकिन जो लिस्ट के स्थान पर पायथन [https://docs.python.org/library/stdtypes.html#dict डिक्ट] उत्पन्न करता था।
===शब्दकोश बोध===
पायथन भाषा के संस्करण 3.x और 2.7 ने [[साहचर्य सरणी]] समझ के लिए एक नया वाक्यविन्यास पेश किया, जो सूची समझ के रूप में समान है, लेकिन इसके बजाय पायथन [https://docs.python.org/library/stdtypes.html#dict dicts] उत्पन्न करता है। सूचियों का.
<syntaxhighlight lang="python">
<syntaxhighlight lang="python">
>>> s = {key: val for key, val in enumerate('ABCD') if val not in 'CB'}
>>> s = {key: val for key, val in enumerate('ABCD') if val not in 'CB'}
Line 95: Line 87:
>>>
>>>
</syntaxhighlight>
</syntaxhighlight>
रैकेट हैश टेबल समझ रैकेट हैश टेबल उत्पन्न करती है (रैकेट शब्दकोश प्रकार का एक कार्यान्वयन)।
रैकेट हैश टेबल कॉम्प्रिहेंशन रैकेट हैश टेबल (रैकेट शब्दकोश प्रकार का कार्यान्वयन) उत्पन्न करती है।
<syntaxhighlight lang="scheme">
<syntaxhighlight lang="scheme">
(for/hash ([(val key) (in-indexed "ABCD")]
(for/hash ([(val key) (in-indexed "ABCD")]
Line 101: Line 93:
   (values key val))
   (values key val))
</syntaxhighlight>
</syntaxhighlight>
 
===समानांतर लिस्ट कॉम्प्रिहेंशन===
 
[[ग्लासगो हास्केल कंपाइलर|ग्लासगो हास्केल संकलक]] में '''समानांतर लिस्ट कॉम्प्रिहेंशन''' (जिसे '''ज़िप-कॉम्प्रिहेंशन''' के रूप में भी जाना जाता है) नामक एक्सटेंशन है जो लिस्ट कॉम्प्रिहेंशन सिंटैक्स के भीतर विशेषण की कई स्वतंत्र शाखाओं की अनुमति देता है। जबकि अल्पविराम द्वारा अलग किए गए विशेषण आश्रित ("नेस्टेड") होते हैं, पाइपों द्वारा अलग किए गए विशेषण शाखाओं का मूल्यांकन समानांतर (यह मल्टीथ्रेडेडनेस के किसी भी रूप को संदर्भित नहीं करता है- इसका अर्थ केवल यह है कि शाखाएं ज़िप की गई हैं) में किया जाता है।
===समानांतर सूची समझ===
[[ग्लासगो हास्केल कंपाइलर]] में समानांतर सूची समझ (जिसे ज़िप-समझ के रूप में भी जाना जाता है) नामक एक एक्सटेंशन है जो सूची समझ वाक्यविन्यास के भीतर क्वालीफायर की कई स्वतंत्र शाखाओं की अनुमति देता है।
जबकि अल्पविराम द्वारा अलग किए गए क्वालीफायर आश्रित (नेस्टेड) ​​होते हैं, पाइपों द्वारा अलग किए गए क्वालीफायर शाखाओं का मूल्यांकन समानांतर में किया जाता है (यह मल्टीथ्रेडेडनेस के किसी भी रूप को संदर्भित नहीं करता है: इसका मतलब केवल यह है कि शाखाएं मैप (उच्च-क्रम फ़ंक्शन) हैं)।
<syntaxhighlight lang="haskell">
<syntaxhighlight lang="haskell">
-- regular list comprehension
-- regular list comprehension
Line 119: Line 108:
-- [(1,3),(2,4),(3,5)]
-- [(1,3),(2,4),(3,5)]
</syntaxhighlight>
</syntaxhighlight>
रैकेट की समझ मानक लाइब्रेरी में इसकी समझ के समानांतर और नेस्टेड संस्करण शामिल हैं, जो नाम में for बनाम for* द्वारा प्रतिष्ठित हैं। उदाहरण के लिए, वेक्टर समझ for/vector और for*/vector अनुक्रमों पर समानांतर बनाम नेस्टेड पुनरावृत्ति द्वारा वैक्टर बनाते हैं। हास्केल सूची समझ उदाहरणों के लिए रैकेट कोड निम्नलिखित है।
रैकेट की कॉम्प्रिहेंशन मानक लाइब्रेरी में इसके कॉम्प्रिहेंशन के समानांतर और नेस्टेड संस्करण सम्मिलित हैं, जो नाम में "फॉर" बनाम "फॉर*" द्वारा प्रतिष्ठित हैं। उदाहरण के लिए, वेक्टर कॉम्प्रिहेंशन "फॉर/वेक्टर" और "फॉर*/वेक्टर" अनुक्रमों पर समानांतर बनाम नेस्टेड पुनरावृत्ति द्वारा वेक्टर बनाते हैं। हास्केल लिस्ट कॉम्प्रिहेंशन उदाहरणों के लिए रैकेट कोड निम्नलिखित है।
<syntaxhighlight lang="scheme">
<syntaxhighlight lang="scheme">
> (for*/list ([x (in-range 1 6)] [y (in-range 3 6)]) (list x y))
> (for*/list ([x (in-range 1 6)] [y (in-range 3 6)]) (list x y))
Line 126: Line 115:
'((1 3) (2 4) (3 5))
'((1 3) (2 4) (3 5))
</syntaxhighlight>
</syntaxhighlight>
पायथन में, हम निम्नानुसार कार्य कर सकते हैं:
पायथन में, हम निम्नानुसार कार्य कर सकते हैं-
<syntaxhighlight lang="python">
<syntaxhighlight lang="python">
# regular list comprehension
# regular list comprehension
Line 136: Line 125:
[(1, 3), (2, 4), (3, 5)]
[(1, 3), (2, 4), (3, 5)]
</syntaxhighlight>
</syntaxhighlight>
जूलिया में, व्यावहारिक रूप से समान परिणाम निम्नानुसार प्राप्त किए जा सकते हैं:
जूलिया में, व्यावहारिक रूप से समान परिणाम निम्नानुसार प्राप्त किए जा सकते हैं-
<syntaxhighlight lang="julia">
<syntaxhighlight lang="julia">
# regular array comprehension
# regular array comprehension
Line 144: Line 133:
>>> b = [x for x in zip(1:3, 3:5)]
>>> b = [x for x in zip(1:3, 3:5)]
</syntaxhighlight>
</syntaxhighlight>
एकमात्र अंतर यह है कि जूलिया में सूचियों के बजाय, हमारे पास सारणियाँ हैं।
एकमात्र अंतर यह है कि जूलिया में लिस्ट के स्थान पर, हमारे पास अरे हैं।


=== XQuery और XPath ===
=== एक्सक्वेरी और एक्सपाथ ===
मूल एनपीएल उपयोग की तरह, ये मूल रूप से डेटाबेस एक्सेस भाषाएं हैं।
मूल एनपीएल उपयोग की तरह, ये मूलतः डेटाबेस एक्सेस भाषाएं हैं।


यह समझ की अवधारणा को और अधिक महत्वपूर्ण बनाता है, क्योंकि संपूर्ण सूची को पुनः प्राप्त करना और उस पर काम करना कम्प्यूटेशनल रूप से असंभव है (प्रारंभिक 'संपूर्ण सूची' संपूर्ण XML डेटाबेस हो सकती है)।
यह कॉम्प्रिहेंशन की अवधारणा को और अधिक महत्वपूर्ण बनाता है, क्योंकि संपूर्ण लिस्ट को पुनः प्राप्त करना और उस पर काम करना कम्प्यूटेशनल रूप से असंभव है (प्रारंभिक 'संपूर्ण लिस्ट' संपूर्ण एक्सएमएल (XML) डेटाबेस हो सकती है)।


XPath में, अभिव्यक्ति:
एक्सपाथ में, अभिव्यक्ति-
<syntaxhighlight lang="xquery">
<syntaxhighlight lang="xquery">
/library/book//paragraph[@style='first-in-chapter']
/library/book//paragraph[@style='first-in-chapter']
</syntaxhighlight>
</syntaxhighlight>
वैचारिक रूप से चरणों की एक श्रृंखला के रूप में मूल्यांकन किया जाता है जहां प्रत्येक चरण एक सूची तैयार करता है और अगला चरण पिछले चरण के आउटपुट में प्रत्येक तत्व पर एक फ़िल्टर फ़ंक्शन लागू करता है।<ref>{{cite web | url = http://www.w3.org/TR/xpath#section-Location-Steps | title = 2.1 Location Steps | work = XML Path Language (XPath) | date = 16 November 1999 | publisher = [[W3C]] | access-date = 24 December 2008 | archive-url = https://web.archive.org/web/20121209085946/http://www.w3.org/TR/xpath/#section-Location-Steps | archive-date = 9 December 2012 | url-status = dead }}</ref>
वैचारिक रूप से "चरणों" की श्रृंखला के रूप में मूल्यांकन किया जाता है जहां प्रत्येक चरण एक लिस्ट तैयार करता है और अगला चरण पिछले चरण के आउटपुट में प्रत्येक तत्व पर फ़िल्टर फ़ंक्शन लागू करता है।<ref>{{cite web | url = http://www.w3.org/TR/xpath#section-Location-Steps | title = 2.1 Location Steps | work = XML Path Language (XPath) | date = 16 November 1999 | publisher = [[W3C]] | access-date = 24 December 2008 | archive-url = https://web.archive.org/web/20121209085946/http://www.w3.org/TR/xpath/#section-Location-Steps | archive-date = 9 December 2012 | url-status = dead }}</ref>
XQuery में, पूर्ण XPath उपलब्ध है, लेकिन [[FLWOR]] स्टेटमेंट का भी उपयोग किया जाता है, जो एक अधिक शक्तिशाली समझ निर्माण है।<ref>{{cite web | url = https://www.w3schools.com/XQuery/xquery_flwor.asp | title = XQuery FLWOR अभिव्यक्तियाँ| work = [[W3Schools]] | url-status = dead | archive-url = https://web.archive.org/web/20111008001258/http://w3schools.com/xquery/xquery_flwor.asp | archive-date = 2011-10-08 }}</ref>
 
एक्सक्वेरी में, पूर्ण एक्सपाथ उपलब्ध है, लेकिन [[FLWOR|एफएलडब्लयूओआर (FLWOR)]] कथनों का भी उपयोग किया जाता है, जो कि अधिक शक्तिशाली कॉम्प्रिहेंशन निर्माण है।<ref>{{cite web | url = https://www.w3schools.com/XQuery/xquery_flwor.asp | title = XQuery FLWOR अभिव्यक्तियाँ| work = [[W3Schools]] | url-status = dead | archive-url = https://web.archive.org/web/20111008001258/http://w3schools.com/xquery/xquery_flwor.asp | archive-date = 2011-10-08 }}</ref>
<syntaxhighlight lang="xquery">
<syntaxhighlight lang="xquery">
for $b in //book
for $b in //book
Line 167: Line 157:
   </shortBook>
   </shortBook>
</syntaxhighlight>
</syntaxhighlight>
यहां XPath //पुस्तक का मूल्यांकन एक अनुक्रम (उर्फ सूची) बनाने के लिए किया जाता है; जहां खंड एक कार्यात्मक फिल्टर है, परिणाम को क्रमबद्ध करता है, और {{tag|shortBook}} XML स्निपेट वास्तव में एक अज्ञात फ़ंक्शन है जो अन्य कार्यात्मक भाषाओं में पाए जाने वाले 'मैप' दृष्टिकोण का उपयोग करके अनुक्रम में प्रत्येक तत्व के लिए XML बनाता/बदलता है।
यहां एक्सपाथ //बुक का मूल्यांकन अनुक्रम (उर्फ लिस्ट) बनाने के लिए किया जाता है जहां क्लॉस कार्यात्मक "फ़िल्टर" है, परिणाम को क्रमबद्ध करता है, और {{tag|शॉर्टबुक}} एक्सएमएल स्निपेट वास्तव में एक अज्ञात फ़ंक्शन है जो अन्य कार्यात्मक भाषाओं में पाए जाने वाले 'मैप' दृष्टिकोण का उपयोग करके अनुक्रम में प्रत्येक तत्व के लिए एक्सएमएल बनाता/बदलता है।


तो, किसी अन्य कार्यात्मक भाषा में उपरोक्त FLWOR कथन को इस तरह लागू किया जा सकता है:
तो, किसी अन्य कार्यात्मक भाषा में उपरोक्त एफएलडब्लयूओआर कथन को इस प्रकार कार्यान्वित किया जा सकता है-<syntaxhighlight lang="xquery">
<syntaxhighlight lang="xquery">
map(
map(
   newXML(shortBook, newXML(title, $1.title), newXML(firstPara, $1...))
   newXML(shortBook, newXML(title, $1.title), newXML(firstPara, $1...))
Line 179: Line 168:
)
)
</syntaxhighlight>
</syntaxhighlight>
=== C# में एलआईएनक्यू (LINQ) ===


 
C# 3.0 में संबंधित सुविधाओं का एक समूह है जिसे एलआईएनक्यू कहा जाता है, जो ऑब्जेक्ट गणना में हेरफेर करने के लिए क्वेरी ऑपरेटरों के सेट को परिभाषित करता है।
=== C# में LINQ ===
 
सी शार्प (प्रोग्रामिंग भाषा)|सी# 3.0 में [[ भाषा एकीकृत क्वेरी ]] नामक संबंधित सुविधाओं का एक समूह है, जो ऑब्जेक्ट गणना में हेरफेर करने के लिए क्वेरी ऑपरेटरों के एक सेट को परिभाषित करता है।


<syntaxhighlight lang="csharp">
<syntaxhighlight lang="csharp">
var s = Enumerable.Range(0, 100).Where(x => x * x > 3).Select(x => x * 2);
var s = Enumerable.Range(0, 100).Where(x => x * x > 3).Select(x => x * 2);
</syntaxhighlight>
</syntaxhighlight>
यह एसक्यूएल की याद दिलाते हुए एक वैकल्पिक समझ वाक्यविन्यास भी प्रदान करता है:
यह एसक्यूएल (SQL) की याद दिलाते हुए वैकल्पिक कॉम्प्रिहेंशन सिंटैक्स भी प्रदान करता है-


<syntaxhighlight lang="csharp">
<syntaxhighlight lang="csharp">
var s = from x in Enumerable.Range(0, 100) where x * x > 3 select x * 2;
var s = from x in Enumerable.Range(0, 100) where x * x > 3 select x * 2;
</syntaxhighlight>
</syntaxhighlight>
LINQ विशिष्ट सूची समझ कार्यान्वयन पर एक क्षमता प्रदान करता है। जब समझ का मूल उद्देश्य कार्यान्वित होता है <code>IQueryable</code> इंटरफ़ेस, केवल समझ के जंजीर तरीकों को निष्पादित करने के बजाय, कमांड के पूरे अनुक्रम को एक अमूर्त सिंटैक्स ट्री (एएसटी) ऑब्जेक्ट में परिवर्तित कर दिया जाता है, जिसे व्याख्या और निष्पादित करने के लिए IQueryable ऑब्जेक्ट को पास किया जाता है।
एलआईएनक्यू विशिष्ट लिस्ट कॉम्प्रिहेंशन कार्यान्वयन पर क्षमता प्रदान करता है। जब कॉम्प्रिहेंशन का मूल ऑब्जेक्ट <code>आईक्वेरीबल(IQueryable)</code> इंटरफ़ेस को कार्यान्वित करता है, तो केवल कॉम्प्रिहेंशन की श्रृंखलाबद्ध विधियों को निष्पादित करने के स्थान पर, कमांड का पूरा अनुक्रम संक्षेप सिंटैक्स ट्री (एएसटी) ऑब्जेक्ट में परिवर्तित हो जाता है, जिसे व्याख्या और निष्पादित करने के लिए आईक्वेरीबल ऑब्जेक्ट को पास किया जाता है।  


यह, अन्य बातों के अलावा, IQueryable को अनुमति देता है
यह, अन्य बातों के अलावा, आईक्वेरीबल को इसकी अनुमति देता है
* असंगत या अकुशल समझ को फिर से लिखें
* किसी असंगत या अप्रभावी कॉम्प्रिहेंशन को दोबारा लिखें
* निष्पादन के लिए एएसटी को किसी अन्य क्वेरी भाषा (जैसे एसक्यूएल) में अनुवाद करें
* निष्पादन के लिए एएसटी (AST) को किसी अन्य क्वेरी भाषा (उदाहरण के लिए एसक्यूएल) में अनुवाद करें


=== सी++ ===
=== C++ ===
C++ में सीधे तौर पर सूची समझ का समर्थन करने वाली कोई भाषा सुविधा नहीं है, लेकिन [[ऑपरेटर ओवरलोडिंग]] (उदाहरण के लिए, ओवरलोडिंग) है <code>|</code>, <code>>></code>, <code>>>=</code>) एम्बेडेड क्वेरी [[डोमेन-विशिष्ट भाषा]]ओं (डीएसएल) के लिए अभिव्यंजक वाक्यविन्यास प्रदान करने के लिए सफलतापूर्वक उपयोग किया गया है। वैकल्पिक रूप से, एक कंटेनर में तत्वों का चयन करने के लिए इरेज़-रिमूव मुहावरे का उपयोग करके सूची समझ का निर्माण किया जा सकता है और उन्हें बदलने के लिए STL एल्गोरिदम for_each का उपयोग किया जा सकता है।
C++ में सीधे तौर पर लिस्ट कॉम्प्रिहेंशन का सपोर्ट करने वाली कोई भाषा सुविधा नहीं है, लेकिन [[ऑपरेटर ओवरलोडिंग]] (उदाहरण के लिए, ओवरलोडिंग <code>|</code>, <code>>></code>, <code>>>=</code>) का उपयोग "अंतः स्थापित" क्वेरी [[डोमेन-विशिष्ट भाषा|डोमेन-विशिष्ट भाषाओं]] (डीएसएल (DSL)) के लिए अभिव्यंजक सिंटैक्स प्रदान करने के लिए सफलतापूर्वक किया गया है। वैकल्पिक रूप से, कंटेनर में तत्वों का चयन करने के लिए मिटाओ-हटाओ मुहावरे का उपयोग करके लिस्ट कॉम्प्रिहेंशन का निर्माण किया जा सकता है और उन्हें बदलने के लिए एसटीएल (STL) एल्गोरिदम फॉर_ईच का उपयोग किया जा सकता है।
<syntaxhighlight lang="cpp">
<syntaxhighlight lang="cpp">
#include <algorithm>
#include <algorithm>
Line 237: Line 224:
}
}
</syntaxhighlight>
</syntaxhighlight>
C++ को सेट बिल्डर नोटेशन के समान सूची-समझ निर्माण/सिंटैक्स प्रदान करने में कुछ प्रयास किए गए हैं।
C++ को सेट बिल्डर संकेतन के समान लिस्ट-कॉम्प्रिहेंशन निर्माण/सिंटैक्स प्रदान करने में कुछ प्रयास किए गए हैं।
* [[ C++ लाइब्रेरीज़ को बूस्ट करें ]]़ में। रेंज [http://www.boost.org/libs/range] लाइब्रेरी में एडेप्टर की एक धारणा है [http://www.boost.org/libs/range/doc/html/range/reference/adaptors.html] जिसे किसी भी रेंज पर लागू किया जा सकता है और फ़िल्टरिंग, ट्रांसफ़ॉर्मेशन आदि किया जा सकता है। इस लाइब्रेरी के साथ, मूल हास्केल उदाहरण जैसा दिखेगा (गुमनाम फ़िल्टरिंग और ट्रांसफ़ॉर्मिंग के लिए Boost.Lambda [http://www.boost.org/libs/lambda] का उपयोग करना) फ़ंक्शन) ([http://codepad.org/y4bpgLJu पूर्ण उदाहरण]):<syntaxhighlight lang="cpp">
* [[ C++ लाइब्रेरीज़ को बूस्ट करें |बूस्ट]] में।[http://www.boost.org/libs/range] रेंज लाइब्रेरी में एडेप्टर की एक अवधारणा है[http://www.boost.org/libs/range/doc/html/range/reference/adaptors.html] जिसे किसी भी रेंज पर लागू किया जा सकता है और फ़िल्टरिंग, ट्रांसफॉर्मेशन आदि किया जा सकता है। इस लाइब्रेरी के साथ, मूल हास्केल उदाहरण इस तरह दिखेगा (अनाम फ़िल्टरिंग और ट्रांसफॉर्मिंग फ़ंक्शंस के लिए बूस्ट.लैम्बडा[http://www.boost.org/libs/lambda] का उपयोग करना) ([http://codepad.org/y4bpgLJu पूर्ण उदाहरण])-<syntaxhighlight lang="cpp">
counting_range(1,10) | filtered( _1*_1 > 3 ) | transformed(ret<int>( _1*2 ))
counting_range(1,10) | filtered( _1*_1 > 3 ) | transformed(ret<int>( _1*2 ))
</syntaxhighlight>
</syntaxhighlight>
* यह<ref>{{cite web | url = http://mfoliveira.org/blog/2011/01/04/simple-list-comprehension-in-cp-using-preprocessor-macros/ | title = प्रीप्रोसेसर मैक्रोज़ का उपयोग करके C++ में एकल-चर सूची समझ| access-date = 2011-01-09 | archive-url = https://web.archive.org/web/20110821211656/http://mfoliveira.org/blog/2011/01/04/simple-list-comprehension-in-cp-using-preprocessor-macros/ | archive-date = 2011-08-21 | url-status = dead }}</ref> कार्यान्वयन एक मैक्रो का उपयोग करता है और << ऑपरेटर को ओवरलोड करता है। यह 'if' के अंदर मान्य किसी भी अभिव्यक्ति का मूल्यांकन करता है, और कोई भी चर नाम चुना जा सकता है। हालाँकि, यह थ्रेड सुरक्षा नहीं है। उपयोग उदाहरण:
* यह<ref>{{cite web | url = http://mfoliveira.org/blog/2011/01/04/simple-list-comprehension-in-cp-using-preprocessor-macros/ | title = प्रीप्रोसेसर मैक्रोज़ का उपयोग करके C++ में एकल-चर सूची समझ| access-date = 2011-01-09 | archive-url = https://web.archive.org/web/20110821211656/http://mfoliveira.org/blog/2011/01/04/simple-list-comprehension-in-cp-using-preprocessor-macros/ | archive-date = 2011-08-21 | url-status = dead }}</ref> कार्यान्वयन एक मैक्रो का उपयोग करता है और << ऑपरेटर को ओवरलोड करता है। यह 'इफ' के अंदर मान्य किसी भी अभिव्यक्ति का मूल्यांकन करता है, और कोई भी चर नाम चुना जा सकता है। हालाँकि, यह थ्रेड सुरक्षित नहीं है। उपयोग उदाहरण-
<syntaxhighlight lang="cpp">
<syntaxhighlight lang="cpp">
list<int> N;
list<int> N;
Line 251: Line 238:
S << list_comprehension(3.1415 * x, x, N, x * x > 3)
S << list_comprehension(3.1415 * x, x, N, x * x > 3)
</syntaxhighlight>
</syntaxhighlight>
* यह<ref>{{cite web | url = http://www.tedunangst.com/listcc.html | title = सी++ सूची समझ| access-date = 2011-01-09 | archive-url = https://web.archive.org/web/20170707125836/http://www.tedunangst.com/listcc.html | archive-date = 2017-07-07 | url-status = dead }}</ref> कार्यान्वयन कक्षाओं और ऑपरेटर ओवरलोडिंग का उपयोग करके हेड/टेल स्लाइसिंग प्रदान करता है, और | सूचियों को फ़िल्टर करने के लिए ऑपरेटर (फ़ंक्शन का उपयोग करके)। उपयोग उदाहरण:
* यह<ref>{{cite web | url = http://www.tedunangst.com/listcc.html | title = सी++ सूची समझ| access-date = 2011-01-09 | archive-url = https://web.archive.org/web/20170707125836/http://www.tedunangst.com/listcc.html | archive-date = 2017-07-07 | url-status = dead }}</ref> कार्यान्वयन क्लासेस और ऑपरेटर ओवरलोडिंग का उपयोग करके हेड/टेल स्लाइसिंग प्रदान करता है, और | लिस्ट को फ़िल्टर करने के लिए ऑपरेटर (फ़ंक्शन का उपयोग करके)। उपयोग उदाहरण-
<syntaxhighlight lang="cpp">
<syntaxhighlight lang="cpp">
bool even(int x) { return x % 2 == 0; }
bool even(int x) { return x % 2 == 0; }
Line 268: Line 255:
t = t < 7 | even | x2;
t = t < 7 | even | x2;
</syntaxhighlight>
</syntaxhighlight>
* एंबेडेड क्वेरी और ट्रैवर्सल के लिए भाषा (LEESA)।<ref>{{cite web | url = http://www.dre.vanderbilt.edu/LEESA/ | title = Language for Embedded Query and Traversal (LEESA)}}</ref>) C++ में एक एम्बेडेड DSL है जो ऑपरेटर ओवरलोडिंग का उपयोग करके एक्स-पाथ-जैसी क्वेरीज़ को कार्यान्वित करता है। क्वेरीज़ को XSD से xml-to-c++ बाइंडिंग का उपयोग करके प्राप्त किए गए समृद्ध रूप से टाइप किए गए xml ट्री पर निष्पादित किया जाता है। बिल्कुल कोई स्ट्रिंग एन्कोडिंग नहीं है. यहां तक ​​कि एक्सएमएल टैग के नाम भी कक्षाएं हैं और इसलिए, टाइपो के लिए कोई रास्ता नहीं है। यदि LEESA एक्सप्रेशन गलत पथ बनाता है जो डेटा मॉडल में मौजूद नहीं है, तो C++ कंपाइलर कोड को अस्वीकार कर देगा।<br>एक कैटलॉग xml पर विचार करें।
* एंबेडेड क्वेरी और ट्रैवर्सल के लिए भाषा (एलईईएसए (LEESA)<ref>{{cite web | url = http://www.dre.vanderbilt.edu/LEESA/ | title = Language for Embedded Query and Traversal (LEESA)}}</ref>) C++ में अंतः स्थापित डीएसएल है जो ऑपरेटर ओवरलोडिंग का उपयोग करके एक्स-पाथ-जैसी क्वेरीज़ को कार्यान्वित करता है। क्वेरीज़ को एक्सएसडी (XSD) से एक्सएमएल-से-सी++ बाइंडिंग का उपयोग करके प्राप्त किए गए समृद्ध रूप से टाइप किए गए एक्सएमएल ट्री पर निष्पादित किया जाता है। इसमें बिल्कुल कोई स्ट्रिंग एन्कोडिंग नहीं है। यहां तक कि एक्सएमएल टैग के नाम भी क्लासेस हैं और इसलिए, टाइपो के लिए कोई मार्ग नहीं है। यदि कोई एलईईएसए अभिव्यक्ति गलत पाथ बनाती है जो डेटा मॉडल में उपस्थित नहीं है, तो C++ संकलक कोड को अस्वीकार कर देगा। <br>कैटलॉग एक्सएमएल पर विचार करें।
<syntaxhighlight lang="xml">
<syntaxhighlight lang="xml">
<catalog>
<catalog>
Line 283: Line 270:
</catalog>
</catalog>
</syntaxhighlight>
</syntaxhighlight>
लीसा प्रदान करता है <code>>></code> XPath/विभाजक के लिए. XPath का // विभाजक जो पेड़ में मध्यवर्ती नोड्स को छोड़ देता है उसे LEESA में रणनीतिक प्रोग्रामिंग के रूप में जाना जाता है का उपयोग करके कार्यान्वित किया जाता है। नीचे दिए गए उदाहरण में, कैटलॉग_, पुस्तक_, लेखक_ और नाम_ क्रमशः कैटलॉग, पुस्तक, लेखक और नाम वर्गों के उदाहरण हैं।
एलईईएसए एक्सपाथ/विभाजक के लिए <code>>></code> प्रदान करता है। एक्सपाथ का // विभाजक जो ट्री में मध्यवर्ती नोड्स को "स्किप्स" करता है, उसे एलईईएसए में युक्‍तिपूर्ण प्रोग्रामिंग के रूप में जाना जाता है का उपयोग करके कार्यान्वित किया जाता है। नीचे दिए गए उदाहरण में, कैटलॉग_, बुक_, ऑथर_ और नाम_ क्रमशः कैटलॉग, बुक, ऑथर और नाम क्लासेज के उदाहरण हैं।
<syntaxhighlight lang="cpp">
<syntaxhighlight lang="cpp">
// Equivalent X-Path: "catalog/book/author/name"
// Equivalent X-Path: "catalog/book/author/name"
Line 299: Line 286:
                         >> name_);
                         >> name_);
</syntaxhighlight>
</syntaxhighlight>
==यह भी देखें==
==यह भी देखें==
* सेट-बिल्डर नोटेशन
* सेट-बिल्डर संकेतन
* SQL#क्वेरीज़ में इसके FROM और WHERE क्लॉज के साथ सेलेक्ट (SQL) स्टेटमेंट
* एसक्यूएल में सेलेक्ट स्टेटमेंट इसके फ़्रॉम और वेयर क्लॉसेस के साथ


==नोट्स और संदर्भ==
==नोट्स और संदर्भ==
Line 314: Line 299:
* [http://lambda-the-ultimate.org/classic/message11326.html Discussion on list comprehensions in Scheme and related constructs]
* [http://lambda-the-ultimate.org/classic/message11326.html Discussion on list comprehensions in Scheme and related constructs]
* [http://langexplr.blogspot.com/2007/02/list-comprehensions-across-languages_18.html List Comprehensions across languages]
* [http://langexplr.blogspot.com/2007/02/list-comprehensions-across-languages_18.html List Comprehensions across languages]
===स्वयंसिद्ध===
===स्वयंसिद्ध===
* [https://web.archive.org/web/20051018040438/http://page.axiom-developer.org/zope/mathaction/Streams Axiom स्ट्रीम उदाहरण]
* [https://web.archive.org/web/20051018040438/http://page.axiom-developer.org/zope/mathaction/Streams Axiom स्ट्रीम उदाहरण]
Line 328: Line 309:


===हास्केल===
===हास्केल===
* हास्केल 98 रिपोर्ट, अध्याय [http://haskell.org/onlinereport/exps.html#list-compressions 3.11 सूची समझ]।
* हास्केल 98 रिपोर्ट, अध्याय [http://haskell.org/onlinereport/exps.html#list-compressions 3.11 लिस्ट कॉम्प्रिहेंशन]।
* गौरवशाली ग्लासगो हास्केल संकलन प्रणाली उपयोगकर्ता गाइड, अध्याय [https://web.archive.org/web/20051129140339/http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns। html#समानांतर-सूची-समझ 7.3.4 समानांतर सूची समझ]।
* गौरवशाली ग्लासगो हास्केल संकलन प्रणाली उपयोगकर्ता गाइड, अध्याय [https://web.archive.org/web/20051129140339/http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns। html#समानांतर-लिस्ट-कॉम्प्रिहेंशन 7.3.4 समानांतर लिस्ट कॉम्प्रिहेंशन]।
* द हग्स 98 उपयोगकर्ता गाइड, अध्याय [https://web.archive.org/web/20140515114545/http://cvs.haskell.org/Hugs/pages/users_guide/hugs-ghc.html#ZIP-COMPREHENSION 5.1. 2 समानांतर सूची समझ (उर्फ ज़िप-समझ)]।
* द हग्स 98 उपयोगकर्ता गाइड, अध्याय [https://web.archive.org/web/20140515114545/http://cvs.haskell.org/Hugs/pages/users_guide/hugs-ghc.html#ZIP-COMPREHENSION 5.1. 2 समानांतर लिस्ट कॉम्प्रिहेंशन (उर्फ ज़िप-कॉम्प्रिहेंशन)]।


===OCaml===
===OCaml===
Line 338: Line 319:
===पायथन===
===पायथन===
* पायथॉन ट्यूटोरियल, [https://docs.python.org/tutorial/datastructures.html#list-compressionions लिस्ट कॉम्प्रिहेंशन]।
* पायथॉन ट्यूटोरियल, [https://docs.python.org/tutorial/datastructures.html#list-compressionions लिस्ट कॉम्प्रिहेंशन]।
* पायथन भाषा संदर्भ, [https://docs.python.org/reference/expressions.html#list-displays सूची प्रदर्शित करता है]।
* पायथन भाषा संदर्भ, [https://docs.python.org/reference/expressions.html#list-displays लिस्ट प्रदर्शित करता है]।
* पायथन एन्हांसमेंट प्रस्ताव [https://www.python.org/peps/pep-0202.html PEP 202: सूची समझ]।
* पायथन एन्हांसमेंट प्रस्ताव [https://www.python.org/peps/pep-0202.html PEP 202: लिस्ट कॉम्प्रिहेंशन]।
* पायथन भाषा संदर्भ, [https://docs.python.org/reference/expressions.html#generator-expressions जेनरेटर एक्सप्रेशन]।
* पायथन भाषा संदर्भ, [https://docs.python.org/reference/expressions.html#generator-expressions जेनरेटर एक्सप्रेशन]।
* पायथन एन्हांसमेंट प्रस्ताव [https://python.org/peps/pep-0289.html PEP 289: जेनरेटर एक्सप्रेशंस]।
* पायथन एन्हांसमेंट प्रस्ताव [https://python.org/peps/pep-0289.html PEP 289: जेनरेटर एक्सप्रेशंस]।
Line 349: Line 330:
श्रेणी: उदाहरण रैकेट कोड वाले लेख
श्रेणी: उदाहरण रैकेट कोड वाले लेख


 
[[Category:Articles with hatnote templates targeting a nonexistent page]]
[[Category: Machine Translated Page]]
[[Category:Created On 11/07/2023]]
[[Category:Created On 11/07/2023]]
[[Category:Lua-based templates]]
[[Category:Machine Translated Page]]
[[Category:Pages with script errors]]
[[Category:Short description with empty Wikidata description]]
[[Category:Templates Vigyan Ready]]
[[Category:Templates that add a tracking category]]
[[Category:Templates that generate short descriptions]]
[[Category:Templates using TemplateData]]

Latest revision as of 10:31, 14 August 2023

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

अवलोकन

सेट-बिल्डर संकेतन में निम्नलिखित उदाहरण पर विचार करें।

या प्रायः

इसे रीड किया जा सकता है, " सभी संख्याओं का सेट है "2 गुना " सच दैट प्राकृतिक संख्याओं () के सेट का एलिमेंट या मेंमबर है, एंड का वर्ग से बड़ा है।"

सबसे छोटी प्राकृतिक संख्या, x = 1, स्थिति x2>3 को संतुष्ट करने में विफल रहती है (स्थिति 12>3 गलत है) इसलिए 2 ·1 को S में सम्मिलित नहीं किया गया है। अगली प्राकृतिक संख्या, 2, प्रत्येक अन्य प्राकृतिक संख्या की तरह स्थिति (22>3) को संतुष्ट करती है। इस प्रकार x में 2, 3, 4, 5... होते हैं चूँकि सेट S में सभी संख्याएँ "2 गुना x" होती हैं, इसलिए इसे S = {4, 6, 8, 10,...} द्वारा दिया जाता है। दूसरे शब्दों में, S, 2 से बड़ी सभी सम संख्याओं का सेट है।

उदाहरण के इस एनोटेटेड संस्करण में-

  • एक इनपुट सेट के सदस्यों का प्रतिनिधित्व करने वाला चर है।
  • इनपुट सेट का प्रतिनिधित्व करता है, जो इस उदाहरण में प्राकृतिक संख्याओं का सेट है
  • इनपुट सेट के सदस्यों पर फ़िल्टर के रूप में कार्य करने वाली निर्धारक अभिव्यक्ति है।
  • आउटपुट अभिव्यक्ति है जो इनपुट सेट के सदस्यों से नए सेट के सदस्यों का उत्पादन करती है जो विधेय अभिव्यक्ति को संतुष्ट करते हैं।
  • ब्रेसिज़ इंगित करते हैं कि परिणाम एक सेट है
  • ऊर्ध्वाधर पट्टी को "सच दैट" के रूप में रीड किया जाता है। बार और कोलन ":" का प्रयोग एक दूसरे के स्थान पर किया जाता है।
  • अल्पविराम निर्धारक को अलग करते हैं और इसे "एंड" के रूप में रीड किया जा सकता है।

लिस्ट कॉम्प्रिहेंशन में इनपुट लिस्ट या पुनरावर्तक के क्रम में लिस्ट की पीढ़ी का प्रतिनिधित्व करने के लिए समान वाक्यात्मक घटक होते हैं-

  • इनपुट लिस्ट के सदस्यों का प्रतिनिधित्व करने वाला चर।
  • इनपुट लिस्ट (या पुनरावर्तक)।
  • वैकल्पिक निर्धारक अभिव्यक्ति।
  • और आउटपुट अभिव्यक्ति, इनपुट पुनरावर्तनीय के सदस्यों से आउटपुट लिस्ट के सदस्यों का उत्पादन करती है जो निर्धारक को संतुष्ट करते हैं।

आउटपुट लिस्ट के सदस्यों की पीढ़ी का क्रम इनपुट में वस्तुओं के क्रम पर आधारित है।

हास्केल के लिस्ट कॉम्प्रिहेंशन सिंटैक्स में, यह सेट-बिल्डर निर्माण इसी तरह लिखा जाएगा, जैसे- 

s = [ 2*x | x <- [0..], x^2 > 3 ]

यहां, लिस्ट [0..] का प्रतिनिधित्व करती है, x^2>3 निर्धारक का प्रतिनिधित्व करती है, और 2*x आउटपुट अभिव्यक्ति का प्रतिनिधित्व करती है।

लिस्ट कॉम्प्रिहेंशन एक परिभाषित क्रम (सेट के सदस्यों के विपरीत) में परिणाम देता है और लिस्ट का कॉम्प्रिहेंशन किसी लिस्ट के सदस्यों को क्रम में उत्पन्न कर सकता है, न कि संपूर्ण लिस्ट तैयार करने से, उदाहरण के लिए, अनंत लिस्ट के सदस्यों को पिछली हास्केल परिभाषा की अनुमति मिलती है।

इतिहास

संबंधित निर्माणों का अस्तित्व "लिस्ट कॉम्प्रिहेंशन" शब्द के उपयोग से पहले का है। एसईटीएल (SETL) प्रोग्रामिंग भाषा (1969) में एक सेट निर्माण संरचना है जो लिस्ट कॉम्प्रिहेंशन के समान है। उदाहरण के लिए, यह कोड 2 से N तक सभी अभाज्य संख्याओं को प्रिंट करता है- 

print([n in [2..N] | forall m in {2..n - 1} | n mod m > 0]);

कंप्यूटर बीजगणित प्रणाली एएक्सआईओएम (AXIOM) (1973) में समान निर्माण होता है जो स्ट्रीम को प्रोसेस करता है।

ऐसे निर्माणों के लिए "कॉम्प्रिहेंशन" शब्द का प्रथम उपयोग रॉड बर्स्टल और जॉन डार्लिंगटन द्वारा 1977 से उनकी कार्यात्मक प्रोग्रामिंग भाषा एनपीएल (NPL) के विवरण में किया गया था। डेविड टर्नर अपने पूर्वव्यापी "कार्यात्मक प्रोग्रामिंग भाषाओं के कुछ इतिहास" में[1] याद करते हैं-

एनपीएल को बर्स्टॉल द्वारा पीओपी2 (POP2) में कार्यान्वित किया गया था और प्रोग्राम ट्रांसफॉर्मेशन (बर्स्टल और डार्लिंगटन 1977) पर डार्लिंगटन के काम के लिए उपयोग किया गया था। भाषा प्रथम क्रम की थी, दृढ़ता से (लेकिन बहुरूपी रूप से नहीं) टाइप की गई, पूरी तरह कार्यात्मक, कॉल-बाय-वैल्यू थी। इसमें "सेट अभिव्यक्तियाँ" भी थे जैसे 

setofeven (X)  <=  <:x : x in X & even(x):>}}

"लिस्ट कॉम्प्रिहेंशन" शब्द से जुड़े फ़ुटनोट में, टर्नर यह भी नोट करते है

मैंने प्रारम्भ में इन जेडएफ (ZF) अभिव्यक्तियों को ज़र्मेलो-फ्रैंकल सेट सिद्धांत का संदर्भ कहा था - यह फिल वाडलर थे जिन्होंने बेहतर शब्द लिस्ट कॉम्प्रिहेंशन को गढ़ा था।

एनपीएल के साथ बर्स्टॉल और डार्लिंगटन के काम ने 1980 के दशक के दौरान कई कार्यात्मक प्रोग्रामिंग भाषाओं को प्रभावित किया, लेकिन सभी में लिस्ट कॉम्प्रिहेंशन सम्मिलित नहीं था। 1985 में जारी टर्नर की प्रभावशाली, शुद्ध, स्लो, कार्यात्मक प्रोग्रामिंग भाषा मिरांडा एक अपवाद थी। बाद में विकसित मानक शुद्ध स्लो कार्यात्मक भाषा हास्केल में लिस्ट कॉम्प्रिहेंशन सहित मिरांडा की कई विशेषताएं सम्मिलित हैं।

कॉम्प्रिहेंशन को डेटाबेस के लिए क्वेरी संकेतन के रूप में प्रस्तावित किया गया था[2] और इसे क्लेस्ली डेटाबेस क्वेरी भाषा में लागू किया गया था।[3]

विभिन्न प्रोग्रामिंग भाषाओं में उदाहरण

Main article: प्रोग्रामिंग भाषाओं की तुलना (लिस्ट कॉम्प्रिहेंशन)

समान निर्माण

मोनाड कॉम्प्रिहेंशन

हास्केल में, मोनैड कॉम्प्रिहेंशन कार्यात्मक प्रोग्रामिंग में अन्य मोनैड के लिए लिस्ट कॉम्प्रिहेंशन का सामान्यीकरण है।

सेट कॉम्प्रिहेंशन

पायथन भाषा का संस्करण 3.x और 2.7 सेट कॉम्प्रिहेंशन के लिए सिंटैक्स का परिचय देता है। लिस्ट कॉम्प्रिहेंशन के समान, सेट कॉम्प्रिहेंशन लिस्ट के स्थान पर पायथन सेट उत्पन्न करते हैं। 

>>> s = {v for v in 'ABCDABCD' if v not in 'CB'}
>>> print(s)
{'A', 'D'}
>>> type(s)
<class 'set'>
>>>

रैकेट सेट कॉम्प्रिहेंशन लिस्ट के स्थान पर रैकेट सेट उत्पन्न करता है। 

(for/set ([v "ABCDABCD"] #:unless (member v (string->list "CB")))
         v))

शब्दकोश कॉम्प्रिहेंशन

पायथन भाषा के संस्करण 3.x और 2.7 ने शब्दकोश कॉम्प्रिहेंशन के लिए एक नया सिंटैक्स पेश किया, जो लिस्ट कॉम्प्रिहेंशन के रूप में समान था लेकिन जो लिस्ट के स्थान पर पायथन डिक्ट उत्पन्न करता था। 

>>> s = {key: val for key, val in enumerate('ABCD') if val not in 'CB'}
>>> s
{0: 'A', 3: 'D'}
>>>

रैकेट हैश टेबल कॉम्प्रिहेंशन रैकेट हैश टेबल (रैकेट शब्दकोश प्रकार का कार्यान्वयन) उत्पन्न करती है। 

(for/hash ([(val key) (in-indexed "ABCD")]
           #:unless (member val (string->list "CB")))
  (values key val))

समानांतर लिस्ट कॉम्प्रिहेंशन

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

-- regular list comprehension
a = [(x,y) | x <- [1..5], y <- [3..5]]
-- [(1,3),(1,4),(1,5),(2,3),(2,4) ...

-- zipped list comprehension
b = [(x,y) | (x,y) <- zip [1..5] [3..5]]
-- [(1,3),(2,4),(3,5)]

-- parallel list comprehension
c = [(x,y) | x <- [1..5] | y <- [3..5]]
-- [(1,3),(2,4),(3,5)]

रैकेट की कॉम्प्रिहेंशन मानक लाइब्रेरी में इसके कॉम्प्रिहेंशन के समानांतर और नेस्टेड संस्करण सम्मिलित हैं, जो नाम में "फॉर" बनाम "फॉर*" द्वारा प्रतिष्ठित हैं। उदाहरण के लिए, वेक्टर कॉम्प्रिहेंशन "फॉर/वेक्टर" और "फॉर*/वेक्टर" अनुक्रमों पर समानांतर बनाम नेस्टेड पुनरावृत्ति द्वारा वेक्टर बनाते हैं। हास्केल लिस्ट कॉम्प्रिहेंशन उदाहरणों के लिए रैकेट कोड निम्नलिखित है। 

> (for*/list ([x (in-range 1 6)] [y (in-range 3 6)]) (list x y))
'((1 3) (1 4) (1 5) (2 3) (2 4) (2 5) (3 3) (3 4) (3 5) (4 3) (4 4) (4 5) (5 3) (5 4) (5 5))
> (for/list ([x (in-range 1 6)] [y (in-range 3 6)]) (list x y))
'((1 3) (2 4) (3 5))

पायथन में, हम निम्नानुसार कार्य कर सकते हैं- 

# regular list comprehension
>>> a = [(x, y) for x in range(1, 6) for y in range(3, 6)]
[(1, 3), (1, 4), (1, 5), (2, 3), (2, 4), ...

# parallel/zipped list comprehension
>>> b = [x for x in zip(range(1, 6), range(3, 6))]
[(1, 3), (2, 4), (3, 5)]

जूलिया में, व्यावहारिक रूप से समान परिणाम निम्नानुसार प्राप्त किए जा सकते हैं- 

# regular array comprehension
>>> a = [(x, y) for x in 1:5 for y in 3:5]

# parallel/zipped array comprehension
>>> b = [x for x in zip(1:3, 3:5)]

एकमात्र अंतर यह है कि जूलिया में लिस्ट के स्थान पर, हमारे पास अरे हैं।

एक्सक्वेरी और एक्सपाथ

मूल एनपीएल उपयोग की तरह, ये मूलतः डेटाबेस एक्सेस भाषाएं हैं।

यह कॉम्प्रिहेंशन की अवधारणा को और अधिक महत्वपूर्ण बनाता है, क्योंकि संपूर्ण लिस्ट को पुनः प्राप्त करना और उस पर काम करना कम्प्यूटेशनल रूप से असंभव है (प्रारंभिक 'संपूर्ण लिस्ट' संपूर्ण एक्सएमएल (XML) डेटाबेस हो सकती है)।

एक्सपाथ में, अभिव्यक्ति- 

/library/book//paragraph[@style='first-in-chapter']

वैचारिक रूप से "चरणों" की श्रृंखला के रूप में मूल्यांकन किया जाता है जहां प्रत्येक चरण एक लिस्ट तैयार करता है और अगला चरण पिछले चरण के आउटपुट में प्रत्येक तत्व पर फ़िल्टर फ़ंक्शन लागू करता है।[4]

एक्सक्वेरी में, पूर्ण एक्सपाथ उपलब्ध है, लेकिन एफएलडब्लयूओआर (FLWOR) कथनों का भी उपयोग किया जाता है, जो कि अधिक शक्तिशाली कॉम्प्रिहेंशन निर्माण है।[5] 

for $b in //book
where $b[@pages < 400]
order by $b//title
return
  <shortBook>
    <title>{$b//title}</title>
    <firstPara>{($book//paragraph)[1]}</firstPara>
  </shortBook>

यहां एक्सपाथ //बुक का मूल्यांकन अनुक्रम (उर्फ लिस्ट) बनाने के लिए किया जाता है जहां क्लॉस कार्यात्मक "फ़िल्टर" है, परिणाम को क्रमबद्ध करता है, और ‎<शॉर्टबुक>...‎</शॉर्टबुक> एक्सएमएल स्निपेट वास्तव में एक अज्ञात फ़ंक्शन है जो अन्य कार्यात्मक भाषाओं में पाए जाने वाले 'मैप' दृष्टिकोण का उपयोग करके अनुक्रम में प्रत्येक तत्व के लिए एक्सएमएल बनाता/बदलता है।

तो, किसी अन्य कार्यात्मक भाषा में उपरोक्त एफएलडब्लयूओआर कथन को इस प्रकार कार्यान्वित किया जा सकता है-

map(
  newXML(shortBook, newXML(title, $1.title), newXML(firstPara, $1...))
  filter(
    lt($1.pages, 400),
    xpath(//book)
  )
)

C# में एलआईएनक्यू (LINQ)

C# 3.0 में संबंधित सुविधाओं का एक समूह है जिसे एलआईएनक्यू कहा जाता है, जो ऑब्जेक्ट गणना में हेरफेर करने के लिए क्वेरी ऑपरेटरों के सेट को परिभाषित करता है। 

var s = Enumerable.Range(0, 100).Where(x => x * x > 3).Select(x => x * 2);

यह एसक्यूएल (SQL) की याद दिलाते हुए वैकल्पिक कॉम्प्रिहेंशन सिंटैक्स भी प्रदान करता है- 

var s = from x in Enumerable.Range(0, 100) where x * x > 3 select x * 2;

एलआईएनक्यू विशिष्ट लिस्ट कॉम्प्रिहेंशन कार्यान्वयन पर क्षमता प्रदान करता है। जब कॉम्प्रिहेंशन का मूल ऑब्जेक्ट आईक्वेरीबल(IQueryable) इंटरफ़ेस को कार्यान्वित करता है, तो केवल कॉम्प्रिहेंशन की श्रृंखलाबद्ध विधियों को निष्पादित करने के स्थान पर, कमांड का पूरा अनुक्रम संक्षेप सिंटैक्स ट्री (एएसटी) ऑब्जेक्ट में परिवर्तित हो जाता है, जिसे व्याख्या और निष्पादित करने के लिए आईक्वेरीबल ऑब्जेक्ट को पास किया जाता है।

यह, अन्य बातों के अलावा, आईक्वेरीबल को इसकी अनुमति देता है

  • किसी असंगत या अप्रभावी कॉम्प्रिहेंशन को दोबारा लिखें
  • निष्पादन के लिए एएसटी (AST) को किसी अन्य क्वेरी भाषा (उदाहरण के लिए एसक्यूएल) में अनुवाद करें

C++

C++ में सीधे तौर पर लिस्ट कॉम्प्रिहेंशन का सपोर्ट करने वाली कोई भाषा सुविधा नहीं है, लेकिन ऑपरेटर ओवरलोडिंग (उदाहरण के लिए, ओवरलोडिंग |, >>, >>=) का उपयोग "अंतः स्थापित" क्वेरी डोमेन-विशिष्ट भाषाओं (डीएसएल (DSL)) के लिए अभिव्यंजक सिंटैक्स प्रदान करने के लिए सफलतापूर्वक किया गया है। वैकल्पिक रूप से, कंटेनर में तत्वों का चयन करने के लिए मिटाओ-हटाओ मुहावरे का उपयोग करके लिस्ट कॉम्प्रिहेंशन का निर्माण किया जा सकता है और उन्हें बदलने के लिए एसटीएल (STL) एल्गोरिदम फॉर_ईच का उपयोग किया जा सकता है। 

#include <algorithm>
#include <list>
#include <numeric>

using namespace std;

template<class C, class P, class T>
C comprehend(C&& source, const P& predicate, const T& transformation)
{
  // initialize destination
  C d = forward<C>(source);

  // filter elements
  d.erase(remove_if(begin(d), end(d), predicate), end(d));

  // apply transformation
  for_each(begin(d), end(d), transformation);

  return d;
}

int main()
{
  list<int> range(10);
      // range is a list of 10 elements, all zero
  iota(begin(range), end(range), 1);
      // range now contains 1, 2, ..., 10

  list<int> result = comprehend(
      range,
      [](int x) { return x * x <= 3; },
      [](int &x) { x *= 2; });
      // result now contains 4, 6, ..., 20
}

C++ को सेट बिल्डर संकेतन के समान लिस्ट-कॉम्प्रिहेंशन निर्माण/सिंटैक्स प्रदान करने में कुछ प्रयास किए गए हैं।

  • बूस्ट में।[1] रेंज लाइब्रेरी में एडेप्टर की एक अवधारणा है[2] जिसे किसी भी रेंज पर लागू किया जा सकता है और फ़िल्टरिंग, ट्रांसफॉर्मेशन आदि किया जा सकता है। इस लाइब्रेरी के साथ, मूल हास्केल उदाहरण इस तरह दिखेगा (अनाम फ़िल्टरिंग और ट्रांसफॉर्मिंग फ़ंक्शंस के लिए बूस्ट.लैम्बडा[3] का उपयोग करना) (पूर्ण उदाहरण)-
    counting_range(1,10) | filtered( _1*_1 > 3 ) | transformed(ret<int>( _1*2 ))
  • यह[6] कार्यान्वयन एक मैक्रो का उपयोग करता है और << ऑपरेटर को ओवरलोड करता है। यह 'इफ' के अंदर मान्य किसी भी अभिव्यक्ति का मूल्यांकन करता है, और कोई भी चर नाम चुना जा सकता है। हालाँकि, यह थ्रेड सुरक्षित नहीं है। उपयोग उदाहरण-
list<int> N;
list<double> S;

for (int i = 0; i < 10; i++)
    N.push_back(i);

S << list_comprehension(3.1415 * x, x, N, x * x > 3)
  • यह[7] कार्यान्वयन क्लासेस और ऑपरेटर ओवरलोडिंग का उपयोग करके हेड/टेल स्लाइसिंग प्रदान करता है, और | लिस्ट को फ़िल्टर करने के लिए ऑपरेटर (फ़ंक्शन का उपयोग करके)। उपयोग उदाहरण-
bool even(int x) { return x % 2 == 0; }
bool x2(int &x) { x *= 2; return true; }

list<int> l, t;
int x, y;

for (int i = 0; i < 10; i++)
     l.push_back(i);

(x, t) = l | x2;
(t, y) = t;

t = l < 9;
t = t < 7 | even | x2;
  • एंबेडेड क्वेरी और ट्रैवर्सल के लिए भाषा (एलईईएसए (LEESA)[8]) C++ में अंतः स्थापित डीएसएल है जो ऑपरेटर ओवरलोडिंग का उपयोग करके एक्स-पाथ-जैसी क्वेरीज़ को कार्यान्वित करता है। क्वेरीज़ को एक्सएसडी (XSD) से एक्सएमएल-से-सी++ बाइंडिंग का उपयोग करके प्राप्त किए गए समृद्ध रूप से टाइप किए गए एक्सएमएल ट्री पर निष्पादित किया जाता है। इसमें बिल्कुल कोई स्ट्रिंग एन्कोडिंग नहीं है। यहां तक कि एक्सएमएल टैग के नाम भी क्लासेस हैं और इसलिए, टाइपो के लिए कोई मार्ग नहीं है। यदि कोई एलईईएसए अभिव्यक्ति गलत पाथ बनाती है जो डेटा मॉडल में उपस्थित नहीं है, तो C++ संकलक कोड को अस्वीकार कर देगा।
    कैटलॉग एक्सएमएल पर विचार करें।
<catalog>
  <book>
    <title>Hamlet</title>
    <price>9.99</price>
    <author>
      <name>William Shakespeare</name>
      <country>England</country>
    </author>
  </book>
  <book>...</book>
...
</catalog>

एलईईएसए एक्सपाथ/विभाजक के लिए >> प्रदान करता है। एक्सपाथ का // विभाजक जो ट्री में मध्यवर्ती नोड्स को "स्किप्स" करता है, उसे एलईईएसए में युक्‍तिपूर्ण प्रोग्रामिंग के रूप में जाना जाता है का उपयोग करके कार्यान्वित किया जाता है। नीचे दिए गए उदाहरण में, कैटलॉग_, बुक_, ऑथर_ और नाम_ क्रमशः कैटलॉग, बुक, ऑथर और नाम क्लासेज के उदाहरण हैं। 

// Equivalent X-Path: "catalog/book/author/name"
std::vector<name> author_names = 
evaluate(root, catalog_ >> book_ >> author_ >> name_);

// Equivalent X-Path: "catalog//name"
std::vector<name> author_names = 
evaluate(root, catalog_ >> DescendantsOf(catalog_, name_));

// Equivalent X-Path: "catalog//author[country=="England"]"
std::vector<name> author_names = 
evaluate(root, catalog_  >> DescendantsOf(catalog_, author_)
                         >> Select(author_, [](const author & a) { return a.country() == "England"; })
                         >> name_);

यह भी देखें

  • सेट-बिल्डर संकेतन
  • एसक्यूएल में सेलेक्ट स्टेटमेंट इसके फ़्रॉम और वेयर क्लॉसेस के साथ

नोट्स और संदर्भ

  1. ↑ Turner, David (2012). "कार्यात्मक प्रोग्रामिंग भाषाओं का कुछ इतिहास" (PDF). International Symposium on Trends in Functional Programming, Springer, Berlin, Heidelberg. pp. 1–20.
  2. ↑ Comprehensions, a query notation for DBPLs
  3. ↑ The functional guts of the Kleisli query system
  4. ↑ "2.1 Location Steps". XML Path Language (XPath). W3C. 16 November 1999. Archived from the original on 9 December 2012. Retrieved 24 December 2008.
  5. ↑ "XQuery FLWOR अभिव्यक्तियाँ". W3Schools. Archived from the original on 2011-10-08.
  6. ↑ "प्रीप्रोसेसर मैक्रोज़ का उपयोग करके C++ में एकल-चर सूची समझ". Archived from the original on 2011-08-21. Retrieved 2011-01-09.
  7. ↑ "सी++ सूची समझ". Archived from the original on 2017-07-07. Retrieved 2011-01-09.
  8. ↑ "Language for Embedded Query and Traversal (LEESA)".

बाहरी संबंध

स्वयंसिद्ध

क्लोजर

सामान्य लिस्प

हास्केल

OCaml

पायथन

श्रेणी:प्रोग्रामिंग निर्माण श्रेणी:उदाहरण कोड वाले लेख श्रेणी:हास्केल कोड के उदाहरण वाले लेख श्रेणी: पायथन (प्रोग्रामिंग भाषा) कोड के उदाहरण वाले लेख श्रेणी: उदाहरण रैकेट कोड वाले लेख

Retrieved from ‘https://www.vigyanwiki.in/index.php?title=लिस्ट_कॉम्प्रिहेंशन&oldid=245335’