Strukturgleichheit in F #

Question

Ich habe einen Plattentyp, der eine Funktion enthält:

{foo : int; bar : int -> int} 

Ich mag diese Art strukturelle Gleichheit zu haben. Gibt es einen Weg, den ich nur markieren kann, dass die bar in Gleichheitstests ignoriert werden sollte? Oder gibt es einen anderen Weg?

Answer 1

Siehe Don blog Beitrag zu diesem Thema, speziell der Abschnitt Custom Equality und Vergleich.

Das Beispiel, das er auf die Satzstruktur ist nahezu identisch gibt Ihnen vorschlagen:

/// A type abbreviation indicating we’re using integers for unique stamps on objects 
type stamp = int 

/// A type containing a function that can’t be compared for equality 
[<CustomEquality; CustomComparison>] 
type MyThing = 
    { Stamp: stamp; 
     Behaviour: (int -> int) } 

    override x.Equals(yobj) = 
     match yobj with 
     | :? MyThing as y -> (x.Stamp = y.Stamp) 
     | _ -> false 

    override x.GetHashCode() = hash x.Stamp 
    interface System.IComparable with 
     member x.CompareTo yobj = 
      match yobj with 
      | :? MyThing as y -> compare x.Stamp y.Stamp 
      | _ -> invalidArg "yobj" "cannot compare values of different types" 

Answer 2

genauer Ihre ursprüngliche Frage zu beantworten, können Sie einen benutzerdefinierten Typ, dessen Vergleich zwischen Instanzen erstellen ist immer wahr:

[<CustomEquality; NoComparison>] 
type StructurallyNull<'T> = 
    { v: 'T } 

    override x.Equals(yobj) = 
     match yobj with 
     | :? StructurallyNull<'T> as y -> true 
     | _ -> false 

    override x.GetHashCode() = 0 

type MyType = { 
    foo: int; 
    bar: StructurallyNull<int -> int> 
}