जेनेरिक पैरामीटर प्रकारों के साथ कार्य

Question

मैं यह समझने की कोशिश कर रहा हूं कि कई प्रकार के पैरामीटर (जैसे int और int64) पर काम करने वाले फ़ंक्शन को कैसे परिभाषित किया जाए। जैसा कि मैं इसे समझता हूं, एफ # में फ़ंक्शन अधिभार संभव नहीं है (निश्चित रूप से संकलक शिकायत करता है)। उदाहरण के लिए निम्नलिखित कार्य करें।

let sqrt_int = function 
    | n:int -> int (sqrt (float n)) 
    | n:int64 -> int64 (sqrt (float n)) 

निश्चित रूप से संकलक शिकायत है कि वाक्य रचना, अवैध है (पैटर्न मिलान में प्रकार की कमी समर्थित नहीं हैं ऐसा लगता है), हालांकि मैं इस दिखाता है मैं प्राप्त करने के लिए चाहते हैं क्या सोचते हैं: एक समारोह है कि कई पैरामीटर प्रकार पर चल रही है और अनुसार प्रकार का एक मूल्य देता है। मुझे एहसास है कि सामान्य प्रकार/प्रकार अनुमान/पैटर्न मिलान के कुछ संयोजन का उपयोग करके एफ # में यह संभव है, लेकिन वाक्यविन्यास ने मुझे दूर कर दिया है। मैंने इसका उपयोग करने का भी प्रयास किया है:? ऑपरेटर (गतिशील प्रकार परीक्षण) और जब पैटर्न मिलान ब्लॉक में खंड, लेकिन यह अभी भी सभी प्रकार की त्रुटियों का उत्पादन करता है।

जैसा कि मैं भाषा के लिए नया हूं, मैं यहां कुछ असंभव करने की कोशिश कर रहा हूं, इसलिए वैकल्पिक समाधान होने पर कृपया मुझे बताएं।

Answer 1

अधिभार आमतौर पर प्रकार-संदर्भित भाषाओं का बगबू है (कम से कम जब, एफ # की तरह, प्रकार प्रणाली टाइप-क्लास रखने के लिए पर्याप्त शक्तिशाली नहीं है)। एफ # में आपके पास विकल्पों की एक संख्या हैं:

• , विधियों (एक प्रकार के सदस्य) पर अधिक भार है, जिसमें मामले ज्यादा अन्य नेट भाषाओं में के रूप में की तरह काम करता है अधिक भार (आप तदर्थ अधिभार सदस्यों कर सकते हैं का प्रयोग करें, प्रदान की गई कॉलों को संख्या/प्रकार के पैरामीटर द्वारा अलग किया जा सकता है)
• फ़ंक्शंस पर विज्ञापन-प्रसार ओवरलोडिंग के लिए "इनलाइन", "^", और स्थिर सदस्य बाधाओं का उपयोग करें (यह वही है जो विभिन्न गणित ऑपरेटरों को काम करने की आवश्यकता है int/float/etc पर; यहां वाक्यविन्यास अजीब है, यह F # लाइब्रेरी के अलावा थोड़ा-सा उपयोग किया जाता है)
• एक अतिरिक्त शब्दकोश-संचालन पैरामीटर पारित करके कक्षाओं को अनुकरण करें (यह वही है जो अनौपचारिक में से एक में करता है एफ # पावरपैक ली braries मनमाने ढंग से उपयोगकर्ता-निर्धारित प्रकार के लिए विभिन्न मठ एल्गोरिदम)
• पतन वापस गतिशील टाइपिंग के लिए (एक 'obj' पैरामीटर में पारित, एक गतिशील प्रकार परीक्षण करना, फेंक बुरा प्रकार के लिए एक क्रम अपवाद) सामान्यीकरण करने के लिए

अपने विशेष उदाहरण के लिए, मैं शायद सिर्फ विधि से अधिक भार का प्रयोग करेंगे:

type MathOps = 
    static member sqrt_int(x:int) = x |> float |> sqrt |> int 
    static member sqrt_int(x:int64) = x |> float |> sqrt |> int64 

let x = MathOps.sqrt_int 9 
let y = MathOps.sqrt_int 100L 

Answer 2

हां, यह किया जा सकता है। this hubFS thread पर एक नज़र डालें।

इस मामले में, समाधान होगा:

let inline retype (x:'a) : 'b = (# "" x : 'b #) 
let inline sqrt_int (n:'a) = retype (sqrt (float n)) : 'a 

चेतावनी: कोई संकलन समय प्रकार की जाँच। अर्थात। sqrt_int "blabla" ठीक संकलित करता है लेकिन आपको रनटाइम पर FormatException मिलेगा।

Answer 3

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

| :? type -> 

या यदि आप प्रकार की जाँच और कास्टिंग संयोजित करना चाहते हैं:

| :? type as foo -> 

Answer 4

यहाँ क्रम प्रकार चेकों का उपयोग कर एक और तरीका है ...

let sqrt_int<'a> (x:'a) : 'a = // ' 
    match box x with 
    | :? int as i -> downcast (i |> float |> sqrt |> int |> box) 
    | :? int64 as i -> downcast (i |> float |> sqrt |> int64 |> box) 
    | _ -> failwith "boo" 

let a = sqrt_int 9 
let b = sqrt_int 100L 
let c = sqrt_int "foo" // boom 

Answer 5

यह काम करता है:

type T = T with 
    static member ($) (T, n:int ) = int (sqrt (float n)) 
    static member ($) (T, n:int64) = int64 (sqrt (float n)) 

let inline sqrt_int (x:'t) :'t = T $ x 

यह जो तर्क के प्रकार पर एक संकलन समय देखने में आता है स्थिर की कमी और अधिक भार का उपयोग करता है,।

स्थिर बाधाओं स्वचालित रूप से एक ऑपरेटर (इस मामले में ऑपरेटर $) की उपस्थिति में उत्पन्न कर रहे हैं लेकिन यह हमेशा हाथ से लिखा जा सकता है:

type T = T with 
    static member Sqr (T, n:int ) = int (sqrt (float n)) 
    static member Sqr (T, n:int64) = int64 (sqrt (float n)) 

let inline sqrt_int (x:'N) :'N = ((^T or ^N) : (static member Sqr: ^T * ^N -> _) T, x) 

इस here के बारे में अधिक।