तर्कों के रूप में कार्यों का अनुमान टाइप करें

Question

मैं एक ऐसा फ़ंक्शन लिखना चाहता हूं जो कई टुपल को तर्क के रूप में लेता है और उनके तत्वों को चुनता है और दूसरे फ़ंक्शन पर जाता है, जहां मुझे एक और तर्क के रूप में दिया जाता है। मैं इस तरह sth की कोशिश की है:

let function (tup1:'A*'A) (tup2:'B*'B) i = 
    otherFunction (i tup1) (i tup2) 
function Tup1 Tup2 fst 

मैं एक त्रुटि मिल गया है, क्योंकि i'A*'A ->'A नहीं 'B*'B->'B होने की उम्मीद थी। क्या यह कोड काम करने के लिए कोई तरीका है?

अग्रिम धन्यवाद।

Answer 1

आप मूल रूप से ∀'a.'a*'a->'a के तर्क को पास करना चाहते हैं, लेकिन एफ # (और अन्य एमएल) में, केवल rank-1 polymorphism समर्थित है ताकि आप इसे सीधे नहीं कर सकें ।

type Untupler = 
    abstract Apply : 'a*'a -> 'a 

let myFunction tup1 tup2 (i:Untupler) = 
    otherFunction (i.Apply tup1) (i.Apply tup2) 

myFunction Tup1 Tup2 { new Untupler with member __.Apply (x,y) = x } 

Answer 2

जब आप itup1 के साथ फ़ंक्शन का उपयोग करते हैं, तो यह 'A * 'A -> 'A प्रकार का अनुमानित है। इसका अर्थ यह है कि जब आप tup2 के साथ इसका उपयोग करते हैं, तो काम करने का एकमात्र तरीका यह है कि tup2'A * 'A है।

फ़ंक्शन i फ़ंक्शन उसी प्रकार के भीतर प्रकार नहीं बदल सकता है। यदि आप चाहते करने के लिए एक रास्ता है, मैं इसके बारे में पता नहीं कर रहा हूँ, लेकिन आप इस तरह इस मुद्दे से बचने कर सकते हैं:

let myFunction x y = 
    otherFunction x y 

इस तरह कॉल यह:

myFunction (fst tup1) (fst tup2) 

यह थोड़ा अधिक डालता है कॉलर की ज़िम्मेदारी, लेकिन लाभ यह है कि यह संभव है :)