anchor.diff:                                  | _, false -> +1
                                   | _, _ -> x.Value.CompareTo (box y.Value)
   
  -                    type StructuralEquatable<'a when 'a : struct and 'a : (new : unit ->  'a) and 'a :> ValueType and 'a :> IStructuralEquatable>() =
  +                    [<Struct; NoComparison; NoEquality>]
  +                    type StructuralEquatable<'a when 'a : struct and 'a : (new : unit ->  'a) and 'a :> ValueType and 'a :> IStructuralEquatable> =
                           interface Specializations.IEssenceOfEquals<Nullable<'a>> with
                               member __.Ensorcel (ec:IEqualityComparer, x:Nullable<'a>, y:Nullable<'a>) =
                                   match x.HasValue, y.HasValue with
  
positive.code:                         fun () -> defaultGetHashCode t
                      |]
                              
                  type Function<'a>() =
                      static let func : Specializations.IEssenceOfGetHashCode<'a> =
                          match createGetHashCodeDelegate typeof<'a> with
                          | null -> raise (Exception "invalid logic")
                          | :? Specializations.IEssenceOfGetHashCode<'a> as f -> f
                          | f -> upcast Specializations.GetHashCodeTypes.FromFunc(unboxPrim f)
  
                      static member Func = func
  
              /// Intrinsic for calls to depth-unlimited structural hashing that were not optimized by static conditionals.
              //
  
negative.code:                         | f -> unboxPrim f
  
                      static member Func = func
  
                      interface IGetEssenceOfEqualsObj with
                          member __.Get () = box func
  
              /// Implements generic equality between two values, with PER semantics for NaN (so equality on two NaN values returns false)
              //
  