anchor.diff:       | Many rs -> yield! rs
        | Branch (at, apps, vars) ->
          match getAt at actual with
  -        | None | Some (Var _) ->
  +        | None | Some (Var' _) ->
             yield! HashEqMap.toSeq apps
                    |> Seq.collect (fun (_, formal) ->
                       filter formal actual)
  -        | Some (App (tc, _)) ->
  +        | Some (App' (tc, _)) ->
             match HashEqMap.tryFind tc apps with
              | None -> ()
              | Some formal ->
  
positive.code:        Some ty
       | i::is ->
         match getAt is ty with
          | Some (App (_, args)) when i < args.Length ->
            Some args.[i]
          | _ ->
            None
  
negative.code: 
    let rec tryMatchIn formal actual v2ty =
      match (resolveTop v2ty formal, resolveTop v2ty actual) with
       | (Var' fv, Var' av) when fv = av ->
         Some v2ty
       | (Var' v, ty) | (ty, Var' v) when not (occurs v2ty v ty) ->
         Some (HashEqMap.add v ty v2ty)
       | (App' (formal, pars), App' (actual, args)) when formal = actual ->
         assert (pars.Length = args.Length)
         let rec loop i v2ty =
           if i < pars.Length then
  