anchor.diff:                           vars))
                      (HashEqMap.empty, [])
                  |> fun (apps, vars) ->
  +                  // Classify types that had a type variable at the
  +                  // classification position using the remaining positions.
                     let vars = build' ats vars
  +
  +                  // Were some types classified distinct from others at the
  +                  // position `at`?
                     if HashEqMap.isEmpty apps then
  +                    // No, just produce whatever we get from classifying the
  +                    // types that had a variable at the examined position.
                       force vars
                     else
  +                    // Yes, so we produce a branch node.
                       (at,
                        apps
                        |> HashEqMap.map
                            (fun (n, tyds) ->
  -                            build'
  -                             (List.init n (fun i -> i::at) @ ats)
  -                             tyds),
  +                            // Add the new positions in these types to the
  +                            // sequence of positions to classify types against.
  +                            let ats = List.init n (fun i -> i::at) @ ats
  +                            build' ats tyds),
                        vars) |> Branch
   
     /// Builds a type tree corresponding to the given association sequence.
  
positive.code: 
    /// Returns a sequence values from the type tree whose associated types may
    /// unify with the given type.
    let rec filter (formal: TyTree<'r>) (actual: Ty) : seq<'r> =
      match force formal with
       | Empty -> Seq.empty
       | One r -> Seq.singleton r
       | Many rs -> rs :> seq<_>
       | Branch (at, apps, vars) ->
         match getAt at actual with
          | None | Some (Var _) -> seq {
              yield! HashEqMap.toSeq apps
                     |> Seq.collect (fun (_, formal) ->
                        filter formal actual)
              yield! filter vars actual
            }
          | Some (App (tc, args)) ->
            match HashEqMap.tryFind tc apps with
             | None ->
               filter vars actual
             | Some formal ->
               filter formal actual
  
  ////////////////////////////////////////////////////////////////////////////////
  
  
negative.code: /// `T<A, U<[B]>>`.
  type TyCursor = list<int>
  
  /// Represents a mapping of types to values of type `'r` such that given a type,
  /// the type value pairs of the mapping can be filtered based on the given type
  /// and produced in an order from more specific to less specific types with
  