anchor.diff:                           Seq.singleton (result, objEnv, tyEnv)
                       | parTy::parTys ->
                         Ty.resolve tyEnv parTy
  -                      |> tryGenerate' limit rules objEnv tyEnv (ty::stack)
  +                      |> tryGen limit reached rules objEnv tyEnv (ty::stack)
                         |> Seq.collect (fun (result, objEnv, tyEnv) ->
                            let rec inner resolvedArgs rules objEnv = function
                              | [] ->
  
positive.code:      | App (Def tc, _) -> tc = typedefof<Rec<_>>
       | _ -> false
  
    let rec tryGenerate' limit rules objEnv tyEnv stack ty =
      if limit <= 0 then
        Seq.empty
      else
        match HashEqMap.tryFind ty objEnv with
  
negative.code:                  let ty = Ty.resolve tyEnv ty
                   let stack = stack |> List.map (Ty.resolve tyEnv)
  
                   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
                      | [] ->
  