pattern matching su un'unione discriminata

Question

Esiste un modo per pattern matching sulle funzioni sindacali discriminati, ad esempio: -

type Test = 
    | A of string 
    | B of int 
    | C of char 

let DefaultTest t = 
    match t with 
    | A(_) -> A(null) 
    | B(_) -> B(0) 
    | C(_) -> C('\u0000') 

let a = A |> DefaultTest 

Ovviamente questo codice non è valido F # come DefaultTest accetta un parametro di tipo di prova, piuttosto che ' a -> Test. C'è un modo per raggiungere questo senza specificando un valore per l'unione discriminata?

Quello che sto cercando, in definitiva, è una funzione che immette una funzione di tipo 'a -> Test e output Test (valore predefinito di' a).

Answer 1

Annunciare la mia non è chiaro quello che sei dopo, ma questo aiuta?

type Foo = 
    | A of int 
    | B of string 

let CallWithDefault f = 
    let x = Unchecked.defaultof<_> 
    f x 

let defaultA = CallWithDefault A  
let defaultB = CallWithDefault B  
printfn "(%A) (%A)" defaultA defaultB 

Answer 2

Questo potrebbe funzionare quando tutti i costruttori hanno lo stesso tipo di argomento, ad esempio int. allora si potrebbe

partita t 0 di
| A 0 -> ...
| B 0 -> ...

Answer 3

Non sei sicuro di quello che stai dopo, ma qualcosa di simile:

let DefaultTest (t :obj) = 
    match t with 
    | :? (string->Test) as a -> Some (a null) 
    | :? (int -> Test) as b -> Some (b 0) 
    | :? (char -> Test) as c -> Some (c '\u0000') 
    | _ -> Option.None 

potrebbe funzionare per voi ...