anchor.diff:                              else
                                   let signature =
   
  -                                    let cs = getColourScheme()
  -
                                       let backupSignature = func.FullType.Format symbolUse.DisplayContext
                                       let argInfos =
                                           func.CurriedParameterGroups 
                                           |> Seq.map Seq.toList 
                                           |> Seq.toList 
   
  -                                    let retType = hl (GLib.Markup.EscapeText(func.ReturnParameter.Type.Format symbolUse.DisplayContext)) cs.UserTypes
  +                                    let retType = Highlight.asUserType (escapeText(func.ReturnParameter.Type.Format symbolUse.DisplayContext))
   
                                       //example of building up the parameters using Display name and Type
                                       let signature =
  -                                        let padLength = argInfos |> List.concat |> List.map (fun p -> p.DisplayName.Length) |> List.max
  -                                        let parameters = 
  -                                            match argInfos with
  -                                            | [] -> retType
  -                                            | [[single]] -> "   " + single.DisplayName + hl ": " cs.KeywordOperators + hl (GLib.Markup.EscapeText(single.Type.Format symbolUse.DisplayContext)) cs.UserTypes
  -                                            | many ->
  +                                        let padLength = 
  +                                            let allLengths = argInfos |> List.concat |> List.map (fun p -> p.DisplayName.Length)
  +                                            match allLengths with
  +                                            | [] -> 0
  +                                            | l -> l |> List.max
  +
  +                                        match argInfos with
  +                                        | [] -> retType //When does this occur, val type within  module?
  +                                        | [[]] -> retType //A ctor with () parameters seems to be a list with an empty list
  +                                        | [[single]] -> "   " + single.DisplayName + Highlight.asSymbol ":" ++ Highlight.asUserType (escapeText (single.Type.Format symbolUse.DisplayContext))
  +                                                        + "\n   " +  Highlight.asSymbol "->" ++ retType
  +                                        | many ->
  +                                            let allParams =
                                                   many
                                                   |> List.map(fun listOfParams ->
  +
                                                                   listOfParams
                                                                   |> List.map(fun (p:FSharpParameter) ->
  -                                                                                "   " + p.DisplayName.PadRight (padLength) + hl ": " cs.KeywordOperators + hl (GLib.Markup.EscapeText(p.Type.Format symbolUse.DisplayContext)) cs.UserTypes)
  -                                                                                |> String.concat (hl " * " cs.KeywordOperators + "\n"))
  -                                                |> String.concat (hl " ->" cs.KeywordOperators + "\n")
  -                                        parameters + hl ("\n   " + (String.replicate (padLength-1) " ") +  "-> ") cs.KeywordOperators + retType
  +                                                                                "   " + p.DisplayName.PadRight (padLength) + Highlight.asSymbol ":" ++ Highlight.asUserType (escapeText (p.Type.Format symbolUse.DisplayContext)))
  +                                                                                |> String.concat (Highlight.asSymbol " *" ++ "\n"))
  +                                                |> String.concat (Highlight.asSymbol " ->" + "\n") 
  +                                            allParams +  "\n   " + (String.replicate (max (padLength-1) 0) " ") +  Highlight.asSymbol "->" ++ retType
   
                                       let modifiers = 
                                           if func.IsMember then 
  
positive.code: | ToolTip of string * XmlDoc * TextSegment
  | EmptyTip
  
  [<AutoOpen>]
  module NewTooltips =
      let getColourScheme () =
          Highlighting.SyntaxModeService.GetColorStyle (IdeApp.Preferences.ColorScheme)
  
  
negative.code:         let color = getColourScheme().GetForeground (style) |> GtkUtil.ToGdkColor
          let  colorString = HelperMethods.GetColorString (color)
          "<span foreground=\"" + colorString + "\">" + str + "</span>"
  
      let asSymbol s =
          let cs = getColourScheme ()
          hl s cs.KeywordOperators
  
      let asKeyword k =
          let cs = getColourScheme ()
          hl k cs.KeywordTypes
      
      let asUserType u =
          let cs = getColourScheme ()
          hl u cs.UserTypes
  
  [<AutoOpen>]
  module NewTooltips =
  
      let escapeText = GLib.Markup.EscapeText
  
      /// Add two strings with a space between
      let (++) a b = a + " " + b
  