Haskell Language
सूची की समझ

बुनियादी सूची की समझ

हास्केल के पास सूची की समझ है , जो गणित में सेट की समझ और पायथन और जावास्क्रिप्ट जैसी अनिवार्य भाषाओं में समान कार्यान्वयन की तरह हैं। उनके सबसे मूल में, सूची बोध निम्नलिखित रूप लेते हैं।

[ x | x <- someList ]

उदाहरण के लिए

[ x | x <- [1..4] ]    -- [1,2,3,4]

कार्यों को सीधे x पर भी लागू किया जा सकता है:

[ f x | x <- someList ]

यह इसके बराबर है:

map f someList

उदाहरण:

[ x+1 | x <- [1..4]]    -- [2,3,4,5]

जेनरेटर एक्सप्रेशंस में पैटर्न

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

[x | Just x <- [Just 1, Nothing, Just 3]]     -- [1, 3]

इसके पैटर्न में एक चर x वाला जेनरेटर नया दायरा बनाता है, जिसमें उसके दाईं ओर सभी एक्सप्रेशंस होते हैं, जहाँ x को उत्पन्न तत्व माना जाता है।

इसका मतलब है कि गार्ड को कोडित किया जा सकता है

[ x | x <- [1..4], even x] ==
[ x | x <- [1..4], () <- [() | even x]] ==
[ x | x <- [1..4], () <- if even x then [()] else []]

गार्ड

सूची समझ की एक और विशेषता गार्ड है, जो फ़िल्टर के रूप में भी कार्य करती है। गार्ड बूलियन अभिव्यक्ति हैं और सूची समझ में बार के दाईं ओर दिखाई देते हैं।

उनका सबसे बुनियादी उपयोग है

[x    | p x]   ===   if p x then [x] else []

गार्ड में इस्तेमाल किया गया कोई भी वैरिएबल इसके बायीं ओर दिखाई देना चाहिए, अन्यथा स्कोप में हो सकता है। इसलिए,

[ f x | x <- list, pred1 x y, pred2 x]     -- `y` must be defined in outer scope

के बराबर है

map f (filter pred2 (filter (\x -> pred1 x y) list))          -- or,

-- ($ list) (filter (`pred1` y) >>> filter pred2 >>> map f)     

-- list >>= (\x-> [x | pred1 x y]) >>= (\x-> [x | pred2 x]) >>= (\x -> [f x])

( >>= ऑपरेटर infixl 1 , अर्थात यह बाईं ओर संबद्ध है (कोष्ठक है)। उदाहरण:

[ x       | x <- [1..4], even x]           -- [2,4]

[ x^2 + 1 | x <- [1..100], even x ]        -- map (\x -> x^2 + 1) (filter even [1..100])

नेस्टेड जेनरेटर

सूची की समझ भी कई सूचियों से तत्वों को आकर्षित कर सकती है, इस स्थिति में परिणाम दो तत्वों के हर संभव संयोजन की सूची होगी, जैसे कि दो सूचियों को नेस्टेड फैशन में संसाधित किया गया था। उदाहरण के लिए,

[ (a,b) | a <- [1,2,3], b <- ['a','b'] ]

-- [(1,'a'), (1,'b'), (2,'a'), (2,'b'), (3,'a'), (3,'b')]

समानांतर समझ

समानांतर सूची के साथ भाषा का विस्तार,

[(x,y) | x <- xs | y <- ys]

के बराबर है

zip xs ys

उदाहरण:

[(x,y) | x <- [1,2,3] | y <- [10,20]] 

-- [(1,10),(2,20)]

लोकल बाइंडिंग

सूची के अंतर कुछ अंतर मान रखने के लिए चर के लिए स्थानीय बाइंडिंग पेश कर सकते हैं:

[(x,y) | x <- [1..4], let y=x*x+1, even y]    -- [(1,2),(3,10)]

एक चाल के साथ एक ही प्रभाव प्राप्त किया जा सकता है,

[(x,y) | x <- [1..4], y <- [x*x+1], even y]   -- [(1,2),(3,10)]

let सूची comprehensions में हमेशा की तरह, पुनरावर्ती है। लेकिन जनरेटर बाइंडिंग नहीं हैं, जो छायांकन को सक्षम करता है:

[x | x <- [1..4], x <- [x*x+1], even x]       -- [2,10]

संकेतन करें

किसी भी सूची समझ तदनुसार साथ कोडित किया जा सकता है सूची इकाई के do अंकन ।

[f x | x <- xs]                 f  <$> xs         do { x <- xs ; return (f x) }

[f x | f <- fs, x <- xs]        fs <*> xs         do { f <- fs ; x <- xs ; return (f x) }

[y   | x <- xs, y <- f x]       f  =<< xs         do { x <- xs ; y <- f x ; return y }

Control.Monad.guard का उपयोग कर गार्ड को नियंत्रित किया जा सकता है। Control.Monad.guard :

[x   | x <- xs, even x]                           do { x <- xs ; guard (even x) ; return x }