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




functional-programming terminology (15)

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

  1. कार्यात्मक प्रतिक्रियाशील प्रोग्रामिंग (एफआरपी) अभ्यास में क्या मतलब है?
  2. प्रतिक्रियाशील प्रोग्रामिंग (गैर-प्रतिक्रियाशील प्रोग्रामिंग के विपरीत?) में क्या शामिल है?

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


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

मैं हेनरिक अपफेलमस (प्रतिक्रियाशील केला के लेखक) के नीचे उद्धरण देता हूं।

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

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

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

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

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 पर निर्भर करता t ताकि यह बाह्य उत्तेजना मॉडल के लिए possiblilty शामिल हो

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

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

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

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

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

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

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

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


एक स्प्रेडशीट जैसे अधिनियमों के रूप में उल्लेख किया। आमतौर पर एक घटना संचालित ढांचे के आधार पर।

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

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

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

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

सब अच्छा मज़ा :)।


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

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

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

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

यह जटिलता और डीबगिंग समय को बड़े पैमाने पर कम कर देता है।

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

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

एक इवेंटस्ट्रीम एक इवेंटस्ट्रीम + कुछ परिवर्तन समारोह है।

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

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

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

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

उद्धरण - पर्यवेक्षक पैटर्न को अस्वीकार करना http://infoscience.epfl.ch/record/148043/files/DeprecatingObserversTR2010.pdf


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

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


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

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

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

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

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

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

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

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


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

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

प्रतिक्रियाशील प्रोग्रामिंग एसिंक्रोनस डेटा स्ट्रीम के साथ प्रोग्रामिंग है।

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

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


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

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

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


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

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

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

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


.NET के लिए आरएक्स, प्रतिक्रियाशील एक्सटेंशन देखें। वे इंगित करते हैं कि IENumerable के साथ आप मूल रूप से एक स्ट्रीम से 'खींच' रहे हैं। IQueryable / IEnumerable पर लिंक प्रश्न सेट हैं जो सेट को परिणामों से 'चूसते हैं'। लेकिन IOervervable पर एक ही ऑपरेटरों के साथ आप लिंक प्रतिक्रियाएं लिख सकते हैं जो 'प्रतिक्रिया' करते हैं।

उदाहरण के लिए, आप एक लिंक क्वेरी लिख सकते हैं (एम से MyObservableSetOfMouseMovements जहां एमएक्स <100 और एमवाई <100 नया प्वाइंट (एमएक्स, एमवाई) चुनें)।

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


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

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

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

  • एक पर्यवेक्षक एक इटरटेबल का दोहरी है।

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

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


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

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

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

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


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


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

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

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

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

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

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

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

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

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

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

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

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

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


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

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







frp