anchor.diff:                      | t when t.Equals typeof<float32>    -> generalize (Func<_,_,_>(fun _ (a:float32)    -> a.GetHashCode()))
   
                       | t when t.IsValueType ->
  -                        (Func<_,_,_>(fun ec (a:'a) ->
  -                            (box a).GetHashCode ()))
  +                        let ec = Expression.Parameter typeof<IEqualityComparer>
  +                        let a = Expression.Parameter typeof<'a>
  +                        let lambda = Expression.Lambda<_> (Expression.Call(a, "GetHashCode", [||]), ec, a)
  +                        lambda.Compile ()
  +
   #if FX_ATLEAST_40
                       | t when t.IsSealed -> // only sealed as a derived class might inherit from IStructuralEquatable
                           (Func<_,_,_>(fun ec (a:'a) ->
  
positive.code:                             
                  static member Func = _func
  
              type GenericSpecializeEqualsWithRelation<'relation, 'a>() =
                  static let generalize (func:Func<IEqualityComparer,'aa,'aa,bool>) =
                      match box func with
                      | :? Func<IEqualityComparer,'a, 'a, bool> as f -> f
                      | _ -> raise (Exception "invalid logic")
  
                  static let _specialized =
                      let relationBasedFunc =
                          match typeof<'relation> with
                          | r when r.Equals typeof<UnknownEquivalenceRelation> -> null
                          | r when r.Equals typeof<PartialEquivalenceRelation> ->
                              match typeof<'a> with
                              | t when t.Equals typeof<float>   -> generalize (Func<_,_,_,_>(fun _ (x:float)   y -> (# "ceq" x y : bool #)))
                              | t when t.Equals typeof<float32> -> generalize (Func<_,_,_,_>(fun _ (x:float32) y -> (# "ceq" x y : bool #)))
                              | _ -> null
                          | r when r.Equals typeof<EquivalenceRelation> ->
                              match typeof<'a> with
                              | t when t.Equals typeof<float>   -> generalize (Func<_,_,_,_>(fun _ (x:float)   y -> if not (# "ceq" x x : bool #) && not (# "ceq" y y : bool #) then true else (# "ceq" x y : bool #)))
                              | t when t.Equals typeof<float32> -> generalize (Func<_,_,_,_>(fun _ (x:float32) y -> if not (# "ceq" x x : bool #) && not (# "ceq" y y : bool #) then true else (# "ceq" x y : bool #)))
                              | _ -> null
                          | _ -> raise (Exception "invalid logic")
  
                      match relationBasedFunc with
                      | null -> GenericSpecializeEquals<'a>.Func
                      | func -> func
  
                  static let _func =
                      match _specialized with
                      | null ->
                          match typeof<'relation> with
                          | r when r.Equals typeof<UnknownEquivalenceRelation> -> Func<_,_,_,_>(fun (comp:IEqualityComparer) x y -> comp.Equals (box x, box y))
                          | r when r.Equals typeof<PartialEquivalenceRelation> -> Func<_,_,_,_>(fun (comp:IEqualityComparer) x y -> GenericEqualityObj false comp ((box x), (box y)))
                          | r when r.Equals typeof<EquivalenceRelation>        -> Func<_,_,_,_>(fun (comp:IEqualityComparer) x y -> GenericEqualityObj true comp ((box x), (box y)))
                          | _ -> raise (Exception "invalid logic")                    
                      | f -> f
                              
                  static member Func = _func
  
              /// Implements generic equality between two values, with PER semantics for NaN (so equality on two NaN values returns false)
              //
  
negative.code:         let anyToStringShowingNull x = anyToString "null" x
  
          module HashCompare = 
              open System.Reflection
              open System.Linq.Expressions
  
              //-------------------------------------------------------------------------
              // LangaugePrimitives.HashCompare: Physical Equality
              //------------------------------------------------------------------------- 
  