हास्केल: 'पार' क्यों परिभाषित किया गया था?</p> <pre><code>par :: a -> b -> b </code></pre> <p>ध्यान दें, कि तर्क एक फेंक दी जाती है:

Question

par के रूप में घोषित किया गया है। बराबर उपयोग करने के लिए आपको एक ही अभिव्यक्ति का उपयोग कई बार करने की ज़रूरत है।

अपने उद्देश्य समानांतर में ए और बी निष्पादित करने के लिए है, तो क्यों यह इस तरह से परिभाषित नहीं किया गया था ?:

par :: (a, b) -> (a, b) 

(unevaluated) भाव की एक टपल ले रहा है और एक ही भाव लौटने - वे कर रहे हैं, जबकि संभावित रूप से पृष्ठभूमि धागे पर भौतिकीकृत किया जा रहा है।

ऐसा लगता है कि बाद वाला मॉडल पूर्व की तुलना में सरल है। इस तरह से डिजाइन क्यों चुना गया था?

Answer 1

पूर्व में, आप आसानी से दो से अधिक संगणना,

c1 `par` c2 `par` c3 `par` c4 `pseq` something c1 c2 c3 c4 

जो बल्कि बाद में बोझिल होगा चिंगारी कर सकते हैं।

Answer 2

tupled संस्करण आप सुझाव है, Control.Parallel.Strategies में parTuple2 के रूप में पाया जा सकता है प्रकार के साथ:

evalTuple2 :: Strategy a -> Strategy b -> Strategy (a, b) 

क्यों बराबर कि जिस तरह से डिजाइन किया गया था के रूप में, बराबर 'उच्च स्तर है ', Real World Haskell चर्चा की 24 अध्याय है, जहां वे एक quicksort parallelize के रूप में: सभी बातें हम की जरूरत नहीं है

हमारे कोड के लिए इन परिवर्तनों को उल्लेखनीय हैं कहना।

• कितने कोर उपयोग करने के लिए।
• एक दूसरे के साथ संवाद करने के लिए कौन से थ्रेड करते हैं।
• उपलब्ध कोरों के बीच काम को विभाजित करने के लिए कैसे करें।
• धागे के बीच कौन सा डेटा साझा किया जाता है, और जो निजी हैं।
• यह निर्धारित करने के लिए कि सभी प्रतिभागियों को कब समाप्त किया जाता है।

A Monad for Deterministic Parallelism, मार्लो, न्यूटन, और Peyton जोन्स लिखने में:

बराबर ऑपरेटर एक आकर्षक भाषा डिजाइन क्योंकि यह आलसी मूल्यांकन और वायदा के बीच ओवरलैप से फ़ायदा उठाने की है। आलसी मूल्यांकन को लागू करने के लिए हमारे पास अभिव्यक्तियों का प्रतिनिधित्व होना चाहिए, जिनका मूल्यांकन अभी तक नहीं किया गया है, लेकिन जिसका मूल्य बाद में मांगे जा सकते हैं; और इसी तरह एक भविष्य एक गणना है जिसका मूल्य समानांतर में मूल्यांकन किया जा रहा है और जिसके लिए हम प्रतीक्षा कर सकते हैं। इसलिए, बराबर, प्रभाव में एक भविष्य