anchor.diff:          module HashCompare = 
               open System.Reflection
               open System.Linq.Expressions
  +            open System.Runtime.CompilerServices
   
               //-------------------------------------------------------------------------
               // LangaugePrimitives.HashCompare: Physical Equality
  
positive.code:                     | _ -> raise (Exception "invalid logic")
  
                  static let pass0 =
                      match typeof<'relation> with
                      | r when r.Equals typeof<PartialEquivalenceRelation> ->
                          match typeof<'a> with
  
negative.code:                     | t when t.Equals typeof<nativeint>  -> generalize (Func<_,_,_,_>(fun _ (x:nativeint) y -> (# "ceq" x y : bool #)))
                      | t when t.Equals typeof<unativeint> -> generalize (Func<_,_,_,_>(fun _ (x:unativeint)y -> (# "ceq" x y : bool #)))
                      | t when t.Equals typeof<char>       -> generalize (Func<_,_,_,_>(fun _ (x:char)      y -> (# "ceq" x y : bool #)))
                      | t when t.Equals typeof<string>     -> generalize (Func<_,_,_,_>(fun _ (x:string)    y -> System.String.Equals((# "" x : string #),(# "" y : string #))))
                      | t when t.Equals typeof<decimal>    -> generalize (Func<_,_,_,_>(fun _ (x:decimal)   y -> System.Decimal.op_Equality((# "" x:decimal #), (# "" y:decimal #))))
                      | _ -> null
                              
                  static member Func = _func
  
              type GenericSpecializeEquals_EqualityInterfaces<'a>() =
                  static let _func =
                      match typeof<'a> with
                      | t when t.IsArray || typeof<System.Array>.IsAssignableFrom t ->
  