प्रतिक्रियाशील प्रोग्रामिंग

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

इस आलेख के बाकी ने मान लिया कि पाठक फंक्शनलर्स से परिचित है। यदि यह मामला नहीं है, तो मैं अत्यधिक अनुशंसा करता हूं कि आप अपने आप को उनके साथ परिचित करें, क्योंकि पूरे लेख की समझ इस पर निर्भर करती है।

मुख्य विचार

FRP में दो नए डेटा प्रकार दिखाई देते हैं: ईवेंट और बिहेवियर । ये दोनों प्रकार के फंक्शनलर्स हैं, और उन पर कई कार्य फंक्शंस के कॉम्बिनेटरों द्वारा किए जाएंगे। हम इन प्रकारों का वर्णन करते हैं।

घटना

घटना घटनाओं की एक धारा है जिसमें एक सटीक समय टिकट होता है। इसकी कल्पना की जा सकती है (सिर्फ कल्पना करें, क्योंकि वास्तव में सब कुछ इतना सरल नहीं है):

type Event a = [(Time, a)] 

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

 ("Wellcome, " ++) <$> eusers 

उन उपयोगकर्ताओं से अभिवादन की एक धारा बनाएंगे, जिन्होंने चैट में प्रवेश किया है।

व्यवहार

व्यवहार का अर्थ है एक मूल्य जो समय के साथ बदलता है।

 type Behavior a = Time -> a 

यह प्रकार गेम ऑब्जेक्ट्स के लिए अच्छी तरह से अनुकूल है, हमारे खेल में सांप व्यवहार होगा।
हम लागू फ़ंक्शन के साथ व्यवहार और घटना को जोड़ सकते हैं:

 apply :: Behavior t (a -> b) -> Event ta -> Event tb apply bf ex = [(time, bf time x) | (time, x) <- ex] 

जैसा कि आप इस परिभाषा से देख सकते हैं, लागू होता है व्यवहार के अंदर फ़ंक्शन को लागू करता है, समय को ध्यान में रखते हुए।

हम सीधे सांप के पास जाते हैं।

खेल यांत्रिकी

अभी के लिए, प्रतिक्रियाशील प्रोग्रामिंग के बारे में भूल जाओ और खेल के यांत्रिकी को ले लो। शुरुआत के लिए, प्रकार:

 module Snake where type Segment = (Int, Int) type Pos = (Int, Int) type Snake = [Segment] 

सांप का एक खंड निर्देशांक की एक जोड़ी है, और सांप ही इन खंडों की एक श्रृंखला है। टाइप पोज़ केवल सुविधा के लिए है।

 startingSnake :: Snake startingSnake = [(10, 0), (11, 0), (12, 0)] wdth = 64 hdth = 48 

साँप की प्रारंभिक स्थिति और खेल के मैदान के आकार के लिए स्थिर बनाएं।

 moveTo :: Pos -> Snake -> Snake moveTo hs = if h /= head s then h : init s else s keepMoving :: Snake -> Snake keepMoving s = let (x, y) = head s (x', y') = s !! 1 in moveTo (2*x - x', 2*y - y') s ifDied :: Snake -> Bool ifDied s@((x, y):_) = x<0 || x>=wdth || y<0 || y>=hdth || head s `elem` tail s 

MoveTo फ़ंक्शन साँप को निर्दिष्ट स्थान पर ले जाता है, KeepMoving चलता रहता है, और ifDied जाँच करता है कि साँप स्वयं खाने से मर गया है या सीमाओं के साथ टकरा गया है।
यह वह जगह है जहां यांत्रिकी समाप्त होती है, अब सबसे कठिन हिस्सा आगे है - व्यवहार का तर्क।

तर्क

हम आवश्यक मॉड्यूल कनेक्ट करेंगे और कुछ स्थिरांक का वर्णन करेंगे:

 {-# LANGUAGE ScopedTypeVariables #-} import Control.Monad (when) import System.IO import System.Random import Graphics.UI.SDL as S hiding (flip) import Graphics.Rendering.OpenGL hiding (Rect, get) import Reactive.Banana as R import Data.Word (Word32) import Snake screenWidth = wdth*10 screenHeight = hdth*10 screenBpp = 32 ticks = 1000 `div` 20 

स्क्रीनविद, स्क्रीनहाइट - स्क्रीन की चौड़ाई और ऊँचाई, क्रमशः, टिक - मिलीसेकंड की संख्या जिसके द्वारा फ्रेम स्क्रीन पर टिका रहेगा।

अब चलिए इनपुट्स पर फैसला करते हैं। बाहरी दुनिया से, केवल दो घटनाएं हमारे पास आएंगी: एक कुंजी प्रेस और एक घड़ी संकेत। इसलिए हमें घटनाओं के लिए केवल दो "स्लॉट" की जरूरत है और वे newAddHandler फ़ंक्शन द्वारा बनाए गए हैं:

 main :: IO () main = withInit [InitEverything] $ do initScreen sources <- (,) <$> newAddHandler <*> newAddHandler network <- compile $ setupNetwork sources actuate network eventLoop sources network 

SetupNetwork में, इवेंट और व्यवहार का एक "नेटवर्क" बनाया जाएगा, संकलन NetworkNescription को EventNetwork में संकलित करेगा, और इसे लॉन्च करेगा। ईवेंट रिसेपर्स से मस्तिष्क को सिग्नल की तरह, ईवेंटब्लूप फ़ंक्शन से नेटवर्क को भेजा जाएगा।

 eventLoop :: (EventSource SDLKey, EventSource Word32) -> EventNetwork -> IO () eventLoop (essdl, estick) network = loop 0 Nothing where loop lt k = do s <- pollEvent t <- getTicks case s of (KeyDown (Keysym key _ _)) -> loop t (Just key) NoEvent -> do maybe (return ()) (fire essdl) k fire estick t loop t Nothing _ -> when (s /= Quit) (loop tk) 

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

यहाँ, वैसे, EventSource से संक्रमण है, जो AddAandler में, NewAddHandler देता है:

 type EventSource a = (AddHandler a, a -> IO ()) addHandler :: EventSource a -> AddHandler a addHandler = fst fire :: EventSource a -> a -> IO () fire = snd 

अब सबसे महत्वपूर्ण भाग शुरू करते हैं: घटनाओं के नेटवर्क का वर्णन।

 setupNetwork :: forall t. (EventSource SDLKey, EventSource Word32) -> NetworkDescription t () setupNetwork (essdl, estick) = do -- Keypress and tick events esdl <- fromAddHandler (addHandler essdl) etick <- fromAddHandler (addHandler estick) 

सबसे पहले हमें उन टाइमर और कीबोर्ड ईवेंट से इवेंट मिलते हैं, जिन्हें हमने इवेंटऑलॉप में निकाल दिया था।

 let ekey = filterE (flip elem [SDLK_DOWN, SDLK_UP, SDLK_LEFT, SDLK_RIGHT]) esdl moveSnake :: SDLKey -> Snake -> Snake moveSnake ks = case k of SDLK_UP -> moveTo (x, y-1) s SDLK_DOWN -> moveTo (x, y+1) s SDLK_LEFT -> moveTo (x-1, y) s SDLK_RIGHT -> moveTo (x+1, y) s where (x, y) = head s 

अब एक ऐसी घटना बनाते हैं जिसका अर्थ है कि तीर को दबाते हुए - हमें अन्य कुंजियों की आवश्यकता नहीं है। जैसा कि आप शायद पहले से ही अनुमान लगा चुके हैं, फ़िल्टरE उन घटनाओं को फ़िल्टर करता है जो विधेय को संतुष्ट नहीं करती हैं। MoveSnake केवल दबाए गए साँप के आधार पर साँप को हिलाता है।

 brandom <- fromPoll randomFruits -- Snake let bsnake :: Behavior t Snake bsnake = accumB startingSnake $ (const startingSnake <$ edie) `union` (moveSnake <$> ekey) `union` (keepMoving <$ etick) `union` ((\s -> s ++ [last s]) <$ egot) edie = filterApply ((\s _ -> ifDied s) <$> bsnake) etick 

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

 accumB :: a -> Event t (a -> a) -> Behavior ta 

यही है, मोटे तौर पर, जब कोई घटना होती है, तो उसके अंदर का फ़ंक्शन वर्तमान मूल्य पर लागू किया जाएगा।
उदाहरण के लिए:

 accumB "x" [(time1,(++"y")),(time2,(++"z"))] 

एक व्यवहार बनाएगा, जो time1 पर "xy" को अपने आप में रखेगा, और time2 - "xyz" पर।
हमारे लिए एक और समारोह अज्ञात है। यह घटनाओं को एक में जोड़ता है (यदि दो घटनाएं एक साथ हुईं, तो संघ पहले तर्क के लिए प्राथमिकता देता है)।
अब हम समझ सकते हैं कि bsnake कैसे काम करता है। सबसे पहले, साँप शुरू करने के बराबर है, और फिर इसके साथ कई परिवर्तन होते हैं:

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

सांप के मृत होने पर ईडी की घटना को निकाल दिया जाता है, और इसे फ़िल्टरएप्ली का उपयोग करके हासिल किया जाता है:

 filterApply :: Behavior t (a -> Bool) -> Event ta -> Event ta 

यह फ़ंक्शन उन घटनाओं को अनसुना करता है जो व्यवहार के अंदर विधेय को संतुष्ट नहीं करते हैं। जैसा कि नाम से पता चलता है, यह कुछ ऐसा है जैसे फ़िल्टर + लागू करें।
ध्यान दें कि हम कितनी बार किसी कार्य को करने के लिए कॉम्बिनेटरियल फंक्शनलर्स का उपयोग करते हैं।

अब फल पर चलते हैं:

 -- Fruits bfruit :: Behavior t Pos bfruit = stepper (hdth `div` 2, wdth `div` 2) (brandom <@ egot) egot = filterApply ((\fsr _ -> elem fs && notElem rs) <$> bfruit <*> bsnake <*> brandom) etick 

ब्रैंडोम में निर्देशांक के साथ एक नया फल दिखाई देता है जैसे ही सांप ने वर्तमान को इकट्ठा किया है। कॉम्बिनेटर <@ "ईवेंट के लिए एक व्यवहार की सामग्री" को स्थानांतरित करता है, अर्थात्, इस मामले में, ईगॉट घटना की सामग्री को ब्रैंडम से यादृच्छिक समन्वय द्वारा प्रतिस्थापित किया जाएगा। स्टेपर फंक्शन, हमारे लिए नया, ईवेंट्स और शुरुआती मूल्य से व्यवहार बनाता है, और संचय से इसका एकमात्र अंतर यह है कि नया व्यवहार ईवेंट पिछले पर निर्भर नहीं करेगा।
अहंकार घटना उस टाइमर सिग्नल पर शुरू होती है जब सांप ने फल एकत्र किया है और एक नया फल उसके शरीर में प्रवेश नहीं करता है।

 -- Counter ecount = accumE 0 $ ((+1) <$ egot) `union` ((const 0) <$ edie) 

ecount बढ़ते हुए बिंदुओं की एक घटना है। जैसा कि आप अनुमान लगा सकते हैं, एक घटना एक व्यवहार बनाता है, न कि एक व्यवहार। काउंटर को ईगो इवेंट में एक-एक करके बढ़ाया जाएगा, और एडी पर शून्य किया जाएगा।

 let edraw = apply ((,,) <$> bsnake <*> bfruit) etick 

edraw को हर टाइमर सिग्नल पर ट्रिगर किया जाता है, और इसमें साँप और फल की वर्तमान स्थिति होती है।

अब मामला छोटा है: स्क्रीन पर छवि प्रदर्शित करें।

 reactimate $ fmap drawScreen edraw reactimate $ fmap (flip setCaption [] . (++) "Snake. Points: " . show) ecount 

प्रतिक्रियाशील फ़ंक्शन किसी ईवेंट से एक IO कार्रवाई को निकालता है। ड्रास्क्रीन स्क्रीन खींचता है, और सेटकैप्शन विंडो का नाम बदलता है।
यह setupNetwork पूरा करता है, और हम केवल लापता फ़ंक्शन जोड़ सकते हैं।
स्क्रीन आरंभीकरण:

 initScreen = do glSetAttribute glDoubleBuffer 1 screen <- setVideoMode screenWidth screenHeight screenBpp [OpenGL] setCaption "Snake. Points: 0" [] clearColor $= Color4 0 0 0 0 matrixMode $= Projection loadIdentity ortho 0 (fromIntegral screenWidth) (fromIntegral screenHeight) 0 (-1) 1 matrixMode $= Modelview 0 loadIdentity 

रैंडम स्थिति जनरेटर:

 randomFruits :: IO Pos randomFruits = (,) <$> (randomRIO (0, wdth-1)) <*> (randomRIO (0, hdth-1)) 

ठीक है, अंत में, प्रतिपादन कार्य:

 showSquare :: (GLfloat, GLfloat, GLfloat, GLfloat) -> Pos -> IO () showSquare (r, g, b, a) (x, y) = do -- Move to offset translate $ Vector3 (fromIntegral x*10 :: GLfloat) (fromIntegral y*10) 0 -- Start quad renderPrimitive Quads $ do -- Set color color $ Color4 rgba -- Draw square vertex $ Vertex3 (0 :: GLfloat) 0 0 vertex $ Vertex3 (10 :: GLfloat) 0 0 vertex $ Vertex3 (10 :: GLfloat) 10 0 vertex $ Vertex3 (0 :: GLfloat) 10 0 loadIdentity showFruit :: Pos -> IO () showFruit = showSquare (0, 1, 0, 1) showSnake :: Snake -> IO () showSnake = mapM_ (showSquare (1, 1, 1, 1)) drawScreen (s, f, t) = do clear [ColorBuffer] showSnake s showFruit f glSwapBuffers t' <- getTicks when ((t'-t) < ticks) (delay $ ticks - t' + t) 

वह सब है। संकलन के लिए आपको आवश्यकता होगी: प्रतिक्रियाशील-केला, ओपेंग्ल, एसडीएल। यहां से आप प्रोग्राम की सोर्स फाइल्स डाउनलोड कर सकते हैं: minus.com/mZyZpD4Hx/1f

निष्कर्ष

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

संदर्भ

hackage.haskell.org/package/reactive-banana - हैक पर प्रतिक्रियाशील-केला
github.com/HeinrichApfelmus/reactive-banana - github पर प्रोजेक्ट रिपॉजिटरी। इसके उदाहरण हैं।