\a -> map ($ a)
निश्चित रूप से ठीक है, लेकिन शायद अभी तक एक सा अच्छे एक Applicative
दृष्टिकोण है: वहाँ है
<**> :: Applicative f => f a -> f (a -> b) -> f b
जो एक उदाहरण <*> :: [a] -> [a->b] -> [b]
है। आप जो चाहते हैं उसे बहुत कुछ लगता है! आपको केवल एक सिंगलटन सूची में अपना a
मान डालना होगा, जिसके लिए Applicative
: pure
में एक समर्पित फ़ंक्शन भी है।
apply :: Applicative f => a -> f (a -> b) -> f b
apply = (<**>) . pure
हालांकि वास्तव में, मैं नहीं बल्कि हस्ताक्षर a -> [a->b] -> [b]
को यह शीर्ष स्तर के बंधन के लिए प्रतिबंधित है, क्योंकि Applicative
बनाता है यह देखने के लिए की तरह आप, संभव सबसे सामान्य हस्ताक्षर है जो यह नहीं है:
apply :: Functor f => a -> f (a -> b) -> f b
apply a = fmap ($ a)
वास्तव में, जब आप कुछ पाइपलाइन में होते हैं तो मेरा समाधान शायद सबसे अच्छा होता है, मुझे apply
परिभाषित करने के लिए सबसे अच्छा है, लेकिन (<**>) . pure
सीधे कोड में उपयोग करें।
अनुप्रयोगी कानूनों, 'तक ((<**>)। शुद्ध) यू == यू <*> शुद्ध y == शुद्ध ($ y) सभी' Applicative's के लिए <*> यू == FMAP ($ वाई) u', लेकिन आखिरी बस सामान्य है। –