anchor.diff:                          fun () -> floatingPointTypes tyRelation ty
                           fun () -> standardTypes ty
                           fun () -> compilerGenerated tyRelation ty
  +                        fun () -> arrays tyRelation ty
                           fun () -> equalityInterfaces ty
                           fun () -> defaultEquality tyRelation ty
                       |]
  
positive.code:             // functionality of GenericSpecializedHash should match GenericHashParamObj, or return null
              // for fallback to that funciton. 
              module GenericSpecializeHash =
                  let standardTypes (t:Type) : obj =
                      if   t.Equals typeof<bool>       then box (Func<IEqualityComparer,bool      ,int>(fun _ a -> a.GetHashCode()))
                      elif t.Equals typeof<float>      then box (Func<IEqualityComparer,float     ,int>(fun _ a -> a.GetHashCode()))
  
negative.code:                             | null, _ | _, null -> false
                              | _, _ -> Calls.StructuralEqualityEquals (ec, x, y)
  
                          member __.GetHashCode (ec:IEqualityComparer, x:'a) =
                              match x with
                              | null -> 0
                              | _ -> Calls.StructuralEqualityGetHashCode (ec, x)
  
                      type Equatable<'a when 'a : not struct and 'a : null and 'a :> IEquatable<'a>>() =
                          member __.Equals (_:IEqualityComparer, x:'a, y:'a) = 
                              match x, y with
  