anchor.diff:                    List.zip many allParamsLengths
                     |> List.map(fun (paramTypes, length) ->
                                     paramTypes
  -                                  |> List.map(fun p -> formatName indent padLength p ++ asUserType (parameterTypeWithPadding p length))
  -                                  |> String.concat (asSymbol " *" ++ "\n"))
  -                  |> String.concat (asSymbol "->" + "\n")
  +                                  |> List.map(fun p -> formatName indent padLength p ++ (parameterTypeWithPadding p length))
  +                                  |> String.concat (" *" ++ "\n"))
  +                  |> String.concat ("->\n")
   
                 let typeArguments =
  -                  allParams +  "\n" + indent + (String.replicate (max (padLength-1) 0) " ") +  asSymbol "->" ++ retType
  +                  allParams +  "\n" + indent + (String.replicate (max (padLength-1) 0) " ") + "->" ++ retType
   
                 if isDelegate then typeArguments
  -              else asKeyword modifiers ++ functionName ++ asSymbol ":" + "\n" + typeArguments
  +              else modifiers ++ functionName ++ ":" + "\n" + typeArguments
   
       let getFuncSignature f c = getFuncSignatureWithFormat f c FormatOptions.Default
   
       let getEntitySignature displayContext (fse: FSharpEntity) =
           let modifier =
               match fse.Accessibility with
  -            | a when a.IsInternal -> asKeyword "internal "
  -            | a when a.IsPrivate -> asKeyword "private "
  +            | a when a.IsInternal -> "internal "
  +            | a when a.IsPrivate -> "private "
               | _ -> ""
   
           let typeName =
  
positive.code:         else typeDisplay + fullName
  
      let getValSignature displayContext (v:FSharpMemberOrFunctionOrValue) =
          let retType = asUserType (escapeText(v.FullType.Format(displayContext)))
          let prefix =
              if v.IsMutable then asKeyword "val" ++ asKeyword "mutable"
              else asKeyword "val"
          let name =
              if v.DisplayName.StartsWith "( "
              then PrettyNaming.QuoteIdentifierIfNeeded v.LogicalName
              else v.DisplayName
          prefix ++ name ++ asSymbol ":" ++ retType
  
      let getFieldSignature displayContext (field: FSharpField) =
          let retType = asUserType (escapeText(field.FieldType.Format displayContext))
          match field.LiteralValue with
          | Some lv -> field.DisplayName ++ asSymbol ":" ++ retType ++ asSymbol "=" ++ asType Number (string lv)
          | None ->
              let prefix =
                  if field.IsMutable then asKeyword "val" ++ asKeyword "mutable"
                  else asKeyword "val"
              prefix ++ field.DisplayName ++ asSymbol ":" ++ retType
  
      let getAPCaseSignature displayContext (apc:FSharpActivePatternCase) =
        let findVal =
  
negative.code:         let retType =
              //This try block will be removed when FCS updates
              try
                  escapeText(func.ReturnParameter.Type.Format displayContext)
              with _ex ->
                  try
                      if func.FullType.GenericArguments.Count > 0 then
                          let lastArg = func.FullType.GenericArguments |> Seq.last
                          escapeText(lastArg.Format displayContext)
                      else "Unknown"
                  with _ -> "Unknown"
  
  