È possibile far rispettare che un record rispetta alcuni invarianti?

Question

Supponiamo ho voluto creare un tipo di record che rappresenta accettabile min/max: limiti

type Bounds = { Min: float; Max: float } 

c'è un modo per far rispettare che Min < Max? È facile scrivere una funzione validateBounds, mi chiedevo solo se esistesse un modo migliore per farlo.

Edit: mi sono reso conto che per questo esempio specifico ho potuto probabilmente ottenere via con esponendo due proprietà e ri-ordinare gli argomenti, quindi diciamo che stavamo cercando di fare

type Person = { Name: string } 

e nome ha bisogno di avere a almeno un personaggio.

Answer 1

Ecco un'altra soluzione basata su livelli di protezione:

module MyModule = 
    type Bounds = private { _min: float; _max: float } with 
     // define accessors, a bit overhead 
     member public this.Min = this._min 
     member public this.Max = this._max 
     static member public Make(min, max) = 
      if min > max then raise (ArgumentException("bad values")) 
      {_min=min; _max=max} 

    // The following line compiles fine, 
    // e.g. within your module you can do "unsafe" initialization 
    let myBadBounds = {_min=10.0; _max=5.0} 

open MyModule 
let b1 = Bounds.Make(10.0, 20.0) // compiles fine 
let b1Min = b1.Min 
let b2 = Bounds.Make(10.0, 5.0) // throws an exception 
// The following line does not compile: the union cases of the type 'Bounds' 
// are not accessible from this code location 
let b3 = {_min=10.0; _max=20.0} 
// The following line takes the "bad" value from the module 
let b4 = MyModule.myBadBounds 

Answer 2

penso che la cosa migliore è un membro statico:

type Bounds = { Min: float; Max: float } 
    with 
     static member Create(min: float, max:float) = 
      if min >= max then 
       invalidArg "min" "min must be less than max" 

      {Min=min; Max=max} 

e utilizzarlo come

> Bounds.Create(3.1, 2.1);; 
System.ArgumentException: min must be less than max 
Parameter name: min 
    at FSI_0003.Bounds.Create(Double min, Double max) in C:\Users\Stephen\Documents\Visual Studio 2010\Projects\FsOverflow\FsOverflow\Script2.fsx:line 5 
    at <StartupCode$FSI_0005>.$FSI_0005.main@() 
Stopped due to error 
> Bounds.Create(1.1, 2.1);; 
val it : Bounds = {Min = 1.1; 
        Max = 2.1;} 

Tuttavia, come fai notare, il grande rovescio della medaglia di questo approccio non è che nulla impedisce la costruzione di un record "non valido" direttamente. Se questa è una grande preoccupazione, considerare l'utilizzo di un tipo di classe per garantire le vostre invarianti:

type Bounds(min:float, max:float) = 
    do 
     if min >= max then 
      invalidArg "min" "min must be less than max" 

    with 
     member __.Min = min 
     member __.Max = max 

insieme con un modello attivo per convenienza simile a quello che si ottiene con i record (in particolare per quanto riguarda i pattern matching):

let (|Bounds|) (x:Bounds) = 
    (x.Min, x.Max) 

tutti insieme:

> let bounds = Bounds(2.3, 1.3);; 
System.ArgumentException: min must be less than max 
Parameter name: min 
    at FSI_0002.Bounds..ctor(Double min, Double max) in C:\Users\Stephen\Documents\Visual Studio 2010\Projects\FsOverflow\FsOverflow\Script2.fsx:line 4 
    at <StartupCode$FSI_0003>.$FSI_0003.main@() 
Stopped due to error 
> let bounds = Bounds(1.3, 2.3);; 

val bounds : Bounds 

> let isMatch = match bounds with Bounds(1.3, 2.3) -> "yes!" | _ -> "no";; 

val isMatch : string = "yes!" 

> let isMatch = match bounds with Bounds(0.3, 2.3) -> "yes!" | _ -> "no";; 

val isMatch : string = "no" 

Answer 3

una soluzione poco raccomandabile per l'esempio di stringa - utilizzare un DU

012.

type cleverstring = |S of char * string 

In questo modo la stringa avrà almeno un carattere. Quindi puoi semplicemente usare cleverstring invece di string nel tuo record, anche se probabilmente vorrai scrivere alcune funzioni wrapper per farlo apparire come una stringa.