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