क्या 'फ्लिप' में बाइनरी के बजाय यूनरी फ़ंक्शन का उपयोग करना संभव है?

Question

Prelude समारोह flip के प्रकार है:

flip :: (a -> b -> c) -> b -> a -> c 

अर्थात, और यह एक द्विआधारी समारोह और दो तर्क लेता है।

Prelude समारोह id के प्रकार है:

id :: a -> a 

लेकिन flip id के प्रकार है:

flip id :: a -> (a -> b) -> b 

कैसे यह संभव id को flip लागू करने के लिए जब id एक एकल समारोह है और flip को पहले तर्क के लिए बाइनरी फ़ंक्शन की आवश्यकता है?

बीटीडब्ल्यू। करने के लिए \ x f -> f x

Answer 1

हास्केल ida = b -> c की स्थापना करके flip को पहले तर्क के प्रकार से मेल करता है flip id समान है। तो:

flip :: (a  -> b -> c) -> b -> a  -> c 
flip :: ((b -> c) -> b -> c) -> b -> (b -> c) -> c 
flip id ::      b -> (b -> c) -> c 

जहां id प्रकार

id :: (b -> c) -> b -> c 

जो

id :: (b -> c) -> (b -> c) 

अर्थात id की एक विशेषज्ञता है कि केवल एकल कार्यों पर लागू होता है के बराबर है की होने के लिए लिया जाता है।

संपादित करें: मुझे लगता है कि मैं अपनी पहली लाइन अलग तरीके से व्यक्त कर सकते हैं के रूप में:
हास्केल deduces कि idflipअगरa = b -> c को पहले तर्क के प्रकार फिट बैठता है।
यदि यह कोई स्पष्ट है।

Answer 2

Nefrubyr इसे बहुत अच्छी तरह से समझाता है।
फ़ंक्शन एप्लिकेशन ऑपरेटर ($) के बारे में सोचने के लिए यह एक और तरीका सहज (आशावादी) बनाना है। obj # show:

($) :: (a -> b) -> (a -> b) 
($) = id 

मैं परिभाषा (#) = flip ($), इस तरह है कि आप अपने लिए आवेदन किया समारोह से पहले तर्क लिख सकते हैं देखा है:

($)id की एक विशेष रूप है।

जाहिर है, के बाद से ($) सिर्फ id का एक विशेष रूप है, आप भी लिख सकते हैं: (#) = flip id