एफ # स्पष्ट मिलान बनाम समारोह वाक्य रचना

Question

अस्पष्ट शीर्षक के बारे में क्षमा करें, लेकिन इस सवाल का हिस्सा क्या इन दो वाक्य रचना शैलियों कहा जाता है है मैं एक या दूसरे का उपयोग करना चाहता हूँ?

Answer 1

मिलान वर्शन एक "पैटर्न मिलान अभिव्यक्ति" कहा जाता है। फ़ंक्शन संस्करण को "पैटर्न मिलान फ़ंक्शन" कहा जाता है। spec की धारा 6.6.4 में मिला।

एक दूसरे का उपयोग शैली की बात है। मैं केवल फ़ंक्शन संस्करण का उपयोग करना पसंद करता हूं जब मुझे केवल एक मैच स्टेटमेंट को परिभाषित करने की आवश्यकता होती है।

Answer 2

वे आपके मामले में एक ही काम करते हैं - function कीवर्ड fun कीवर्ड (अज्ञात लैम्बडा बनाने के लिए) के संयोजन की तरह कार्य करता है, इसके बाद match कीवर्ड होता है।

तो तकनीकी रूप से इन दोनों समान हैं, एक fun के योग के साथ:

let foo1 = fun x -> 
    match x with 
    | 1 -> "one" 
    | _ -> "not one" 

let foo2 = function 
    | 1 -> "one" 
    | _ -> "not one" 

Answer 3

दोनों वाक्यविन्यास बराबर हैं। अधिकांश प्रोग्रामर एक या दूसरे का चयन करते हैं और फिर लगातार इसका उपयोग करते हैं।

पहला वाक्यविन्यास तब भी अधिक पठनीय रहता है जब कार्य कार्य शुरू करने से पहले कई तर्क स्वीकार करता है।

Answer 4

दूसरे वाक्यविन्यास के लिए समर्थक यह है कि जब लैम्ब्डा में उपयोग किया जाता है, तो यह थोड़ी अधिक terse और पठनीय हो सकता है।

List.map (fun x -> match x with | 1 -> "one" | _ -> "not one") [0;1;2;3;1] 

बनाम

List.map (function 1 -> "one" | _ -> "not one") [0;1;2;3;1] 

Answer 5

समारोह संस्करण जहां मैच बयान पूरे समारोह है और समारोह केवल एक ही तर्क (tuples एक के रूप में गिनती) है विशेष मामले में पूर्ण मैच वाक्य रचना के लिए एक छोटी हाथ है। यदि आप दो तर्क चाहते हैं तो आपको पूर्ण मिलान वाक्यविन्यास * का उपयोग करने की आवश्यकता है। आप इसे निम्नलिखित दो कार्यों के प्रकारों में देख सकते हैं।

//val match_test : string -> string -> string 
let match_test x y = match x, y with 
         | "A", _ -> "Hello A" 
         | _, "B" -> "Hello B" 
         | _ -> "Hello ??" 

//val function_test : string * string -> string     
let function_test = function 
         | "A", _ -> "Hello A" 
         | _, "B" -> "Hello B" 
         | _ -> "Hello ??" 

जैसा कि आप देख सकते हैं कि मिलान संस्करण दो अलग-अलग तर्क लेता है जबकि फ़ंक्शन संस्करण एक एकल tupled तर्क लेता है। मैं सबसे एक तर्क कार्यों के लिए समारोह संस्करण का उपयोग के बाद से मैं समारोह वाक्य रचना क्लीनर लग रहा है लगता है।

* यदि आप वास्तव में चाहते थे कि आप फ़ंक्शन संस्करण को सही प्रकार के हस्ताक्षर प्राप्त कर सकें लेकिन यह मेरी राय में बहुत बदसूरत दिखता है - नीचे उदाहरण देखें।

//val function_match_equivalent : string -> string -> string 
let function_match_equivalent x y = (x, y) |> function 
               | "A", _ -> "Hello A" 
               | _, "B" -> "Hello B" 
               | _ -> "Hello ??" 

Answer 6

बस पूर्णता के लिए, मैं सिर्फ Expert FSharp के पेज 321 को मिला:।

"ध्यान दें, लिस्टिंग 12-2 का उपयोग करता है अभिव्यक्ति प्रपत्र function pattern-rules -> expression यह (fun x -> match x with pattern-rules -> expression) के बराबर है और के रूप में विशेष रूप से सुविधाजनक है भेदभाव वाले संघों पर सीधे काम करने वाले कार्यों को परिभाषित करने का एक तरीका।"

Answer 7

समारोह केवल एक ही तर्क के लिए अनुमति देता है, लेकिन पैटर्न मिलान के लिए अनुमति देता है, जबकि मज़ा अधिक सामान्य और सुविधाजनक ढंग से एक समारोह को परिभाषित करने के लिए है यहाँ एक नज़र डालें:। http://caml.inria.fr/pub/docs/manual-ocaml/expr.html

Answer 8

यह एक है पुराने सवाल लेकिन मैं अपने $ 0.02 फेंक देते हैं।

सामान्य तौर पर मैं के बाद से मैं अजगर दुनिया कहाँ से आए बेहतर match संस्करण पसंद "स्पष्ट अंतर्निहित से बेहतर है।"

बेशक पैरामीटर पर प्रकार की जानकारी की जरूरत है, तो function संस्करण नहीं किया जा सकता।

OTOH मैं Stringer द्वारा किए गए तो मैं सरल lambdas में function उपयोग करने के लिए शुरू कर देंगे तर्क पसंद है।