एक आवेदक फंक्शन को कई बार लागू करने के तरीके

Question

हैलो साथी हास्केलर्स।

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

λ> Just (1+) <*> (Just (1+) <*> pure 0) 
Just 2 

मैं लगातार अनुप्रयोगों के किसी भी संख्या को यह सामान्यीकरण करने के लिए चाहते हैं, तो मैं इसे एक fold के साथ क्या कर सकते हैं।

applyAppl :: Applicative f => f (a -> a) -> Int -> f a -> f a 
applyAppl f n i = foldr (<*>) i $ replicate n f 

इस परिभाषा के बाद,

λ> applyAppl (Just (1+)) 10 $ pure 0 
Just 10 

मैं एक अजीब संदेह सामान्यीकरण भी हो सकता है कि इस तरह के sequenceA या traverse के रूप में उच्च क्रम builtin अनुप्रयोगी उपकरणों में से एक के साथ किया है। यह कर सकते हैं?

(। नीचे पहले दो टिप्पणियों को ध्यान में रखना संपादित)

Answer 1

आप का उपयोग iterate सकता है:

applyAppl :: Applicative f => f (a -> a) -> Int -> f a -> f a 
applyAppl f n i = iterate (f <*>) i !! n 

GHCi में लोड किया गया:

ghci> applyAppl (Just (+1)) 10 (pure 0) 
Just 10 

मुझे यकीन है कि है नहीं कर रहा हूँ आपके कार्यान्वयन से जरूरी रूप से बेहतर है, क्योंकि मुझे संदेह है कि दोनों कार्यान्वयन अनिवार्य रूप से एक ही प्रदर्शन प्रोफ़ाइल (हालांकि मैंने इसका परीक्षण नहीं किया है) के साथ कुछ में फ्यूज किया है, लेकिन यह अलग है।

मैंने इस तरह के "iterate(!!) के साथ" स्मृतिकरण के लिए पैटर्न देखा है, इसलिए मुझे पूरा यकीन है कि, कम से कम, इसका खराब प्रदर्शन नहीं होगा।

Answer 2

शायद आप @ दाऊद युवा के जवाब के निम्नलिखित बदलाव के लिए देख रहे हैं:

foo :: Applicative f => f (a -> a) -> Int -> a -> f a 
foo f n i = fmap (($ i) . iterateN n) f 
    where iterateN n f = (!! n) . iterate f 

देने:

> foo (Just (1+)) 10 0 
Just 10 
> 

यह "अनुप्रयोगी मशीनरी" applicatives के लिए functor उदाहरण के रूप में उपयोग करता है <*> के स्पष्ट उपयोग के बिना कार्यात्मक पुनरावृत्ति और अनुप्रयोग दोनों को निष्पादित करने के लिए। मुझे यकीन नहीं है कि आप यहां और क्या उम्मीद कर रहे हैं।