anchor.diff:              Writer: ColumnIndentedTextWriter
               /// Map generic types to specific instances for specialized interface implementation
               TypeInstantations: Map<string, string>
  +            /// Data for interface instantiation
  +            ArgInstantiations: (FSharpGenericParameter * FSharpType) seq
               /// Indentation inside method bodies
               Indentation: int
               /// Object identifier of the interface e.g. 'x', 'this', '__', etc.
               ObjectIdent: string
               /// A list of lines represents skeleton of each member
               MethodBody: string []
  +            /// Context in order to display types in the short form
               DisplayContext: FSharpDisplayContext
           }
   
  
positive.code:     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)
          (genericDefinition, ctx.TypeInstantations)
          ||> Map.fold (fun s k v -> s.Replace(k, v))
  
  
negative.code:     let rec internal getInterfaces (e: FSharpEntity) = 
          seq { for iface in e.AllInterfaces ->
                  let typ = getNonAbbreviatedType iface
                  // Argument should be kept lazy so that it is only evaluated when instantiating a new type
                  typ.TypeDefinition, Seq.zip typ.TypeDefinition.GenericParameters typ.GenericArguments
          }
          |> Seq.distinct
  
      /// Get members in the decreasing order of inheritance chain
      let internal getInterfaceMembers (e: FSharpEntity) = 
          seq {
              for (iface, instantiations) in getInterfaces e do
                  yield! iface.MembersFunctionsAndValues |> Seq.choose (fun m -> 
                             // Use this hack when FCS doesn't return enough information on .NET properties
                             if iface.IsFSharp || not m.IsProperty then Some (m, instantiations) else None)
           }
  
      let countInterfaceMembers e =
  