अस्पष्ट शीर्षक के बारे में क्षमा करें, लेकिन इस प्रश्न का एक हिस्सा इन दो वाक्यविन्यास शैलियों को क्या कहा जाता है:
let foo1 x =
match x with
| 1 -> "one"
| _ -> "not one"
let foo2 = function
| 1 -> "one"
| _ -> "not one"
दूसरा भाग दोनों के बीच क्या अंतर है, और जब मैं एक या दूसरे का उपयोग करना चाहूंगा?
जवाबों:
मैच संस्करण को "पैटर्न मिलान अभिव्यक्ति" कहा जाता है। फ़ंक्शन संस्करण को "पैटर्न मिलान फ़ंक्शन" कहा जाता है। युक्ति के खंड ६.६.४ में मिला ।
एक के ऊपर एक का इस्तेमाल करना स्टाइल की बात है। मैं केवल फ़ंक्शन संस्करण का उपयोग करना पसंद करता हूं जब मुझे एक फ़ंक्शन को परिभाषित करने की आवश्यकता होती है जो केवल एक मैच स्टेटमेंट है।
दूसरे सिंटैक्स के लिए समर्थक यह है कि जब एक लैम्ब्डा में उपयोग किया जाता है, तो यह थोड़ा अधिक प्रचलित और पठनीय हो सकता है।
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]
फ़ंक्शन संस्करण विशेष मामले में पूर्ण मैच सिंटैक्स के लिए एक छोटा हाथ है जहां मैच स्टेटमेंट पूरे फ़ंक्शन है और फ़ंक्शन में केवल एक ही तर्क है (एक के रूप में ट्यूपल्स की गिनती)। यदि आप दो तर्क रखना चाहते हैं तो आपको पूर्ण मिलान वाक्यविन्यास * का उपयोग करने की आवश्यकता है। आप इसे निम्नलिखित दो कार्यों के प्रकारों में देख सकते हैं।
//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 ??"
जैसा कि आप देख सकते हैं कि मैच संस्करण दो अलग-अलग तर्क लेता है, जबकि फ़ंक्शन संस्करण एकल टैप किए गए तर्क लेता है। जब से मुझे फ़ंक्शन सिंटैक्स क्लीनर दिखता है, तब से मैं सबसे अधिक तर्क कार्यों के लिए फ़ंक्शन संस्करण का उपयोग करता हूं।
* यदि आप वास्तव में चाहते थे कि आपको फ़ंक्शन संस्करण सही प्रकार के हस्ताक्षर मिल सकें, लेकिन यह मेरी राय में बहुत बदसूरत लगता है - नीचे उदाहरण देखें।
//val function_match_equivalent : string -> string -> string
let function_match_equivalent x y = (x, y) |> function
| "A", _ -> "Hello A"
| _, "B" -> "Hello B"
| _ -> "Hello ??"
वे आपके मामले में एक ही काम करते हैं - functionकीवर्ड कीवर्ड के संयोजन की तरह काम करता है fun(एक अनाम लंबो का उत्पादन करने के लिए) इसके बादmatch ।
तो तकनीकी रूप से ये दोनों एक जैसे हैं fun:
let foo1 = fun x ->
match x with
| 1 -> "one"
| _ -> "not one"
let foo2 = function
| 1 -> "one"
| _ -> "not one"
funतकनीकी रूप से परिभाषित किया गया है function | _ -> ...?
fun x y -> ...होगा fun x -> fun y -> ..., और फिर fun x -> ...होगा function | x -> ...। यही कारण है कि आप पैटर्न मिलान fun- जैसे कर सकते हैं fun (x::xs) -> ...।
बस पूर्णता के लिए, मुझे सिर्फ एक्सपर्ट FSharp के पेज 321 पर जाना है :
"ध्यान दें, 12-2 को सूचीबद्ध करना अभिव्यक्ति के रूप का उपयोग करता है
function pattern-rules -> expression। यह समान है(fun x -> match x with pattern-rules -> expression)और यह विशेष रूप से सुविधाजनक है जो भेदभाव वाली यूनियनों पर सीधे काम करने वाले कार्यों को परिभाषित करता है।"
फ़ंक्शन केवल एक तर्क के लिए अनुमति देता है लेकिन पैटर्न मिलान के लिए अनुमति देता है, जबकि मज़ा एक फ़ंक्शन को परिभाषित करने के लिए अधिक सामान्य और लचीला तरीका है। यहां देखें: http://caml.inria.fr/pub/docs/manual-ocaml/expr.html
दो वाक्यविन्यास बराबर हैं। अधिकांश प्रोग्रामर एक या दूसरे को चुनते हैं और फिर इसका लगातार उपयोग करते हैं।
पहला वाक्यविन्यास अधिक पठनीय रहता है जब कार्य शुरू करने से पहले फ़ंक्शन कई तर्क स्वीकार करता है।
यह एक पुराना सवाल है लेकिन मैं अपना $ 0.02 फेंक दूंगा।
सामान्य तौर पर मैं matchपायथन दुनिया से आने के बाद से बेहतर संस्करण पसंद करता हूं जहां "स्पष्ट रूप से निहित से बेहतर है।"
बेशक अगर पैरामीटर की जानकारी टाइप की जाती है तो functionसंस्करण का उपयोग नहीं किया जा सकता है।
OTOH मुझे पसंद है Stringerइसलिए मैंने जो तर्क दिया उसे मैं functionसरल लांबडा में प्रयोग करना शुरू कर दूंगा ।