बड़ी तस्वीर पाने के लिए हास्केल कोड के टुकड़ों का संयोजन

Question

यह वह कोड है जो मैं कहीं पर आया था लेकिन जानना चाहता हूं कि यह कैसे काम करता है:

    findIndices :: (a -> Bool) -> [a] -> [Int]
    findIndices _ [] = []
    findIndices pred xs = map fst (filter (pred . snd) (zip [0..] xs))

आउटपुट: findIndices (== 0) [1,2,0,3,0] == [2,4] , जहां पूर्व (== 0) और xs है [1,2,0,3,0]

मैं अपनी समझ दिखाऊंगा:

    (zip [0..] xs)

उपर्युक्त पंक्ति क्या करती है सूची में सब कुछ के लिए सूचकांक डालते हैं। ऊपर दिए गए इनपुट के लिए, यह इस तरह दिखेगा: [(0,1), (1,2), (2,0), (3,3), (4,0)]

    (pred . snd)

मैंने पाया कि इसका मतलब पूर्व (snd (x)) जैसा है। मेरा प्रश्न यह है कि क्या zip लाइन से बनाई गई सूची x है? मैं हाँ की ओर झुक रहा हूँ, लेकिन मेरा अनुमान भड़कीला है।

अगला, मेरी समझ है कि fst और snd। मुझे पता है

    fst(1,2) = 1 

तथा

    snd(1,2) = 2

ये 2 कमांड कोड में कैसे समझ में आते हैं?

फ़िल्टर के बारे में मेरी समझ यह है कि यह उन वस्तुओं की सूची देता है जो किसी शर्त से मेल खाते हैं। उदाहरण के लिए,

    listBiggerThen5 = filter (>5) [1,2,3,4,5,6,7,8,9,10]

देना होगा [6,7,8,9,10]

मानचित्र की मेरी समझ यह है कि यह सूची के प्रत्येक आइटम पर एक फ़ंक्शन लागू करता है। उदाहरण के लिए,

    times4 :: Int -> Int
    times4 x = x * 4
    listTimes4 = map times4 [1,2,3,4,5]

दे [4,8,12,16,20]

यह कैसे काम करता है? मुझे लगता है कि मैं अब तक जो कुछ भी जानता हूं उसमें व्यापक रहा हूं लेकिन टुकड़ों को एक साथ नहीं रख सकता। क्या कोई व्यक्ति मेरी सहायता कर सकता है?

Comments

मैं यह कहना चाहूंगा कि इस प्रश्न को पढ़ना एक दुर्लभ खुशी थी। हमें "यह कोड काम कैसे करता है?" अक्सर सवाल, लेकिन शायद ही कभी इस स्तर की व्याख्या के साथ कि पूछने वाला क्या करता है और पहले से ही समझ में नहीं आता है। यह वास्तव में मजेदार है कि आपके पास जो अंतराल है उसके बारे में एक अच्छा, लक्षित उत्तर लिखें।

— डैनियल वैगनर

धन्यवाद डैनियल! मैंने इस समस्या में बहुत समय बिताया और इसीलिए, मुझे मदद की जरूरत है कि मैं क्या इंगित कर सकता हूं।

— श्रेमन गौतम

मैं जोड़ना चाहूंगा कि @WillNess उत्तर भी काम करता है। यह आंख पर अधिक आसान है और समझने में आसान है।

— श्रेमन गौतम

Answer 1

हास्केल में हम कहना चाहते हैं, प्रकारों का पालन करें । वास्तव में टुकड़े कनेक्ट होते हैं जैसे कि तार से इसी प्रकार के लिए जा रहे तारों द्वारा:

(पहला, फ़ंक्शन रचना है:

   (f >>> g) x  =  (g . f) x  =        g (f x)
   (f >>> g)    =  (g . f)    =  \x -> g (f x)

और फंक्शन कंपोजिशन टाइप इंट्रेंस रूल है:

    f        :: a -> b                   --      x  :: a
          g  ::      b -> c              --    f x  :: b
   -------------------------             -- g (f x) :: c
    f >>> g  :: a ->      c
    g  .  f  :: a ->      c

अभी, )

findIndices :: (b -> Bool) -> [b] -> [Int]
findIndices pred  = \xs -> map fst ( filter (pred . snd) ( zip [0..] xs ))
                  =        map fst . filter (pred . snd) . zip [0..]
                  =  zip [0..]  >>>  filter (snd >>> pred)  >>>  map fst
---------------------------------------------------------------------------
zip :: [a] ->          [b]        ->        [(a,  b)]
zip  [0..] ::          [b]        ->        [(Int,b)]
---------------------------------------------------------------------------
        snd           :: (a,b) -> b
                pred  ::          b -> Bool
       ------------------------------------
       (snd >>> pred) :: (a,b)      -> Bool
---------------------------------------------------------------------------
filter ::               (t          -> Bool) -> [t]   -> [t]
filter (snd >>> pred) ::                      [(a,b)] -> [(a,b)]
filter (snd >>> pred) ::                    [(Int,b)] -> [(Int,b)]
---------------------------------------------------------------------------
    fst ::                                   (a,   b) -> a
map     ::                                  (t        -> s) -> [t] -> [s]
map fst ::                                                 [(a,b)] -> [a]
map fst ::                                               [(Int,b)] -> [Int]

तो, कुल मिलाकर,

zip  [0..] ::          [b]        ->        [(Int,b)]
filter (snd >>> pred) ::                    [(Int,b)] -> [(Int,b)]
map fst ::                                               [(Int,b)] -> [Int]
---------------------------------------------------------------------------
findIndices pred ::    [b] ->                                         [Int]

आपने पूछा है, ये टुकड़े एक साथ कैसे फिट होते हैं?

इस तरह से।

---

लिस्ट कॉम्प्रिहेंशन के साथ , आपका फंक्शन इस प्रकार लिखा जाता है

findIndices pred xs = [ i | (i,x) <- zip [0..] xs, pred x ]

जो छद्मकोड में पढ़ता है:

"परिणाम सूची में iप्रत्येक (i,x)के लिए zip [0..] xsऐसा होता है जो pred xधारण करता है" ।

यह nलंबे-लंबे मोड़ लगाकर करता है

xs = [a,b,...,z] = [a] ++ [b] ++ ... ++ [z]

में

  [0 | pred a] ++ [1 | pred b] ++ ... ++ [n-1 | pred z]

कहाँ [a | True]है [a]और [a | False]है []।

Comments

आपको अपना वोट मैन मिला। धन्यवाद!

— श्रीमान गौतम

Answer 2

मैंने पाया कि इसका मतलब कुछ ऐसा है pred (snd (x))। मेरा प्रश्न यह है कि क्या zip लाइन से बनाई गई सूची x है? मैं हाँ की ओर झुक रहा हूँ, लेकिन मेरा अनुमान भड़कीला है।

खैर pred . snd, का मतलब है \x -> pred (snd x)। तो यह मूल रूप से एक फ़ंक्शन का निर्माण करता है जो एक तत्व xको मैप करता है pred (snd x)।

इस प्रकार इसका मतलब है कि अभिव्यक्ति की तरह दिखता है:

filter (\x -> pred (snd x)) (zip [0..] xs)

यहाँ xइस प्रकार एक 2-टपल द्वारा उत्पन्न है zip। तो क्रम जानना चाहते हैं कि में (0, 1), (1,2), (2, 0), आदि परिणाम में रखा जाता है, snd xइन 2-tuples (ताकि का दूसरा तत्व ले जाएगा 1, 2, 0, आदि), और देखें कि क्या predथा तत्व पर या संतुष्ट नहीं है। यदि यह संतुष्ट है, तो यह तत्व को बनाए रखेगा, अन्यथा वह तत्व (2-ट्यूपल) फ़िल्टर हो जाता है।

तो अगर (== 0)है predicate, तो filter (pred . snd) (zip [0..] xs)2-tuples में शामिल होंगे [(2, 0), (4, 0)]।

लेकिन अब परिणाम 2-ट्यूपल्स की एक सूची है। यदि हम सूचकांक चाहते हैं, तो हमें किसी तरह 2-ट्यूपल से छुटकारा पाने की आवश्यकता है, और इन 2-ट्यूपल्स का दूसरा तत्व। हम fst :: (a, b) -> aउस के लिए उपयोग करते हैं: यह अपने पहले तत्व पर 2-ट्यूपल मैप करता है। तो एक सूची के लिए [(2, 0), (4, 0)], map fst [(2, 0), (4, 0)]वापस आ जाएगा [2, 4]।

Comments

हे विलेम, क्या एक महान व्याख्या! मैंने अब पूरा कोड समझ लिया है। धन्यवाद महोदय!

— श्रेमन गौतम