anchor.diff:                      | r when r.Equals typeof<PartialEquivalenceRelation> -> null
                       | _ -> raise (Exception "invalid logic")
   
  +                type GenericEqualityObj_ER<'a>() =
  +                    member __.Equals (comp:IEqualityComparer, x:'a, y:'a) = GenericEqualityObj true comp (box x, box y)
  +                        
  +                type GenericEqualityObj_PER<'a>() =
  +                    member __.Equals (comp:IEqualityComparer, x:'a, y:'a) = GenericEqualityObj false comp (box x, box y)
  +
  +                let arrays (tyRelation:Type) (t:Type) : obj =
  +                    if t.IsArray || typeof<System.Array>.IsAssignableFrom t then
  +                        // TODO: Future; currently just returns default
  +                        match tyRelation with
  +                        | r when r.Equals typeof<PartialEquivalenceRelation> -> makeEquatableDelegate t t typedefof<GenericEqualityObj_PER<_>>
  +                        | r when r.Equals typeof<EquivalenceRelation>        -> makeEquatableDelegate t t typedefof<GenericEqualityObj_ER<_>>
  +                        | _ -> raise (Exception "invalid logic")
  +                    else null
  +
                   let equalityInterfaces (t:Type) : obj =
                       let make = makeEquatableDelegate t t
   
                       let equatable = mos.makeEquatableType t
   
  -                    if t.IsArray || typeof<System.Array>.IsAssignableFrom t then
  -                        // I could do something here, but I doubt it would have any real performance impact
  -                        null
  -
  -                    elif t.IsGenericType && ((t.GetGenericTypeDefinition ()).Equals typedefof<System.Nullable<_>>) then
  +                    if t.IsGenericType && ((t.GetGenericTypeDefinition ()).Equals typedefof<System.Nullable<_>>) then
                           let nt = get (t.GetGenericArguments()) 0
                           let make = makeEquatableDelegate t nt 
                           
  
positive.code:             // functionality of GenericSpecializedHash should match GenericHashParamObj, or return null
              // for fallback to that funciton. 
              module GenericSpecializeHash =
                  let standardTypes (t:Type) : obj =
                      if   t.Equals typeof<bool>       then box (Func<IEqualityComparer,bool      ,int>(fun _ a -> a.GetHashCode()))
                      elif t.Equals typeof<float>      then box (Func<IEqualityComparer,float     ,int>(fun _ a -> a.GetHashCode()))
  
negative.code: 
                      else null
  
                  let defaultCompare ty =
                      makeCompareDelegate ty ty typedefof<GenericComparerObj<_>>
  
  