Come convertire implicitamente in tipi di super comuni in F # pattern matches?

Question

Problema Sommario

Nel momento in cui utilizza f # devo costringere in modo esplicito un valore per il tipo di genitore di questo tipo al fine di ottenere di pattern corrispondenti espressioni di digitare controlla correttamente. Preferirei un modo più ordinato di fare.

Esempio

Supponiamo che io sono un po 'di classe gerarchia:

type Foo() = 
    abstract member Value : unit -> string 

type A (i:int) = 
    inherit Foo() 
     override this.Value() = i.ToString() 

type B (s:string) = 
    inherit Foo() 
     override this.Value() = s 

Idealmente, e in alcuni linguaggi di programmazione in Normalmente, vorrei scrivere l'equivalente di quanto segue:

let bar (i:int) : Foo = 
    match i with 
     | 1 -> B "one" 
     | _ -> A i 

Tuttavia non riesce a digitare correttamente il check, dandomi l'errore, "Questa espressione avrebbe dovuto avere tipo Foo ma lei e ha tipo B ". Non capisco perché il compilatore non abbia abbastanza informazioni per dedurre un super tipo comune per l'espressione della corrispondenza e quindi verificare che il super tipo comune sia 'Foo'.

Allo stato attuale sono costretto a fornire una coercizione esplicita per tutti i casi nella partita modello:

let bar2 (i:int) : Foo = 
    match i with 
     | 1 -> (B "one") :> Foo 
     | _ -> (A i) :> Foo 

vorrei evitare questo.

Ulteriori avvertenze

• L'intuizione suggerisce che questo è il risultato di un problema più generale. Avrei pensato però che qualcosa di così comune come la corrispondenza dei pattern, o se le istruzioni che esibiscono la stessa proprietà, avrebbero una regola di controllo del tipo per tenere conto dei super-tipi comuni.
• Prima che qualcuno mi suggerisca - Apprezzo che se A o B fossero espressioni oggetto funzionerebbe, ma il mio vero esempio è la creazione di istanze di classi C# in cui sono classi normali.
• C'è un modo per me di dichiarare le funzioni per convertire implicitamente i tipi, come ad esempio scala ha, quindi posso applicare le conversioni automatiche per il modulo in cui sto facendo questa generazione?

Grazie per qualsiasi aiuto in merito.

Answer 1

userei upcast, alla

[<AbstractClass>] 
type Foo() = 
    abstract member Value : unit -> string 

type A (i:int) = 
    inherit Foo() 
    override this.Value() = i.ToString() 

type B (s) = 
    inherit Foo() 
    override this.Value() = s 

let bar2 i : Foo = 
    match i with 
    | 1 -> upcast B "one" 
    | _ -> upcast A i 

Hai ancora aggiungere a ogni ramo, ma questo è spesso preferibile alla fusione al tipo, dal momento che spesso il typename è come una lunghezza di 20 o 30 caratteri (MyNamespace.ThisThingy), mentre upcast ha solo 6 caratteri.

Ma, in breve, le regole del linguaggio non consentono nient'altro, i tipi di tutti i rami devono essere uguali.

Answer 2

Ho visto questa domanda un paio di volte prima, ma mi sono appena reso conto che c'è un modo abbastanza interessante per risolvere il problema (senza effetti negativi significativi come il grande sovraccarico di runtime).

È possibile utilizzare un'espressione di calcolo molto semplice che dispone solo di membro Return. Il builder avrà un parametro di tipo e Return aspetterà valori di questo tipo. Il trucco è che F # fa inserisce automaticamente i richiami quando si chiama un membro. Ecco la dichiarazione:

type ExprBuilder<'T>() = 
    member x.Return(v:'T) = v 

let expr<'T> = ExprBuilder<'T>() 

Per scrivere un semplice pattern matching che restituisce nulla come obj, è ora possibile scrivere:

let foo a = expr<obj> { 
    match a with 
    | 0 -> return System.Random() 
    | _ -> return "Hello" } 

Hai ancora essere espliciti circa il tipo di ritorno (al momento della creazione espressione di calcolo), ma trovo la sintassi abbastanza accurata (ma è sicuramente un uso complicato che potrebbe confondere le persone che lo vedranno per la prima volta).