एक व्युत्पन्न प्रकार की एक बहस (एफ #)

Question

मैं अपने आवेदन में एक वर्ग मिल गया है के साथ एक समारोह का प्रयोग करें - सादगी के लिए मान लेते हैं तो वह ऐसा परिभाषित किया है करते हैं:

type baseType() = 
    member this.A = 5. 

इसके अलावा, मैं एक बहुत मिल गया है ऐसे कार्यों का जो इस प्रकार की वस्तुओं को तर्क के रूप में लेते हैं। इसके अलावा, उनमें से कुछ इस प्रकार की एक सरणी ले:

let myFun (xArr : baseType[]) = 
    // ... do something inspirig ;) 

अब मुझे एहसास हुआ है कि यह एक और वर्ग है जो "baseType" से निकला है करने के लिए अच्छा होगा। उदा .:

type inhType() = 
    inherit baseType() 
    member this.B = 8. 

हालांकि, मैं विरासत में मिला प्रकार की सरणियों कार्यों के साथ "पीछे"

let baseArr = [| baseType() |] 
let inhArr = [| inhType() |] 

myFun baseArr 
myFun inhArr // won't work 

जो "करना अच्छा होगा" की तरह उपयोग नहीं कर सकते। क्या इतने सारे बदलाव किए बिना मेरे कार्यों का पुन: उपयोग करने का कोई आसान तरीका है?

मुझे लगता है कि समाधान में से एक का उपयोग करके मेरी सरणी को मैप करना है। फ़ंक्शन (मजेदार (डी: इन्ह टाइप) -> डी:> बेस टाइप), लेकिन मुझे आश्चर्य है कि क्या कुछ और किया जा सकता है।

Answer 1

आपको flexible type को स्वीकार करने के रूप में अपने कार्य को एनोटेट करने की आवश्यकता है।

type A() = class end 
type B() = inherit A() 

let aArr = [| A() |] 
let bArr = [| B() |] 

// put # before type to indicate it's a flexible type 
let f (x : #A[]) =() 

f aArr 
f bArr // works! 

Answer 2

तुम भी एक प्रकार एनोटेशन का उपयोग करके एक उप-प्रकार, B, के उदाहरण के साथ A की एक सरणी पॉप्युलेट कर सकते हैं:

let bArr: A[] = [| B() |] 

यह एक बंद उपयोग के लिए या यदि समारोह है उपयोगी हो सकता है एक तीसरे पक्ष पुस्तकालय में। एक और आम उपयोग बॉक्सिंग सरणी बना रहा है (obj[])।