anchor.diff:  
     let rec private build' (ats: list<TyCursor>)
                            (tyrs: list<Ty<_> * 'r>) : TyTree<'r> =
  -    // `tyrs` is the remaining association sequence we wish to classify.
       lazy match tyrs with
             | [] -> Empty
             | [(_, r)] -> One r
             | tyrs ->
  -            // `ats` is a sequence of positions that we haven't yet classified
  -            // types against.
               match ats with
                | [] ->
  -               // No more positions to classify against, so we just create a
  -               // leaf consisting of all the remaining values.
                  tyrs
                  |> Array.ofList
                  |>!Ty.inPlaceSelectSpecificFirst
                  |> Array.map snd
                  |> Many
                | at::ats ->
  -               // Classify types based on the position `at`.
                  tyrs
                  |> List.fold
                      (fun (apps, vars) (ty, r) ->
                        match getAt at ty with
                         | None ->
  -                        // This cannot happen, because while building the tree,
  -                        // we only produce positions we know to exist in the
  -                        // types.
  -                        failwith "Bug"
  +                        failwith "Bug: Only existing positions are be produced?"
                         | Some (Var _) ->
                           (apps, (ty, r)::vars)
                         | Some (App (tc, args)) ->
  
positive.code:               apps: HashEqMap<TyCon, TyTree<'r>> *
                vars: TyTree<'r>
  
  /// Operations on type tress.
  module TyTree =
    /// Examines the structure of the given type to determine whether the type has
    /// that position and, if so, returns the type at that position.
    let rec internal getAt (is: TyCursor) ty =
      match is with
       | [] ->
  
negative.code:      | _ ->
         ty
  
    let rec resolve v2ty ty =
      match resolveTop v2ty ty with
       | Var v -> Var v
       | App (tc, tys) ->
         App (tc, tys |> Array.map (resolve v2ty))
  
    let rec private occurs v2ty v ty =
      match ty with
       | Var v' -> v = v'
  