anchor.diff:      let internal hasAttrib<'T> (attribs: IList<FSharpAttribute>) = 
           attribs |> Seq.exists (fun a -> isAttrib<'T>(a))
   
  -    let internal (|MeasureProd|_|) (typ: FSharpType) = 
  -        if typ.HasTypeDefinition && typ.TypeDefinition.LogicalName = "*" && typ.GenericArguments.Count = 2 then
  -            Some (typ.GenericArguments.[0], typ.GenericArguments.[1])
  -        else None
  -
  -    let internal (|MeasureInv|_|) (typ: FSharpType) = 
  -        if typ.HasTypeDefinition && typ.TypeDefinition.LogicalName = "/" && typ.GenericArguments.Count = 1 then 
  -            Some typ.GenericArguments.[0]
  -        else None
  -
  -    let internal (|MeasureOne|_|) (typ: FSharpType) = 
  -        if typ.HasTypeDefinition && typ.TypeDefinition.LogicalName = "1" && typ.GenericArguments.Count = 0 then 
  -            Some ()
  -        else None
  -
       let internal getTypeParameterName (typar: FSharpGenericParameter) =
           (if typar.IsSolveAtCompileTime then "^" else "'") + typar.Name
   
  -    let internal formatTypeArgument (ctx: Context) (typar: FSharpGenericParameter) =
  -        let genericName = getTypeParameterName typar
  -        match ctx.TypeInstantations.TryFind(genericName) with
  -        | Some specificName ->
  -            specificName
  -        | None ->
  -            genericName
  -
  -    let internal formatTypeArguments ctx (typars:seq<FSharpGenericParameter>) =
  -        Seq.map (formatTypeArgument ctx) typars |> List.ofSeq
  -
       let internal bracket (str: string) = 
           if str.Contains(" ") then "(" + str + ")" else str
   
       let internal formatType ctx (typ: FSharpType) =
  -        let genericDefinition = typ.Format(ctx.DisplayContext)
  +        let genericDefinition = typ.Instantiate(Seq.toList ctx.ArgInstantiations).Format(ctx.DisplayContext)
           (genericDefinition, ctx.TypeInstantations)
           ||> Map.fold (fun s k v -> s.Replace(k, v))
   
  
positive.code:                 |> Seq.fold (fun acc (x, y) -> Map.add x y acc) insts
              else insts
  
          let ctx = { Writer = writer; TypeInstantations = instantiations; Indentation = indentation; 
                      ObjectIdent = objectIdent; MethodBody = lines; DisplayContext = displayContext }
          writer.Indent startColumn
          for v in getInterfaceMembers e do
              formatMember ctx v
          writer.Dump()
  
      let internal (|IndexerArg|) = function
  
negative.code:         let instantiations = 
              let insts =
                  Seq.zip typeParams typeInstances
                  // Filter out useless instances (replacing with the same name or wildcard)
                  |> Seq.filter(fun (t1, t2) -> t1 <> t2 && t2 <> "_") 
                  |> Map.ofSeq
              // A simple hack to handle instantiation of type alias 
              if e.IsFSharpAbbreviation then
  