(कार्यात्मक) प्रतिक्रियाशील प्रोग्रामिंग क्या है?

Question

मैंने प्रतिक्रियात्मक प्रोग्रामिंग पर विकिपीडिया लेख पढ़ा है । मैंने कार्यात्मक प्रतिक्रियाशील प्रोग्रामिंग पर छोटा लेख भी पढ़ा है । वर्णन काफी सारगर्भित हैं।

1. कार्यात्मक प्रतिक्रियाशील प्रोग्रामिंग (FRP) का क्या अर्थ है?
2. प्रतिक्रियाशील प्रोग्रामिंग क्या है (गैर-प्रतिक्रियाशील प्रोग्रामिंग के विपरीत?) जिसमें शामिल है?

मेरी पृष्ठभूमि अनिवार्य / ओओ भाषाओं में है, इसलिए इस प्रतिमान से संबंधित एक स्पष्टीकरण की सराहना की जाएगी।

Comments

यहाँ एक सक्रिय कल्पना और अच्छी कहानी कहने के कौशल वाला एक लड़का पूरी चीज़ को लेता है। paulstovell.com/reactive-programming

— melaos

किसी को वास्तव में हमारे लिए सभी ऑटोडिडैक्ट्स के लिए "कार्यात्मक प्रतिक्रियाशील प्रोग्रामिंग के लिए डमीज़" लिखना होगा। मैंने पाया है कि हर संसाधन, यहां तक ​​कि एल्म, लगता है कि आपने पिछले पांच वर्षों में सीएस में मास्टर की उपाधि प्राप्त की है। FRP के बारे में जानने वालों को लगता है कि इस मामले को भोलेपन से देखने की क्षमता पूरी तरह से खो गई है, शिक्षण, प्रशिक्षण और प्रचार के लिए कुछ महत्वपूर्ण है।

— टेकजेन

एक और उत्कृष्ट एफआरपी परिचय: प्रतिक्रियाशील प्रोग्रामिंग का परिचय जो आपने मेरे सहयोगी आंद्रे

— जॉनिक जूल

मेरे द्वारा देखे गए सर्वश्रेष्ठ में से एक, उदाहरण आधारित: gist.github.com/staltz/868e7e9bc2a7b8c1f754

— Razmig

मैं स्प्रेडशीट सादृश्य को पहले रफ इंप्रेशन के रूप में बहुत उपयोगी मानता हूं (बॉब का जवाब देखें: stackoverflow.com/a/1033066/1593924 )। एक स्प्रेडशीट सेल अन्य कोशिकाओं (पुल) में परिवर्तन के प्रति प्रतिक्रिया करता है, लेकिन बाहर नहीं पहुंचता है और दूसरों को बदलता है (धक्का नहीं देता है)। अंतिम परिणाम यह है कि आप अपने स्वयं के डिस्प्ले को अपडेट करने के लिए एक सेल और एक ज़िलियन दूसरों को 'स्वतंत्र रूप से' बदल सकते हैं।

— जॉन कोम्ब्स

Answer 1

यदि आप एफआरपी के लिए एक महसूस करना चाहते हैं, तो आप 1998 से पुराने फ्रेंक ट्यूटोरियल से शुरू कर सकते हैं , जिसमें एनिमेटेड चित्रण हैं। कागजात के लिए, फंक्शनल रिएक्टिव एनीमेशन के साथ शुरू करें और फिर मेरे होम पेज पर प्रकाशन लिंक पर लिंक और हस्केल विकी पर एफआरपी लिंक का पालन करें ।

व्यक्तिगत रूप से, मैं यह सोचना पसंद करता हूं कि एफआरपी का मतलब क्या है, इसे कैसे लागू किया जाए, इसे संबोधित करने से पहले। (एक विनिर्देश के बिना कोड एक प्रश्न के बिना एक उत्तर है और इस प्रकार "गलत भी नहीं है"।) इसलिए मैं प्रतिनिधित्व / कार्यान्वयन की शर्तों में एफआरपी का वर्णन नहीं करता हूं, जैसा कि थॉमस के एक अन्य उत्तर में करता है (रेखांकन, नोड्स, किनारों, फायरिंग, निष्पादन, आदि)। कई संभावित कार्यान्वयन शैली हैं, लेकिन कोई भी कार्यान्वयन यह नहीं कहता है कि एफआरपी क्या है ।

मैं लारेंस जी के सरल विवरण के साथ प्रतिध्वनित करता हूं कि एफआरपी "डेटैटिप्स के बारे में है जो 'समय के साथ एक मूल्य का प्रतिनिधित्व करता है"। परम्परागत अनिवार्यता प्रोग्रामिंग इन गतिशील मूल्यों को केवल अप्रत्यक्ष रूप से राज्य और उत्परिवर्तन के माध्यम से पकड़ती है। संपूर्ण इतिहास (भूत, वर्तमान, भविष्य) का कोई प्रथम श्रेणी प्रतिनिधित्व नहीं है। इसके अलावा, केवल विवेकपूर्ण रूप से विकसित मूल्य (अप्रत्यक्ष रूप से) पर कब्जा किया जा सकता है, क्योंकि अनिवार्य प्रतिमान अस्थायी रूप से असतत है। इसके विपरीत, एफआरपी इन विकसित मूल्यों को सीधे पकड़ लेता है और निरंतर विकसित मूल्यों के साथ कोई कठिनाई नहीं है ।

एफआरपी इस बात में भी असामान्य है कि यह सैद्धांतिक और व्यावहारिक चूहों के घोंसले के बिना चल रहा है जो घोंसले को अनिवार्य कर देता है। शब्दार्थ, FRP की संगति ठीक-ठाक , निर्धारित और निरंतर होती है । (मैं अर्थ के बारे में बात कर रहा हूं, कार्यान्वयन नहीं। एक कार्यान्वयन संगामिति या समानांतरवाद को शामिल कर सकता है या नहीं।) तर्कशक्ति, तर्कसंगत और अनौपचारिक दोनों के लिए अर्थ निर्धारण महत्वपूर्ण है। जबकि समसामयिक अनिवार्यता को अनिवार्य प्रोग्रामिंग में जोड़ दिया जाता है (nondeterministic interleaving के कारण), यह एफआरपी में सरल नहीं है।

तो, FRP क्या है? आप स्वयं इसका आविष्कार कर सकते थे। इन विचारों से शुरू करें:

• गतिशील / विकसित मूल्य (यानी, "समय के साथ मूल्य") अपने आप में प्रथम श्रेणी के मूल्य हैं। आप उन्हें परिभाषित कर सकते हैं और उन्हें जोड़ सकते हैं, उन्हें कार्यों से बाहर कर सकते हैं। मैंने इन चीजों को "व्यवहार" कहा।

• व्यवहार कुछ प्राइमरी से बना होता है, जैसे स्थिर (स्थिर) व्यवहार और समय (एक घड़ी की तरह), और फिर अनुक्रमिक और समानांतर संयोजन के साथ। एन व्यवहारों को एन-एरी फ़ंक्शन (स्थिर मूल्यों पर), "बिंदु-वार", यानी, समय के साथ लगातार लागू करके संयुक्त किया जाता है।

• असतत घटनाओं के लिए खाते में, "घटनाओं" का एक अन्य प्रकार (परिवार) है, जिनमें से प्रत्येक में घटनाओं की एक धारा (परिमित या अनंत) है। प्रत्येक घटना का एक संबद्ध समय और मूल्य होता है।

• रचनात्मक शब्दावली के साथ आने के लिए जिसमें सभी व्यवहार और घटनाओं का निर्माण किया जा सकता है, कुछ उदाहरणों के साथ खेलते हैं। टुकड़ों में विघटित करते रहें जो अधिक सामान्य / सरल हैं।

• ताकि आप जान सकें कि आप ठोस आधार पर हैं, पूरे मॉडल को एक सांकेतिक आधार देते हैं, जो कि अर्थ-संबंधी शब्दार्थ की तकनीक का उपयोग करते हैं, जिसका अर्थ है कि (a) प्रत्येक प्रकार का एक समान सरल और सटीक गणितीय प्रकार "अर्थ" है, और ( बी) प्रत्येक आदिम और ऑपरेटर का घटक के अर्थ के एक समारोह के रूप में एक सरल और सटीक अर्थ है। कभी, अपनी अन्वेषण प्रक्रिया में कार्यान्वयन के विचारों को मिलाएं। इस विवरण आप के लिए निरर्थक शब्द है, तो परामर्श (क) प्रकार वर्ग morphisms साथ Denotational डिजाइन , (ख) पुश-पुल कार्यात्मक प्रतिक्रियाशील प्रोग्रामिंग (कार्यान्वयन बिट्स अनदेखी), और (ग) Denotational शब्दार्थ हास्केल wikibooks पेज। खबरदार है कि अपने दो संस्थापकों क्रिस्टोफर स्ट्रेची और डाना स्कॉट से: दो सेटर के शब्दार्थों के दो भाग होते हैं: आसान और अधिक उपयोगी स्ट्रेची भाग और कठिन और कम उपयोगी (सॉफ़्टवेयर डिज़ाइन के लिए) स्कॉट भाग।

यदि आप इन सिद्धांतों से चिपके रहते हैं, तो मुझे उम्मीद है कि आपको FRP की भावना में कुछ और-या-कम मिलेगा।

मुझे ये सिद्धांत कहां से मिले? सॉफ्टवेयर डिजाइन में, मैं हमेशा एक ही सवाल पूछता हूं: "इसका क्या मतलब है?"। इस शब्द के लिए डेनेटेशनल शब्दार्थ ने मुझे एक सटीक रूपरेखा प्रदान की, और एक जो मेरे सौंदर्यशास्त्र (परिचालन या स्वयंसिद्ध अर्थ विज्ञान के विपरीत, दोनों को फिट करता है) जो मुझे असंतुष्ट छोड़ते हैं। तो मैंने खुद से पूछा कि व्यवहार क्या है? मुझे जल्द ही एहसास हुआ कि अनिवार्य गणना की अस्थायी रूप से असतत प्रकृति , व्यवहार की एक प्राकृतिक वर्णन के बजाय मशीन की एक विशेष शैली के लिए एक आवास है। व्यवहार का सबसे सरल सटीक वर्णन जो मैं सोच सकता हूं, वह है "(निरंतर) समय का कार्य", इसलिए यह मेरा मॉडल है। प्रसन्नता से, यह मॉडल निरंतर, नियतात्मक संगामिति को आसानी और अनुग्रह के साथ संभालता है।

यह इस मॉडल को सही ढंग से और कुशलता से लागू करने के लिए काफी चुनौती है, लेकिन यह एक और कहानी है।

Comments

मुझे कार्यात्मक प्रतिक्रियाशील प्रोग्रामिंग के बारे में पता है। यह मेरे स्वयं के अनुसंधान (इंटरैक्टिव सांख्यिकीय ग्राफिक्स में) से संबंधित लगता है और मुझे यकीन है कि कई विचार मेरे काम के लिए सहायक होंगे। हालांकि, मुझे भाषा के अतीत से गुजरना बहुत मुश्किल लगता है - क्या मुझे वास्तव में "डीनोटेशनल सेमेंटिक्स" और "टाइप क्लास मॉर्फिज्म" के बारे में जानना चाहिए कि क्या चल रहा है? विषय के लिए एक सामान्य दर्शक परिचय बहुत उपयोगी होगा।

— हैडली

@ जोनल: आप स्पष्ट रूप से जानते हैं कि आप किस बारे में बात कर रहे हैं, लेकिन आपकी भाषा मानती है कि मेरे पास कम्प्यूटेशनल गणित में डॉक्टरेट है, जो मैं नहीं करता। मेरे पास सिस्टम इंजीनियरिंग में एक पृष्ठभूमि है और कंप्यूटर और प्रोग्रामिंग भाषाओं के साथ 20+ वर्षों का अनुभव है, फिर भी मुझे लगता है कि आपकी प्रतिक्रिया मुझे चकित करती है। मैं आपको चुनौती देता हूं कि आप अपना जवाब अंग्रेजी में ;-)

— mindplay.dk

@ minplay.dk: आपकी टिप्पणी मुझे उस बारे में जाने के लिए बहुत कुछ नहीं देती है जो आपको विशेष रूप से समझ में नहीं आता है, और मैं इस बात का जंगली अनुमान लगाने में असमर्थ हूं कि आप किस विशेष वर्ग के अंग्रेजी की तलाश कर रहे हैं। हालाँकि, मैं आपको विशेष रूप से यह बताने के लिए आमंत्रित करता हूं कि ऊपर दिए गए मेरे स्पष्टीकरण के कौन से पहलू हैं, जिन पर आप ट्रिप कर रहे हैं, ताकि मैं और अन्य आपकी मदद कर सकें। उदाहरण के लिए, क्या ऐसे विशेष शब्द हैं जिन्हें आप परिभाषित करना चाहते हैं या अवधारणाएँ जिनके लिए आप संदर्भ जोड़ सकते हैं? मैं वास्तव में अपने लेखन की स्पष्टता और पहुंच में सुधार करना पसंद करता हूं - इसे नीचे किए बिना।

— २०:११

"नियतत्व" / "निश्चय" का अर्थ है एक एकल, अच्छी तरह से परिभाषित सही मूल्य। इसके विपरीत, लगभग सभी प्रकार की अनिवार्यता अलग-अलग उत्तर दे सकती है, जो एक अनुसूचक पर निर्भर करता है कि आप देख रहे हैं या नहीं और वे गतिरोध भी कर सकते हैं। "सिमेंटिक" (और अधिक विशेष रूप से "डिनोटेशनल") एक अभिव्यक्ति या प्रतिनिधित्व के मूल्य ("डिनोटेशन") को संदर्भित करता है, "ऑपरेशनल" के विपरीत (उत्तर की गणना कैसे की जाती है या कितनी जगह और / या समय का उपभोग किया जाता है मशीन की तरह)।

— कोन

मैं @ mindplay.dk से सहमत हूं, हालांकि मैं इस क्षेत्र में बहुत लंबे समय तक रहने की कोई कमी नहीं कर सकता। हालांकि ऐसा लग रहा था कि आप जानते हैं कि आप किस बारे में बात कर रहे हैं, इसने मुझे यह समझने की त्वरित, संक्षिप्त और सरल समझ नहीं दी, क्योंकि मैं एसओ पर उम्मीद करने के लिए काफी खराब हूं। इस जवाब ने मुख्य रूप से मुझे पहले प्रश्न का उत्तर दिए बिना नए प्रश्नों के एक टन तक पहुंचा दिया। मुझे उम्मीद है कि क्षेत्र में अभी भी अपेक्षाकृत अज्ञानी होने के अनुभव को साझा करना आपको एक अंतर्दृष्टि दे सकता है कि आपको वास्तव में कितना सरल और संक्षिप्त होना चाहिए। मैं ओपी, btw के समान पृष्ठभूमि से आता हूं।

— असके बी।

Answer 2

शुद्ध कार्यात्मक प्रोग्रामिंग में, कोई दुष्प्रभाव नहीं हैं। कई प्रकार के सॉफ़्टवेयर के लिए (उदाहरण के लिए, उपयोगकर्ता इंटरैक्शन के साथ कुछ भी) साइड-इफेक्ट कुछ स्तर पर आवश्यक हैं।

व्यवहार की तरह साइड-इफ़ेक्ट प्राप्त करने का एक तरीका यह है कि फ़ंक्शनल स्टाइल को बरकरार रखते हुए फ़ंक्शनल रिएक्टिव प्रोग्रामिंग का उपयोग किया जाए। यह कार्यात्मक प्रोग्रामिंग, और प्रतिक्रियाशील प्रोग्रामिंग का संयोजन है। (आपके द्वारा जुड़ा विकिपीडिया लेख उत्तरार्द्ध के बारे में है।)

प्रतिक्रियाशील प्रोग्रामिंग के पीछे मूल विचार यह है कि कुछ डेटाटिप्स हैं जो "समय के साथ" मूल्य का प्रतिनिधित्व करते हैं। इन बदलते समय के मूल्यों को शामिल करने वाली संगणनाओं में स्वयं मूल्य होंगे जो समय के साथ बदलते हैं।

उदाहरण के लिए, आप पूर्णांक-समय मानों की एक जोड़ी के रूप में माउस निर्देशांक का प्रतिनिधित्व कर सकते हैं। मान लें कि हमारे पास कुछ ऐसा था (यह छद्म कोड है):

x = <mouse-x>;
y = <mouse-y>;

किसी भी समय, x और y में माउस के निर्देशांक होंगे। गैर-प्रतिक्रियाशील प्रोग्रामिंग के विपरीत, हमें केवल एक बार यह असाइनमेंट बनाने की आवश्यकता है, और x और y चर स्वचालित रूप से "अप टू डेट" रहेंगे। यही कारण है कि प्रतिक्रियाशील प्रोग्रामिंग और कार्यात्मक प्रोग्रामिंग इतनी अच्छी तरह से एक साथ काम करते हैं: प्रतिक्रियाशील प्रोग्रामिंग चर को उत्परिवर्तित करने की आवश्यकता को दूर करता है जबकि अभी भी आपको बहुत कुछ करने देता है जो आप चर म्यूटेशन के साथ पूरा कर सकते हैं।

यदि हम इसके बाद कुछ गणनाएँ करते हैं, तो परिणामी मूल्य भी ऐसे मान होंगे जो समय के साथ बदलते हैं। उदाहरण के लिए:

minX = x - 16;
minY = y - 16;
maxX = x + 16;
maxY = y + 16;

इस उदाहरण में, minXहमेशा माउस पॉइंटर के x निर्देशांक से 16 कम होगा। प्रतिक्रियाशील-जागरूक पुस्तकालयों के साथ आप तब कुछ कह सकते हैं:

rectangle(minX, minY, maxX, maxY)

और एक 32x32 बॉक्स को माउस पॉइंटर के चारों ओर खींचा जाएगा और इसे जहां भी ले जाएगा, उसे ट्रैक करेगा।

यहाँ कार्यात्मक प्रतिक्रियाशील प्रोग्रामिंग पर एक बहुत अच्छा पेपर है ।

Comments

तो प्रतिक्रियाशील प्रोग्रामिंग तो घोषणात्मक प्रोग्रामिंग का एक रूप है?

— ट्रोलेन्सन

> तो प्रतिक्रियाशील प्रोग्रामिंग तो घोषणात्मक प्रोग्रामिंग का एक रूप है? फंक्शनल रिएक्टिव प्रोग्रामिंग फंक्शनल प्रोग्रामिंग का एक रूप है, जो डिक्लेक्टिव प्रोग्रामिंग का एक रूप है।

— कॉनल

@ user712092 वास्तव में नहीं, नहीं। उदाहरण के लिए, यदि मैं sqrt(x)आपके मैक्रो के साथ C में कॉल करता हूं, तो वह गणना करता है sqrt(mouse_x())और मुझे एक डबल वापस देता है। एक सच्चे कार्यात्मक प्रतिक्रियाशील प्रणाली में, sqrt(x)एक नया "दोहरा समय" लौटाएगा। यदि आप एक FR सिस्टम को अनुकरण करने की कोशिश कर रहे थे, तो आपको #defineमैक्रोज़ के पक्ष में चर को बंद करने की बहुत आवश्यकता होगी। FR सिस्टम आम तौर पर केवल सामान की पुनर्गणना करता है जब उसे पुनर्गणना करने की आवश्यकता होती है, जबकि मैक्रोज़ का उपयोग करने का मतलब होगा कि आप सब कुछ का पुनर्मूल्यांकन कर रहे हैं, सब कुछ सबएक्सप्रेस के नीचे।

— लॉरेंस गोंसाल्वेस

"कई प्रकार के सॉफ़्टवेयर के लिए (उदाहरण के लिए, उपयोगकर्ता सहभागिता के साथ कुछ भी) साइड-इफ़ेक्ट कुछ स्तर पर आवश्यक हैं।" और शायद कार्यान्वयन स्तर पर ही। शुद्ध, आलसी कार्यात्मक प्रोग्रामिंग के कार्यान्वयन में बहुत सारे दुष्प्रभाव हैं, और प्रतिमान की सफलताओं में से एक उन प्रभावों को प्रोग्रामिंग मॉडल से बाहर रखना है। कार्यात्मक उपयोगकर्ता इंटरफेस में मेरे अपने सुझाव बताते हैं कि उन्हें पूरी तरह से साइड-इफ़ेक्ट के बिना भी प्रोग्राम किया जा सकता है।

— कॉनल

@tieTYT x को कभी भी पुन: असाइन / उत्परिवर्तित नहीं किया गया है। x का मान समय के साथ मूल्यों का अनुक्रम है। इसे देखने का एक और तरीका यह है कि x के बजाय एक "सामान्य" मान है, एक संख्या की तरह, x का मान (वैचारिक रूप से) एक फ़ंक्शन है जो पैरामीटर के रूप में समय लेता है। (यह एक ओवरसाइम्प्लिफिकेशन का एक सा है। आप समय मान नहीं बना सकते हैं जो आपको माउस स्थिति की चीजों के भविष्य की भविष्यवाणी करने की अनुमति देगा।)

— लॉरेंस गोंसाल्वेस

Answer 3

अपने प्रोग्राम की कल्पना करना क्या है, इसके बारे में पहले अंतर्ज्ञान तक पहुंचने का एक आसान तरीका एक स्प्रेडशीट है और आपके सभी चर सेल हैं। यदि किसी स्प्रेडशीट में कोई भी सेल बदलती है, तो कोई भी सेल जो उस सेल को संदर्भित करता है, साथ ही बदल जाती है। यह FRP के साथ समान है। अब कल्पना करें कि कुछ कोशिकाएं अपने आप बदल जाती हैं (या बल्कि बाहरी दुनिया से ली गई हैं): जीयूआई स्थिति में, माउस की स्थिति एक अच्छा उदाहरण होगी।

यह जरूरी नहीं कि बहुत याद आती है। जब आप वास्तव में FRP सिस्टम का उपयोग करते हैं तो रूपक बहुत तेजी से टूट जाता है। एक के लिए, आमतौर पर असतत घटनाओं को मॉडल करने का प्रयास किया जाता है (उदाहरण के लिए माउस को क्लिक किया जा रहा है)। मैं केवल आपको यह बताने के लिए यहां डाल रहा हूं कि यह कैसा है।

Comments

एक अत्यंत उपयुक्त उदाहरण। सैद्धांतिक सामग्री होना बहुत अच्छा है, और शायद कुछ लोगों को इसका अर्थ मिलता है कि बिना किसी आधार के उदाहरण के लिए, लेकिन मुझे इसके साथ शुरू करने की आवश्यकता है जो मेरे लिए नहीं है, न कि यह क्या है। जो मुझे हाल ही में मिला (नेटफ्लिक्स द्वारा आरएक्स वार्ता से!) यह है कि आरपी (या आरएक्स, वैसे भी), इन "बदलते मूल्यों" को प्रथम श्रेणी बनाता है और आपको उनके बारे में कारण बताता है, या उन कार्यों को लिखता है जो उनके साथ काम करते हैं। यदि आप चाहें, तो स्प्रेडशीट या सेल बनाने के लिए कार्य लिखें। और यह तब संभालता है जब एक मूल्य समाप्त हो जाता है (दूर हो जाता है) और आपको स्वचालित रूप से साफ करने देता है।

— बेंजो

यह उदाहरण इवेंट-संचालित प्रोग्रामिंग और प्रतिक्रियाशील दृष्टिकोण के बीच अंतर पर जोर देता है, जहां आप सिर्फ बुद्धिमान रूटिंग का उपयोग करने के लिए निर्भरता की घोषणा करते हैं।

— किंजलोम

Answer 4

मेरे लिए यह प्रतीक के 2 अलग-अलग अर्थ हैं =:

1. गणित में x = sin(t)इसका मतलब है, कि xहै अलग नाम के लिए sin(t)। इसलिए लेखन x + yवैसा ही है जैसा कि sin(t) + y। कार्यात्मक प्रतिक्रियाशील प्रोग्रामिंग इस संबंध में गणित की तरह है: यदि आप लिखते हैं x + y, तो tइसका उपयोग उस समय के मूल्य के साथ गणना की जाती है जो इसका उपयोग करता है।
2. सी-लाइक प्रोग्रामिंग भाषाओं (अनिवार्य भाषा) में, x = sin(t)एक असाइनमेंट है: इसका मतलब है कि असाइनमेंट के समय लिए गए मूल्य कोx संग्रहीत करता है । sin(t)

Comments

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

— डिडियर ए।

गणित में x = sin(t)साधन xका मूल्य है sin(t)दी के लिए t। यह फ़ंक्शन के लिए एक अलग नाम नहीं है sin(t)। अन्यथा यह होगा x(t) = sin(t)।

— दिमित्री जैतसेव

+ दिमित्री ज़ैतसेव समान चिन्ह के गणित में कई अर्थ हैं। उनमें से एक यह है कि जब भी आप बाईं ओर देखते हैं तो आप इसे दाईं ओर स्वैप कर सकते हैं । उदाहरण के लिए 2 + 3 = 5या a**2 + b**2 = c**2।

— user712092

Answer 5

ठीक है, पृष्ठभूमि के ज्ञान और विकिपीडिया पृष्ठ को पढ़ने से लेकर जिस पर आपने ध्यान दिलाया है, ऐसा प्रतीत होता है कि प्रतिक्रियाशील प्रोग्रामिंग डेटाफ्लो कंप्यूटिंग की तरह है, लेकिन विशिष्ट बाहरी "उत्तेजनाओं" के कारण नोड्स के एक सेट को आग लगा देता है और उनकी संगणना करता है।

यह यूआई डिजाइन के लिए बहुत अच्छी तरह से अनुकूल है, उदाहरण के लिए, जिसमें एक यूजर इंटरफेस कंट्रोल (जैसे कि म्यूजिक प्ले करने वाले एप्लिकेशन पर वॉल्यूम कंट्रोल) को छूने पर विभिन्न डिस्प्ले आइटम और ऑडियो आउटपुट की वास्तविक मात्रा को अपडेट करने की आवश्यकता हो सकती है। जब आप वॉल्यूम (एक स्लाइडर, मान लेते हैं) को संशोधित करते हैं जो एक निर्देशित ग्राफ में नोड से जुड़े मूल्य को संशोधित करने के अनुरूप होगा।

उस "वॉल्यूम मान" नोड से किनारों वाले विभिन्न नोड्स को स्वचालित रूप से ट्रिगर किया जाएगा और किसी भी आवश्यक संगणना और अद्यतन स्वाभाविक रूप से आवेदन के माध्यम से लहर जाएगा। उपयोगकर्ता उत्तेजना के लिए आवेदन "प्रतिक्रिया" करता है। कार्यात्मक प्रतिक्रियाशील प्रोग्रामिंग बस एक कार्यात्मक भाषा में या आमतौर पर एक कार्यात्मक प्रोग्रामिंग प्रतिमान में इस विचार का कार्यान्वयन होगा।

"डेटाफ्लो कंप्यूटिंग" पर अधिक जानकारी के लिए, विकिपीडिया पर उन दो शब्दों की खोज करें या अपने पसंदीदा खोज इंजन का उपयोग करें। सामान्य विचार यह है: कार्यक्रम नोड्स का एक निर्देशित ग्राफ है, प्रत्येक कुछ सरल गणना करता है। ये नोड्स ग्राफ़ लिंक द्वारा एक दूसरे से जुड़े होते हैं जो कुछ नोड्स के आउटपुट दूसरों के इनपुट को प्रदान करते हैं।

जब एक नोड आग लगाता है या अपनी गणना करता है, तो इसके आउटपुट से जुड़े नोड्स में उनके संगत इनपुट "ट्रिगर" या "चिह्नित" होते हैं। किसी भी नोड में सभी इनपुट ट्रिगर / चिह्नित / उपलब्ध हैं जो स्वचालित रूप से आग लगाते हैं। ग्राफ़ को अंतर्निहित या स्पष्ट किया जा सकता है जो इस बात पर निर्भर करता है कि कैसे प्रतिक्रियाशील प्रोग्रामिंग कार्यान्वित की जाती है।

नोड्स को समानांतर में फायरिंग के रूप में देखा जा सकता है, लेकिन अक्सर उन्हें क्रमिक रूप से या सीमित समानता के साथ निष्पादित किया जाता है (उदाहरण के लिए, उन्हें निष्पादित करने वाले कुछ धागे हो सकते हैं)। एक प्रसिद्ध उदाहरण मैनचेस्टर डेटाफ्लो मशीन था , जिसने (IIRC) एक या अधिक निष्पादन इकाइयों के माध्यम से ग्राफ में नोड्स के निष्पादन को शेड्यूल करने के लिए एक टैग की गई डेटा आर्किटेक्चर का उपयोग किया था। डेटाफ्लो कंप्यूटिंग उन स्थितियों के लिए काफी उपयुक्त है, जिसमें संगणना को ट्रिगर करना संगणना के कैस्केड को जन्म देता है, एक घड़ी (या घड़ियों) द्वारा संचालित होने की कोशिश करने से बेहतर काम करता है।

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

"गैर-प्रतिक्रियाशील" प्रोग्रामिंग निष्पादन और बाहरी आदानों के संबंध के प्रवाह के एक बहुत अलग दृष्टिकोण के साथ प्रोग्रामिंग होगी। यह कुछ हद तक व्यक्तिपरक होने की संभावना है, क्योंकि लोगों को संभवतः कुछ भी कहने के लिए लुभाया जाएगा जो बाहरी आदानों के प्रति प्रतिक्रिया करता है "उन्हें"। लेकिन बात की भावना को देखते हुए, एक कार्यक्रम जो एक निश्चित अंतराल पर एक घटना कतार को प्रदूषित करता है और फ़ंक्शन (या थ्रेड्स) को मिली किसी भी घटना को कम प्रतिक्रियाशील बनाता है (क्योंकि यह केवल एक निश्चित अंतराल पर उपयोगकर्ता इनपुट में भाग लेता है)। फिर, यह यहां की बात की भावना है: एक बहुत ही निचले स्तर पर एक प्रणाली में एक तेज मतदान अंतराल के साथ एक मतदान कार्यान्वयन डालने की कल्पना कर सकता है और इसके ऊपर एक प्रतिक्रियाशील फैशन में कार्यक्रम कर सकता है।

Comments

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

— थॉमस कम्मेयर

आपने डेटा प्रवाह का उल्लेख किया है, जिससे कुछ मान IMHO जुड़ता है।

— रेनर जोसविग

यही QML का मतलब है, ऐसा लगता है;)

— mlvljr

मेरे लिए, यह उत्तर समझने में सबसे आसान था, खासकर क्योंकि "अनुप्रयोग के माध्यम से तरंग" और "संवेदी-जैसे नोड्स" जैसे प्राकृतिक एनालॉग्स का उपयोग। महान!

— अक्सेली पलन

दुर्भाग्य से, मैनचेस्टर डाटाफ्लो मशीन लिंक मृत है।

— Pac0

Answer 6

एफआरपी के बारे में कई पेज पढ़ने के बाद आखिरकार मैं एफआरपी के बारे में इस ज्ञानवर्धक लेखन के बारे में आया , इसने आखिरकार मुझे समझा कि एफआरपी वास्तव में क्या है।

मैं हेनरिक एपेलमस (प्रतिक्रियाशील केले के लेखक) के नीचे बोली लगाता हूं।

कार्यात्मक प्रतिक्रियाशील प्रोग्रामिंग का सार क्या है?

एक आम जवाब यह होगा कि "एफआरपी एक प्रणाली का वर्णन करने योग्य समय के बजाय समय-भिन्न कार्यों के संदर्भ में एक प्रणाली है", और यह निश्चित रूप से गलत नहीं होगा। यह शब्दार्थ है। लेकिन मेरी राय में, अधिक विशुद्ध रूप से संतोषजनक उत्तर निम्नलिखित विशुद्ध रूप से वाक्यगत कसौटी द्वारा दिया गया है:

कार्यात्मक प्रतिक्रियाशील प्रोग्रामिंग का सार घोषणा के समय पूरी तरह से एक मूल्य के गतिशील व्यवहार को निर्दिष्ट करना है।

उदाहरण के लिए, एक काउंटर का उदाहरण लें: आपके पास "अप" और "डाउन" लेबल वाले दो बटन हैं जिनका उपयोग काउंटर को बढ़ाने या घटाने के लिए किया जा सकता है। Imperatively, आप पहले एक प्रारंभिक मान निर्दिष्ट करेंगे और फिर जब भी कोई बटन दबाया जाता है तो उसे बदल सकते हैं; कुछ इस तरह:

counter := 0                               -- initial value
on buttonUp   = (counter := counter + 1)   -- change it later
on buttonDown = (counter := counter - 1)

मुद्दा यह है कि घोषणा के समय, काउंटर के लिए केवल प्रारंभिक मूल्य निर्दिष्ट किया गया है; काउंटर का गतिशील व्यवहार कार्यक्रम के बाकी हिस्सों में निहित है। इसके विपरीत, कार्यात्मक प्रतिक्रियाशील प्रोग्रामिंग इस तरह की घोषणा के समय पूरे गतिशील व्यवहार को निर्दिष्ट करती है:

counter :: Behavior Int
counter = accumulate ($) 0
            (fmap (+1) eventUp
             `union` fmap (subtract 1) eventDown)

जब भी आप काउंटर की गतिशीलता को समझना चाहते हैं, तो आपको केवल इसकी परिभाषा को देखना होगा। जो कुछ भी हो सकता है वह दाएं हाथ की तरफ दिखाई देगा। यह अनिवार्य दृष्टिकोण के विपरीत बहुत अधिक है जहां बाद की घोषणाएं पहले घोषित मूल्यों के गतिशील व्यवहार को बदल सकती हैं।

इसलिए, मेरी समझ में एक एफआरपी कार्यक्रम समीकरणों का एक सेट है:

j असतत है: 1,2,3,4 ...

fइस पर निर्भर करता है tकि यह बाहरी उत्तेजनाओं को मॉडल करने के लिए ओस्टेबिल्टी को शामिल करता है

कार्यक्रम के सभी राज्य को चरों में समझाया जाता है x_i

एफआरपी पुस्तकालय प्रगति समय का ध्यान रखता है, दूसरे शब्दों में, लेने के jलिए j+1।

मैं इन समीकरणों को इस वीडियो में बहुत अधिक विस्तार से समझाता हूं ।

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

मूल उत्तर के लगभग 2 साल बाद, हाल ही में मैं इस नतीजे पर पहुंचा कि FRP कार्यान्वयन का एक और महत्वपूर्ण पहलू है। उन्हें (और आमतौर पर) एक महत्वपूर्ण व्यावहारिक समस्या को हल करने की आवश्यकता है: कैश अमान्य ।

समीकरणों के लिए x_i-s एक निर्भरता ग्राफ का वर्णन करते हैं। जब x_iसमय पर कुछ परिवर्तन होते हैं jतो अन्य सभी x_i'मूल्यों को j+1अद्यतन करने की आवश्यकता नहीं होती है, इसलिए सभी निर्भरताओं को पुनर्गणना की आवश्यकता नहीं होती है क्योंकि कुछ x_i'से स्वतंत्र हो सकते हैं x_i।

इसके अलावा, x_i-s जो परिवर्तन करते हैं , उन्हें आकस्मिक रूप से अपडेट किया जा सकता है। उदाहरण के लिए के एक नक्शे के संचालन पर विचार करते हैं f=g.map(_+1)स्काला, जहां में fऔर gकर रहे हैं Listके Ints। यहाँ से fमेल खाता है x_i(t_j)और gहै x_j(t_j)। अब अगर मैं किसी तत्व को प्रस्तुत करता हूं gतो mapसभी तत्वों के लिए ऑपरेशन को अंजाम देना बेकार होगा g। कुछ एफआरपी कार्यान्वयन (उदाहरण के लिए रिफ्लेक्स- एफआरपी ) का उद्देश्य इस समस्या को हल करना है। इस समस्या को वृद्धिशील कंप्यूटिंग के रूप में भी जाना जाता है ।

दूसरे शब्दों में, x_iFRP में व्यवहार ( -s) को कैश-एड कम्प्यूटेशन के रूप में सोचा जा सकता है। एफआरपी इंजन का काम यह है कि x_iअगर वे कुछ f_iबदल जाते हैं , तो इन कैश-एस ( -s) को कुशलतापूर्वक अमान्य और पुनः स्थापित करना कार्य है।

Comments

मैं तुम्हारे साथ वहीं था जब तक तुम असतत समीकरणों के साथ नहीं गए थे । एफआरपी का संस्थापक विचार निरंतर समय था , जहां कोई " j+1" नहीं है। इसके बजाय, निरंतर समय के कार्यों के बारे में सोचें। न्यूटन के रूप में, लीबनिज और अन्य लोगों ने हमें दिखाया, इन कार्यों को अलग-अलग तरीके से वर्णन करने के लिए, ओडीई के अभिन्न और प्रणालियों का उपयोग करते हुए, इन कार्यों का वर्णन करने के लिए यह अक्सर गहरा (और "शाब्दिक अर्थ में" प्राकृतिक) होता है। अन्यथा, आप बात के बजाय एक अनुमान एल्गोरिथ्म (और एक गरीब एक) का वर्णन कर रहे हैं।

— कोन

एचटीएमएल टेम्प्लेटिंग और लेआउट भाषा लैक्सक्स एफआरपी के तत्वों को व्यक्त करता है।

@ यह मुझे आश्चर्यचकित करता है कि ओआरडी से एफआरपी अलग कैसे है। वे अलग कैसे हैं?

— jhegedus

@jhegedus उस एकीकरण में (संभवतः पुनरावर्ती, यानी, ODEs) FRP के निर्माण ब्लॉकों में से एक प्रदान करता है, संपूर्णता नहीं। एफआरपी शब्दावली का हर तत्व (एकीकरण तक सीमित नहीं है) ठीक निरंतर समय के संदर्भ में समझाया गया है। क्या वह स्पष्टीकरण मदद करता है?

— कोनल

Answer 7

कॉनल इलियट ( प्रत्यक्ष पीडीएफ , 233 केबी) द्वारा सरल रूप से कुशल कार्यात्मक प्रतिक्रिया वाला पेपर काफी अच्छा परिचय है। संबंधित पुस्तकालय भी काम करता है।

कागज अब एक और कागज, पुश-पुल कार्यात्मक प्रतिक्रियाशील प्रोग्रामिंग ( प्रत्यक्ष पीडीएफ , 286 केबी) द्वारा सुपरक्यूट किया गया है ।

Answer 8

अस्वीकरण: मेरा उत्तर rx.js के संदर्भ में है - जावास्क्रिप्ट के लिए एक 'प्रतिक्रियाशील प्रोग्रामिंग' लाइब्रेरी।

कार्यात्मक प्रोग्रामिंग में, संग्रह के प्रत्येक आइटम के माध्यम से पुनरावृत्ति करने के बजाय, आप संग्रह के लिए उच्च आदेश फ़ंक्शन (HoFs) लागू करते हैं। तो एफआरपी के पीछे का विचार यह है कि प्रत्येक व्यक्तिगत घटना को संसाधित करने के बजाय, घटनाओं की एक धारा बनाएं (एक अवलोकन योग्य के साथ कार्यान्वित) और इसके बजाय HoFs को लागू करें। इस तरह आप सिस्टम को डेटा पाइपलाइन के रूप में कल्पना कर सकते हैं जो प्रकाशकों को ग्राहकों से जोड़ रहा है।

एक अवलोकन योग्य उपयोग करने के प्रमुख लाभ हैं:
i) यह आपके कोड से राज्य को दूर करता है, उदाहरण के लिए, यदि आप चाहते हैं कि ईवेंट हैंडलर केवल प्रत्येक 'n' इवेंट के लिए निकाल दिया जाए, या पहले 'n' ईवेंट के बाद फायरिंग रोक दें; या पहले 'एन' इवेंट्स के बाद ही फायरिंग शुरू करें, आप बस काउंटरों को सेट करने, अपडेट करने और चेक करने के बजाय HoFs (फ़िल्टर, टेक यूटिल, क्रमशः छोड़ें) का उपयोग कर सकते हैं।
ii) यह कोड इलाके को बेहतर बनाता है - यदि आपके पास घटक के राज्य को बदलने वाले 5 अलग-अलग ईवेंट हैंडलर हैं, तो आप उनके वेधशालाओं को मर्ज कर सकते हैं और मर्ज किए गए ऑब्जर्वेबल पर एक ईवेंट हैंडलर को परिभाषित कर सकते हैं, प्रभावी रूप से 5 ईवेंट हैंडलर्स को 1 में जोड़ सकते हैं। यह बहुत अच्छा है। आपके संपूर्ण सिस्टम में कौन-सी ईवेंट्स किसी घटक को प्रभावित कर सकती हैं, इसके बारे में जानना आसान है, क्योंकि यह सभी एक ही हैंडलर में मौजूद है।

• एक ऑब्जर्वेबल एक Iterable का दोहरी है।

एक Iterable एक आलसी भस्म अनुक्रम है - प्रत्येक आइटम को पुनरावृत्त द्वारा खींचा जाता है जब भी वह इसका उपयोग करना चाहता है, और इसलिए गणना उपभोक्ता द्वारा संचालित होती है।

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

Comments

एक नमूदार और iterables से इसके भेदभाव की सीधी परिभाषा के लिए बहुत बहुत धन्यवाद । मुझे लगता है कि एक सच्ची समझ हासिल करने के लिए एक प्रसिद्ध अवधारणा के साथ एक जटिल अवधारणा की तुलना करना अक्सर बहुत सहायक होता है।

"तो एफआरपी के पीछे का विचार यह है कि प्रत्येक व्यक्तिगत घटना को संसाधित करने के बजाय, घटनाओं की एक धारा बनाएं (एक नमूदार * के साथ कार्यान्वित) और इसके बजाय HoFs को लागू करें।" मुझसे गलती हो सकती है, लेकिन मेरा मानना ​​है कि यह वास्तव में FRP नहीं है, बल्कि ऑब्जर्वर डिज़ाइन पैटर्न पर एक अच्छा अमूर्त है जो HoF के माध्यम से कार्यात्मक संचालन की अनुमति देता है (जो महान है!) जबकि अभी भी अभिप्रेत कोड के साथ उपयोग करने का इरादा है। इस विषय पर चर्चा - lambda-the-ultimate.org/node/4982

— nqe

Answer 9

यार, यह एक शानदार विचार है! 1998 में मुझे इस बारे में पता क्यों नहीं चला? वैसे भी, यहाँ फ्रैंक ट्यूटोरियल की मेरी व्याख्या है । सुझावों का सबसे अधिक स्वागत है, मैं इसके आधार पर एक गेम इंजन शुरू करने के बारे में सोच रहा हूं।

import pygame
from pygame.surface import Surface
from pygame.sprite import Sprite, Group
from pygame.locals import *
from time import time as epoch_delta
from math import sin, pi
from copy import copy

pygame.init()
screen = pygame.display.set_mode((600,400))
pygame.display.set_caption('Functional Reactive System Demo')

class Time:
    def __float__(self):
        return epoch_delta()
time = Time()

class Function:
    def __init__(self, var, func, phase = 0., scale = 1., offset = 0.):
        self.var = var
        self.func = func
        self.phase = phase
        self.scale = scale
        self.offset = offset
    def copy(self):
        return copy(self)
    def __float__(self):
        return self.func(float(self.var) + float(self.phase)) * float(self.scale) + float(self.offset)
    def __int__(self):
        return int(float(self))
    def __add__(self, n):
        result = self.copy()
        result.offset += n
        return result
    def __mul__(self, n):
        result = self.copy()
        result.scale += n
        return result
    def __inv__(self):
        result = self.copy()
        result.scale *= -1.
        return result
    def __abs__(self):
        return Function(self, abs)

def FuncTime(func, phase = 0., scale = 1., offset = 0.):
    global time
    return Function(time, func, phase, scale, offset)

def SinTime(phase = 0., scale = 1., offset = 0.):
    return FuncTime(sin, phase, scale, offset)
sin_time = SinTime()

def CosTime(phase = 0., scale = 1., offset = 0.):
    phase += pi / 2.
    return SinTime(phase, scale, offset)
cos_time = CosTime()

class Circle:
    def __init__(self, x, y, radius):
        self.x = x
        self.y = y
        self.radius = radius
    @property
    def size(self):
        return [self.radius * 2] * 2
circle = Circle(
        x = cos_time * 200 + 250,
        y = abs(sin_time) * 200 + 50,
        radius = 50)

class CircleView(Sprite):
    def __init__(self, model, color = (255, 0, 0)):
        Sprite.__init__(self)
        self.color = color
        self.model = model
        self.image = Surface([model.radius * 2] * 2).convert_alpha()
        self.rect = self.image.get_rect()
        pygame.draw.ellipse(self.image, self.color, self.rect)
    def update(self):
        self.rect[:] = int(self.model.x), int(self.model.y), self.model.radius * 2, self.model.radius * 2
circle_view = CircleView(circle)

sprites = Group(circle_view)
running = True
while running:
    for event in pygame.event.get():
        if event.type == QUIT:
            running = False
        if event.type == KEYDOWN and event.key == K_ESCAPE:
            running = False
    screen.fill((0, 0, 0))
    sprites.update()
    sprites.draw(screen)
    pygame.display.flip()
pygame.quit()

संक्षेप में: यदि प्रत्येक घटक को एक संख्या की तरह माना जा सकता है, तो पूरे सिस्टम को गणित समीकरण की तरह माना जा सकता है, है ना?

Comments

यह थोड़ा देर से है, लेकिन वैसे भी ... फ्रैग एफआरपी का उपयोग करने वाला एक खेल है ।

— arx

Answer 10

पॉल हुडक की पुस्तक, द हास्केल स्कूल ऑफ एक्सप्रेशन , न केवल हास्केल का एक अच्छा परिचय है, बल्कि यह एफआरपी पर भी काफी समय खर्च करता है। यदि आप एफआरपी के साथ शुरुआत कर रहे हैं, तो मैं आपको यह सलाह देता हूं कि एफआरपी कैसे काम करता है।

इस पुस्तक का एक नया पुनर्लेखन (रिलीज़ २०११, अद्यतन २०१४), द हस्कल स्कूल ऑफ़ म्यूज़िक भी दिखता है ।

Answer 11

पिछले उत्तरों के अनुसार, ऐसा लगता है कि गणितीय रूप से, हम केवल एक उच्च क्रम में सोचते हैं। एक मूल्य के बारे में सोच करने के बजाय x प्रकार होने एक्स , हम एक समारोह के बारे में सोच एक्स : टी → एक्स , जहां टी समय के प्रकार है, यह प्राकृतिक संख्या को पूर्णांक या सातत्य हो। अब जब हम y : = x + 1 को प्रोग्रामिंग लैंग्वेज में लिखते हैं, तो हम वास्तव में समीकरण y ( t ) = x ( t ) + 1 का अर्थ करते हैं ।

Answer 12

एक स्प्रेडशीट की तरह कार्य करता है। आमतौर पर एक घटना संचालित ढांचे के आधार पर।

सभी "प्रतिमानों" के साथ, यह नयापन बहस का विषय है।

अभिनेताओं के वितरित प्रवाह नेटवर्क के मेरे अनुभव से, यह नोड्स के नेटवर्क पर राज्य की स्थिरता की एक सामान्य समस्या का आसानी से शिकार हो सकता है अर्थात आप बहुत सारे दोलन और अजीब छोरों में फंसने के साथ समाप्त होते हैं।

यह कुछ शब्दार्थों के रूप में संदर्भित लूप या प्रसारण से बचने के लिए कठिन है, और काफी अराजक हो सकता है क्योंकि अभिनेताओं का नेटवर्क कुछ अप्रत्याशित स्थिति पर परिवर्तित (या नहीं) करता है।

इसी तरह, कुछ राज्य अच्छी तरह से परिभाषित किनारों होने के बावजूद नहीं पहुंच सकते हैं, क्योंकि वैश्विक राज्य समाधान से दूर हो जाते हैं। 2 + 2 हो सकता है या नहीं हो सकता है 2 के 2 के आधार पर 4 हो सकता है, और क्या वे इस तरह से रुके थे। स्प्रैडशीट में सिंक्रोनस क्लॉक और लूप डिटेक्शन होता है। वितरित अभिनेता आम तौर पर नहीं करते हैं।

सभी अच्छे मजाक :)।

Answer 13

मुझे एफआरपी के बारे में क्लोजर सब्रेडिट पर यह अच्छा वीडियो मिला। यह समझना बहुत आसान है, भले ही आप क्लोजर न जानते हों।

यहां देखें वीडियो: http://www.youtube.com/watch?v=nket0K1RXU4

यहां वीडियो स्रोत को दूसरी छमाही में देखें: https://github.com/Cicayda/yolk-examples/blob/master/src/yolk_examples/client/autocomplete.cljs

Answer 14

आंद्रे स्टाल्ट्ज का यह लेख मैंने अब तक देखा सबसे अच्छा और स्पष्ट विवरण है।

लेख के कुछ उद्धरण:

रिएक्टिव प्रोग्रामिंग अतुल्यकालिक डेटा धाराओं के साथ प्रोग्रामिंग है।

उसके शीर्ष पर, आपको उन धाराओं में से किसी को संयोजित करने, बनाने और फ़िल्टर करने के लिए फ़ंक्शंस का एक अद्भुत टूलबॉक्स दिया जाता है।

यहाँ शानदार आरेखों का एक उदाहरण दिया गया है जो लेख का एक हिस्सा हैं:

Answer 15

यह समय के साथ गणितीय डेटा परिवर्तनों (या समय की अनदेखी) के बारे में है।

कोड में इसका मतलब कार्यात्मक शुद्धता और घोषणात्मक प्रोग्रामिंग है।

राज्य कीड़े मानक अनिवार्य प्रतिमान में एक बड़ी समस्या हैं। कार्यक्रमों के निष्पादन में विभिन्न बिट्स कोड अलग-अलग "समय" पर कुछ साझा स्थिति को बदल सकते हैं। इससे निपटना कठिन है।

एफआरपी में आप वर्णन करते हैं (जैसे कि घोषणात्मक प्रोग्रामिंग में) कैसे डेटा एक राज्य से दूसरे में बदल जाता है और क्या ट्रिगर करता है। यह आपको समय को नजरअंदाज करने की अनुमति देता है क्योंकि आपका कार्य केवल इसकी जानकारी पर प्रतिक्रिया कर रहा है और एक नया बनाने के लिए अपने वर्तमान मूल्यों का उपयोग कर रहा है। इसका मतलब है कि राज्य परिवर्तन नोड्स के ग्राफ (या पेड़) में निहित है और कार्यात्मक रूप से शुद्ध है।

यह व्यापक रूप से जटिलता और डिबगिंग समय को कम करता है।

एक कार्यक्रम में गणित में ए = बी + सी और ए = बी + सी के बीच अंतर के बारे में सोचो। गणित में आप एक ऐसे रिश्ते का वर्णन कर रहे हैं जो कभी नहीं बदलेगा। एक कार्यक्रम में, इसका कहना है कि "अभी है" ए + बी + सी है। लेकिन अगला कमांड B ++ हो सकता है जिस स्थिति में A B + C के बराबर नहीं है। गणित या घोषणात्मक प्रोग्रामिंग में A हमेशा B + C के बराबर होगा, चाहे आप किसी भी समय पूछें।

इसलिए समय के साथ साझा राज्य की जटिलताओं को हटाकर और मूल्यों को बदलते हुए। आप कार्यक्रम के बारे में तर्क करना बहुत आसान है।

एक EventStream एक EventStream + कुछ परिवर्तन फ़ंक्शन है।

एक व्यवहार एक घटना है + स्मृति में कुछ मूल्य।

जब ईवेंट फायर होता है तो ट्रांसफ़ॉर्मेशन फंक्शन चलाकर वैल्यू को अपडेट किया जाता है। यह उत्पन्न करने वाला मान व्यवहार मेमोरी में संग्रहीत होता है।

व्यवहारों को नए व्यवहारों के निर्माण के लिए तैयार किया जा सकता है जो एन अन्य व्यवहारों में परिवर्तन हैं। यह रचित मान इनपुट घटनाओं (व्यवहार) आग के रूप में पुनर्गणना करेगा।

"चूंकि पर्यवेक्षक स्टेटलेस हैं, इसलिए अक्सर हमें स्टेट मशीन का अनुकरण करने के लिए उनमें से कई की आवश्यकता होती है जैसा कि ड्रैग उदाहरण में है। हमें उस राज्य को बचाना होगा जहां यह सभी शामिल पर्यवेक्षकों के लिए सुलभ है जैसे ऊपर चर मार्ग में।"

उद्धरण - ऑब्जर्वर पैटर्न को दर्शाते हुए http://infoscience.epfl.ch/record/148043/files/DeprecatingObserversTR2010.pdf

Comments

यह बिल्कुल ऐसा है कि मैं घोषित प्रोग्रामिंग के बारे में कैसा महसूस करता हूं, और आप सिर्फ मेरे से बेहतर विचार का वर्णन करते हैं।

— neevek

Answer 16

प्रतिक्रियाशील प्रोग्रामिंग के बारे में संक्षिप्त और स्पष्ट विवरण Cyclejs पर दिखाई देता है - प्रतिक्रियाशील प्रोग्रामिंग , यह सरल और दृश्य नमूनों का उपयोग करता है।

एक [मॉड्यूल / घटक / वस्तु] प्रतिक्रियाशील है इसका मतलब यह बाहरी घटनाओं पर प्रतिक्रिया करके अपने स्वयं के राज्य के प्रबंधन के लिए पूरी तरह से जिम्मेदार है।

इस दृष्टिकोण का क्या लाभ है? यह नियंत्रण का उलटा है , मुख्य रूप से क्योंकि [मॉड्यूल / घटक / वस्तु] स्वयं के लिए जिम्मेदार है, सार्वजनिक लोगों के खिलाफ निजी तरीकों का उपयोग करके इनकैप्सुलेशन में सुधार करता है।

यह एक अच्छा स्टार्टअप पॉइंट है, नॉलेज का पूरा स्रोत नहीं है। वहां से आप अधिक जटिल और गहरे कागजों पर कूद सकते हैं।

Answer 17

.NET के लिए Rx, रिएक्टिव एक्सटेंशन्स देखें। वे बताते हैं कि IEnumerable के साथ आप मूल रूप से एक धारा से 'खींच' रहे हैं। IQueryable / IEnumerable पर Linq क्वेरीज़ एक सेट से परिणाम को 'चूसना' करने वाले ऑपरेशन हैं। लेकिन IObservable पर एक ही ऑपरेटर के साथ आप Linq प्रश्नों को लिख सकते हैं जो 'प्रतिक्रिया' करता है।

उदाहरण के लिए, आप एक Linq क्वेरी लिख सकते हैं जैसे (m से MyObservableSetOfMouseMovements में जहाँ mX <100 और mY <100 नए बिंदु (mX, mY) का चयन करें)।

और आरएक्स एक्सटेंशन के साथ, यह है: आपके पास यूआई कोड है जो माउस आंदोलनों की आने वाली धारा पर प्रतिक्रिया करता है और जब भी आप 100,100 बॉक्स में होते हैं, तब ...

Answer 18

एफआरपी फंक्शनल प्रोग्रामिंग (हर चीज के विचार पर बनाया गया प्रोग्रामिंग प्रतिमान) का एक संयोजन है और प्रतिक्रियाशील प्रोग्रामिंग प्रतिमान (इस विचार पर निर्मित कि सब कुछ एक स्ट्रीम (ऑब्जर्वर और ऑब्जर्वेबल दर्शन) है)। यह दुनिया का सबसे अच्छा माना जाता है।

शुरू करने के लिए प्रतिक्रियाशील प्रोग्रामिंग पर आंद्रे स्टाल्ट्ज़ पोस्ट देखें।