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:                  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")
                   else
                     match parTys with
                      | [] ->
  
negative.code:      | App (Def tc, _) -> tc = typedefof<Rec<_>>
       | _ -> false
  
    let rec tryGen limit reached rules objEnv tyEnv stack ty =
      if limit <= 0 then
        reached := true
        Seq.empty
      else
        match HashEqMap.tryFind ty objEnv with
  