anchor.diff:  
                      match HashEqMap.tryFind ty objEnv with
                       | Some o ->
  -                      Seq.singleton (Value (ty, o), objEnv, tyEnv)
  +                      Seq.singleton (Value 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) ->
  +                          | Value recO ->
                               match recO with
                                | :? IRecObj as recO' ->
                                  let o = recO'.GetObj ()
  -                               Some (Value (ty, o),
  +                               Some (Value o,
                                        objEnv
                                        |> HashEqMap.add recTy recO
                                        |> HashEqMap.add ty o,
  
positive.code:   type ObjEnv<'v when 'v : equality> = HashEqMap<Ty<'v>, obj>
  
    type Result<'v> =
      | Value of ty: Ty<'v> * value: obj
      | Ruled of ty: Ty<'v> * args: array<Result<'v>> * rule: Rule<'v>
  
    let rec tryResolveResult objEnv tyEnv result =
  
negative.code:        |> Seq.tryPick (fun (result, _, _) ->
            match result with
             | Ruled _ -> None
             | Value value -> Some (unbox<'a> value)))
  