anchor.diff:          else typeDisplay + fullName
   
       let getValSignature displayContext (v:FSharpMemberOrFunctionOrValue) =
  -        let retType = asUserType (escapeText(v.FullType.Format(displayContext)))
  +        let retType = (escapeText(v.FullType.Format(displayContext)))
           let prefix =
  -            if v.IsMutable then asKeyword "val" ++ asKeyword "mutable"
  -            else asKeyword "val"
  +            if v.IsMutable then "val" ++ "mutable"
  +            else "val"
           let name =
               if v.DisplayName.StartsWith "( "
               then PrettyNaming.QuoteIdentifierIfNeeded v.LogicalName
               else v.DisplayName
  -        prefix ++ name ++ asSymbol ":" ++ retType
  +        prefix ++ name ++ ":" ++ retType
   
       let getFieldSignature displayContext (field: FSharpField) =
  -        let retType = asUserType (escapeText(field.FieldType.Format displayContext))
  +        let retType = (escapeText(field.FieldType.Format displayContext))
           match field.LiteralValue with
  -        | Some lv -> field.DisplayName ++ asSymbol ":" ++ retType ++ asSymbol "=" ++ asType Number (string lv)
  +        | Some lv -> field.DisplayName ++ ":" ++ retType ++ "=" ++ (string lv)
           | None ->
               let prefix =
  -                if field.IsMutable then asKeyword "val" ++ asKeyword "mutable"
  -                else asKeyword "val"
  -            prefix ++ field.DisplayName ++ asSymbol ":" ++ retType
  +                if field.IsMutable then "val" ++ "mutable"
  +                else "val"
  +            prefix ++ field.DisplayName ++ ":" ++ retType
   
       let getAPCaseSignature displayContext (apc:FSharpActivePatternCase) =
         let findVal =
  
positive.code:         if unionCase.UnionCaseFields.Count > 0 then
              let typeList =
                  unionCase.UnionCaseFields
                  |> Seq.map (fun unionField -> unionField.Name ++ asSymbol ":" ++ asUserType (escapeText (unionField.FieldType.Format displayContext)))
                  |> String.concat (asSymbol " * " )
              unionCase.DisplayName ++ asKeyword "of" ++ typeList
           else unionCase.DisplayName
  
      let formatGenericParameter displayContext (param:FSharpGenericParameter) =
  
negative.code:             match format.Highlight with
              | Some paramName when paramName = name ->
                  match padding - name.Length with
                  | i when i > 0 -> indent + asUnderline name + String.replicate i " " + ":"
                  | _ -> indent + asUnderline name + ":"
              | _ -> indent + name.PadRight padding + ":"
  
          let isDelegate =
              match func.EnclosingEntitySafe with
              | Some ent -> ent.IsDelegate
              | _ ->
                  LoggingService.logWarning "getFuncSignatureWithFormat: No enclosing entity found for: %s" func.DisplayName
                  false
  
          match argInfos with
          | [] ->
              //When does this occur, val type within  module?
              if isDelegate then retType
              else modifiers ++ functionName ++ ":" ++ retType
  
          | [[]] ->
              //A ctor with () parameters seems to be a list with an empty list
              if isDelegate then retType
              else modifiers ++ functionName ++ "() :" ++ retType
          | many ->
                let allParamsLengths =
                    many |> List.map (List.map (fun p -> (p.Type.Format displayContext).Length) >> List.sum)
  