anchor.diff:  open System.Threading.Tasks
   open System.Threading
   open System.Collections.Concurrent
  +open System.Collections.Generic
   open System.Reflection
   open System
   
  
positive.code:                   else
                      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
                                           |> addObj monoTy o,
                                           tyEnv)
                                   | _ ->
                                     failwith "Bug")
                   else
                     match parTys with
                      | [] ->
  
negative.code: 
    let newEmpty () =
      {cache = {rules = ConcurrentDictionary<_, _> ()
                trees = ConcurrentDictionary<_, _> ()
                lastFailures = Queue ()
                limitReached = false}
       rules = HashEqSet.empty
       tree = TyTree.build []}
  
  