anchor.diff:                      member this.ReturnType = returnType
                       member this.ParTypes = [||]
                       member this.GenericArgTypes = genArgs.Force ()
  -                    member this.Invoke (genArgTys: array<Type>, _: array<obj>) =
  +                    member this.Invoke (genArgTys: array<Type>,
  +                                        argTys: array<Type>,
  +                                        _: array<obj>) =
                        (if t.IsGenericType
                         then t.GetGenericTypeDefinition().MakeGenericType(genArgTys)
                         else t).GetConstructor([||]).Invoke [||] |> Some}
  
positive.code: 
                   if rule.ParTypes.Length <> 0
                      && stack |> List.exists ((=) ty) then
                    if isRec ty || Ty.containsVars ty then
                      Seq.empty
                    else
                      match HashEqMap.tryFind ty objEnv with
                       | Some o ->
                         Seq.singleton (Value o, objEnv, tyEnv)
                       | None ->
                         let recTy = App (Def typedefof<Rec<_>>, [|ty|])
                         tryGen limit reached rules objEnv tyEnv (ty::stack) recTy
                         |> Seq.choose (fun (result, objEnv, tyEnv) ->
                            match result with
                             | Ruled _ -> None
                             | Value recO ->
                               match recO with
                                | :? IRecObj as recO' ->
                                  let o = recO'.GetObj ()
                                  Some (Value o,
                                        objEnv
                                        |> HashEqMap.add recTy recO
                                        |> HashEqMap.add ty o,
                                        tyEnv)
                                | _ ->
                                  failwith "Bug")
                   else
                     match parTys with
                      | [] ->
                        match Ruled (ty, List.rev args |> Array.ofList, rule)
                              |> tryResolveResult objEnv tyEnv with
                         | None ->
                           Seq.empty
                         | Some (objEnv, result) ->
  
                           let objEnv =
                             match result with
                              | Value o ->
                                let recTy = App (Def typedefof<Rec<_>>, [|ty|])
                                match HashEqMap.tryFind recTy objEnv with
                                 | None ->
                                   ()
                                 | Some recO ->
                                   match recO with
                                    | :? IRecObj as recO' ->
                                      recO'.SetObj o
                                    | _ ->
                                      failwith "Bug"
                                objEnv
                                |> HashEqMap.add ty o
                              | Ruled _ ->
                                objEnv
  
                           Seq.singleton (result, objEnv, tyEnv)
                      | parTy::parTys ->
                        Ty.resolve tyEnv parTy
  
negative.code:       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
  