Scopo di un'unione discriminata a caso singolo

Question

Sto definendo un parser osservabile/reattivo monadico. Questo comportamento si comporta in modo abbastanza diverso da un normale parser in quanto è una query continua. Il tipo di fondo è:

IObservable<'a> -> IObservable<'b> 

Guardando varie implementazioni di parser in linguaggi funzionali, sembra come se il modo più appropriato per definire le cose è un singolo caso un'unione discriminata:

type Pattern<'a,'b> = Pattern of (IObservable<'a> -> IObservable<'b>) 

il che significa che quindi necessario estrarre la funzione di fondo di usarlo:

let find (Pattern p) = p 

la domanda è: questo solo per convenzione, o per scopi di proroga al più tardi, o è la è un motivo per farlo anche se la definizione non cambia mai?

Bonus domanda: Se è solo per una firma di tipo più conveniente, perché non basta usare un tipo alias:

type Pattern<'a,'b> = IObservable<'a> -> IObservable<'b> 

ho avanzato una piuttosto un modo attraverso questo, e non ho trovato un caso in cui la componibilità è influenzata dal non utilizzo del DU.

Answer 1

compilatore F # non conserva informazioni sul tipo di abbreviazione, in modo da non beneficiare di inferenza di tipo a tutti. La firma del tipo può essere intesa come specifica del programma; lasciare che il correttore di tipi faccia il loro lavoro è un buon modo per garantire la correttezza dei tuoi programmi.

È necessario specificare esplicitamente il tipo di annotazione ovunque nel caso di tipo alias:

type Vector = float * float 

// val add : float * float -> float * float -> Vector 
let add ((x1, y1): Vector) ((x2, y2): Vector): Vector = (x1 + y1, x2 + y2) 

ma non ti dà la trasparenza come l'utilizzo a valle:

type Vector = V of float * float 

// val add : Vector -> Vector -> Vector 
let add (V(x1, y1)) (V(x2, y2)) = V(x1 + y1, x2 + y2) 

Nei programmi complessi di tipo chiare firme anzi rendono più facile mantenere la componibilità.

Non solo è più semplice aggiungere più casi a DU a singolo caso, ma è anche più facile estendere DU con metodi membro e statici. Un esempio è che sovrascrivi spesso ToString() per una bella stampa.

Answer 2

Da quello che ho capito, il tipo di unione discriminato con un singolo caso è lì per fornire un nome semanticamente rilevante per il dominio del problema, per un tipo di back-end altrimenti generico il cui nome è 'stringa'.

Si tratta di una correzione delle perdite astrazione luce per la semantica, e solo quello, per quanto ne so