anchor.diff:                   | None ->
                      failwith "Bug"
                    | Some genArgTys ->
  -                   rule.Invoke (genArgTys, argTys, argVals)
  +                   rule.Invoke genArgTys argTys argVals
                      |> Option.map (fun o ->
                         (HashEqMap.add monoTy o objEnv, Value (monoTy, o))))
   
  
positive.code: 
  ////////////////////////////////////////////////////////////////////////////////
  
  type [<AbstractClass>] Rule<'v> () =
    abstract ReturnType: Ty<'v>
    abstract ParTypes: array<Ty<'v>>
    abstract GenericArgTypes: array<Ty<'v>>
    abstract Invoke: array<Type> * array<Type> * array<obj> -> option<obj>
  
  module Rule =
    let mapVars v2w (rule: Rule<_>) =
      let returnType = Ty.mapVars v2w rule.ReturnType
      let parTypes = lazy Array.map (Ty.mapVars v2w) rule.ParTypes
      let genericArgTypes = lazy Array.map (Ty.mapVars v2w) rule.GenericArgTypes
      {new Rule<_> () with
        member ir.ReturnType = returnType
        member ir.ParTypes = parTypes.Force ()
        member ir.GenericArgTypes = genericArgTypes.Force ()
        member ir.Invoke (genArgTys, argTys, argObjs) =
         rule.Invoke (genArgTys, argTys, argObjs)}
  
    let freshVars (rule: Rule<Type>) : Rule<Int64> =
      mapVars (Fresh.newMapper ()) rule
  
negative.code:     t.GetMethods (B.DeclaredOnly ||| B.Instance ||| B.Public ||| B.NonPublic)
      |> Array.filter (fun m -> not m.IsAbstract)
      |> Array.map (fun m ->
         {ReturnType = Ty.ofType m.ReturnType
          ParTypes =
            m.GetParameters () |> Array.map (fun p -> Ty.ofType p.ParameterType)
          GenericArgTypes =
            if m.ContainsGenericParameters
            then m.GetGenericArguments () |> Array.map Ty.ofType
            else [||]
          Invoke = fun genArgTys _ argObjs ->
            let m = if m.ContainsGenericParameters
                    then m.MakeGenericMethod genArgTys
                    else m
  