tipo per rappresentare una stringa che non è vuoto o spazi in F #

Question

Amo la semplicità di tipi come

type Code = Code of string 

ma vorrei mettere alcune restrizioni stringa (in questo caso - non consentono vuota stringhe solo spazi). Qualcosa come

type nonemptystring = ??? 
type Code = Code of nonemptystring 

Come si definisce questo tipo in modo idiatico F #? So che posso renderlo una classe con costruttore o un modulo limitato con funzione di fabbrica, ma c'è un modo semplice?

Answer 1

Sfortunatamente non esiste una sintassi comoda per dichiarare un sottoinsieme limitato di tipi, ma vorrei sfruttare i pattern attivi per farlo. Come dici giustamente, si può fare un tipo e verificare la validità è quando si costruisce è:

/// String type which can't be null or whitespace 
type FullString (string) = 
    let string = 
     match (System.String.IsNullOrWhiteSpace string) with 
     |true -> invalidArg "string" "string cannot be null or whitespace" 
     |false -> string 
    member this.String = string 

Ora, la costruzione di questo tipo ingenuamente possono generare eccezioni di runtime e non vogliamo che! Quindi cerchiamo di usare modelli attivi:

let (|FullStr|WhitespaceStr|NullStr|) (str : string) = 
    match str with 
    |null -> NullStr 
    |str when System.String.IsNullOrWhiteSpace str -> WhitespaceStr 
    |str -> FullStr(FullString(str)) 

Ora abbiamo qualcosa che possiamo usare con la sintassi pattern matching per costruire le nostre FullString s. Questa funzione è sicura in fase di esecuzione perché creiamo solo un FullString se siamo nel caso valido.

È possibile utilizzare in questo modo:

let printString str = 
    match str with 
    |NullStr -> printfn "The string is null" 
    |WhitespaceStr -> printfn "The string is whitespace" 
    |FullStr fstr -> printfn "The string is %s" (fstr.String) 

Answer 2

Un string è essenzialmente una sequenza di valori char (in Haskell, BTW, Stringè un tipo alias per [Char]). Una domanda più generale, quindi, sarebbe se fosse possibile dichiarare staticamente un elenco con una determinata dimensione.

Tale lingua è nota come Dependent Types e F # non ce l'ha. La risposta breve, quindi, è che non è possibile farlo in modo dichiarativo.

Il metodo più semplice, e probabilmente anche più idiomatica, modo, allora, sarebbe definire Code come un unico caso Discriminazione in Union:

type Code = Code of string 

Nel modulo che definisce Code, devi anche definire un funzione che i clienti possono utilizzare per creare Code valori:

let tryCreateCode candidate = 
    if System.String.IsNullOrWhiteSpace candidate 
    then None 
    else Some (Code candidate) 

Questa funzione contiene la logica runtime che impedisce ai client di creare vuoti Code valori:

> tryCreateCode "foo";; 
val it : Code option = Some (Code "foo") 
> tryCreateCode "";; 
val it : Code option = None 
> tryCreateCode " ";; 
val it : Code option = None 

Cosa impedisce a un client di creare un valore Code non valido, quindi? Ad esempio, un client non potrebbe aggirare la funzione tryCreateCode e scrivere semplicemente Code ""?

Questo è dove signature files entra.Si crea un file di firma (.fsi), e in che dichiarano tipi e le funzioni in questo modo:

type Code 
val tryCreateCode : string -> Code option 

Qui, il tipo Code è dichiarato, ma la sua 'costruttore' non lo è. Ciò significa che non puoi creare direttamente valori di questo tipo. Questo, ad esempio, non compila:

Code "" 

L'errore dato è:

errore FS0039: Il valore, costruttore dello spazio dei nomi o il tipo di 'codice' non è definito

L'unico modo per creare un valore Code è utilizzare la funzione tryCreateCode.

Come dato qui, non è più possibile accedere al valore di stringa sottostante Code, a meno che non si fornisce anche una funzione per questo:

let toString (Code x) = x 

e dichiararla nello stesso file .fsi come sopra:

val toString : Code -> string 

Potrebbe sembrare molto lavoro, ma in realtà sono solo sei righe di codice e tre righe di tipo dichiarazione (nel file .fsi).