anchor.diff:              | _                         -> "type"
   
           let enumtip () =
  -            asSymbol " =" + "\n" +
  -            asSymbol "|" ++
  +            " =\n" +
  +            "|" ++
               (fse.FSharpFields
               |> Seq.filter (fun f -> not f.IsCompilerGenerated)
               |> Seq.map (fun field -> match field.LiteralValue with
  -                                     | Some lv -> field.Name + asSymbol " = " + asType Number (string lv)
  +                                     | Some lv -> field.Name + " = " + (string lv)
                                        | None -> field.Name )
  -            |> String.concat ("\n" + asSymbol "| " ) )
  +            |> String.concat ("\n" + "| " ) )
   
           let uniontip () =
  -            asSymbol " =" + "\n" +
  -            asSymbol "|" ++ (fse.UnionCases
  +            " =" + "\n" +
  +            "|" ++ (fse.UnionCases
                                     |> Seq.map (getUnioncaseSignature displayContext)
  -                                  |> String.concat ("\n" + asSymbol "| " ) )
  +                                  |> String.concat ("\n" + "| " ) )
   
           let delegateTip () =
               let invoker =
                   fse.MembersFunctionsAndValues |> Seq.find (fun f -> f.DisplayName = "Invoke")
               let invokerSig = getFuncSignatureWithFormat displayContext invoker {Indent=6;Highlight=None}
  -            asSymbol " =" + "\n" +
  -            "   " + asKeyword "delegate" + " of\n" + invokerSig
  +            " =" + "\n" +
  +            "   " + "delegate" + " of\n" + invokerSig
   
           let typeDisplay =
               let name =
                   if fse.GenericParameters.Count > 0 then
                       let p = fse.GenericParameters |> Seq.map (formatGenericParameter displayContext) |> String.concat ","
  -                    asUserType fse.DisplayName + asBrackets (escapeText "<") + asUserType p + asBrackets (escapeText ">")
  -                else asUserType fse.DisplayName
  -
  -            let basicName = modifier + asKeyword typeName ++ name
  +                    fse.DisplayName + (escapeText "<") + p + (escapeText ">")
  +                else fse.DisplayName
  +
  +            let basicName = modifier + typeName ++ name
   
               if fse.IsFSharpAbbreviation then
                   let unannotatedType = fse.UnAnnotate()
  -                basicName ++ asBrackets "=" ++ asKeyword (escapeText unannotatedType.DisplayName)
  +                basicName ++ "=" ++ (escapeText unannotatedType.DisplayName)
               else
                   basicName
   
  
positive.code:                     | _, _ -> c.MemberName, false
  
                  seq {
                      yield asSymbol " : ("
                      if c.MemberIsStatic then yield asKeyword "static "
  
                      yield asKeyword "member "
                      yield asUserType formattedMemberName
                      yield asSymbol " : "
  
                      if isProperty then
                          yield asUserType (c.MemberReturnType.Format displayContext)
                      else
                          if c.MemberArgumentTypes.Count <= 1 then
                              yield asUserType "unit"
                          else
                              yield asGenericParamName param
                          yield asSymbol " -> "
                          yield asUserType ((c.MemberReturnType.Format displayContext).TrimStart())
  
                      yield asBrackets ")"
                  }
  
              let typeConstraint (tc: FSharpType) =
                  seq {
                      yield asSymbol " :> "
                      yield asUserType (tc.Format displayContext)
                  }
  
              let constructorConstraint () =
                  seq {
                      yield asSymbol " : "
                      yield asBrackets "("
                      yield asKeyword "new"
                      yield asSymbol " : "
                      yield asKeyword "unit"
                      yield asSymbol " -> '"
                      yield param.DisplayName
                      yield asBrackets ")"
                  }
              let enumConstraint (ec: FSharpType) =
                  seq {
                      yield asSymbol " : "
                      yield asKeyword "enum"
                      yield asBrackets (escapeText "<")
                      yield asUserType (ec.Format displayContext)
                      yield asBrackets (escapeText ">")
                  }
  
              let delegateConstraint (tc: FSharpGenericParameterDelegateConstraint) =
                  seq {
                      yield asSymbol " : "
                      yield asKeyword "delegate"
                      yield asBrackets (escapeText "<")
                      yield asUserType (tc.DelegateTupledArgumentType.Format displayContext)
                      yield asSymbol ", "
                      yield asUserType (tc.DelegateReturnType.Format displayContext)
                      yield asBrackets (escapeText ">")
                  }
  
              let symbols =
                  match constrainedBy with
                  | _ when constrainedBy.IsCoercesToConstraint -> typeConstraint constrainedBy.CoercesToTarget
                  | _ when constrainedBy.IsMemberConstraint -> memberConstraint constrainedBy.MemberConstraintData
                  | _ when constrainedBy.IsSupportsNullConstraint -> seq { yield asSymbol " : "; yield asKeyword "null" }
                  | _ when constrainedBy.IsRequiresDefaultConstructorConstraint -> constructorConstraint()
                  | _ when constrainedBy.IsReferenceTypeConstraint -> seq { yield asSymbol " : "; yield asKeyword "not struct" }
                  | _ when constrainedBy.IsEnumConstraint -> enumConstraint constrainedBy.EnumConstraintTarget
                  | _ when constrainedBy.IsComparisonConstraint -> seq { yield asSymbol " : "; yield asKeyword "comparison" }
                  | _ when constrainedBy.IsEqualityConstraint -> seq { yield asSymbol " : "; yield asKeyword "equality" }
                  | _ when constrainedBy.IsDelegateConstraint -> delegateConstraint constrainedBy.DelegateConstraintData
                  | _ when constrainedBy.IsUnmanagedConstraint -> seq { yield asSymbol " : "; yield asKeyword "unmanaged"}
                  | _ when constrainedBy.IsNonNullableValueTypeConstraint -> seq { yield asSymbol " : "; yield asKeyword "struct" }
                  | _ -> Seq.empty
  
              seq {
                  yield asKeyword " when "
                  yield asGenericParamName param
                  yield! symbols
              }
  
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"
  
  