anchor.diff:                      elif t.Equals typeof<float32>    then box (Func<IEqualityComparer,float32   ,int>(fun _ a -> a.GetHashCode()))
                       else null
   
  -                let makeReturnType ty =
  -                    let func3Typedef = typedefof<Func<_,_,_>>
  -                    func3Typedef.MakeGenericType [| typeof<IEqualityComparer>; ty; typeof<int> |]
  +                let makeGetHashCodeReturnType ty =
  +                    mos.makeGenericType<Func<_,_,_>> [| typeof<IEqualityComparer>; ty; typeof<int> |]
   
                   let makeGetHashCodeDelegate (ty:Type) (ct:Type) (def:Type) : obj =
                       let concrete = def.MakeGenericType [|ct|]
                       let instance = Activator.CreateInstance concrete
  -                    upcast Delegate.CreateDelegate (makeReturnType ty, instance, "GetHashCode")
  +                    upcast Delegate.CreateDelegate (makeGetHashCodeReturnType ty, instance, "GetHashCode")
   
                   type Calls =
                       static member StructualEqualityGetHashCode<'a when 'a :> IStructuralEquatable> (ec, x:'a) = x.GetHashCode (ec) 
  
positive.code:                         let make = makeEquatableDelegate t nt 
                          
                          if typeof<IStructuralEquatable>.IsAssignableFrom nt               then make typedefof<NullableStructualEquality<DummyStructInterfaces>>
                          elif (makeEquatableType nt).IsAssignableFrom nt                   then make typedefof<NullableEquatable<DummyStructInterfaces>>
                          else                                                                   make typedefof<NullableEquals<DummyStructInterfaces>>
  
                      elif t.IsValueType && typeof<IStructuralEquatable>.IsAssignableFrom t then make typedefof<StructStructualEquality<DummyStructInterfaces>>
  
negative.code:                 let equalityInterfaces (t:Type) : obj =
                      let make = makeEquatableDelegate t t
  
                      let equatable = mos.makeEquatableType t
  
                      if t.IsArray || typeof<System.Array>.IsAssignableFrom t then
                          // I could do something here, but I doubt it would have any real performance impact
  