Come applicare una funzione a una variante?

Question

lasciate che questo tipo =

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

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

Se voglio applicare una funzione del tipo di una di un componente A, devo sistematicamente di decostruire la componente?

per exemple devo fare:

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

e quindi per qualsiasi funzione su un componente A? C'è qualche mezzo per evitare la tua ridondanza?

Answer 1

Dipende molto dal tipo di operazione che si eseguirà sui tipi.

La soluzione data dalla @nlucaroni è perfettamente bene, ma se si vuole fare qualcosa di un po 'più generico (e complesso) è possibile utilizzare un record di tenere le funzioni della mappa parziali:

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); 
} 

Se non vogliono avere a scrivere la funzione (fun _ -> None) ogni volta, è anche possibile utilizzare un valore di default che si estende:

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

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

si può fare le stesse cose con funtori, ma questo a mio parere questo diventa eccessivo.

Answer 2

è possibile passare un ordine-funzioni superiore a una funzione che fa la distruzione di componenti per voi,

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

Il tipo di questo sarebbe,

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

Come si può vedere, polimorfico per qualsiasi funzione applicata a qualsiasi valore di A. Inoltre, la maggior parte delle persone evita il catch-all, _, e per essere esauriente.