दूसरा पैरामीटर फ़ंक्शंस की सूची कैसे बनता है?</p> <pre><code>Prelude Control.Applicative> :t zipWith id zipWith id :: [b -> c] -> [b] -> [c] </code></pre> <p>क्यों संकलक अगले तर्क के लिए उम्मीद करता कार्यों की एक सूची:

Question

मैं निम्नलिखित zipWith और मुठभेड़ के साथ एक सा खेल रहा हूँ?

मैंने विश्लेषण करने की कोशिश की, लेकिन निष्कर्ष निकाला नहीं जा सका, अगला तर्क फ़ंक्शंस की सूची क्यों होना चाहिए।

हस्ताक्षर कैसे लागू हो रहा है, जब मैं idzipWith पास करता हूं?

Answer 1

zipWith के प्रकार है:

zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] 

और id के प्रकार है:

id :: d -> d 

तो अगर हम अब zipWith id के प्रकार के प्राप्त करने के लिए चाहते हैं, हम में id :: d -> d के प्रकार धक्का zipWith के पहले तर्क का प्रकार:

d -> d 
~ a -> (b -> c) 

तो इसका मतलब है कि: a ~ d और a ~ b -> c। तो इसका मतलब है कि कि zipWith id के प्रकार है:

zipWith id :: [a] -> [b] -> [c] 
-> zipWith id :: [b -> c] -> [b] -> [c] 

कैसे यह काम: पहली सूची तत्वों x :: b की एक सूची कार्यों f :: b -> c की एक सूची है, और दूसरी सूची, को रोकने के लिए है, और यह इस प्रकार गणना तत्वों की एक सूची f x :: c।

उदाहरण के लिए:

Prelude> zipWith id [(+1),(5/),(3*),(3-)] [1,4,2,5] 
[2.0,1.25,6.0,-2.0] 

1+1 के बाद से 2.0 है, 5/41.25 है, 3*26.0 है और 3-5-2.0 है।

तो zipWith id दो तत्वों f और x अधिक वर्बोज़ (id f) x ले जाएगा, और इन पर id f x लागू होते हैं, या। चूंकि id ff है, इसलिए यह f x की गणना करेगा।

हम इस प्रकार निष्कर्ष निकाल सकते हैं कि zipWithतत्ववार मैपिंग है।

Answer 2

धन्यवाद, विलेम वान ऑनसेम महान उत्तर के लिए धन्यवाद।

चलिए zipWith id को ghc की प्रकार अनुमान प्रणाली की आंखों से समझते हैं।

पहले, zipWith

Prelude> :info zipWith 
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] 
    -- Defined in ‘GHC.List’ 

zipWith पहले तर्क के प्रकार पर विचार एक समारोह जो एक समारोह जो दो तर्क लेता स्वीकार करता है।

(a -> b -> c) भी a -> (b -> c)

रूप में फिर से लिखा जा सकता है अब zipWith id पर विचार करें। id का प्रकार a -> a

हमने id को ऐसे स्थान पर रखा है जहां दो तर्क फ़ंक्शन जाना चाहिए।

तो, प्रकार निष्कर्ष a -> (b -> c) तरह (a -> b -> c) देखो बनाना होगा (नोटिस a -> (b -> c) एक arument एक लेता है और b -> c यानी एक भी तर्क समारोह देता है।)

लेकिन, a -> (b -> c) बनाने एक पहचान समारोह तभी संभव है यदि a है होगा (बी -> सी)।

जब a है (ख -> ग) समारोह a -> b -> c हो जाता है ((ख -> ग) -> (ख -> ग))

तो, प्रकार inferencing प्रणाली a(b -> c) और उसके एवज में के रूप में यह निष्कर्ष निकाल होगा आउटपुट [a] -> [b] -> [c]a को b -> c के साथ बदल देगा।

a को (बी -> सी) के साथ बदलें।

मेक (ए -> बी -> सी) id जैसा दिखता है। (ए -> बी -> सी) उपरोक्त प्रतिस्थापन द्वारा id की तरह दिखने के लिए बनाया जा सकता है।

((ख -> ग) -> ख -> ग) जो भी रूप में लिखा जा सकता है ((ख -> ग) -> (ख -> ग)) जो id :: x -> x जहां x है (ख -> ग)

zipWith :: ((b -> c) -> b -> c) -> [b -> c] -> [b] -> [c] 

तो अंत में हम मिल उत्पादन [b -> c] -> [b] -> [c]