anchor.diff:    let tryGenerate (rules: obj) : option<'a> =
       let desTy = typeof<'a> |> Ty.ofType |> mapVars (Fresh.newMapper ())
       let rules =
  -      Dictionary<_, _> ()
  -      |> RuleSet.newEmpty
  +      RuleSet.newEmpty ()
         |> RuleSet.maybeAddRules rules
       seq {1 .. Int32.MaxValue}
       |> Seq.tryPick (fun limit ->
  
positive.code:        if hasInferenceRules t
            && HashEqSet.contains t ruleSet.rules |> not
         then let rules = HashEqSet.add t ruleSet.rules
              if ruleSet.env.ContainsKey t |> not then
                ruleSet.env.Add (t, collectRules o |> Seq.toArray)
              {ruleSet with
                rules = rules
                tree = lazy (rules
                             |> HashEqSet.toSeq
                             |> Seq.collect (fun t ->
                                ruleSet.env.[t]
                                |> Seq.map (fun rule -> (rule.ReturnType, rule)))
                             |> TyTree.build
                             |> force)}
         else ruleSet
  
    let rulesFor (ruleSet: RuleSet) (desiredTy: Ty<_>) = seq {
  
negative.code:     o.GetType ()
      |> collectRules
  
    let newEmpty () = {
      rulesCache = Dictionary<_, _> ()
      treesCache = Dictionary<_, _> ()
      rules = HashEqSet.empty
      tree = TyTree.build []
    }
  
    let maybeAddRules (o: obj) ruleSet =
      match o with
  