anchor.diff:  
     /// 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> =
  +  let rec filter (formal: TyTree<'r>) (actual: Ty) : seq<'r> = seq {
       match force formal with
  -     | Empty -> Seq.empty
  -     | One r -> Seq.singleton r
  -     | Many rs -> rs :> seq<_>
  +     | Empty -> ()
  +     | One r -> yield r
  +     | Many rs -> yield! rs
        | Branch (at, apps, vars) ->
  +       // Does the `actual` type have some non-var type at the branch position?
          match getAt at actual with
  -        | None | Some (Var _) -> seq {
  -            yield! HashEqMap.toSeq apps
  -                   |> Seq.collect (fun (_, formal) ->
  -                      filter formal actual)
  -            yield! filter vars actual
  -          }
  +        | None | Some (Var _) ->
  +          // No, so we can't filter out `apps` types at this branch.
  +          yield! HashEqMap.toSeq apps
  +                 |> Seq.collect (fun (_, formal) ->
  +                    filter formal actual)
           | Some (App (tc, args)) ->
  +          // Yes, so we need only produce those `apps` that have the same tycon.
             match HashEqMap.tryFind tc apps with
  -           | None ->
  -             filter vars actual
  +           | None -> ()
              | Some formal ->
  -             filter formal actual
  +             yield! filter formal actual
  +       // We also need to produce the `vars` types.
  +       yield! filter vars actual
  +  }
   
   ////////////////////////////////////////////////////////////////////////////////
   
  
positive.code: 
  /// Operations on type tress.
  module TyTree =
    let rec private build' (ats: list<TyCursor>) (tyrs: list<Ty * 'r>) : TyTree<'r> =
      lazy match tyrs with
            | [] -> Empty
            | [(_, r)] -> One r
            | tyrs ->
              match ats with
               | [] ->
                 tyrs
                 |> Array.ofList
                 &> inPlaceSelectSpecificFirst
                 |> Array.map snd
                 |> Many
               | at::ats ->
                 tyrs
                 |> List.fold
                     (fun (apps, vars) (ty, r) ->
                       match getAt at ty with
                        | None -> failwith "Bug"
                        | Some (Var _) ->
                          (apps, (ty, r) :: vars)
                        | Some (App (tc, args)) ->
                          (HashEqMap.addOrUpdate tc
                            (fun _ -> (args.Length, [(ty, r)]))
  
negative.code:                          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) ->
                              // 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.
  