हालांकि यह कभी-कभी इस तरह से व्यक्त किया जाता है, कार्यात्मक प्रोग्रामिंग 'स्टेटफुल कंप्यूटेशन को रोकता नहीं है। यह जो करता है वह प्रोग्रामर को राज्य को स्पष्ट करने के लिए मजबूर करता है।
उदाहरण के लिए, चलिए कुछ प्रोग्राम की मूल संरचना को एक अनिवार्य कतार (कुछ छद्म भाषा में) का उपयोग करके लेते हैं:
q := Queue.new();
while (true) {
if (Queue.is_empty(q)) {
Queue.add(q, producer());
} else {
consumer(Queue.take(q));
}
}
एक कार्यात्मक कतार डेटा संरचना के साथ संबंधित संरचना (अभी भी एक अनिवार्य भाषा में, ताकि एक समय में एक अंतर से निपटने के लिए) इस तरह दिखाई दे:
q := Queue.empty;
while (true) {
if (q = Queue.empty) {
q := Queue.add(q, producer());
} else {
(tail, element) := Queue.take(q);
consumer(element);
q := tail;
}
}
चूंकि अब कतार अपरिवर्तनीय है, इसलिए वस्तु स्वयं नहीं बदलती है। इस छद्म कोड में, qस्वयं एक चर है; असाइनमेंट q := Queue.add(…)और q := tailयह एक अलग वस्तु की ओर इशारा करते हैं। कतार फ़ंक्शन का इंटरफ़ेस बदल गया है: प्रत्येक को ऑपरेशन से उत्पन्न नई कतार ऑब्जेक्ट को वापस करना होगा।
विशुद्ध रूप से कार्यात्मक भाषा में, यानी बिना किसी साइड इफ़ेक्ट वाली भाषा में, आपको सभी स्थिति स्पष्ट करने की आवश्यकता है। चूंकि निर्माता और उपभोक्ता संभवतः कुछ कर रहे हैं, इसलिए उनका राज्य उनके कॉलर के इंटरफेस में भी होना चाहिए।
main_loop(q, other_state) {
if (q = Queue.empty) {
let (new_state, element) = producer(other_state);
main_loop(Queue.add(q, element), new_state);
} else {
let (tail, element) = Queue.take(q);
let new_state = consumer(other_state, element);
main_loop(tail, new_state);
}
}
main_loop(Queue.empty, initial_state)
ध्यान दें कि अब राज्य के हर टुकड़े को कैसे प्रबंधित किया जाता है। कतार हेरफेर फ़ंक्शन इनपुट के रूप में एक कतार लेते हैं और आउटपुट के रूप में एक नई कतार बनाते हैं। निर्माता और उपभोक्ता अपने राज्य से भी गुजरते हैं।
समवर्ती प्रोग्रामिंग कार्यात्मक प्रोग्रामिंग के अंदर इतनी अच्छी तरह से फिट नहीं है , लेकिन यह कार्यात्मक प्रोग्रामिंग के आसपास बहुत अच्छी तरह से फिट बैठता है। विचार अलग संगणना नोड्स का एक गुच्छा चलाने और उन्हें संदेशों का आदान-प्रदान करने का है। प्रत्येक नोड एक कार्यात्मक कार्यक्रम चलाता है, और संदेश भेजने और प्राप्त करने के दौरान इसकी स्थिति बदल जाती है।
उदाहरण जारी रखते हुए, चूंकि एक ही कतार है, इसलिए इसे एक विशेष नोड द्वारा प्रबंधित किया जाता है। उपभोक्ता एक तत्व प्राप्त करने के लिए उस नोड को एक संदेश भेजते हैं। निर्माता एक तत्व जोड़ने के लिए उस नोड को एक संदेश भेजते हैं।
main_loop(q) =
consumer->consume(q->take()) || q->add(producer->produce());
main_loop(q)
एक "औद्योगिक" भाषा है कि संगामिति right³ हो जाता है Erlang । सीखना Erlang निश्चित रूप से समवर्ती प्रोग्रामिंग के बारे में ज्ञानोदय का मार्ग है।
हर कोई अब साइड-इफ़ेक्ट-फ्री भाषाओं पर स्विच करता है!
Several इस शब्द के कई अर्थ हैं; यहाँ मुझे लगता है कि आप इसका उपयोग साइड इफेक्ट्स के बिना प्रोग्रामिंग के लिए कर रहे हैं, और इसका अर्थ है कि मैं भी उपयोग कर रहा हूँ।
² अंतर्निहित अवस्था के साथ प्रोग्रामिंग अनिवार्य प्रोग्रामिंग है ; ऑब्जेक्ट ओरिएंटेशन पूरी तरह से ऑर्थोगोनल चिंता है।
³ भड़काऊ, मुझे पता है, लेकिन मेरा मतलब है। साझा मेमोरी के साथ थ्रेड्स समवर्ती प्रोग्रामिंग की विधानसभा भाषा है। संदेश पास करना समझने में बहुत आसान है, और जैसे ही आप संक्षिप्तता का परिचय देते हैं, साइड इफेक्ट्स की कमी वास्तव में चमक जाती है।
Coming और यह किसी ऐसे व्यक्ति से आ रहा है जो एर्लांग का प्रशंसक नहीं है, लेकिन अन्य कारणों से।