anchor.diff:            (objEnv, None)
           | (objEnv, Some args) ->
             let ty = Ty.resolve tyEnv ty
  -          match (lazy Ty.containsVars ty,
  -                 lazy (Array.chooseAll
  -                         <| function Value (_, v) -> Some v
  -                                   | Ruled _ -> None
  -                         <| args)) with
  -           | (Force true, _) | (_, Force None) ->
  -             (objEnv, Ruled (ty, args, rule) |> Some)
  -           | (Force false, Force (Some argVals)) ->
  -             let genArgTys =
  -               rule.GenericArgTypes
  -               |> Array.map (Ty.resolve tyEnv >> Ty.toMonoType >> Option.get) // XXX
  -             match rule.Invoke (genArgTys, argVals) with
  -              | None -> (objEnv, None)
  -              | Some o ->
  -                (HashEqMap.add ty o objEnv, Value (ty, o) |> Some)
  +          if Ty.containsVars ty then
  +            (objEnv, Ruled (ty, args, rule) |> Some)
  +          else
  +            match Array.chooseAll
  +                   <| function Value v -> Some v
  +                             | Ruled _ -> None
  +                   <| args with
  +             | None ->
  +               (objEnv, Ruled (ty, args, rule) |> Some)
  +             | Some argVals ->
  +               let genArgTys =
  +                 rule.GenericArgTypes
  +                 |> Array.map (Ty.resolve tyEnv >> Ty.toMonoType >> Option.get)
  +               match rule.Invoke (genArgTys, argVals) with
  +                | None -> (objEnv, None)
  +                | Some o ->
  +                  (HashEqMap.add ty o objEnv, Value o |> Some)
   
     let inline isRec ty =
       match ty with
  
positive.code: 
                     match HashEqMap.tryFind ty objEnv with
                      | Some o ->
                        Seq.singleton (Value (ty, o), objEnv, tyEnv)
                      | None ->
                        let recTy = App (Def typedefof<Rec<_>>, [|ty|])
                        tryGenerate' limit rules objEnv tyEnv (ty::stack) recTy
                        |> Seq.tryPick (fun (result, objEnv, tyEnv) ->
                           match result with
                            | Ruled _ -> None
                            | Value (_, recO) ->
                              match recO with
                               | :? IRecObj as recO' ->
                                 let o = recO'.GetObj ()
                                 Some (Value (ty, o),
                                       objEnv
                                       |> HashEqMap.add recTy recO
                                       |> HashEqMap.add ty o,
  
negative.code:     else
        match HashEqMap.tryFind ty objEnv with
         | Some o ->
           Seq.singleton (Value o, objEnv, tyEnv)
         | None ->
           let limit = limit - 1
           RuleSet.rulesFor rules ty
  