हैकेल पैटर्न मिलान का एफ # संस्करण

Question

मैं एफ # में यह हैकेल कैसे साफ कर सकता हूं?

add 1 2 x = 3 + x 
add 1 x y = 1 + x + y 
add z x y = z + x + y 

Answer 1

आप समारोह में ही ओवरलोड नहीं कर सकते, लेकिन आप सीधे मिलान पैटर्न का उपयोग कर सकते हैं:

let add z x y =    // curried multiple parameters 
    match z, x, y with  // convert to three-tuple to match on 
    | 1, 2, x -> 3 + x 
    | 1, x, y -> 1 + x + y 
    | z, x, y -> z + x + y 

प्रयोग के रूप में की उम्मीद है: add 1 2 3

आप का उपयोग करने को तैयार हैं तर्क के रूप में tuples (यानी करी और करी आंशिक आवेदन), आप इसे और अधिक शॉर्टेंड भी लिख सकते हैं:

let add =      // expect three-tuple as first (and only) parameter 
    function     // use that one value directly to match on 
    | 1, 2, x -> 3 + x 
    | 1, x, y -> 1 + x + y 
    | z, x, y -> z + x + y 

प्रयोग अब है: हास्केल में add (1, 2, 3)

Answer 2

याद रखें कि पैटर्न के साथ घोषणाओं की एक सूची के रूप में general form of functions:

f x1 .. xn = case (x1, .. xn) of 
       (pat1, ..., patn) -> e1 
       (pat2, ..., patn) -> e2 
       (pat3, ..., patn) -> e3 

तो

:

f pat1 ... = e1 
f pat2 ... = e2 
f pat3 ... = e3 

case विश्लेषण के लिए सिर्फ चीनी है समान अनुवाद पैटर्न मिलान के साथ अन्य भाषाओं में किया जा सकता है लेकिन घोषणा-स्तर पैटर्न के बिना।

Answer 3

यह पूरी तरह से वाक्य रचनात्मक है। हास्केल की तरह बोली, मानक ML और मेथेमेटिका आप अलग अलग मैच मामलों को लिखने के लिए रूप में यदि वे विभिन्न कार्यों थे अनुमति देते हैं:

factorial 0 = 1 
factorial 1 = 1 
factorial n = n * factorial(n-1) 

जबकि OCaml और एफ # जैसी भाषाओं के लिए एक एकल समारोह परिभाषा है और में match या समकक्ष का उपयोग करने की आवश्यकता उसके शरीर:

let factorial = function 
    | 0 -> 1 
    | 1 -> 1 
    | n -> n * factorial(n-1) 

ध्यान दें कि आप बार बार समारोह नाम कॉपी करने के लिए इस सिंटैक्स का उपयोग नहीं है और आप और अधिक आसानी से मैच मामलों कारक बन सकते हैं:

let factorial = function 
    | 0 | 1 -> 1 
    | n -> n * factorial(n-1) 

जैसा कि यमन ने लिखा था, एफ # में let f a b = match a, b with ... के साथ करीबी करें।

balance :: RB a -> a -> RB a -> RB a 
balance (T R a x b) y (T R c z d) = T R (T B a x b) y (T B c z d) 
balance (T R (T R a x b) y c) z d = T R (T B a x b) y (T B c z d) 
balance (T R a x (T R b y c)) z d = T R (T B a x b) y (T B c z d) 
balance a x (T R b y (T R c z d)) = T R (T B a x b) y (T B c z d) 
balance a x (T R (T R b y c) z d) = T R (T B a x b) y (T B c z d) 
balance a x b = T B a x b 

के बराबर OCaml या एफ # तुलना:

क्लासिक लाल-काले पेड़ कार्यान्वयन में, मैं समारोह के नाम और मानक ML और हास्केल में दाएँ हाथ के पक्ष काफी बदसूरत के दोहराव को खोजने

let balance = function 
    | B, z, (T(R, y, T(R, x, a, b), c) | T(R, x, a, T(R, y, b, c))), d 
    | B, x, a, (T(R, z, T(R, y, b, c), d) | T(R, y, b, T(R, z, c, d))) -> 
     T(R, y, T(B, x, a, b), T(B, z, c, d)) 
    | a, b, c, d -> T(a, b, c, d)