आवेदक functors के लिए प्रोग्रामिंग अभ्यास कहां मिलना है?

Question

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

व्यक्तिगत अभ्यास ठीक है जैसे कहीं और सूचीबद्ध अभ्यासों के पॉइंटर्स हैं।

Answer 1

कुछ प्रश्नों को उत्तर के रूप में पोस्ट करने में मनोरंजक लगता है। सुडोकू के आधार पर Applicative और Traversable के बीच इंटरप्ले पर यह एक मजेदार है।

(1) विचार करें

data Triple a = Tr a a a 

का निर्माण

instance Applicative Triple 
instance Traversable Triple 

ताकि Applicative उदाहरण "vectorization" करता है और Traversable उदाहरण बाएँ से सही काम करता है। उपयुक्त Functor उदाहरण बनाने के लिए मत भूलना: जांचें कि आप इसे Applicative या Traversable उदाहरण से निकाल सकते हैं। आपको

newtype I x = I {unI :: x} 

बाद वाले के लिए उपयोगी हो सकता है।

(2) पर विचार करें

newtype (:.) f g x = Comp {comp :: f (g x)} 

दिखाओ कि

instance (Applicative f, Applicative g) => Applicative (f :. g) 
instance (Traversable f, Traversable g) => Traversable (f :. g) 

अब परिभाषित

type Zone = Triple :. Triple 

मान लीजिए हम क्षैतिज क्षेत्रों

की एक ऊर्ध्वाधर क्षेत्र के रूप में एक Board प्रतिनिधित्व करते हैं

traverse की कार्यक्षमता का उपयोग करके वर्टिकल जोन के क्षैतिज क्षेत्र के रूप में और वर्गों के वर्ग के रूप में इसे पुनर्व्यवस्थित करने के तरीके को दिखाएं।

(3) पर विचार करें

newtype Parse x = Parser {parse :: String -> [(x, String)]} deriving Monoid 

या कुछ अन्य उपयुक्त निर्माण (यह देखते हुए कि के लिए पुस्तकालय Monoid व्यवहार | शायद | अनुचित है)।निर्माण

instance Applicative Parse 
instance Alternative Parse -- just follow the `Monoid` 

और

ch :: (Char -> Bool) -> Parse Char 

जो खपत और एक चरित्र बचाता है अगर यह किसी दिए गए विधेय द्वारा स्वीकार किया जाता लागू।

(4) एक पार्सर जो खाली स्थान के लिए किसी भी मात्रा की खपत, एक भी अंक की लागू (0 कारतूस का प्रतिनिधित्व करता है)

square :: Parse Int 

उपयोग pure और traverse के निर्माण के लिए

board :: Parse (Board Int) 

(5) निरंतर मज़दूरों पर विचार करें

newtype K a x = K {unK :: a} 

और constru सीटी

instance Monoid a => Applicative (K a) 

तो traverse का उपयोग लागू करने के लिए

crush :: (Traversable f, Monoid b) => (a -> b) -> f a -> b 

Bool के लिए newtype रैपर का निर्माण इसके संयोजक और वियोगी monoid संरचनाओं व्यक्त। any और all के संस्करणों को लागू करने के लिए crush का उपयोग करें जो Traversable फ़ैक्टर के लिए काम करता है।

(6) को लागू करें

duplicates :: (Traversable f, Eq a) => f a -> [a] 

मूल्यों जो एक से अधिक बार की सूची कंप्यूटिंग। (पूरी तरह से तुच्छ नहीं।) (इस अंतर कलन का उपयोग कर ऐसा करने के लिए एक सुंदर तरीका है, लेकिन है कि एक और कहानी है।)

(7) को लागू करें

complete :: Board Int -> Bool 
ok :: Board Int -> Bool 

जो जाँच एक बोर्ड है अगर (1) पूर्ण केवल किसी भी पंक्ति, कॉलम या बॉक्स में डुप्लीकेट से रहित [1..9] और (2) में अंकों का।

Answer 2

Typeclassopedia देखें। यह जमीन से एक अच्छी व्याख्या और रास्ते में कुछ अभ्यास के साथ आता है।

Answer 3

उदाहरण के लिए: Applicative Functors

Answer 4

एक शानदार तरीका अभ्यास करने के लिए नहीं बल्कि एक monadic शैली की तुलना में एक अनुप्रयोगी में Parsec उपयोग करने के लिए है। अधिकांश पार्सर्स पूरी तरह से आवेदक होते हैं, इसलिए आपको do नोटेशन का उपयोग करने की आवश्यकता नहीं है।

ईजी। अभिव्यक्तियों के लिए:

import qualified Text.Parsec as P 
import qualified Text.Parsec.Token as P 
import Control.Applicative 

data Expr = Number Int | Plus Expr Expr 

lex = P.makeTokenParser ... -- language config 

expr = number <|> plus 
    where 
    number = Number <$> P.integer lex 
    plus = Plus <$> number <* P.symbol lex "+" <*> expr