anchor.diff:  let parameterAndTypeToTS parameterName (fsharpType:FSharpType) =
   
       //We have to check it's not some of these or will throw on accessing TypeDefinition
  +    //TODO: handle abbreviations
       let isOption =
           fsharpType.IsAbbreviation &&
           not fsharpType.IsGenericParameter &&
  
positive.code:         | Type singleType -> sprintf "\t\t\t%s%s: %s;" case.DisplayName optional (typeToTS singleType)
          | Types types -> sprintf "\t\t\t%s%s: %s;" case.DisplayName optional "OnlySupportSingleTypeCases"
  
      let casesAsString (cases:IList<FSharpUnionCase>) = cases |> Seq.map (cases |> caseAsString) |> String.concat "\n"
      let simpleCasesAsString (cases:IList<FSharpUnionCase>) = cases |> Seq.map (fun case -> "\"" + case.DisplayName + "\"") |> String.concat " | "
  
  
      let unionsAsString = unions |> Seq.map (fun union -> match union.UnionCases with
                                                              | Mixture cases -> sprintf "\t\texport interface %s {\n%s\n\t\t}" (entityNameToString union) (casesAsString cases)
                                                              | AllJustNames cases -> sprintf "\t\texport type %s = %s" union.DisplayName (simpleCasesAsString cases))
  
      //Classes
  
negative.code:         | 1 -> Type case.UnionCaseFields.[0].FieldType
          | _ -> Types case.UnionCaseFields.[0]
  
      let (|AllJustNames|NamesAndNumbers|ComplexTypes|) (cases:IList<FSharpUnionCase>) =
          if cases |> Seq.exists (fun case -> case.UnionCaseFields.Count > 0) then
              if cases |> Seq.collect (fun case -> case.UnionCaseFields) |> Seq.exists (fun field -> not (isNumber field.FieldType)) then
                  ComplexTypes cases
              else
                  NamesAndNumbers cases
          else
              AllJustNames cases
  
  