Czy możliwe jest egzekwowanie przestrzegania przez Rekordy niektórych niezmienników?

Question

Załóżmy, że chciał stworzyć typ rekordu, który reprezentuje dopuszczalne granice Min/Max:

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

Czy istnieje sposób, aby wymusić że Min < Max? Łatwo jest napisać funkcję validateBounds, zastanawiałem się tylko, czy istnieje lepszy sposób na zrobienie tego.

Edit: zdałem sobie sprawę, że w tym konkretnym przykładzie prawdopodobnie mógłbym uciec wystawiając dwie właściwości i re-order argumenty, więc powiedzmy, że staraliśmy się zrobić

type Person = { Name: string } 

i nazwa musi mieć co przynajmniej jeden znak.

Answer 1

Oto kolejny rozwiązanie oparte na poziomach ochrony:

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

myślę najlepiej jest statyczny element:

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} 

i używać go jak

> 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;} 

Jednakże, jak podkreślić, wielki dół stroną tego podejścia jest, że nic nie stoi na przeszkodzie, aby bezpośrednio stworzyć "nieważny" rekord. Jeśli jest to poważny problem, należy rozważyć użycie typu klasy dla zagwarantowania swoich niezmienników:

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 

razem z aktywnym wzorzec dla wygody podobny do tego, co można uzyskać z dokumentacji (w szczególności w odniesieniu do dopasowywania wzorca):

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

wszystko razem:

> 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

na podejrzanie rozwiązanie na przykład String - użycie DU

type cleverstring = |S of char * string 

Spowoduje to, że ciąg będzie miał co najmniej jeden znak. Wtedy możesz użyć tylko cleverstring zamiast string w swoim rekordzie, chociaż prawdopodobnie chcesz napisać niektóre funkcje opakowania, aby wyglądał jak ciąg znaków.