anchor.diff:                   let ty = Ty.resolve tyEnv ty
                    let stack = stack |> List.map (Ty.resolve tyEnv)
   
  -                 if rule.ParTypes.Length <> 0 &&
  -                    isRec ty |> not &&
  -                    Ty.containsVars ty |> not &&
  -                    stack |> List.exists ((=) ty) then
  -
  -                   match HashEqMap.tryFind ty objEnv with
  -                    | Some o ->
  -                      Seq.singleton (Value o, objEnv, tyEnv)
  -                    | None ->
  -                      let recTy = App (Def typedefof<Rec<_>>, [|ty|])
  -                      tryGenerate' limit 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")
  +                 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
                       | [] ->
  
positive.code:     let rules =
        RuleSet.newEmpty ()
        |> RuleSet.maybeAddRules rules
      seq {1 .. Int32.MaxValue}
      |> Seq.tryPick (fun limit ->
         tryGenerate' limit rules HashEqMap.empty HashEqMap.empty [] desTy
         |> Seq.tryPick (fun (result, _, _) ->
            match result with
             | Ruled _ -> None
             | Value value -> Some (unbox<'a> value)))
  
negative.code:                          Seq.singleton (result, objEnv, tyEnv)
                      | parTy::parTys ->
                        Ty.resolve tyEnv parTy
                        |> tryGen limit reached rules objEnv tyEnv (ty::stack)
                        |> Seq.collect (fun (result, objEnv, tyEnv) ->
                           let rec inner resolvedArgs rules objEnv = function
                             | [] ->
  