anchor.diff:                          match tyRelation with
                           | r when r.Equals typeof<PartialEquivalenceRelation> ->
                               match ty with
  -                            | t when t.Equals typeof<float>             -> upcast (Func<IEqualityComparer,float,            float,            bool>(fun _ x y -> (# "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 -> (# "ceq" x y : bool #)))
  +                            | t when t.Equals typeof<float32>           -> box (Func<IEqualityComparer,float32,          float32,          bool>(fun _ x y -> (# "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
                                   | _ -> (# "ceq" x.Value y.Value : bool #)))
  -                            | t when t.Equals typeof<float32>           -> upcast (Func<IEqualityComparer,float32,          float32,          bool>(fun _ x y -> (# "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:                 | false -> false
  
  #if FX_ATLEAST_40 // should probably create some compilation flag for this stuff
              type private EquivalenceRelation = class end
              type private PartialEquivalenceRelation = class end
  
              module mos =
                  let makeEquatableType ty =
                      let equatableTypedef = typedefof<IEquatable<_>>
                      equatableTypedef.MakeGenericType [|ty|]
  
                  let makeComparableType ty =
                      let comparableTypedef = typedefof<IComparable<_>>
                      comparableTypedef.MakeGenericType [|ty|]
  
                  // TODO: Copy to a Comparable version
                  let rec tryFindObjectsInterfaceMethod (objectType:Type) (interfaceType:Type) (methodName:string) (methodArgTypes:array<Type>) =
                      if not (interfaceType.IsAssignableFrom objectType) then null
                      else
                          let methodInfo = interfaceType.GetMethod (methodName, methodArgTypes) 
  
negative.code:                             | _ -> null
                          | r when r.Equals typeof<EquivalenceRelation> ->
                              match ty with
                              | 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<Nullable<float32>> -> box (Func<IEqualityComparer,Nullable<float32>,Nullable<float32>,bool>(fun _ x y ->
                                  match x.HasValue, y.HasValue with
                                  | false, false -> true
                                  | false, _ 
  