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

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

अवलोकन

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

$S=\{2\cdot x\mid x\in \mathbb {N} ,\ x^{2}>3\}$

या प्रायः

$S=\{2\cdot x:x\in \mathbb {N} ,\ x^{2}>3\}$

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

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

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

$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}}}\}$

• $x$ एक इनपुट सेट के सदस्यों का प्रतिनिधित्व करने वाला चर है।
• $\mathbb {N}$ इनपुट सेट का प्रतिनिधित्व करता है, जो इस उदाहरण में प्राकृतिक संख्याओं का सेट है
• $x^{2}>3$ इनपुट सेट के सदस्यों पर फ़िल्टर के रूप में कार्य करने वाली निर्धारक अभिव्यक्ति है।
• $2\cdot x$ आउटपुट अभिव्यक्ति है जो इनपुट सेट के सदस्यों से नए सेट के सदस्यों का उत्पादन करती है जो विधेय अभिव्यक्ति को संतुष्ट करते हैं।
• $\{\}$ ब्रेसिज़ इंगित करते हैं कि परिणाम एक सेट है
• $\mid$ $,$ ऊर्ध्वाधर पट्टी को "सच दैट" के रूप में पढ़ा जाता है। बार और कोलन ":" का प्रयोग एक दूसरे के स्थान पर किया जाता है।
• अल्पविराम निर्धारक को अलग करते हैं और इसे "एंड" के रूप में रीड किया जा सकता है।

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

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

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

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

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

यहां, सूची [0..] $\mathbb {N}$ का प्रतिनिधित्व करती है, x^2>3 निर्धारक का प्रतिनिधित्व करती है, और 2*x आउटपुट अभिव्यक्ति का प्रतिनिधित्व करती है।

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

इतिहास

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

प्रिंट([n in [2..N] | forall m in {2..n - 1} | n mod m > 0]);

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

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

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

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

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

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

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

समझ को डेटाबेस के लिए क्वेरी संकेतन के रूप में प्रस्तावित किया गया था और इसे क्लेस्ली डेटाबेस क्वेरी भाषा में लागू किया गया था।

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

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']

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

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

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 ))
  

• यह कार्यान्वयन एक मैक्रो का उपयोग करता है और << ऑपरेटर को ओवरलोड करता है। यह 'इफ' के अंदर मान्य किसी भी अभिव्यक्ति का मूल्यांकन करता है, और कोई भी चर नाम चुना जा सकता है। हालाँकि, यह थ्रेड सुरक्षित नहीं है। उपयोग उदाहरण-

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)

• यह कार्यान्वयन क्लासेस और ऑपरेटर ओवरलोडिंग का उपयोग करके हेड/टेल स्लाइसिंग प्रदान करता है, और | सूचियों को फ़िल्टर करने के लिए ऑपरेटर (फ़ंक्शन का उपयोग करके)। उपयोग उदाहरण-

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)) 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_);

यह भी देखें

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

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

• लिस्ट कॉम्प्रिहेंशन द फ्री ऑन-लाइन डिक्शनरी ऑफ कंप्यूटिंग में, संपादक डेनिस होवे.
• Wadler, Philip (1990). "मोनाड्स को समझना". Proceedings of the 1990 ACM Conference on LISP and Functional Programming, Nice.

बाहरी संबंध

• SQL-like set operations with list comprehension one-liners in the Python Cookbook
• Discussion on list comprehensions in Scheme and related constructs
• List Comprehensions across languages

स्वयंसिद्ध

• Axiom स्ट्रीम उदाहरण

क्लोजर

• एपीआई दस्तावेज़ीकरण के लिए - मैक्रो के लिए

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

• लिस्प कॉम्प्रिहेंशन मैक्रो का कार्यान्वयन गाइ लैपल्मे द्वारा

हास्केल

• हास्केल 98 रिपोर्ट, अध्याय 3.11 सूची समझ।
• गौरवशाली ग्लासगो हास्केल संकलन प्रणाली उपयोगकर्ता गाइड, अध्याय html#समानांतर-सूची-समझ 7.3.4 समानांतर सूची समझ।
• द हग्स 98 उपयोगकर्ता गाइड, अध्याय 5.1. 2 समानांतर सूची समझ (उर्फ ज़िप-समझ)।

OCaml

• OCaml बैटरियां शामिल
• OCaml बैटरियों में शामिल भाषा एक्सटेंशन

पायथन

• पायथॉन ट्यूटोरियल, लिस्ट कॉम्प्रिहेंशन।
• पायथन भाषा संदर्भ, सूची प्रदर्शित करता है।
• पायथन एन्हांसमेंट प्रस्ताव PEP 202: सूची समझ।
• पायथन भाषा संदर्भ, जेनरेटर एक्सप्रेशन।
• पायथन एन्हांसमेंट प्रस्ताव PEP 289: जेनरेटर एक्सप्रेशंस।

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