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:             | :? FSharpField as fsf -> fsf.XmlDoc, fsf.XmlDocSig
              | _ -> ResizeArray() :> IList<_>, ""
  
          if xmlDoc.Count > 0 then Full (String.Join( "\n", xmlDoc |> Seq.map GLib.Markup.EscapeText))
          else
              if String.IsNullOrWhiteSpace xmlDocSig then XmlDoc.EmptyDoc
              else Lookup(xmlDocSig, symbolUse.Symbol.Assembly.FileName)
  
negative.code:                                             elif func.IsInstanceMember then "val"
                                              else "val" //does this need to be static prefixed?
  
                                      Highlight.asKeyword modifiers ++ func.DisplayName ++ Highlight.asSymbol ":" + "\n" + signature
  
                                  ToolTip(signature, getSummaryFromSymbol symbolUse, getSegFromSymbolUse editor symbolUse)                            
  
                      else
                          //val name : Type
                          let signature =
                                  let retType = Highlight.asUserType (escapeText(func.ReturnParameter.Type.Format symbolUse.DisplayContext))
                                  let prefix = 
                                      if func.IsMutable then Highlight.asKeyword "val" ++ Highlight.asKeyword "mutable"
                                      else Highlight.asKeyword "val"
                                  prefix ++ func.DisplayName ++ Highlight.asSymbol ":" ++ retType
  
                          ToolTip(signature, getSummaryFromSymbol symbolUse, getSegFromSymbolUse editor symbolUse)
                      with exn -> ToolTips.EmptyTip
  