anchor.diff:       | _ ->
          ty
   
  -  /// Fully recursively resolves the type with respect to the given substition
  -  /// of type variables to types.
     let rec resolve v2ty ty =
       match resolveTop v2ty ty with
        | Var v -> Var v
        | App (tc, tys) ->
          App (tc, tys |> Array.map (resolve v2ty))
   
  -  /// Tests whether the type variable `v` occurs in the type `ty` with respect
  -  /// to the given substitution of type variables to types.
     let rec private occurs v2ty v ty =
       match ty with
        | Var v' -> v = v'
  
positive.code:             sprintf "%A%A" t tys
  
  module Ty =
    /// Converts a .Net type to a `Ty`.
    let rec ofType (t: Type) =
      if t.IsArray then
        App (Arr (t.GetArrayRank ()), [|ofType (t.GetElementType ())|])
  
negative.code: 
    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
                 |>!Ty.inPlaceSelectSpecificFirst
                 |> Array.map snd
                 |> Many
               | at::ats ->
                 tyrs
                 |> List.fold
                     (fun (apps, vars) (ty, r) ->
                       match getAt at ty with
                        | None ->
                          failwith "Bug: Only existing positions are be produced?"
                        | Some (Var _) ->
                          (apps, (ty, r)::vars)
                        | Some (App (tc, args)) ->
  