हास्केल में निरंतरता

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

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

निरंतरता शैली प्रोग्रामिंग

शुरू करने के लिए, आइए देखें कि निरंतरता की शैली में निरंतरता और प्रोग्रामिंग क्या हैं।

सामान्य कार्य:

square :: Int -> Int
square x = x*x

incr :: Int -> Int
incr x = x+1

func :: Int -> Int
func x = square (incr x)

और अब सीक्वल की शैली में:

 square_cps :: Int -> (Int -> r) -> r square_cps xk = k (x*x) incr_cps :: Int -> (Int -> r) -> r incr_cps xk = k (x+1) func_cps :: Int -> (Int -> r) -> r func_cps xk = incr_cps x $ \inc -> square_cps inc $ \sq -> k sq 

अब फ़ंक्शन, स्वयं तर्कों के अलावा, फ़ंक्शन के लिए एक इनपुट लेते हैं जिसे परिणाम पर लागू किया जाएगा। यह एक निरंतरता है।
निरंतरताओं की मदद से, हम फ़ंक्शन कनेक्ट कर सकते हैं, जो कि func_cps में होता है। सबसे पहले, incr_cps को incr_cps , और इसके परिणाम "निरंतरता" (\inc -> ...) में square_cps है, फिर square_cps जिसका परिणाम निरंतरता (\sq -> ...) को दिया जाता है, जो अंत में सबसे बाहरी निरंतरता k को दिया जाता है।

यहाँ निरंतरता प्रकार (Int -> r) क्योंकि यह आवश्यक नहीं है कि निरंतरता Int वापस आएगी।
उदाहरण के लिए, परिणाम को कंसोल पर प्रिंट करने के लिए, हम print को एक निरंतरता के रूप में पास कर सकते हैं:

main = func_cps 5 print

मोनाद कंट

आप सीक्वेल की शैली में कुछ पैटर्न देख सकते हैं।
उदाहरण के लिए, सरल कार्य, जैसे कि square_cps और incr_cps , हमने एक समान तरीके से घोषित किया:

function ... = \k -> k (...)

और हमने उन्हें इस तरह से जोड़ा:

 fun1 ... $ \r1 -> fun2 ... $ \r2 -> ... 

यह सब हमें भिक्षुओं की याद दिलाता है, पहला उदाहरण return समान है, और दूसरा >>= ।

हम इस रूप में मठ का परिचय देते हैं:

newtype Cont ra = Cont { runCont :: (a -> r) -> r }

लेकिन क्यों (a -> r) -> r ?
तथ्य यह है कि जब हमने निरंतरता की शैली में फ़ंक्शन लिखा था, तो प्रत्येक फ़ंक्शन ने एक अतिरिक्त पैरामीटर लिया जो गणना जारी रखता है।
यदि हम तर्कों के साथ जारी रखने की शैली में एक फ़ंक्शन को "भरें" (निरंतरता तक), तो इसका प्रकार होगा (a -> r) -> r , जहां फ़ंक्शन के परिणाम का प्रकार है, अगर हम इसे जारी रखने के लिए बिना पास लौटे हैं, और r - परिणाम के प्रकार जो निरंतरता वापस आएगी:

> :t square_cps 5
square_cps :: (Int -> r) -> r

चलिए कंट को मोनाड बनाने की कोशिश करते हैं।

 instance Monad (Cont r) where return n = Cont $ \k -> kn ... 

return n एक ऐसा कंटेंट है जो तुरंत प्राप्त होने वाले एन पर लागू होता है।

  m >>= f = Cont $ \k -> runCont m (\a -> runCont (fa) k) 

m >>= f वह runCont जो शुरू होता है ( runCont बस " runCont " कंट, फंक्शन को runCont करता है) m निरंतरता के साथ (\a -> runCont (fa) k) , जो गणना का परिणाम हो सकता है, और इसे असाइन करें (या हो सकता है) और यह नहीं मिलेगा, क्योंकि फ़ंक्शन निरंतरता को अनदेखा कर सकता है)। फिर, दूसरे कंट को प्राप्त करने के लिए f पर लागू किया जाएगा, जो कि k के सबसे बाहरी निरंतरता के साथ लॉन्च किया जाएगा।

हम अपने कार्यक्रम को मठ के उपयोग से फिर से लिखते हैं:

 square_Cont :: Int -> Cont r Int 
 square_Cont x = return (x*x) 
 
 incr_Cont :: Int -> Cont r Int 
 incr_Cont x = return (x+1) 
 
 func_Cont :: Int -> Cont r Int func_Cont x = do inc <- incr_Cont x sq <- square_Cont inc return sq 

main = runCont (func_Cont 5) print

अब सब कुछ बहुत साफ दिखता है।

कंट के साथ काम करने वाले कार्यों को आगे बढ़ाते हैं।

callCC

आइए एक सरल उदाहरण से शुरू करें:

square :: Int -> Cont r Int
square n = callCC $ \k -> k (n*n)

क्या बेकार कार्य? ऐसा लगता है कि यह कंट कंस्ट्रक्टर का पर्याय है।
लेकिन यह इतना आसान नहीं है। आइए देखें callCC के प्रकार:

callCC :: ((a -> Cont rb) -> Cont ra) -> Cont ra

वास्तव में, callCC एक फ़ंक्शन लेता है जो एक अन्य फ़ंक्शन लेता है, जैसे (a -> Cont rb) और रिटर्न Cont ra । अर्थात, k (n*n) हमारे उदाहरण में Cont r Int प्रकार का है।
मैं callCC क्या उपयोग कर सकता हूं? उदाहरण के लिए, किसी फ़ंक्शन से जल्दी से बाहर निकलने के लिए:

 import Control.Monad (when) hehe :: Int -> Cont r String hehe n = callCC $ \exit -> do let fac = product [1..n] when (n > 7) $ exit "OVER 9000" return $ show fac main = do n <- fmap read getLine runCont (hehe n) putStrLn 

चलो हमारे कार्यक्रम की कोशिश करें:

> main
3
6
> main
10
OVER 9000

यह कार्यक्रम तथ्य की गणना करता है, और अगर यह 9000 से अधिक निकला, तो यह "OVER 9000" संदेश लौटाता है, और यदि नहीं, तो बस इसका मूल्य।
यहां हमने exit उपयोग अनिवार्य भाषाओं में किया - उन्होंने गणना को बाधित किया और एक अलग परिणाम निकाला।

नेस्टेड कॉलसीसी ब्लॉकों का उपयोग करना भी संभव है:

 bar :: String -> Cont r String bar s = do callCC $ \exit1 -> do let ws = words s names = foldl (\ac -> a ++ ", " ++ c) (head ws) (tail ws) r' <- callCC $ \exit2 -> do when (null ws) $ exit1 "No people" when (length ws == 1) $ exit2 "There is " return "There are: " return $ r' ++ names main = do ns <- getLine runCont (bar ns) putStrLn 

आइए कोशिश करते हैं:

> main

No people
> main
Bob
There is Bob
> main
Bob Alice
There are: Bob, Alice

यदि नामों की सूची खाली है, तो हम बाहर exit1 "No people" , आंतरिक ब्लॉक के माध्यम से "कूद" कहते हैं।
यदि केवल एक व्यक्ति है, तो हम "वहाँ" का उपयोग करते हैं, यदि उनमें से बहुत सारे हैं, तो "वहाँ हैं:"।
ध्यान दें कि जब गणना कॉलसीसी ब्लॉक में वापस पहुंचती है, तो परिणाम हमेशा की तरह वापस आ जाता है।

तो callCC फ़ंक्शन कैसे callCC ? आइए देखें:

callCC f = Cont $ \k -> runCont (f (\a -> Cont $ \_ -> ka)) k

यह कंटेंट में निरंतरता की शैली में फ़ंक्शन को लपेटने के साथ, सामान्य तरीके से शुरू होता है। तब (f (\a -> Cont $ \_ -> ka)) k निरंतरता के साथ शुरू होता है।
(\a -> Cont $ \_ -> ka) एक ऐसा फंक्शन है जो कुछ लेता है और एक कॉन्ट को लौटाता है, इसकी निरंतरता को अनदेखा करता है और इसके बजाय इसका उपयोग करता है।

आइए देखें कि यह कैसे काम करता है:

square n = callCC $ \k -> k (n*n)
= Cont $ \k' -> runCont ((\k -> k (n*n)) (\a -> Cont $ \_ -> k' a)) k'
= Cont $ \k' -> runCont ((\a -> Cont $ \_ -> k' a) (n*n)) k'
= Cont $ \k' -> runCont (Cont $ \_ -> k' (n*n)) k'
= Cont $ \k' -> (\_ -> k' (n*n)) k'
= Cont $ \k' -> k' (n*n)

सब कुछ वैसा ही है जैसा हमें उम्मीद थी। अधिक जटिल मामले पर विचार करें:

 hehe :: Int -> Cont r String hehe n = callCC $ \exit -> do let fac = product [1..n] when (n > 7) $ exit "OVER 9000" return $ show fac = callCC $ \exit -> (when (n > 7) $ exit "OVER 9000") >> (return $ show (product [1..n])) --    let   = Cont $ \k -> runCont ((\exit -> (when (n > 7) $ exit "OVER 9000") >> (return $ show (product [1..n]))) (\a -> Cont $ \_ -> ka)) k = Cont $ \k -> runCont ((when (n > 7) $ (\a -> Cont $ \_ -> ka) "OVER 9000") >> (return $ show (product [1..n]))) k = Cont $ \k -> runCont ((when (n > 7) $ (Cont $ \_ -> k "OVER 9000")) >> (return $ show (product [1..n]))) k 

जब काम करता है, तो यह वापस आ जाएगा (Cont $ \_ -> k "OVER 9000") । यह कंट अपने निरंतरता का उपयोग नहीं करता है, जिसका अर्थ है कि बाकी कोड निष्पादित नहीं करेगा।

getCC

getCC और getCC' फ़ंक्शन हमें वर्तमान निरंतरता को "प्राप्त" करने और कार्यक्रम के पिछले राज्य में वापस जाने के लिए उपयोग करने की अनुमति देते हैं।
उदाहरण के लिए:

 foo :: Int -> Cont r String foo s = do (i, back) <- getCC' s when (i < 20) $ back (i*2) return $ show i 

foo अपने तर्क को तब तक दोगुना करता है जब तक कि वह 20 से अधिक या बराबर न हो जाए।

> runCont (foo 5) id
"20"
> runCont (foo 3) id
"24"
> runCont (foo 2) id
"32"

(i, back) <- getCC' s - i s i मान प्रदान करता है और इस स्थान पर एक "लिंक" बनाता है।
back (i*2) - पिछली स्थिति में लौटता है, लेकिन i i*2 बराबर।

यह सब दृढ़ता से गोटो जैसा है, हालांकि यहां हम केवल पिछले राज्यों में जा सकते हैं।

getCC' फ़ंक्शन इस तरह घोषित किया गया है:

 getCC' :: t -> Cont r (t, t -> Cont ra) getCC' x0 = callCC (\c -> let fx = c (x, f) in return (x0, f)) 

आइए इसे जानने की कोशिश करें। आइए इसे सरल करना शुरू करें:

getCC' x0 = Cont $ \k -> runCont ((\c -> let fx = c (x, f) in return (x0, f)) (\a -> Cont $ \_ -> ka)) k
= Cont $ \k -> runCont (let fx = (\a -> Cont $ \_ -> ka) (x, f) in return (x0, f)) k
= Cont $ \k -> runCont (let fx = Cont $ \_ -> k (x, f) in return (x0, f)) k
= Cont $ \k -> runCont (let fx = Cont $ \_ -> k (x, f) in Cont $ \k' -> k' (x0, f)) k
= Cont $ \k -> let fx = Cont $ \_ -> k (x, f) in k (x0, f)

f फ़ंक्शन अपने तर्क की एक जोड़ी को लागू करता है और खुद को बाहरी (getCC'shnom) निरंतरता पर लागू करता है, और इसे कंट में लपेटता है।
और k (x0, f) - तर्क getCC' से जोड़ी को लागू करता है getCC' और बाहरी निरंतरता के लिए f ।
जब हम कहीं और f कॉल करते हैं, तो यह एक getCC' लौटाता है, वर्तमान निरंतरता का उपयोग करके नहीं, बल्कि वह जो getCC' लिए चालू था। getCC' इस प्रकार, हम पिछले राज्य में वापसी करते हैं।

इसके अलावा, getCC' का एक "छोटा भाई" है - getCC , लेकिन यह केवल ContT (Cont के लिए ट्रांसफार्मर) के साथ उपयोगी है:

 import Control.Monad (when) import Control.Monad.Cont getCC :: MonadCont m => m (ma) getCC = callCC (\c -> let x = cx in return x) foo :: ContT () IO () foo = do back <- getCC liftIO $ putStr "Do you want to coninue? [y/n] " a <- liftIO $ getLine when (a == "y" || a == "Y") $ back main = runContT foo return 

> main
Do you want to coninue? [y/n] y
Do you want to coninue? [y/n] y
Do you want to coninue? [y/n] n
>

कार्यक्रम उपयोगकर्ता को "एन" जवाब देने तक जारी रखने की अनुमति मांगेगा।
इससे पता चलता है कि getCC केवल पिछली स्थिति में लौटने की अनुमति देता है, लेकिन तर्क पारित करने का अवसर नहीं देता है।

मुझे कंट का उपयोग कहाँ करना चाहिए?

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

मूल रूप से, कॉनट का उपयोग अन्य साधुओं के साथ एक ट्रांसफार्मर की तरह किया जाता है। इससे जटिल नियंत्रण संरचनाओं को बनाने और / या गणनाओं को तेज करने में आसानी होती है।

प्रयुक्त सामग्री की सूची

निरंतरता शैली
हॉकेल में गोटो
हास्केल कार्यक्रमों को तेज और छोटा बनाना