anchor.diff:                              | _ -> null
                           | r when r.Equals typeof<EquivalenceRelation> ->
                               match ty with
  -                            | t when t.Equals typeof<float>             -> upcast (Func<IEqualityComparer,float,            float,            bool>(fun _ x y -> if not (# "ceq" x x : bool #) && not (# "ceq" y y : bool #) then true else (# "ceq" x y : bool #)))
  -                            | t when t.Equals typeof<Nullable<float>>   -> upcast (Func<IEqualityComparer,Nullable<float>,  Nullable<float>,  bool>(fun _ x y ->
  +                            | t when t.Equals typeof<float>             -> box (Func<IEqualityComparer,float,            float,            bool>(fun _ x 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>           -> box (Func<IEqualityComparer,float32,          float32,          bool>(fun _ x y -> if not (# "ceq" x x : bool #) && not (# "ceq" y y : bool #) then true else (# "ceq" x y : bool #)))
  +                            | t when t.Equals typeof<Nullable<float>>   -> box (Func<IEqualityComparer,Nullable<float>,  Nullable<float>,  bool>(fun _ x y ->
                                   match x.HasValue, y.HasValue with
                                   | false, false -> true
                                   | false, _ 
                                   | _, false -> false
                                   | _ -> if not (# "ceq" x.Value x.Value : bool #) && not (# "ceq" y.Value y.Value : bool #) then true else (# "ceq" x.Value y.Value : bool #)))
  -                            | t when t.Equals typeof<float32>           -> upcast (Func<IEqualityComparer,float32,          float32,          bool>(fun _ x y -> if not (# "ceq" x x : bool #) && not (# "ceq" y y : bool #) then true else (# "ceq" x y : bool #)))
  -                            | t when t.Equals typeof<Nullable<float32>> -> upcast (Func<IEqualityComparer,Nullable<float32>,Nullable<float32>,bool>(fun _ x y ->
  +                            | t when t.Equals typeof<Nullable<float32>> -> box (Func<IEqualityComparer,Nullable<float32>,Nullable<float32>,bool>(fun _ x y ->
                                   match x.HasValue, y.HasValue with
                                   | false, false -> true
                                   | false, _ 
  
positive.code:                         && isCompilerGeneratedMethod ty "Equals" [|typeof<obj>|] 
                      | _ -> false
  
                  let hasFSharpCompilerGeneratedComparison (ty:Type) =
                      match ty.GetCustomAttribute typeof<CompilationMappingAttribute> with
                      | :? CompilationMappingAttribute as m when (m.SourceConstructFlags.Equals SourceConstructFlags.ObjectType(*struct*)) || (m.SourceConstructFlags.Equals SourceConstructFlags.RecordType) ->
  
negative.code:                     elif t.Equals typeof<decimal>    then box (Func<IComparer,decimal   ,decimal   ,int>(fun _ x y -> System.Decimal.Compare((# "" x:decimal #), (# "" y:decimal #))))
                      else null
  
                  let compilerGenerated tyRelation ty =
                      match tyRelation with
                      | r when r.Equals typeof<EquivalenceRelation> ->
                          if mos.hasFSharpCompilerGeneratedComparison ty then
                              if ty.IsValueType
                                  then makeCompareDelegate ty ty Exemplars.valueTypeComparableGeneric
                                  else makeCompareDelegate ty ty Exemplars.refTypeComparableGeneric
                          else null
                      | r when r.Equals typeof<PartialEquivalenceRelation> -> null
                      | _ -> raise (Exception "invalid logic")
  
                  let comparisonInterfaces (t:Type) : obj =
                      let make = makeCompareDelegate t t
  
                      let comparableGeneric = mos.makeComparableType t
  
                      if t.IsArray || typeof<System.Array>.IsAssignableFrom t then
                          // TODO: Future
                          null
  
                      elif t.IsGenericType && ((t.GetGenericTypeDefinition ()).Equals typedefof<System.Nullable<_>>) then
                          let underlyingType = get (t.GetGenericArguments()) 0
                          let make = makeCompareDelegate t underlyingType 
                          let underlyingComparableGeneric = mos.makeComparableType underlyingType
                          
                          if typeof<IStructuralComparable>.IsAssignableFrom underlyingType   then make Exemplars.nullableStructualComparable
                          elif underlyingComparableGeneric.IsAssignableFrom underlyingType   then make Exemplars.nullableComparableGeneric
                          else                                                                    make Exemplars.nullableComparable
  
                      elif t.IsValueType && typeof<IStructuralComparable>.IsAssignableFrom t then make Exemplars.valueTypeStructualComparable
                      elif t.IsValueType && comparableGeneric.IsAssignableFrom t             then make Exemplars.valueTypeComparableGeneric
                      elif t.IsValueType && typeof<IComparable>.IsAssignableFrom t           then make Exemplars.valueTypeComparable
  
                      elif typeof<IStructuralComparable>.IsAssignableFrom t                  then make Exemplars.refTypeStructualComparable
  
                      // only sealed as a derived class might inherit from IStructuralComparable
                      elif t.IsSealed && comparableGeneric.IsAssignableFrom t                then make Exemplars.refTypeComparableGeneric
                      elif t.IsSealed && typeof<IComparable>.IsAssignableFrom t              then make Exemplars.refTypeComparable
  
                      else null
  
                  type GenericComparerObj<'a>() =
                      member __.CompareTo (comp:IComparer, x:'a, y:'a) = comp.Compare (box x, box y)
  
                  let defaultCompare ty =
                      makeCompareDelegate ty ty typedefof<GenericComparerObj<_>>
  
                  let createCompareDelegate (tyRelation:Type) (ty:Type) : obj =
                      mos.takeFirstNonNull [|
                          fun () -> floatingPointTypes tyRelation ty
                          fun () -> standardTypes ty
                          fun () -> compilerGenerated tyRelation ty
                          fun () -> comparisonInterfaces ty
                          fun () -> defaultCompare ty
                      |]
  
                  type Function<'relation, 'a>() =
                      static let func : Func<IComparer,'a, 'a, int> =
                          match createCompareDelegate typeof<'relation> typeof<'a> with
                          | null -> raise (Exception "invalid logic")
                          | f -> unboxPrim f
  
  