anchor.diff:                     | (:? IStructuralComparable as x),_ ->
                          x.CompareTo(yobj,comp)
                      // Check for IComparable
  -                   | (:? System.IComparable as x),_ ->
  -                        if comp.ComparerType.Equals ComparerType.ER then
  -                            x.CompareTo yobj
  -                        else 
  -                            match xobj, yobj with
  -                            | (:? float as x), (:? float as y) -> 
  -                                if System.Double.IsNaN x || System.Double.IsNaN y
  -                                    then getPERNaNCompareToResult comp
  -                                    else x.CompareTo y
  -                            | (:? float32 as x), (:? float32 as y) -> 
  -                                if System.Single.IsNaN x || System.Single.IsNaN y
  -                                    then getPERNaNCompareToResult comp
  -                                    else x.CompareTo y
  -                            | _ -> x.CompareTo yobj
  -
  +                   | (:? System.IComparable as x),_ -> 
  +                       if comp.ThrowsOnPER then 
  +                           match xobj,yobj with 
  +                           | (:? float as x),(:? float as y) -> 
  +                                if (System.Double.IsNaN x || System.Double.IsNaN y) then 
  +                                    raise NaNException
  +                           | (:? float32 as x),(:? float32 as y) -> 
  +                                if (System.Single.IsNaN x || System.Single.IsNaN y) then 
  +                                    raise NaNException
  +                           | _ -> ()
  +                       x.CompareTo(yobj)
                      | (:? nativeint as x),(:? nativeint as y) -> if (# "clt" x y : bool #) then (-1) else (# "cgt" x y : int #)
                      | (:? unativeint as x),(:? unativeint as y) -> if (# "clt.un" x y : bool #) then (-1) else (# "cgt.un" x y : int #)
                      | _,(:? IStructuralComparable as yc) ->
  
positive.code:         //-------------------------------------------------------------------------
          // LanguagePrimitives: PUBLISH IEqualityComparer AND IComparer OBJECTS
          //------------------------------------------------------------------------- 
  
          let inline MakeGenericEqualityComparer<'T>() = 
              // type-specialize some common cases to generate more efficient functions 
              { new System.Collections.Generic.IEqualityComparer<'T> with 
                    member self.GetHashCode(x) = GenericHash x 
                    member self.Equals(x,y) = GenericEquality x y }
  
          let inline MakeGenericEqualityComparerWithEssence<'T>() : IEqualityComparer<'T> =
              unboxPrim (HashCompare.makeEqualityComparer typeof<'T>)
  
          let inline MakeGenericLimitedEqualityComparer<'T>(limit:int) = 
              // type-specialize some common cases to generate more efficient functions 
  
negative.code:             type GenericComparer with
                  interface System.Collections.IComparer with
                      override c.Compare(x:obj,y:obj) = GenericCompare c (x,y)
              
              /// The unique object for comparing values in PER mode (where local exceptions are thrown when NaNs are compared)
              let fsComparerPER        = GenericComparer(true)  
  
              /// The unique object for comparing values in ER mode (where "0" is returned when NaNs are compared)
              let fsComparerER = GenericComparer(false) 
                      
              /// Compare two values of the same generic type, using "comp".
              //
              // "comp" is assumed to be either fsComparerPER or fsComparerER (and hence 'Compare' is implemented via 'GenericCompare').
  