anchor.diff:          match x with
           | InterfaceData.Interface(typ, _)
           | InterfaceData.ObjExpr(typ, _) ->
  +            let rec (|TypeIdent|_|) = function
  +                | SynType.Var(SynTypar.Typar(s, req , _), _) ->
  +                    match req with
  +                    | NoStaticReq -> 
  +                        Some ("'" + s.idText)
  +                    | HeadTypeStaticReq -> 
  +                        Some ("^" + s.idText)
  +                | SynType.LongIdent(LongIdentWithDots(xs, _)) ->
  +                    xs |> Seq.map (fun x -> x.idText) |> String.concat "." |> Some
  +                | SynType.App(t, _, ts, _, _, isPostfix, _) ->
  +                    match t, ts with
  +                    | TypeIdent typeName, [] -> Some typeName
  +                    | TypeIdent typeName, [TypeIdent typeArg] -> 
  +                        if isPostfix then 
  +                            Some (sprintf "%s %s" typeArg typeName)
  +                        else
  +                            Some (sprintf "%s<%s>" typeName typeArg)
  +                    | TypeIdent typeName, _ -> 
  +                        let typeArgs = ts |> Seq.choose (|TypeIdent|_|) |> String.concat ", "
  +                        if isPostfix then 
  +                            Some (sprintf "(%s) %s" typeArgs typeName)
  +                        else
  +                            Some(sprintf "%s<%s>" typeName typeArgs)
  +                    | _ ->
  +                        debug "Unsupported case with %A and %A" t ts
  +                        None
  +                | SynType.Anon _ -> 
  +                    Some "_"
  +                | SynType.Tuple(ts, _) ->
  +                    Some (ts |> Seq.choose (snd >> (|TypeIdent|_|)) |> String.concat " * ")
  +                | SynType.Array(dimension, TypeIdent typeName, _) ->
  +                    Some (sprintf "%s [%s]" typeName (new String(',', dimension-1)))
  +                | SynType.MeasurePower(TypeIdent typeName, power, _) ->
  +                    Some (sprintf "%s^%i" typeName power)
  +                | SynType.MeasureDivide(TypeIdent numerator, TypeIdent denominator, _) ->
  +                    Some (sprintf "%s/%s" numerator denominator)
  +                | _ -> 
  +                    None
               match typ with
               | SynType.App(_, _, ts, _, _, _, _)
               | SynType.LongIdentApp(_, _, _, ts, _, _, _) ->
  -                let (|TypeIdent|_|) = function
  -                    | SynType.Var(SynTypar.Typar(s, req , _), _) ->
  -                        match req with
  -                        | NoStaticReq -> 
  -                            Some ("'" + s.idText)
  -                        | HeadTypeStaticReq -> 
  -                            Some ("^" + s.idText)
  -                    | SynType.LongIdent(LongIdentWithDots(xs, _)) ->
  -                        xs |> Seq.map (fun x -> x.idText) |> String.concat "." |> Some
  -                    | _ -> 
  -                        None
                   ts |> Seq.choose (|TypeIdent|_|) |> Seq.toArray
               | _ ->
                   [||]
  
positive.code:     let rec internal getInterfaces (e: FSharpEntity) = 
          seq { for iface in e.AllInterfaces ->
                  let typ = getNonAbbreviatedType iface
                  typ.TypeDefinition 
          }
          |> Seq.distinct
  
      /// Get members in the decreasing order of inheritance chain
      let internal getInterfaceMembers (e: FSharpEntity) = 
          seq {
              for iface in getInterfaces e do
                  yield! iface.MembersFunctionsAndValues |> Seq.filter (fun m -> 
                             // Use this hack when FCS doesn't return enough information on .NET properties
                             iface.IsFSharp || not m.IsProperty)
           }
  
      let countInterfaceMembers e =
  
negative.code: 
          let modifiers =
              [ if v.InlineAnnotation = FSharpInlineAnnotation.AlwaysInline then yield "inline"
                if v.Accessibility.IsInternal then yield "internal" ]
  
          let argInfos = 
              v.CurriedParameterGroups |> Seq.map Seq.toList |> Seq.toList 
  