एक संस्करण में फ़ंक्शन को कैसे लागू किया जा रहा है?

Question

इस प्रकार करते हैं =

type intC = int;; 
type boolC = bool; 
type stringC = string;; 

type component = A of intC | B of boolC | C of stringC;; 

मैं प्रकार एक घटक एक के एक पर एक समारोह को लागू करना चाहते हैं, तो मैं योजनाबद्ध तरीके से की जरूरत घटक deconstruct करने के लिए करते हैं?

let add comp = 
    match comp with 
    | A i -> Some (i + 2) (*only A interests me, I return i + 2*) 
    | _ -> None   (*otherwise I return nothing*) 

और फिर एक घटक एक पर किसी भी कार्य के लिए:

उदाहरण के लिए

मुझे क्या करना है? क्या आपकी अनावश्यकता से बचने का कोई मतलब है?

Answer 1

यह वास्तव में निर्भर करता है कि आप किस प्रकार के ऑपरेशन को अपने प्रकार पर करेंगे।

समाधान @nlucaroni द्वारा दिए गए बिल्कुल ठीक है, लेकिन आप एक रिकॉर्ड का उपयोग कर सकते अगर आप कुछ में थोड़ा और अधिक सामान्य (और जटिल) करना चाहते हैं आपके आंशिक नक्शा कार्यों धारण करने के लिए:

type 'a component_m = { 
    a : intC -> 'a; 
    b : boolC -> 'a; 
    c : stringC -> 'a; 
} 

let map_component m = function 
    | A a -> m.a a 
    | B b -> m.b b 
    | C c -> m.c c 

let add = map_component { 
    a = (fun x -> Some (x + 2)); 
    b = (fun _ -> None); 
    c = (fun _ -> None); 
} 

आप तो (fun _ -> None) समारोह हर बार लिखने के लिए नहीं करना चाहते हैं, आप एक डिफ़ॉल्ट मान है कि आप का विस्तार का उपयोग कर सकते हैं:

let none = { 
    a = (fun _ -> None); 
    b = (fun _ -> None); 
    c = (fun _ -> None); 
} 

let add = map_component { none with a = fun x -> Some (x+2) } 

आप functors के साथ एक ही काम कर सकते हैं, लेकिन यह मेरी राय में इस overkill हो जाता है।

Answer 2

आप एक समारोह है कि आप के लिए घटक विनाश करता है के लिए एक उच्च क्रम-समारोह पारित कर सकते हैं

let apply_if_a f = function 
    | A i   -> Some (f i) 
    | (B _ | C _) -> None 

इस के लिए प्रकार होगा,

val apply_if_a : (int -> 'a) -> component -> 'a option 

आप देख सकते हैं, A के किसी भी मूल्य पर लागू किसी भी फ़ंक्शन के लिए पॉलिमॉर्फिक। इसके अलावा, अधिकांश लोग पकड़ने से दूर रहते हैं, _, और इसके बजाय संपूर्ण होने के लिए।