क्या एफ # में सी # निहित ऑपरेटर बनाने के बराबर है?

Question

सी # में मैं इस प्रकार एक वर्ग के लिए अंतर्निहित ऑपरेटरों जोड़ सकते हैं:

public class MyClass 
{ 
    private int data; 

    public static implicit operator MyClass(int i) 
    { 
     return new MyClass { data = i }; 
    } 

    public static implicit operator MyClass(string s) 
    { 
     int result; 

     if (int.TryParse(s, out result)) 
     { 
      return new MyClass { data = result }; 
     } 
     else 
     { 
      return new MyClass { data = 999 }; 
     } 
    } 

    public override string ToString() 
    { 
     return data.ToString(); 
    } 
} 

तो मैं किसी भी समारोह है कि एक MyClass एक स्ट्रिंग या किसी पूर्णांक आपत्ति की उम्मीद है पारित कर सकते हैं। जैसे

public static string Get(MyClass c) 
{ 
    return c.ToString(); 
} 

static void Main(string[] args) 
{ 
    string s1 = Get(21); 
    string s2 = Get("hello"); 
    string s3 = Get("23"); 
} 

वहाँ एफ # में ऐसा करने का कोई तरीका है?

Answer 1

जैसा कि अन्य ने बताया है, एफ # में निहित रूपांतरण करने का कोई तरीका नहीं है।

let inline (!>) (x:^a) : ^b = ((^a or ^b) : (static member op_Implicit : ^a -> ^b) x) 

तो फिर तुम इसे इस तरह उपयोग कर सकते हैं: लेकिन, आप हमेशा यह थोड़ा आसान स्पष्ट रूप से चीजों को परिवर्तित करने के लिए (और किसी भी op_Implicit परिभाषाओं कि मौजूदा वर्गों को परिभाषित किया है पुन: उपयोग करने के लिए) बनाने के लिए अपने स्वयं के ऑपरेटर बना सकते हैं:

type A() = class end 
type B() = static member op_Implicit(a:A) = B() 

let myfn (b : B) = "result" 

(* apply the implicit conversion to an A using our operator, then call the function *) 
myfn (!> A()) 

Answer 2

नहीं, ऐसा नहीं है।

Answer 3

लागू रूपांतरण प्रकार और अनुमान के प्रकार के संबंध में लागू रूपांतरण बल्कि समस्याग्रस्त है, इसलिए उत्तर है: नहीं, यह वास्तव में एक समस्याग्रस्त विशेषता होगी।