anchor.diff:  
       let unions = nested |> Seq.filter (fun entity -> entity.IsFSharpUnion)
   
  +    let isNumber (type_:FSharpType) =
  +
  +        let reallyType = if type_.IsAbbreviation then type_.AbbreviatedType else type_
  +
  +        reallyType.HasTypeDefinition &&
  +        not reallyType.IsAbbreviation &&
  +        not reallyType.IsGenericParameter &&
  +        not reallyType.IsFunctionType &&
  +        not reallyType.IsTupleType &&
  +        (reallyType.TypeDefinition.DisplayName = "Double" || //Bit much to assume this is the right "option"
  +         reallyType.TypeDefinition.DisplayName = "int32")
  +
       let (|JustName|Type|Types|) (case:FSharpUnionCase) =
   
           match case.UnionCaseFields.Count with
  
positive.code: let parameterAndTypeToTS parameterName (fsharpType:FSharpType) =
  
      //We have to check it's not some of these or will throw on accessing TypeDefinition
      let isOption =
          fsharpType.IsAbbreviation &&
          not fsharpType.IsGenericParameter &&
  
negative.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 nameOrNumberToString (case:FSharpUnionCase) =
          if case.UnionCaseFields.Count = 1 && isNumber case.UnionCaseFields.[0].FieldType then
              sprintf "{ %s: number }" case.DisplayName
          else
              "\"" + case.DisplayName + "\""
  
      let casesAsString (cases:IList<FSharpUnionCase>) = cases |> Seq.map (cases |> caseAsString) |> String.concat "\n"
      
      let namesAndNumbersCasesAsString (cases:IList<FSharpUnionCase>) = cases |> Seq.map (fun case -> nameOrNumberToString case) |> String.concat " | "
  
      let simpleCasesAsString (cases:IList<FSharpUnionCase>) = cases |> Seq.map (fun case -> nameOrNumberToString case) |> String.concat " | "
  
  
      let unionsAsString = unions |> Seq.map (fun union -> match union.UnionCases with
                                                              | ComplexTypes cases -> sprintf "\t\texport interface %s {\n%s\n\t\t}" (entityNameToString union) (casesAsString cases)
                                                              | NamesAndNumbers cases -> sprintf "\t\texport type %s = %s" union.DisplayName (namesAndNumbersCasesAsString cases)
                                                              | AllJustNames cases -> sprintf "\t\texport type %s = %s" union.DisplayName (simpleCasesAsString cases))
  
      //Classes
  