Structural equality, comparison and hashing

Two bookings for coach S4, berth 21, built in two places of a program: are they the same booking? F# answers yes for records, tuples, lists and unions, which compare their contents, and no for classes, which compare identity unless the class says otherwise. That one rule decides what every =, Set, Map and List.distinct in your code does.

This lesson measures each rule on .NET 10: the order compare gives records and union cases, why nan = nan is false while compare nan nan is 0, so that a Set and a list disagree about the same three numbers, why a string’s hash changed between two runs of one script, and how a key type with its own Equals but no matching hash let a duplicate into a HashSet. You will finish with an email key that behaves in a Set and a Map.

Records, unions and lists compare their contents, classes their identity

equality.fsx builds pairs of values from the same data, twice each, and compares every pair three ways: with F#’s =, with .NET’s Equals, and by asking whether the two are one object:

// Two values built separately from the same data: equal by contents, or only when they are the same object?
type Seat = { Coach: string; Berth: int }

type SeatClass(coach: string, berth: int) =
    member _.Coach = coach
    member _.Berth = berth

let show (what: string) (x: obj) (y: obj) (equal: bool) =
    printfn "%-8s %-6b %-7b %b" what equal (x.Equals y) (obj.ReferenceEquals(x, y))

printfn "%-8s %-6s %-7s %s" "two" "=" "Equals" "same object"
show "records" { Coach = "S4"; Berth = 21 } { Coach = "S4"; Berth = 21 } ({ Coach = "S4"; Berth = 21 } = { Coach = "S4"; Berth = 21 })
show "tuples" ("S4", 21) ("S4", 21) (("S4", 21) = ("S4", 21))
show "lists" [ 21; 22 ] [ 21; 22 ] ([ 21; 22 ] = [ 21; 22 ])
show "arrays" [| 21; 22 |] [| 21; 22 |] ([| 21; 22 |] = [| 21; 22 |])
show "unions" (Some "S4") (Some "S4") (Some "S4" = Some "S4")
show "classes" (SeatClass("S4", 21)) (SeatClass("S4", 21)) (SeatClass("S4", 21) = SeatClass("S4", 21))

let seat = SeatClass("S4", 21)
printfn "a class equals itself: %b" (seat = seat)

from session import run

# equality.fsx compares six kinds of value with =, with .NET's Equals and by identity.
run("""
dotnet fsi equality.fsx
""")

$ dotnet fsi equality.fsx
two      =      Equals  same object
records  true   true    false
tuples   true   true    false
lists    true   true    false
arrays   true   false   false
unions   true   true    false
classes  false  false   false
a class equals itself: true

The last column is false on every row: each pair is two separate objects. Yet records, tuples, lists and unions were = all the same, because F# gives them structural equalitystructural equality: Comparing two values by their contents: two records are equal when every field is equal, even if they are separate objects. F# records, unions and tuples compare this way by default. More in “Tuples, records and anonymous records”: two values are equal when their parts are equal, field by field and item by item. The compiler writes the Equals and GetHashCode of every record and union for you, which is why Equals agreed on those rows.

Classes keep reference equalityreference equality: Equality by identity: two references are equal only when they point to the same object, as obj.ReferenceEquals tests. F# classes compare this way unless they override Equals.: two SeatClass objects with the same coach and berth were unequal, while a seat compared with itself was equal. A class compares by contents only when it overrides Equals, which is the usual reason to model data as a record instead.

Arrays are the row to remember. F#’s = compares their elements, so two arrays of 21 and 22 were equal, but .NET’s Equals on an array compares references, so the same pair was unequal by Equals.

compare reads fields in declaration order and cases from top to bottom

Records and unions also get structural comparisonstructural comparison: Ordering F# records, unions, tuples and lists by their contents, as compare and List.sort do: a record's fields from first to last as declared, union cases in declaration order, list items from the front., which compare, List.sort, max, Set and Map all use. ordering.fsx sorts seats, priorities and names with it:

open System

type Seat = { Coach: string; Berth: int }
// The same two fields, declared in the other order.
type SeatByBerth = { Berth: int; Coach: string }
type Priority = Low | Medium | High

let seats: Seat list = [ { Coach = "S5"; Berth = 3 }; { Coach = "B1"; Berth = 40 }; { Coach = "S5"; Berth = 1 } ]

printfn "compare S4-21 S4-22: %d" (compare { Coach = "S4"; Berth = 21 } { Coach = "S4"; Berth = 22 })
printfn "sorted by Seat:        %s" (seats |> List.sort |> List.map (fun s -> $"{s.Coach}-{s.Berth}") |> String.concat " ")
let byBerth = seats |> List.map (fun s -> { SeatByBerth.Berth = s.Berth; Coach = s.Coach })
printfn "sorted by SeatByBerth: %s" (byBerth |> List.sort |> List.map (fun s -> $"{s.Coach}-{s.Berth}") |> String.concat " ")

printfn "%A, compare Low High = %d" (List.sort [ High; Low; Medium ]) (compare Low High)

let names = [ "bala"; "Arjun"; "anu"; "Bhavna" ]
printfn "List.sort:       %A" (List.sort names)
printfn "InvariantCulture: %A" (List.sortWith (fun x y -> String.Compare(x, y, StringComparison.InvariantCulture)) names)
printfn "compare \"a\" \"B\" = %d" (compare "a" "B")

from session import run

# ordering.fsx sorts records, union cases and names with F#'s compare, then names for readers.
run("""
dotnet fsi ordering.fsx
""")

$ dotnet fsi ordering.fsx
compare S4-21 S4-22: -1
sorted by Seat:        B1-40 S5-1 S5-3
sorted by SeatByBerth: S5-1 S5-3 B1-40
[Low; Medium; High], compare Low High = -2
List.sort:       ["Arjun"; "Bhavna"; "anu"; "bala"]
InvariantCulture: ["anu"; "Arjun"; "bala"; "Bhavna"]
compare "a" "B" = 31

A record compares its fields in the order the type declares them and stops at the first field that differs. Step through the first line of the output:

Seat declares Coach first, so the seats sorted by coach: B1-40 S5-1 S5-3. SeatByBerth holds the same two fields in the other order and sorted the same seats by berth: S5-1 S5-3 B1-40. Reordering a record’s fields is therefore a change of behaviour, not of style. Union cases compare by their order in the type, so [High; Low; Medium] sorted to [Low; Medium; High], and compare Low High returned -2: only the sign of a comparison is promised, so test compare a b < 0, never = -1.

Strings are compared by ordinal comparisonordinal comparison: Comparing strings by the numbers of their UTF-16 code units, as StringComparison.Ordinal and F#'s compare do. It is fast and the same in every culture, but puts every capital letter before every small one. More in “Strings, formatting and culture-safe output”, by the numbers of their characters. Every capital letter comes before every small one, so List.sort put Arjun and Bhavna before anu and bala, and compare "a" "B" was 31. For a list a person reads, pass the culture’s rules: String.Compare with StringComparison.InvariantCulture gave anu, Arjun, bala, Bhavna.

nan is not equal to itself, yet compare calls two nans equal

NaNNaN: Not a number: the float value that 0.0 / 0.0 and other undefined operations produce. NaN is not equal to anything, itself included, so nan = nan is false; test for it with Double.IsNaN. More in “Numbers, arithmetic and explicit conversions” is the one value whose equality and comparison disagree. nan.fsx passes it through every way F# and .NET compare numbers:

open System.Collections.Generic

// One float that is not a number, through every way F# and .NET compare values.
let row (what: string) (result: string) = printfn "%-36s %s" what result

row "nan = nan" (sprintf "%b" (nan = nan))
row "[nan] = [nan]" (sprintf "%b" ([ nan ] = [ nan ]))
row "compare nan nan" (sprintf "%d" (compare nan nan))
row "compare nan 1.0" (sprintf "%d" (compare nan 1.0))
row "nan < 1.0, nan > 1.0" (sprintf "%b, %b" (nan < 1.0) (nan > 1.0))
row "Set.ofList [nan; nan; 1.0]" (sprintf "%d items" (Set.ofList [ nan; nan; 1.0 ]).Count)
row "List.distinct [nan; nan; 1.0]" (sprintf "%d items" (List.distinct [ nan; nan; 1.0 ]).Length)
row "Set.contains nan" (sprintf "%b" (Set.ofList [ nan; 1.0 ] |> Set.contains nan))
row "List.contains nan" (sprintf "%b" (List.contains nan [ nan; 1.0 ]))
row "F# dict: ContainsKey nan" (sprintf "%b" ((dict [ (nan, "a") ]).ContainsKey nan))
row ".NET Dictionary: ContainsKey nan" (sprintf "%b" (let d = Dictionary<float, string>() in d[nan] <- "a"; d.ContainsKey nan))
row ".NET HashSet [nan; nan; 1.0]" (sprintf "%d items" (HashSet [ nan; nan; 1.0 ]).Count)
row "List.sort [2.0; nan; 1.0]" (sprintf "%A" (List.sort [ 2.0; nan; 1.0 ]))
row "List.max [nan; 2.0; 1.0]" (sprintf "%A" (List.max [ nan; 2.0; 1.0 ]))
row "List.max [2.0; nan; 1.0]" (sprintf "%A" (List.max [ 2.0; nan; 1.0 ]))
row "Double.IsNaN nan" (sprintf "%b" (System.Double.IsNaN nan))

from session import run

# nan.fsx: nan under =, compare, F# collections and .NET collections.
run("""
dotnet fsi nan.fsx
""")

$ dotnet fsi nan.fsx
nan = nan                            false
[nan] = [nan]                        false
compare nan nan                      0
compare nan 1.0                      -1
nan < 1.0, nan > 1.0                 false, false
Set.ofList [nan; nan; 1.0]           2 items
List.distinct [nan; nan; 1.0]        3 items
Set.contains nan                     true
List.contains nan                    false
F# dict: ContainsKey nan             false
.NET Dictionary: ContainsKey nan     true
.NET HashSet [nan; nan; 1.0]         2 items
List.sort [2.0; nan; 1.0]            [nan; 1.0; 2.0]
List.max [nan; 2.0; 1.0]             nan
List.max [2.0; nan; 1.0]             2.0
Double.IsNaN nan                     true

nan = nan was false and so was [nan] = [nan], because F#’s = follows the floating-point rule that NaN equals nothing; the LanguagePrimitives reference calls this partial equivalence relation semantics. compare nan nan was 0 and compare nan 1.0 was -1, because comparison needs a total order to sort, so it treats NaN as equal to itself and below every number. .NET’s own Double.Equals sides with comparison: its documentation says two NaN values are equal by Equals and unequal by the equality operator. Step through which functions use which rule:

So the same three numbers made a Set of 2 items and a List.distinct of 3, Set.contains nan was true while List.contains nan was false, and a NaN key was found in a .NET Dictionary but never in F#’s dict. Even List.max changed its answer with the order of the list: nan for [nan; 2.0; 1.0] and 2.0 for [2.0; nan; 1.0], because NaN is neither greater nor smaller than 2.0.

A hash must follow equality, and a string’s hash changes between runs

A hash codehash code: An int computed from a value so that a hash table can find it quickly. Equal values must have equal hash codes, while unequal values may share one; F#'s hash and .NET's GetHashCode compute it. lets a HashSet, a Dictionary or F#’s dict find a value without comparing it with every other: the hash picks a bucket, and Equals runs only on the items there that have the same hash. The FSharp.Core reference describes hash as designed to give equal hashes to values that are equal by =. hashing.fsx runs twice to see which hashes also stay the same from one run to the next, and badkey.fsx breaks the rule on purpose:

open System.IO

type Seat = { Coach: string; Berth: int }

// Run it twice: the first run saves its hashes, the second compares its own with them.
let file = "last-run.txt"
let names = [ "hash 42"; "hash (1, 2)"; "hash [1; 2; 3]"; "hash \"S4\""; "hash of a Seat record" ]
let now = [ hash 42; hash (1, 2); hash [ 1; 2; 3 ]; hash "S4"; hash { Coach = "S4"; Berth = 21 } ]

printfn "hash 42 = %d, hash (1, 2) = %d, hash [1; 2; 3] = %d" now[0] now[1] now[2]
printfn "two equal records, equal hashes in this run: %b" (hash { Coach = "S4"; Berth = 21 } = hash { Coach = "S4"; Berth = 21 })

if File.Exists file then
    let before = File.ReadAllLines file |> Array.map int |> List.ofArray
    for name, b, n in List.zip3 names before now do
        printfn "%-22s same as in the last run: %b" name (b = n)
else
    File.WriteAllLines(file, now |> List.map string)
    printfn "hashes saved for the next run"

open System
open System.Collections.Generic

// Two spellings of one address should be one key. Equals ignores case, but nothing tells the hash to.
[<CustomEquality; NoComparison>]
type Email =
    { Address: string }

    override this.Equals other =
        match other with
        | :? Email as e -> String.Equals(this.Address, e.Address, StringComparison.OrdinalIgnoreCase)
        | _ -> false

let a = { Address = "Asha.Rao@Example.com" }
let b = { Address = "asha.rao@example.com" }
printfn "a = b: %b" (a = b)
printfn "same hash: %b" (hash a = hash b)
printfn "HashSet [a; b] holds %d" (HashSet [ a; b ]).Count

from session import run

# hashing.fsx twice, so the second run can compare its hashes with the first; then a key type whose hash disagrees
# with its equality.
run("""
dotnet fsi hashing.fsx
dotnet fsi hashing.fsx
dotnet fsi badkey.fsx
""")

$ dotnet fsi hashing.fsx
hash 42 = 42, hash (1, 2) = 35, hash [1; 2; 3] = 2535
two equal records, equal hashes in this run: true
hashes saved for the next run
$ dotnet fsi hashing.fsx
hash 42 = 42, hash (1, 2) = 35, hash [1; 2; 3] = 2535
two equal records, equal hashes in this run: true
hash 42                same as in the last run: true
hash (1, 2)            same as in the last run: true
hash [1; 2; 3]         same as in the last run: true
hash "S4"              same as in the last run: false
hash of a Seat record  same as in the last run: false
$ dotnet fsi badkey.fsx


badkey.fsx(6,6): warning FS0346: The struct, record or union type 'Email' has an explicit implementation of 'Object.Equals'. Consider implementing a matching override for 'Object.GetHashCode()'

a = b: true
same hash: false
HashSet [a; b] holds 2

hash 42 was 42, hash (1, 2) was 35 and hash [1; 2; 3] was 2535 in both runs. The string’s hash and the hash of a record holding that string changed between the runs, although the code and the text were the same: .NET randomises string hashes per process. The String.GetHashCode documentation is blunt about the consequence: a hash code is only good inside the process that computed it, so it must never be stored, sent or used as a key that outlives a run. Within one run, two equal records still had equal hashes, which is all a hash table needs.

badkey.fsx shows the other half of the rule. Its Equals ignores case, but nothing told the hash to, so the two spellings were equal and had different hashes. Step through what the HashSet did with them:

Attributes choose what F# generates, and custom equality needs three members

Some types should not get the generated equality at all. A record that holds a function cannot have it, because functions have no equality. The session runs emailkey.fsx, then tries = on such a record in F# Interactive, and then each attribute:

open System

// Custom equality done whole: Equals, a GetHashCode that agrees with it, and a comparison for Set and Map.
[<CustomEquality; CustomComparison>]
type Email =
    { Address: string }

    override this.Equals other =
        match other with
        | :? Email as e -> String.Equals(this.Address, e.Address, StringComparison.OrdinalIgnoreCase)
        | _ -> false

    override this.GetHashCode() = StringComparer.OrdinalIgnoreCase.GetHashCode this.Address

    interface IComparable with
        member this.CompareTo other =
            match other with
            | :? Email as e -> String.Compare(this.Address, e.Address, StringComparison.OrdinalIgnoreCase)
            | _ -> invalidArg "other" "not an Email"

let a = { Address = "Asha.Rao@Example.com" }
let b = { Address = "asha.rao@example.com" }
let c = { Address = "ravi@example.com" }
printfn "a = b: %b, same hash: %b, compare a b: %d" (a = b) (hash a = hash b) (compare a b)
printfn "Set of a, b and c: %d addresses" (Set.count (Set.ofList [ a; b; c ]))
printfn "Map lookup with the other spelling: %A" (Map.tryFind b (Map.ofList [ (a, 3) ]))

// The other way: store one spelling only, and the generated equality, hash and comparison are right already.
type EmailKey = private EmailKey of string

module EmailKey =
    let create (address: string) = EmailKey(address.Trim().ToLowerInvariant())

let k1 = EmailKey.create "Asha.Rao@Example.com"
let k2 = EmailKey.create " asha.rao@example.com"
printfn "EmailKey: k1 = k2: %b, same hash: %b, Set holds %d" (k1 = k2) (hash k1 = hash k2) (Set.count (Set.ofList [ k1; k2 ]))

from session import fsi, run

# emailkey.fsx, then what the compiler says about a record with a function field and about the equality attributes.
run("""
dotnet fsi emailkey.fsx
""")
fsi([
    'type Offer = { Name: string; Apply: decimal -> decimal };;',
    'let festival = { Name = "festival"; Apply = fun price -> price * 0.9m };;',
    'festival = festival;;',
    '[<ReferenceEquality>]\ntype RuleRef = { Name: string; Apply: decimal -> decimal };;',
    'let r1 = { RuleRef.Name = "festival"; Apply = fun price -> price * 0.9m };;',
    'let r2 = { RuleRef.Name = "festival"; Apply = fun price -> price * 0.9m };;',
    'r1 = r1, r1 = r2;;',
    'Set.ofList [ r1 ];;',
    '[<NoComparison>]\ntype Point = { X: int; Y: int };;',
    '{ X = 1; Y = 2 } = { X = 1; Y = 2 };;',
    'Set.ofList [ { X = 1; Y = 2 } ];;',
    '#quit;;',
], args=["--nologo"])

$ dotnet fsi emailkey.fsx
a = b: true, same hash: true, compare a b: 0
Set of a, b and c: 2 addresses
Map lookup with the other spelling: Some 3
EmailKey: k1 = k2: true, same hash: true, Set holds 1
$ dotnet fsi --nologo
> type Offer = { Name: string; Apply: decimal -> decimal };;
type Offer =
  {
    Name: string
    Apply: (decimal -> decimal)
  }

> let festival = { Name = "festival"; Apply = fun price -> price * 0.9m };;
val festival: Offer = { Name = "festival"
                        Apply = <fun:festival@2> }

> festival = festival;;

  festival = festival;;
  ^^^^^^^^

stdin(3,1): error FS0001: The type 'Offer' does not support the 'equality' constraint because it is a record, union or struct with one or more structural element types which do not support the 'equality' constraint. Either avoid the use of equality with this type, or add the 'StructuralEquality' attribute to the type to determine which field type does not support equality

> [<ReferenceEquality>]
- type RuleRef = { Name: string; Apply: decimal -> decimal };;
type RuleRef =
  {
    Name: string
    Apply: (decimal -> decimal)
  }

> let r1 = { RuleRef.Name = "festival"; Apply = fun price -> price * 0.9m };;
val r1: RuleRef = { Name = "festival"
                    Apply = <fun:r1@6> }

> let r2 = { RuleRef.Name = "festival"; Apply = fun price -> price * 0.9m };;
val r2: RuleRef = { Name = "festival"
                    Apply = <fun:r2@7> }

> r1 = r1, r1 = r2;;
val it: bool * bool = (true, false)

> Set.ofList [ r1 ];;

  Set.ofList [ r1 ];;
  -------------^^

stdin(9,14): error FS0001: The type 'RuleRef' does not support the 'comparison' constraint. For example, it does not support the 'System.IComparable' interface

> [<NoComparison>]
- type Point = { X: int; Y: int };;
type Point =
  {
    X: int
    Y: int
  }

> { X = 1; Y = 2 } = { X = 1; Y = 2 };;
val it: bool = true

> Set.ofList [ { X = 1; Y = 2 } ];;

  Set.ofList [ { X = 1; Y = 2 } ];;
  -------------^^^^^^^^^^^^^^^^

stdin(13,14): error FS0001: The type 'Point' does not support the 'comparison' constraint because it has the 'NoComparison' attribute

> #quit;;

festival = festival was error FS0001: the record does not support the equality constraintThe requirement 'T : equality that = and hash place on a type. A record or union satisfies it only when all its fields do, so a field of function type, or [<NoEquality>], takes it away., and the message suggested an attribute. The attributes are how you choose:

• [<ReferenceEquality>] makes = compare identity: r1 = r1 was true and r1 = r2 false, for two rules with the same name and code. It also switches off the generated comparison, so Set.ofList [ r1 ] was error FS0001.
• [<NoComparison>] and [<NoEquality>] say that a type is never compared or never tested for equality. { X = 1; Y = 2 } = { X = 1; Y = 2 } was still true under [<NoComparison>], while Set.ofList of the same point was error FS0001.
• [<CustomEquality; CustomComparison>] hands all three members to you: Equals, a GetHashCode that agrees with it, and IComparable for Set and Map. emailkey.fsx writes them case-insensitively, and the Set held 2 of the 3 addresses and Map.tryFind found the other spelling.

The second half of emailkey.fsx needs no custom code: EmailKey.create stores one spelling, trimmed and in lower case, so the generated equality, hash and comparison are right already, and the Set held one of two spellings. The price is the original spelling, which the key no longer has. Choose for your own type:

Practise: an email key for a Map

practice.fsx makes an email key whose domain ignores case while the part before the @ is kept as written, by storing the domain in lower case. It checks six pairs, a Map lookup and a sort:

open System

// An email address as a Map key: the domain is case-insensitive, the local part before @ is kept as written.
// The domain is lowered once, when the value is made, so the generated equality, hash and comparison are right.
type Email = private { Local: string; Domain: string }

module Email =
    let tryCreate (text: string) =
        match text.Split '@' with
        | [| local; domain |] when local <> "" && domain <> "" -> Some { Local = local; Domain = domain.ToLowerInvariant() }
        | _ -> None

    let text (e: Email) = $"{e.Local}@{e.Domain}"

let email text = (Email.tryCreate text).Value

let pairs =
    [ "asha@Example.com", "asha@example.com", true
      "Asha@example.com", "asha@example.com", false
      "ravi@example.com", "ravi@example.org", false
      "ravi@EXAMPLE.ORG", "ravi@example.org", true
      "anu@example.in", "anu@example.in", true
      "a.nu@example.in", "anu@example.in", false ]

for x, y, expected in pairs do
    let equal = email x = email y
    let hashOk = not equal || hash (email x) = hash (email y)
    printfn "%-17s %-17s equal %-5b expected %-5b hash agrees %b" x y equal expected hashOk

let visits = Map.ofList [ (email "asha@Example.com", 3) ]
printfn "Map lookup: %A" (Map.tryFind (email "asha@example.com") visits)
printfn "Sorted: %s" ([ "ravi@b.in"; "Asha@a.in"; "asha@B.in" ] |> List.map email |> List.sort |> List.map Email.text |> String.concat ", ")
printfn "Not an address: %A" (Email.tryCreate "asha.example.com" |> Option.map Email.text)

from session import run

# practice.fsx checks an email key on six pairs, in a Map and in a sorted list.
run("""
dotnet fsi practice.fsx
""")

$ dotnet fsi practice.fsx
asha@Example.com  asha@example.com  equal true  expected true  hash agrees true
Asha@example.com  asha@example.com  equal false expected false hash agrees true
ravi@example.com  ravi@example.org  equal false expected false hash agrees true
ravi@EXAMPLE.ORG  ravi@example.org  equal true  expected true  hash agrees true
anu@example.in    anu@example.in    equal true  expected true  hash agrees true
a.nu@example.in   anu@example.in    equal false expected false hash agrees true
Map lookup: Some 3
Sorted: Asha@a.in, asha@b.in, ravi@b.in
Not an address: None

Every pair matched its expected result, every equal pair had equal hashes, and the Map found the key under the other spelling of the domain. The sort put Asha before asha because the type declares Local first and compares it by character code, so the capital A comes first.

Answer the questions below on the five ideas of this lesson. Each choice is explained as soon as you pick it, and the questions return first to the idea you have answered least well:

Interview questions

Warm-up, for freshers and 2–5 years: what does structural equality mean in F#, and which types have it?

Structural equality means that two values are equal when their contents are equal: the same fields, the same union case with equal data, the same items in the same order. F# gives it by default to records, unions, tuples, lists, arrays (under =), options and the F# collections, and the compiler writes the matching GetHashCode and, where every field allows it, a comparison. Classes compare by reference unless they override Equals. Two exceptions matter in practice: a record or union with a function field has no equality at all, and floats follow the rule that nan = nan is false. [<ReferenceEquality>], [<NoEquality>] and [<CustomEquality>] change what the compiler generates.

Two harder questions follow, about a report whose two counts of distinct readings disagreed and about a cache key built from a string’s hash:

Key takeaways

• Records, unions, tuples and lists are = when their contents are, classes only when they are one object, and F#’s = compares array elements while .NET’s Equals on arrays does not.
• compare reads a record’s fields in declaration order and union cases from top to bottom, and promises only the sign of its result; strings sort by character code unless you pass a culture.
• nan = nan is false while compare nan nan is 0, so a Set and List.distinct disagree about the same numbers; check Double.IsNaN where data comes in.
• A hash must agree with equality, and string hashes change between runs, so they are never stored or compared across processes.
• Attributes choose the generated members; custom equality needs Equals, GetHashCode and a comparison that agree, and storing one spelling often needs no custom code at all.