फिल्टर के रूप में अपूर्ण पैटर्न मिलान का उपयोग कर?

Question

मान लीजिए मैं निम्नलिखित कोड है:

type Vehicle = 
| Car of string * int 
| Bike of string 

let xs = [ Car("family", 8); Bike("racing"); Car("sports", 2); Bike("chopper") ] 

मैं जैसे पाश के लिए एक अनिवार्य में अधूरा पैटर्न मिलान का उपयोग कर सूची के ऊपर फ़िल्टर कर सकते हैं:

> for Car(kind, _) in xs do 
> printfn "found %s" kind;; 

found family 
found sports 
val it : unit =() 

लेकिन यह एक कारण होगा: warning FS0025: Incomplete pattern matches on this expression. For example, the value 'Bike (_)' may indicate a case not covered by the pattern(s). Unmatched elements will be ignored.

चूंकि बेजोड़ तत्वों की अनदेखी करना मेरा इरादा है, क्या इस चेतावनी से छुटकारा पाने की संभावना है?

और क्या इस काम को सूची-समझ के साथ मैचफेलर अपवाद के बिना बनाने का कोई तरीका है? जैसे ऐसा ही कुछ:

> [for Car(_, seats) in xs -> seats] |> List.sum;; 
val it : int = 10 

Answer 1

दो साल पहले अपने कोड मान्य था और यह यह करने के लिए मानक तरीका था। फिर, भाषा को साफ कर दिया गया है और डिजाइन निर्णय स्पष्ट वाक्यविन्यास का पक्ष लेना था। इस कारण से, मुझे लगता है कि चेतावनी को अनदेखा करना एक अच्छा विचार नहीं है।

अपने कोड के लिए मानक प्रतिस्थापन है:

for x in xs do 
    match x with 
    | Car(kind, _) -> printfn "found %s" kind 
    | _ ->() 

(आप भी उच्च आदेश कार्यों पैड नमूने में है इस्तेमाल कर सकते हैं) एक दूसरे के लिए, List.sumBy अच्छी तरह से फिट होगा:

0:

xs |> List.sumBy (function Car(_, seats) -> seats | _ -> 0) 

आप comprehensions साथ रहना पसंद करते हैं, इस स्पष्ट वाक्य रचना है

Answer 2

ज़रिए आप किसी भी चेतावनी मौन कर सकते हैं #nowarn निर्देश या --nowarn: संकलक विकल्प (चेतावनी नंबर, यहाँ 25 रूप FS0025 में पारित)।

लेकिन अधिक आम तौर पर, नहीं, सबसे अच्छा बात स्पष्ट रूप से फ़िल्टर करना है, जैसा कि दूसरे उत्तर में है (उदाहरण के लिए choose)।

Answer 3

स्पष्ट रूप से यह बताने के लिए कि आप बेजोड़ मामलों को अनदेखा करना चाहते हैं, आप List.choose का उपयोग कर सकते हैं और उन बेजोड़ तत्वों के लिए None वापस कर सकते हैं। आपका कोड एक और अधिक idomatic तरह से लिखा जा सकता है इस प्रकार है:

let _ = xs |> List.choose (function | Car(kind, _) -> Some kind 
            | _ -> None) 
      |> List.iter (printfn "found %s") 

let sum = xs |> List.choose (function | Car(_, seats)-> Some seats 
             | _ -> None) 
      |> List.sum