आत्म संदर्भ में कार्य

Question

मैं Haskell Wiki पर हास्केल निम्नलिखित अभिव्यक्ति सीख रहा हूँ और मैं वास्तव में मुझे हैरान:

fibs = 0 : 1 : zipWith (+) fibs (tail fibs) 

मैं काफी समझ नहीं क्यों यह काम करता है।

यदि मैं मानक करीइंग तर्क लागू करता हूं (zipWith (+)) एक फ़ंक्शन एक तर्क के रूप में सूची लेता है और बदले में, एक और फ़ंक्शन देता है जो तर्क के रूप में एक और सूची लेता है, और एक सूची (zipWith::(a -> b -> c) -> [a] -> [b] -> [c]) देता है। तो, fibs एक सूची के लिए एक संदर्भ है (जिनका अब तक मूल्यांकन नहीं किया गया) और (tail fibs) ही (unevaluated) सूची की पूंछ है। जब हम मूल्यांकन करने के लिए (take 10 fibs) की कोशिश, पहले दो तत्वों 0 और 1 करने के लिए बाध्य कर रहे हैं। दूसरे शब्दों में fibs==[0,1,?,?...] और (tail fibs)==[1,?,?,?]। पहले जोड़े को पूरा करने के बाद fibs[0,1,0+1,?,..] बन जाता है। इसी प्रकार, दूसरे जोड़े के बाद हमें [0,1,0+1,1+(0+1),?,?..]

• क्या मेरा तर्क सही है?
• वहाँ एक सरल तरीका यह समझाने के लिए है? (जो लोग जानते हैं कि हास्केल संकलक इस कोड के साथ करता है? से किसी भी अंतर्दृष्टि) (लिंक और संदर्भ स्वागत कर रहे हैं)
• यह सच है कि कोड के इस प्रकार केवल आलसी मूल्यांकन की वजह से काम करता है?
• क्या मूल्यांकन हो सकता है जब मैं fibs !! 4 करते हैं?
• क्या यह कोड मानता है कि ज़िप प्रक्रियाओं को पहले आखिरी बार संसाधित करता है? (मुझे लगता है कि यह नहीं होना चाहिए, लेकिन मुझे समझ में नहीं आता क्यों नहीं)

EDIT2: मुझे अभी उपरोक्त प्रश्न पूछा गया और here का उत्तर दिया गया। मुझे खेद है अगर मैंने किसी के समय बर्बाद कर दिया।

संपादित करें:

filterAbort :: (a -> Bool) -> [a] -> [a] 
filterAbort p (x:xs) = if p x then x : filterAbort p xs else [] 

main :: Int 
main = primelist !! 10000 
     where primelist = 2 : 3 : 5 : [ x | x <- [7..], odd x, all (\y -> x `mod` y /= 0) (filterAbort (<= (ceiling (sqrt (fromIntegral x)))) primelist) ] 

ध्यान दें कि all (\y -> x mod y /= 0)... कैसे एक्स की चर्चा करते हुए यहां अनंत प्रत्यावर्तन कारण नहीं हो सकता: यहाँ एक और अधिक कठिन मामला (: Project Euler forums स्रोत) को समझने के लिए किया जाता है?

Answer 1

मैं तुम्हारे लिए मूल्यांकन का पता लगाने जाएगा:

साथ

> fibs = 0 : 1 : zipWith (+) fibs (tail fibs) 

:

> zipWith f (a:as) (b:bs) = f a b : zipWith f as bs 
> zipWith _ _  _  = [] 

> tail (_:xs)    = xs 
> tail []     = error "tail" 

तो:

fibs = 0 : 1 : zipWith (+) fibs (tail fibs) 
↪ fibs = 0 : 1 : ((+) 0 1 : zipWith (+) (tail fibs) (tail (tail fibs))) 
↪ fibs = 0 : 1 : 1 : ((+) 1 1 : zipWith (+) (tail (tail fibs)) (taii (tail (tail fibs)))))  
↪ fibs = 0 : 1 : 1 : 2 : ((+) 1 2 : zipWith (+) (tail (tail (tail fibs))) (tail (taii (tail (tail fibs)))))) 
↪ fibs = 0 : 1 : 1 : 2 : 3 : ((+) 2 3 : zipWith (+) (tail (tail (tail (tail fibs)))) (tail (tail (taii (tail (tail fibs))))))) 

आदि तो अगर आप इस संरचना में सूचकांक, यह इंडेक्स मिलने तक फाइबर के प्रत्येक चरण का मूल्यांकन किया जाना चाहिए।

क्यों इस कुशल है? एक शब्द: साझाकरण।

fibs की गणना की जाती है, यह ढेर में बढ़ती है, जो रिकॉर्डिंग मान कंप्यूटर है। fibs के बाद के संदर्भों में fibs के लिए पहले के गणना किए गए मानों का पुन: उपयोग करना होगा। नि: शुल्क यादें!

ढेर में यह साझाकरण कैसा दिखता है?

आप सूची के अंत पर वस्तु के लिए पूछने के रूप में, हास्केल अगले मूल्य की गणना करता है, यह रिकॉर्ड करता है, और कहा कि एक नोड नीचे आत्म संदर्भ ले जाता है।

तथ्य यह है कि यह समाप्त होता है आलस्य पर महत्वपूर्ण रूप से निर्भर करता है।