'कॉन्स्ट' आवेदक मज़ेदार के लिए उपयोगी क्या है?

Question

मुझे Control.Applicative के दस्तावेज़ीकरण में मिला है, लेकिन मुझे केवल Monoid का उपयोग करने पर, यह उपयोगी है, जहां यह उपयोगी है।

मुझे क्या याद आ रही है?

Answer 1

Traversable के साथ संयुक्त होने पर यह उपयोगी है।

getConst . traverse Const :: (Monoid a, Traversable f) => f a -> a 

यह एक साथ सामान की एक गुच्छा ग्लोमिंग के लिए सामान्य नुस्खा है। यह उन मामलों में से एक था जिसने मुझे विश्वास दिलाया कि ApplicativeMonad से अलग करने के लायक था। मैं एक Traversable Term मुक्त चर का प्रतिनिधित्व द्वारा parametrized के लिए हो की जाँच करने के लिए सामान्यीकृत elem

elem :: Eq x => x -> Term x -> Bool 

की तरह सामान की जरूरत है। मैंने Term के प्रतिनिधित्व को बदलना जारी रखा और मुझे एक अरब ट्रॉवर्सल फ़ंक्शंस को संशोधित करने में तंग आ गया, जिनमें से कुछ प्रभावी मैपिंग के बजाय संचय कर रहे थे। मैं एक अमूर्त खोजने के लिए खुश था जो दोनों को कवर किया गया था।

Answer 2

यह उपयोगी है जब आपके पास कोई फ़ंक्शन या डेटा संरचना है जो सभी (Applicative) Functor एस के लिए काम करती है, और इसे एक अपमानजनक अर्थ में पुन: उपयोग करना चाहती है। const या id में गुजरने वाले कार्यों के लिए यह मनमानी कार्यों को काम करने के समान है।

Van Laarhoven lenses मनमाना functors के संदर्भ में परिभाषित है, और Const का प्रयोग कर एक क्षेत्र एक्सेसर प्राप्त करने के लिए (और समान रूप से तुच्छ Identity एक क्षेत्र अपडेटर प्राप्त करने के लिए) कर रहे हैं।

Traversable प्रकार, जैसा कि पिगवर्कर उल्लेख करता है, इसका एक और उदाहरण है।

Answer 3

जैसा कि डेव 4420 का उल्लेख है, वैन लाहरोवेन लेंस के लिए एक्सेसर और अद्यतनकर्ता को लागू करने में Const फ़ैक्टर शामिल है। विस्तार से बता दें: गेब्रियल गोंजालेज बताते

{-# LANGUAGE Rank2Types #-} 

import Control.Applicative 
import Control.Monad.Identity 

-- The definition of Van Laarhoven lenses: 
type Lens a b = forall f . Functor f => (b -> f b) -> (a -> f a) 

-- Getter passes the Const functor to the lens: 
get :: Lens a b -> a -> b 
get l = getConst . (l Const) 

-- Updater passes the Identity functor to the lens: 
modify :: Lens a b -> (b -> b) -> (a -> a) 
modify l f = runIdentity . l (Identity . f) 

set :: Lens a b -> b -> (a -> a) 
set l r = modify l (const r) 

-- Example: ------------------------------------------- 

data Person = Person { _name :: String, _age :: Int } 
    deriving Show 

name :: Lens Person String 
name f (Person n a) = fmap (\x -> Person x a) (f n) 

age :: Lens Person Int 
age f (Person n a) = fmap (\x -> Person n x) (f a) 

main :: IO() 
main = do 
    let john = Person "John" 34 
    print $ get age john 
    print $ set name "Pete" john 

Answer 4

के रूप में, कॉन्स्ट लेंस को Getters प्रदान करने के लिए प्रयोग किया जाता है। http://hackage.haskell.org/package/lens-tutorial-1.0.0/docs/Control-Lens-Tutorial.html। वहां आप केवल उस कॉन्स का उपयोग करते हैं जो एक मजेदार है।

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