lexical_util/
feature_format.rs1#![cfg(feature = "format")]
18
19use core::num;
699
700use static_assertions::const_assert;
701
702use crate::error::Error;
703use crate::format_builder::NumberFormatBuilder;
704use crate::format_flags as flags;
705
706macro_rules! from_flag {
708 ($format:ident, $flag:ident) => {{
709 $format & flags::$flag != 0
710 }};
711}
712
713#[doc(hidden)]
718pub struct NumberFormat<const FORMAT: u128>;
719
720#[rustfmt::skip]
721impl<const FORMAT: u128> NumberFormat<FORMAT> {
722 pub const fn new() -> Self {
726 Self {}
727 }
728
729 pub const fn is_valid(&self) -> bool {
733 self.error().is_success()
734 }
735
736 #[allow(clippy::if_same_then_else)] pub const fn error(&self) -> Error {
739 if !flags::is_valid_radix(self.mantissa_radix()) {
740 Error::InvalidMantissaRadix
741 } else if !flags::is_valid_radix(self.exponent_base()) {
742 Error::InvalidExponentBase
743 } else if !flags::is_valid_radix(self.exponent_radix()) {
744 Error::InvalidExponentRadix
745 } else if !flags::is_valid_digit_separator(FORMAT) {
746 Error::InvalidDigitSeparator
747 } else if !flags::is_valid_base_prefix(FORMAT) {
748 Error::InvalidBasePrefix
749 } else if !flags::is_valid_base_suffix(FORMAT) {
750 Error::InvalidBaseSuffix
751 } else if !flags::is_valid_punctuation(FORMAT) {
752 Error::InvalidPunctuation
753 } else if !flags::is_valid_exponent_flags(FORMAT) {
754 Error::InvalidExponentFlags
755 } else if self.no_positive_mantissa_sign() && self.required_mantissa_sign() {
756 Error::InvalidMantissaSign
757 } else if self.no_positive_exponent_sign() && self.required_exponent_sign() {
758 Error::InvalidExponentSign
759 } else if self.no_special() && self.case_sensitive_special() {
760 Error::InvalidSpecial
761 } else if self.no_special() && self.special_digit_separator() {
762 Error::InvalidSpecial
763 } else if self.integer_digit_separator_flags() == flags::INTEGER_CONSECUTIVE_DIGIT_SEPARATOR {
764 Error::InvalidConsecutiveIntegerDigitSeparator
765 } else if self.fraction_digit_separator_flags() == flags::FRACTION_CONSECUTIVE_DIGIT_SEPARATOR {
766 Error::InvalidConsecutiveFractionDigitSeparator
767 } else if self.exponent_digit_separator_flags() == flags::EXPONENT_CONSECUTIVE_DIGIT_SEPARATOR {
768 Error::InvalidConsecutiveExponentDigitSeparator
769 } else {
770 Error::Success
771 }
772 }
773
774 pub const REQUIRED_INTEGER_DIGITS: bool = from_flag!(FORMAT, REQUIRED_INTEGER_DIGITS);
778
779 #[inline(always)]
781 pub const fn required_integer_digits(&self) -> bool {
782 Self::REQUIRED_INTEGER_DIGITS
783 }
784
785 pub const REQUIRED_FRACTION_DIGITS: bool = from_flag!(FORMAT, REQUIRED_FRACTION_DIGITS);
787
788 #[inline(always)]
790 pub const fn required_fraction_digits(&self) -> bool {
791 Self::REQUIRED_FRACTION_DIGITS
792 }
793
794 pub const REQUIRED_EXPONENT_DIGITS: bool = from_flag!(FORMAT, REQUIRED_EXPONENT_DIGITS);
796
797 #[inline(always)]
799 pub const fn required_exponent_digits(&self) -> bool {
800 Self::REQUIRED_EXPONENT_DIGITS
801 }
802
803 pub const REQUIRED_MANTISSA_DIGITS: bool = from_flag!(FORMAT, REQUIRED_MANTISSA_DIGITS);
805
806 #[inline(always)]
808 pub const fn required_mantissa_digits(&self) -> bool {
809 Self::REQUIRED_MANTISSA_DIGITS
810 }
811
812 pub const REQUIRED_DIGITS: bool = from_flag!(FORMAT, REQUIRED_DIGITS);
814
815 #[inline(always)]
817 pub const fn required_digits(&self) -> bool {
818 Self::REQUIRED_DIGITS
819 }
820
821 pub const NO_POSITIVE_MANTISSA_SIGN: bool = from_flag!(FORMAT, NO_POSITIVE_MANTISSA_SIGN);
823
824 #[inline(always)]
826 pub const fn no_positive_mantissa_sign(&self) -> bool {
827 Self::NO_POSITIVE_MANTISSA_SIGN
828 }
829
830 pub const REQUIRED_MANTISSA_SIGN: bool = from_flag!(FORMAT, REQUIRED_MANTISSA_SIGN);
832
833 #[inline(always)]
835 pub const fn required_mantissa_sign(&self) -> bool {
836 Self::REQUIRED_MANTISSA_SIGN
837 }
838
839 pub const NO_EXPONENT_NOTATION: bool = from_flag!(FORMAT, NO_EXPONENT_NOTATION);
841
842 #[inline(always)]
844 pub const fn no_exponent_notation(&self) -> bool {
845 Self::NO_EXPONENT_NOTATION
846 }
847
848 pub const NO_POSITIVE_EXPONENT_SIGN: bool = from_flag!(FORMAT, NO_POSITIVE_EXPONENT_SIGN);
850
851 #[inline(always)]
853 pub const fn no_positive_exponent_sign(&self) -> bool {
854 Self::NO_POSITIVE_EXPONENT_SIGN
855 }
856
857 pub const REQUIRED_EXPONENT_SIGN: bool = from_flag!(FORMAT, REQUIRED_EXPONENT_SIGN);
859
860 #[inline(always)]
862 pub const fn required_exponent_sign(&self) -> bool {
863 Self::REQUIRED_EXPONENT_SIGN
864 }
865
866 pub const NO_EXPONENT_WITHOUT_FRACTION: bool = from_flag!(FORMAT, NO_EXPONENT_WITHOUT_FRACTION);
868
869 #[inline(always)]
871 pub const fn no_exponent_without_fraction(&self) -> bool {
872 Self::NO_EXPONENT_WITHOUT_FRACTION
873 }
874
875 pub const NO_SPECIAL: bool = from_flag!(FORMAT, NO_SPECIAL);
877
878 #[inline(always)]
880 pub const fn no_special(&self) -> bool {
881 Self::NO_SPECIAL
882 }
883
884 pub const CASE_SENSITIVE_SPECIAL: bool = from_flag!(FORMAT, CASE_SENSITIVE_SPECIAL);
886
887 #[inline(always)]
889 pub const fn case_sensitive_special(&self) -> bool {
890 Self::CASE_SENSITIVE_SPECIAL
891 }
892
893 pub const NO_INTEGER_LEADING_ZEROS: bool = from_flag!(FORMAT, NO_INTEGER_LEADING_ZEROS);
895
896 #[inline(always)]
898 pub const fn no_integer_leading_zeros(&self) -> bool {
899 Self::NO_INTEGER_LEADING_ZEROS
900 }
901
902 pub const NO_FLOAT_LEADING_ZEROS: bool = from_flag!(FORMAT, NO_FLOAT_LEADING_ZEROS);
904
905 #[inline(always)]
907 pub const fn no_float_leading_zeros(&self) -> bool {
908 Self::NO_FLOAT_LEADING_ZEROS
909 }
910
911 pub const REQUIRED_EXPONENT_NOTATION: bool = from_flag!(FORMAT, REQUIRED_EXPONENT_NOTATION);
913
914 #[inline(always)]
916 pub const fn required_exponent_notation(&self) -> bool {
917 Self::REQUIRED_EXPONENT_NOTATION
918 }
919
920 pub const CASE_SENSITIVE_EXPONENT: bool = from_flag!(FORMAT, CASE_SENSITIVE_EXPONENT);
922
923 #[inline(always)]
925 pub const fn case_sensitive_exponent(&self) -> bool {
926 Self::CASE_SENSITIVE_EXPONENT
927 }
928
929 pub const CASE_SENSITIVE_BASE_PREFIX: bool = from_flag!(FORMAT, CASE_SENSITIVE_BASE_PREFIX);
931
932 #[inline(always)]
934 pub const fn case_sensitive_base_prefix(&self) -> bool {
935 Self::CASE_SENSITIVE_BASE_PREFIX
936 }
937
938 pub const CASE_SENSITIVE_BASE_SUFFIX: bool = from_flag!(FORMAT, CASE_SENSITIVE_BASE_SUFFIX);
940
941 #[inline(always)]
943 pub const fn case_sensitive_base_suffix(&self) -> bool {
944 Self::CASE_SENSITIVE_BASE_SUFFIX
945 }
946
947 pub const INTEGER_INTERNAL_DIGIT_SEPARATOR: bool = from_flag!(FORMAT, INTEGER_INTERNAL_DIGIT_SEPARATOR);
955
956 #[inline(always)]
962 pub const fn integer_internal_digit_separator(&self) -> bool {
963 Self::INTEGER_INTERNAL_DIGIT_SEPARATOR
964 }
965
966 pub const FRACTION_INTERNAL_DIGIT_SEPARATOR: bool = from_flag!(FORMAT, FRACTION_INTERNAL_DIGIT_SEPARATOR);
972
973 #[inline(always)]
979 pub const fn fraction_internal_digit_separator(&self) -> bool {
980 Self::FRACTION_INTERNAL_DIGIT_SEPARATOR
981 }
982
983 pub const EXPONENT_INTERNAL_DIGIT_SEPARATOR: bool = from_flag!(FORMAT, EXPONENT_INTERNAL_DIGIT_SEPARATOR);
989
990 #[inline(always)]
996 pub const fn exponent_internal_digit_separator(&self) -> bool {
997 Self::EXPONENT_INTERNAL_DIGIT_SEPARATOR
998 }
999
1000 pub const INTERNAL_DIGIT_SEPARATOR: bool = from_flag!(FORMAT, INTERNAL_DIGIT_SEPARATOR);
1006
1007 #[inline(always)]
1013 pub const fn internal_digit_separator(&self) -> bool {
1014 Self::INTERNAL_DIGIT_SEPARATOR
1015 }
1016
1017 pub const INTEGER_LEADING_DIGIT_SEPARATOR: bool = from_flag!(FORMAT, INTEGER_LEADING_DIGIT_SEPARATOR);
1022
1023 #[inline(always)]
1028 pub const fn integer_leading_digit_separator(&self) -> bool {
1029 Self::INTEGER_LEADING_DIGIT_SEPARATOR
1030 }
1031
1032 pub const FRACTION_LEADING_DIGIT_SEPARATOR: bool = from_flag!(FORMAT, FRACTION_LEADING_DIGIT_SEPARATOR);
1037
1038 #[inline(always)]
1043 pub const fn fraction_leading_digit_separator(&self) -> bool {
1044 Self::FRACTION_LEADING_DIGIT_SEPARATOR
1045 }
1046
1047 pub const EXPONENT_LEADING_DIGIT_SEPARATOR: bool = from_flag!(FORMAT, EXPONENT_LEADING_DIGIT_SEPARATOR);
1052
1053 #[inline(always)]
1058 pub const fn exponent_leading_digit_separator(&self) -> bool {
1059 Self::EXPONENT_LEADING_DIGIT_SEPARATOR
1060 }
1061
1062 pub const LEADING_DIGIT_SEPARATOR: bool = from_flag!(FORMAT, LEADING_DIGIT_SEPARATOR);
1067
1068 #[inline(always)]
1073 pub const fn leading_digit_separator(&self) -> bool {
1074 Self::LEADING_DIGIT_SEPARATOR
1075 }
1076
1077 pub const INTEGER_TRAILING_DIGIT_SEPARATOR: bool = from_flag!(FORMAT, INTEGER_TRAILING_DIGIT_SEPARATOR);
1082
1083 #[inline(always)]
1088 pub const fn integer_trailing_digit_separator(&self) -> bool {
1089 Self::INTEGER_TRAILING_DIGIT_SEPARATOR
1090 }
1091
1092 pub const FRACTION_TRAILING_DIGIT_SEPARATOR: bool = from_flag!(FORMAT, FRACTION_TRAILING_DIGIT_SEPARATOR);
1097
1098 #[inline(always)]
1103 pub const fn fraction_trailing_digit_separator(&self) -> bool {
1104 Self::FRACTION_TRAILING_DIGIT_SEPARATOR
1105 }
1106
1107 pub const EXPONENT_TRAILING_DIGIT_SEPARATOR: bool = from_flag!(FORMAT, EXPONENT_TRAILING_DIGIT_SEPARATOR);
1112
1113 #[inline(always)]
1118 pub const fn exponent_trailing_digit_separator(&self) -> bool {
1119 Self::EXPONENT_TRAILING_DIGIT_SEPARATOR
1120 }
1121
1122 pub const TRAILING_DIGIT_SEPARATOR: bool = from_flag!(FORMAT, TRAILING_DIGIT_SEPARATOR);
1127
1128 #[inline(always)]
1133 pub const fn trailing_digit_separator(&self) -> bool {
1134 Self::TRAILING_DIGIT_SEPARATOR
1135 }
1136
1137 pub const INTEGER_CONSECUTIVE_DIGIT_SEPARATOR: bool = from_flag!(FORMAT, INTEGER_CONSECUTIVE_DIGIT_SEPARATOR);
1139
1140 #[inline(always)]
1142 pub const fn integer_consecutive_digit_separator(&self) -> bool {
1143 Self::INTEGER_CONSECUTIVE_DIGIT_SEPARATOR
1144 }
1145
1146 pub const FRACTION_CONSECUTIVE_DIGIT_SEPARATOR: bool = from_flag!(FORMAT, FRACTION_CONSECUTIVE_DIGIT_SEPARATOR);
1148
1149 #[inline(always)]
1151 pub const fn fraction_consecutive_digit_separator(&self) -> bool {
1152 Self::FRACTION_CONSECUTIVE_DIGIT_SEPARATOR
1153 }
1154
1155 pub const EXPONENT_CONSECUTIVE_DIGIT_SEPARATOR: bool = from_flag!(FORMAT, EXPONENT_CONSECUTIVE_DIGIT_SEPARATOR);
1157
1158 #[inline(always)]
1160 pub const fn exponent_consecutive_digit_separator(&self) -> bool {
1161 Self::EXPONENT_CONSECUTIVE_DIGIT_SEPARATOR
1162 }
1163
1164 pub const CONSECUTIVE_DIGIT_SEPARATOR: bool = from_flag!(FORMAT, CONSECUTIVE_DIGIT_SEPARATOR);
1166
1167 #[inline(always)]
1169 pub const fn consecutive_digit_separator(&self) -> bool {
1170 Self::CONSECUTIVE_DIGIT_SEPARATOR
1171 }
1172
1173 pub const SPECIAL_DIGIT_SEPARATOR: bool = from_flag!(FORMAT, SPECIAL_DIGIT_SEPARATOR);
1175
1176 #[inline(always)]
1178 pub const fn special_digit_separator(&self) -> bool {
1179 Self::SPECIAL_DIGIT_SEPARATOR
1180 }
1181
1182 pub const DIGIT_SEPARATOR: u8 = flags::digit_separator(FORMAT);
1186
1187 #[inline(always)]
1191 pub const fn digit_separator(&self) -> u8 {
1192 Self::DIGIT_SEPARATOR
1193 }
1194
1195 pub const BASE_PREFIX: u8 = flags::base_prefix(FORMAT);
1197
1198 #[inline(always)]
1205 pub const fn base_prefix(&self) -> u8 {
1206 Self::BASE_PREFIX
1207 }
1208
1209 #[inline(always)]
1211 pub const fn has_base_prefix(&self) -> bool {
1212 self.base_prefix() != 0
1213 }
1214
1215 pub const BASE_SUFFIX: u8 = flags::base_suffix(FORMAT);
1217
1218 #[inline(always)]
1225 pub const fn base_suffix(&self) -> u8 {
1226 Self::BASE_SUFFIX
1227 }
1228
1229 #[inline(always)]
1231 pub const fn has_base_suffix(&self) -> bool {
1232 self.base_suffix() != 0
1233 }
1234
1235 pub const MANTISSA_RADIX: u32 = flags::mantissa_radix(FORMAT);
1239
1240 #[inline(always)]
1242 pub const fn mantissa_radix(&self) -> u32 {
1243 Self::MANTISSA_RADIX
1244 }
1245
1246 pub const RADIX: u32 = Self::MANTISSA_RADIX;
1249
1250 #[inline(always)]
1252 pub const fn radix(&self) -> u32 {
1253 Self::RADIX
1254 }
1255
1256 #[inline(always)]
1258 pub const fn radix2(&self) -> u32 {
1259 self.radix().wrapping_mul(self.radix())
1260 }
1261
1262 #[inline(always)]
1264 pub const fn radix4(&self) -> u32 {
1265 self.radix2().wrapping_mul(self.radix2())
1266 }
1267
1268 #[inline(always)]
1270 pub const fn radix8(&self) -> u32 {
1271 self.radix4().wrapping_mul(self.radix4())
1273 }
1274
1275 pub const EXPONENT_BASE: u32 = flags::exponent_base(FORMAT);
1277
1278 #[inline(always)]
1283 pub const fn exponent_base(&self) -> u32 {
1284 Self::EXPONENT_BASE
1285 }
1286
1287 pub const EXPONENT_RADIX: u32 = flags::exponent_radix(FORMAT);
1289
1290 #[inline(always)]
1294 pub const fn exponent_radix(&self) -> u32 {
1295 Self::EXPONENT_RADIX
1296 }
1297
1298 #[inline(always)]
1302 pub const fn flags(&self) -> u128 {
1303 FORMAT & flags::FLAG_MASK
1304 }
1305
1306 #[inline(always)]
1308 pub const fn interface_flags(&self) -> u128 {
1309 FORMAT & flags::INTERFACE_FLAG_MASK
1310 }
1311
1312 #[inline(always)]
1314 pub const fn digit_separator_flags(&self) -> u128 {
1315 FORMAT & flags::DIGIT_SEPARATOR_FLAG_MASK
1316 }
1317
1318 #[inline(always)]
1320 pub const fn exponent_flags(&self) -> u128 {
1321 FORMAT & flags::EXPONENT_FLAG_MASK
1322 }
1323
1324 #[inline(always)]
1326 pub const fn integer_digit_separator_flags(&self) -> u128 {
1327 FORMAT & flags::INTEGER_DIGIT_SEPARATOR_FLAG_MASK
1328 }
1329
1330 #[inline(always)]
1332 pub const fn fraction_digit_separator_flags(&self) -> u128 {
1333 FORMAT & flags::FRACTION_DIGIT_SEPARATOR_FLAG_MASK
1334 }
1335
1336 #[inline(always)]
1338 pub const fn exponent_digit_separator_flags(&self) -> u128 {
1339 FORMAT & flags::EXPONENT_DIGIT_SEPARATOR_FLAG_MASK
1340 }
1341
1342 #[inline(always)]
1346 pub const fn builder() -> NumberFormatBuilder {
1347 NumberFormatBuilder::new()
1348 }
1349
1350 #[inline(always)]
1352 pub const fn rebuild() -> NumberFormatBuilder {
1353 NumberFormatBuilder::rebuild(FORMAT)
1354 }
1355}
1356
1357impl<const FORMAT: u128> Default for NumberFormat<FORMAT> {
1358 fn default() -> Self {
1359 Self::new()
1360 }
1361}
1362
1363#[rustfmt::skip]
1378pub const RUST_LITERAL: u128 = NumberFormatBuilder::new()
1379 .digit_separator(num::NonZeroU8::new(b'_'))
1380 .required_digits(true)
1381 .no_positive_mantissa_sign(true)
1382 .no_special(true)
1383 .internal_digit_separator(true)
1384 .trailing_digit_separator(true)
1385 .consecutive_digit_separator(true)
1386 .build();
1387
1388const_assert!(NumberFormat::<{ RUST_LITERAL }> {}.is_valid());
1389
1390#[rustfmt::skip]
1393pub const RUST_STRING: u128 = NumberFormatBuilder::new().build();
1394const_assert!(NumberFormat::<{ RUST_STRING }> {}.is_valid());
1395
1396pub const PYTHON_LITERAL: u128 = PYTHON3_LITERAL;
1398
1399pub const PYTHON_STRING: u128 = PYTHON3_STRING;
1401
1402pub const PYTHON3_LITERAL: u128 = PYTHON36_LITERAL;
1404
1405#[rustfmt::skip]
1408pub const PYTHON3_STRING: u128 = NumberFormatBuilder::new().build();
1409const_assert!(NumberFormat::<{ PYTHON3_STRING }> {}.is_valid());
1410
1411#[rustfmt::skip]
1414pub const PYTHON36_LITERAL: u128 = NumberFormatBuilder::new()
1415 .digit_separator(num::NonZeroU8::new(b'_'))
1416 .no_special(true)
1417 .no_integer_leading_zeros(true)
1418 .internal_digit_separator(true)
1419 .build();
1420
1421const_assert!(NumberFormat::<{ PYTHON36_LITERAL }> {}.is_valid());
1422
1423#[rustfmt::skip]
1426pub const PYTHON35_LITERAL: u128 = NumberFormatBuilder::new()
1427 .no_special(true)
1428 .no_integer_leading_zeros(true)
1429 .build();
1430
1431const_assert!(NumberFormat::<{ PYTHON35_LITERAL }> {}.is_valid());
1432
1433#[rustfmt::skip]
1436pub const PYTHON2_LITERAL: u128 = NumberFormatBuilder::new()
1437 .no_special(true)
1438 .build();
1439
1440const_assert!(NumberFormat::<{ PYTHON2_LITERAL }> {}.is_valid());
1441
1442#[rustfmt::skip]
1445pub const PYTHON2_STRING: u128 = NumberFormatBuilder::new().build();
1446const_assert!(NumberFormat::<{ PYTHON2_STRING }> {}.is_valid());
1447
1448pub const CXX_LITERAL: u128 = CXX20_LITERAL;
1450
1451pub const CXX_STRING: u128 = CXX20_STRING;
1453
1454#[cfg(feature = "power-of-two")]
1456pub const CXX_HEX_LITERAL: u128 = CXX20_HEX_LITERAL;
1457
1458#[cfg(feature = "power-of-two")]
1460pub const CXX_HEX_STRING: u128 = CXX20_HEX_STRING;
1461
1462#[rustfmt::skip]
1465pub const CXX20_LITERAL: u128 = NumberFormatBuilder::new()
1466 .digit_separator(num::NonZeroU8::new(b'\''))
1467 .case_sensitive_special(true)
1468 .internal_digit_separator(true)
1469 .build();
1470
1471const_assert!(NumberFormat::<{ CXX20_LITERAL }> {}.is_valid());
1472
1473#[rustfmt::skip]
1476pub const CXX20_STRING: u128 = NumberFormatBuilder::new().build();
1477const_assert!(NumberFormat::<{ CXX20_STRING }> {}.is_valid());
1478
1479#[rustfmt::skip]
1482#[cfg(feature = "power-of-two")]
1483pub const CXX20_HEX_LITERAL: u128 = NumberFormatBuilder::new()
1484 .required_exponent_notation(true)
1485 .digit_separator(num::NonZeroU8::new(b'\''))
1486 .mantissa_radix(16)
1487 .exponent_base(num::NonZeroU8::new(2))
1488 .exponent_radix(num::NonZeroU8::new(10))
1489 .case_sensitive_special(true)
1490 .internal_digit_separator(true)
1491 .build();
1492
1493#[cfg(feature = "power-of-two")]
1494const_assert!(NumberFormat::<{ CXX20_HEX_LITERAL }> {}.is_valid());
1495
1496#[rustfmt::skip]
1499#[cfg(feature = "power-of-two")]
1500pub const CXX20_HEX_STRING: u128 = NumberFormatBuilder::new()
1501 .mantissa_radix(16)
1502 .exponent_base(num::NonZeroU8::new(2))
1503 .exponent_radix(num::NonZeroU8::new(10))
1504 .build();
1505
1506#[cfg(feature = "power-of-two")]
1507const_assert!(NumberFormat::<{ CXX20_HEX_STRING }> {}.is_valid());
1508
1509#[rustfmt::skip]
1512pub const CXX17_LITERAL: u128 = NumberFormatBuilder::new()
1513 .digit_separator(num::NonZeroU8::new(b'\''))
1514 .case_sensitive_special(true)
1515 .internal_digit_separator(true)
1516 .build();
1517
1518const_assert!(NumberFormat::<{ CXX17_LITERAL }> {}.is_valid());
1519
1520#[rustfmt::skip]
1523pub const CXX17_STRING: u128 = NumberFormatBuilder::new().build();
1524const_assert!(NumberFormat::<{ CXX17_STRING }> {}.is_valid());
1525
1526#[rustfmt::skip]
1529#[cfg(feature = "power-of-two")]
1530pub const CXX17_HEX_LITERAL: u128 = NumberFormatBuilder::new()
1531 .required_exponent_notation(true)
1532 .digit_separator(num::NonZeroU8::new(b'\''))
1533 .mantissa_radix(16)
1534 .exponent_base(num::NonZeroU8::new(2))
1535 .exponent_radix(num::NonZeroU8::new(10))
1536 .case_sensitive_special(true)
1537 .internal_digit_separator(true)
1538 .build();
1539
1540#[cfg(feature = "power-of-two")]
1541const_assert!(NumberFormat::<{ CXX17_HEX_LITERAL }> {}.is_valid());
1542
1543#[rustfmt::skip]
1546#[cfg(feature = "power-of-two")]
1547pub const CXX17_HEX_STRING: u128 = NumberFormatBuilder::new()
1548 .mantissa_radix(16)
1549 .exponent_base(num::NonZeroU8::new(2))
1550 .exponent_radix(num::NonZeroU8::new(10))
1551 .build();
1552
1553#[cfg(feature = "power-of-two")]
1554const_assert!(NumberFormat::<{ CXX17_HEX_STRING }> {}.is_valid());
1555
1556#[rustfmt::skip]
1559pub const CXX14_LITERAL: u128 = NumberFormatBuilder::new()
1560 .digit_separator(num::NonZeroU8::new(b'\''))
1561 .case_sensitive_special(true)
1562 .internal_digit_separator(true)
1563 .build();
1564
1565const_assert!(NumberFormat::<{ CXX14_LITERAL }> {}.is_valid());
1566
1567#[rustfmt::skip]
1570pub const CXX14_STRING: u128 = NumberFormatBuilder::new().build();
1571const_assert!(NumberFormat::<{ CXX14_STRING }> {}.is_valid());
1572
1573#[rustfmt::skip]
1576#[cfg(feature = "power-of-two")]
1577pub const CXX14_HEX_STRING: u128 = NumberFormatBuilder::new()
1578 .mantissa_radix(16)
1579 .exponent_base(num::NonZeroU8::new(2))
1580 .exponent_radix(num::NonZeroU8::new(10))
1581 .build();
1582
1583#[cfg(feature = "power-of-two")]
1584const_assert!(NumberFormat::<{ CXX14_HEX_STRING }> {}.is_valid());
1585
1586#[rustfmt::skip]
1589pub const CXX11_LITERAL: u128 = NumberFormatBuilder::new()
1590 .case_sensitive_special(true)
1591 .build();
1592
1593const_assert!(NumberFormat::<{ CXX11_LITERAL }> {}.is_valid());
1594
1595#[rustfmt::skip]
1598pub const CXX11_STRING: u128 = NumberFormatBuilder::new().build();
1599const_assert!(NumberFormat::<{ CXX11_STRING }> {}.is_valid());
1600
1601#[rustfmt::skip]
1604#[cfg(feature = "power-of-two")]
1605pub const CXX11_HEX_STRING: u128 = NumberFormatBuilder::new()
1606 .mantissa_radix(16)
1607 .exponent_base(num::NonZeroU8::new(2))
1608 .exponent_radix(num::NonZeroU8::new(10))
1609 .build();
1610
1611#[cfg(feature = "power-of-two")]
1612const_assert!(NumberFormat::<{ CXX11_HEX_STRING }> {}.is_valid());
1613
1614#[rustfmt::skip]
1617pub const CXX03_LITERAL: u128 = NumberFormatBuilder::new()
1618 .case_sensitive_special(true)
1619 .build();
1620
1621const_assert!(NumberFormat::<{ CXX03_LITERAL }> {}.is_valid());
1622
1623#[rustfmt::skip]
1626pub const CXX03_STRING: u128 = NumberFormatBuilder::new().build();
1627const_assert!(NumberFormat::<{ CXX03_STRING }> {}.is_valid());
1628
1629#[rustfmt::skip]
1632pub const CXX98_LITERAL: u128 = NumberFormatBuilder::new()
1633 .case_sensitive_special(true)
1634 .build();
1635
1636const_assert!(NumberFormat::<{ CXX98_LITERAL }> {}.is_valid());
1637
1638#[rustfmt::skip]
1641pub const CXX98_STRING: u128 = NumberFormatBuilder::new().build();
1642const_assert!(NumberFormat::<{ CXX98_STRING }> {}.is_valid());
1643
1644pub const C_LITERAL: u128 = C18_LITERAL;
1646
1647pub const C_STRING: u128 = C18_STRING;
1649
1650#[cfg(feature = "power-of-two")]
1652pub const C_HEX_LITERAL: u128 = C18_HEX_LITERAL;
1653
1654#[cfg(feature = "power-of-two")]
1656pub const C_HEX_STRING: u128 = C18_HEX_STRING;
1657
1658#[rustfmt::skip]
1661pub const C18_LITERAL: u128 = NumberFormatBuilder::new()
1662 .case_sensitive_special(true)
1663 .build();
1664
1665const_assert!(NumberFormat::<{ C18_LITERAL }> {}.is_valid());
1666
1667#[rustfmt::skip]
1670pub const C18_STRING: u128 = NumberFormatBuilder::new().build();
1671const_assert!(NumberFormat::<{ C18_STRING }> {}.is_valid());
1672
1673#[rustfmt::skip]
1676#[cfg(feature = "power-of-two")]
1677pub const C18_HEX_LITERAL: u128 = NumberFormatBuilder::new()
1678 .case_sensitive_special(true)
1679 .required_exponent_notation(true)
1680 .mantissa_radix(16)
1681 .exponent_base(num::NonZeroU8::new(2))
1682 .exponent_radix(num::NonZeroU8::new(10))
1683 .build();
1684
1685#[cfg(feature = "power-of-two")]
1686const_assert!(NumberFormat::<{ C18_HEX_LITERAL }> {}.is_valid());
1687
1688#[rustfmt::skip]
1691#[cfg(feature = "power-of-two")]
1692pub const C18_HEX_STRING: u128 = NumberFormatBuilder::new()
1693 .mantissa_radix(16)
1694 .exponent_base(num::NonZeroU8::new(2))
1695 .exponent_radix(num::NonZeroU8::new(10))
1696 .build();
1697
1698#[cfg(feature = "power-of-two")]
1699const_assert!(NumberFormat::<{ C18_HEX_STRING }> {}.is_valid());
1700
1701#[rustfmt::skip]
1704pub const C11_LITERAL: u128 = NumberFormatBuilder::new()
1705 .case_sensitive_special(true)
1706 .build();
1707
1708const_assert!(NumberFormat::<{ C11_LITERAL }> {}.is_valid());
1709
1710#[rustfmt::skip]
1713pub const C11_STRING: u128 = NumberFormatBuilder::new().build();
1714const_assert!(NumberFormat::<{ C11_STRING }> {}.is_valid());
1715
1716#[rustfmt::skip]
1719#[cfg(feature = "power-of-two")]
1720pub const C11_HEX_LITERAL: u128 = NumberFormatBuilder::new()
1721 .case_sensitive_special(true)
1722 .required_exponent_notation(true)
1723 .mantissa_radix(16)
1724 .exponent_base(num::NonZeroU8::new(2))
1725 .exponent_radix(num::NonZeroU8::new(10))
1726 .build();
1727
1728#[cfg(feature = "power-of-two")]
1729const_assert!(NumberFormat::<{ C11_HEX_LITERAL }> {}.is_valid());
1730
1731#[rustfmt::skip]
1734#[cfg(feature = "power-of-two")]
1735pub const C11_HEX_STRING: u128 = NumberFormatBuilder::new()
1736 .mantissa_radix(16)
1737 .exponent_base(num::NonZeroU8::new(2))
1738 .exponent_radix(num::NonZeroU8::new(10))
1739 .build();
1740
1741#[cfg(feature = "power-of-two")]
1742const_assert!(NumberFormat::<{ C11_HEX_STRING }> {}.is_valid());
1743
1744#[rustfmt::skip]
1747pub const C99_LITERAL: u128 = NumberFormatBuilder::new()
1748 .case_sensitive_special(true)
1749 .build();
1750
1751const_assert!(NumberFormat::<{ C99_LITERAL }> {}.is_valid());
1752
1753#[rustfmt::skip]
1756pub const C99_STRING: u128 = NumberFormatBuilder::new().build();
1757const_assert!(NumberFormat::<{ C99_STRING }> {}.is_valid());
1758
1759#[rustfmt::skip]
1762#[cfg(feature = "power-of-two")]
1763pub const C99_HEX_LITERAL: u128 = NumberFormatBuilder::new()
1764 .case_sensitive_special(true)
1765 .required_exponent_notation(true)
1766 .mantissa_radix(16)
1767 .exponent_base(num::NonZeroU8::new(2))
1768 .exponent_radix(num::NonZeroU8::new(10))
1769 .build();
1770
1771#[cfg(feature = "power-of-two")]
1772const_assert!(NumberFormat::<{ C99_HEX_LITERAL }> {}.is_valid());
1773
1774#[rustfmt::skip]
1777#[cfg(feature = "power-of-two")]
1778pub const C99_HEX_STRING: u128 = NumberFormatBuilder::new()
1779 .mantissa_radix(16)
1780 .exponent_base(num::NonZeroU8::new(2))
1781 .exponent_radix(num::NonZeroU8::new(10))
1782 .build();
1783
1784#[cfg(feature = "power-of-two")]
1785const_assert!(NumberFormat::<{ C99_HEX_STRING }> {}.is_valid());
1786
1787#[rustfmt::skip]
1790pub const C90_LITERAL: u128 = NumberFormatBuilder::new()
1791 .no_special(true)
1792 .build();
1793
1794const_assert!(NumberFormat::<{ C90_LITERAL }> {}.is_valid());
1795
1796#[rustfmt::skip]
1799pub const C90_STRING: u128 = NumberFormatBuilder::new().build();
1800const_assert!(NumberFormat::<{ C90_STRING }> {}.is_valid());
1801
1802#[rustfmt::skip]
1805#[cfg(feature = "power-of-two")]
1806pub const C90_HEX_STRING: u128 = NumberFormatBuilder::new()
1807 .mantissa_radix(16)
1808 .exponent_base(num::NonZeroU8::new(2))
1809 .exponent_radix(num::NonZeroU8::new(10))
1810 .build();
1811
1812#[cfg(feature = "power-of-two")]
1813const_assert!(NumberFormat::<{ C90_HEX_STRING }> {}.is_valid());
1814
1815#[rustfmt::skip]
1818pub const C89_LITERAL: u128 = NumberFormatBuilder::new()
1819 .no_special(true)
1820 .build();
1821
1822const_assert!(NumberFormat::<{ C89_LITERAL }> {}.is_valid());
1823
1824#[rustfmt::skip]
1827pub const C89_STRING: u128 = NumberFormatBuilder::new().build();
1828const_assert!(NumberFormat::<{ C89_STRING }> {}.is_valid());
1829
1830#[rustfmt::skip]
1833#[cfg(feature = "power-of-two")]
1834pub const C89_HEX_STRING: u128 = NumberFormatBuilder::new()
1835 .mantissa_radix(16)
1836 .exponent_base(num::NonZeroU8::new(2))
1837 .exponent_radix(num::NonZeroU8::new(10))
1838 .build();
1839
1840#[cfg(feature = "power-of-two")]
1841const_assert!(NumberFormat::<{ C89_HEX_STRING }> {}.is_valid());
1842
1843#[rustfmt::skip]
1846pub const RUBY_LITERAL: u128 = NumberFormatBuilder::new()
1847 .digit_separator(num::NonZeroU8::new(b'_'))
1848 .required_exponent_sign(true)
1849 .required_digits(true)
1850 .no_special(true)
1851 .no_integer_leading_zeros(true)
1852 .no_float_leading_zeros(true)
1853 .internal_digit_separator(true)
1854 .build();
1855
1856const_assert!(NumberFormat::<{ RUBY_LITERAL }> {}.is_valid());
1857
1858#[rustfmt::skip]
1861#[cfg(feature = "power-of-two")]
1862pub const RUBY_OCTAL_LITERAL: u128 = NumberFormatBuilder::new()
1863 .digit_separator(num::NonZeroU8::new(b'_'))
1864 .mantissa_radix(8)
1865 .required_digits(true)
1866 .no_special(true)
1867 .internal_digit_separator(true)
1868 .build();
1869
1870#[cfg(feature = "power-of-two")]
1871const_assert!(NumberFormat::<{ RUBY_OCTAL_LITERAL }> {}.is_valid());
1872
1873#[rustfmt::skip]
1877pub const RUBY_STRING: u128 = NumberFormatBuilder::new()
1878 .digit_separator(num::NonZeroU8::new(b'_'))
1879 .no_special(true)
1880 .internal_digit_separator(true)
1881 .build();
1882
1883const_assert!(NumberFormat::<{ RUBY_STRING }> {}.is_valid());
1884
1885#[rustfmt::skip]
1888pub const SWIFT_LITERAL: u128 = NumberFormatBuilder::new()
1889 .digit_separator(num::NonZeroU8::new(b'_'))
1890 .required_digits(true)
1891 .no_special(true)
1892 .internal_digit_separator(true)
1893 .trailing_digit_separator(true)
1894 .consecutive_digit_separator(true)
1895 .build();
1896
1897const_assert!(NumberFormat::<{ SWIFT_LITERAL }> {}.is_valid());
1898
1899#[rustfmt::skip]
1902pub const SWIFT_STRING: u128 = NumberFormatBuilder::new()
1903 .required_fraction_digits(true)
1904 .build();
1905
1906const_assert!(NumberFormat::<{ SWIFT_STRING }> {}.is_valid());
1907
1908#[rustfmt::skip]
1911pub const GO_LITERAL: u128 = NumberFormatBuilder::new()
1912 .required_fraction_digits(true)
1913 .no_special(true)
1914 .build();
1915
1916const_assert!(NumberFormat::<{ GO_LITERAL }> {}.is_valid());
1917
1918#[rustfmt::skip]
1921pub const GO_STRING: u128 = NumberFormatBuilder::new()
1922 .required_fraction_digits(true)
1923 .build();
1924
1925const_assert!(NumberFormat::<{ GO_STRING }> {}.is_valid());
1926
1927#[rustfmt::skip]
1930pub const HASKELL_LITERAL: u128 = NumberFormatBuilder::new()
1931 .required_digits(true)
1932 .no_positive_mantissa_sign(true)
1933 .no_special(true)
1934 .build();
1935
1936const_assert!(NumberFormat::<{ HASKELL_LITERAL }> {}.is_valid());
1937
1938#[rustfmt::skip]
1941pub const HASKELL_STRING: u128 = NumberFormatBuilder::new()
1942 .required_digits(true)
1943 .no_positive_mantissa_sign(true)
1944 .case_sensitive_special(true)
1945 .build();
1946
1947const_assert!(NumberFormat::<{ HASKELL_STRING }> {}.is_valid());
1948
1949#[rustfmt::skip]
1952pub const JAVASCRIPT_LITERAL: u128 = NumberFormatBuilder::new()
1953 .case_sensitive_special(true)
1954 .no_float_leading_zeros(true)
1955 .build();
1956
1957const_assert!(NumberFormat::<{ JAVASCRIPT_LITERAL }> {}.is_valid());
1958
1959#[rustfmt::skip]
1962pub const JAVASCRIPT_STRING: u128 = NumberFormatBuilder::new()
1963 .required_exponent_digits(false)
1964 .case_sensitive_special(true)
1965 .build();
1966
1967const_assert!(NumberFormat::<{ JAVASCRIPT_STRING }> {}.is_valid());
1968
1969#[rustfmt::skip]
1972pub const PERL_LITERAL: u128 = NumberFormatBuilder::new()
1973 .digit_separator(num::NonZeroU8::new(b'_'))
1974 .no_special(true)
1975 .internal_digit_separator(true)
1976 .fraction_leading_digit_separator(true)
1977 .exponent_leading_digit_separator(true)
1978 .trailing_digit_separator(true)
1979 .consecutive_digit_separator(true)
1980 .build();
1981
1982const_assert!(NumberFormat::<{ PERL_LITERAL }> {}.is_valid());
1983
1984pub const PERL_STRING: u128 = PERMISSIVE;
1987
1988#[rustfmt::skip]
1991pub const PHP_LITERAL: u128 = NumberFormatBuilder::new()
1992 .case_sensitive_special(true)
1993 .build();
1994
1995const_assert!(NumberFormat::<{ PHP_LITERAL }> {}.is_valid());
1996
1997#[rustfmt::skip]
2000pub const PHP_STRING: u128 = NumberFormatBuilder::new()
2001 .required_exponent_digits(false)
2002 .no_special(true)
2003 .build();
2004
2005const_assert!(NumberFormat::<{ PHP_STRING }> {}.is_valid());
2006
2007#[rustfmt::skip]
2010pub const JAVA_LITERAL: u128 = NumberFormatBuilder::new()
2011 .digit_separator(num::NonZeroU8::new(b'_'))
2012 .no_special(true)
2013 .internal_digit_separator(true)
2014 .consecutive_digit_separator(true)
2015 .build();
2016
2017const_assert!(NumberFormat::<{ JAVA_LITERAL }> {}.is_valid());
2018
2019#[rustfmt::skip]
2022pub const JAVA_STRING: u128 = NumberFormatBuilder::new()
2023 .case_sensitive_special(true)
2024 .build();
2025
2026const_assert!(NumberFormat::<{ JAVA_STRING }> {}.is_valid());
2027
2028#[rustfmt::skip]
2031pub const R_LITERAL: u128 = NumberFormatBuilder::new()
2032 .case_sensitive_special(true)
2033 .build();
2034
2035const_assert!(NumberFormat::<{ R_LITERAL }> {}.is_valid());
2036
2037pub const R_STRING: u128 = PERMISSIVE;
2040
2041#[rustfmt::skip]
2044pub const KOTLIN_LITERAL: u128 = NumberFormatBuilder::new()
2045 .digit_separator(num::NonZeroU8::new(b'_'))
2046 .no_special(true)
2047 .no_integer_leading_zeros(true)
2048 .internal_digit_separator(true)
2049 .consecutive_digit_separator(true)
2050 .build();
2051
2052const_assert!(NumberFormat::<{ KOTLIN_LITERAL }> {}.is_valid());
2053
2054#[rustfmt::skip]
2057pub const KOTLIN_STRING: u128 = NumberFormatBuilder::new()
2058 .case_sensitive_special(true)
2059 .build();
2060
2061const_assert!(NumberFormat::<{ KOTLIN_STRING }> {}.is_valid());
2062
2063#[rustfmt::skip]
2066pub const JULIA_LITERAL: u128 = NumberFormatBuilder::new()
2067 .digit_separator(num::NonZeroU8::new(b'_'))
2068 .case_sensitive_special(true)
2069 .integer_internal_digit_separator(true)
2070 .fraction_internal_digit_separator(true)
2071 .build();
2072
2073const_assert!(NumberFormat::<{ JULIA_LITERAL }> {}.is_valid());
2074
2075#[rustfmt::skip]
2078pub const JULIA_STRING: u128 = NumberFormatBuilder::new().build();
2079const_assert!(NumberFormat::<{ JULIA_STRING }> {}.is_valid());
2080
2081#[rustfmt::skip]
2084#[cfg(feature = "power-of-two")]
2085pub const JULIA_HEX_LITERAL: u128 = NumberFormatBuilder::new()
2086 .digit_separator(num::NonZeroU8::new(b'_'))
2087 .mantissa_radix(16)
2088 .exponent_base(num::NonZeroU8::new(2))
2089 .exponent_radix(num::NonZeroU8::new(10))
2090 .case_sensitive_special(true)
2091 .integer_internal_digit_separator(true)
2092 .fraction_internal_digit_separator(true)
2093 .build();
2094
2095#[cfg(feature = "power-of-two")]
2096const_assert!(NumberFormat::<{ JULIA_HEX_LITERAL }> {}.is_valid());
2097
2098#[rustfmt::skip]
2101#[cfg(feature = "power-of-two")]
2102pub const JULIA_HEX_STRING: u128 = NumberFormatBuilder::new()
2103 .mantissa_radix(16)
2104 .exponent_base(num::NonZeroU8::new(2))
2105 .exponent_radix(num::NonZeroU8::new(10))
2106 .build();
2107
2108#[cfg(feature = "power-of-two")]
2109const_assert!(NumberFormat::<{ JULIA_HEX_STRING }> {}.is_valid());
2110
2111pub const CSHARP_LITERAL: u128 = CSHARP7_LITERAL;
2113
2114pub const CSHARP_STRING: u128 = CSHARP7_STRING;
2116
2117#[rustfmt::skip]
2120pub const CSHARP7_LITERAL: u128 = NumberFormatBuilder::new()
2121 .digit_separator(num::NonZeroU8::new(b'_'))
2122 .required_fraction_digits(true)
2123 .no_special(true)
2124 .internal_digit_separator(true)
2125 .consecutive_digit_separator(true)
2126 .build();
2127
2128const_assert!(NumberFormat::<{ CSHARP7_LITERAL }> {}.is_valid());
2129
2130#[rustfmt::skip]
2133pub const CSHARP7_STRING: u128 = NumberFormatBuilder::new()
2134 .case_sensitive_special(true)
2135 .build();
2136
2137const_assert!(NumberFormat::<{ CSHARP7_STRING }> {}.is_valid());
2138
2139#[rustfmt::skip]
2142pub const CSHARP6_LITERAL: u128 = NumberFormatBuilder::new()
2143 .required_fraction_digits(true)
2144 .no_special(true)
2145 .build();
2146
2147const_assert!(NumberFormat::<{ CSHARP6_LITERAL }> {}.is_valid());
2148
2149#[rustfmt::skip]
2152pub const CSHARP6_STRING: u128 = NumberFormatBuilder::new()
2153 .case_sensitive_special(true)
2154 .build();
2155
2156const_assert!(NumberFormat::<{ CSHARP6_STRING }> {}.is_valid());
2157
2158#[rustfmt::skip]
2161pub const CSHARP5_LITERAL: u128 = NumberFormatBuilder::new()
2162 .required_fraction_digits(true)
2163 .no_special(true)
2164 .build();
2165
2166const_assert!(NumberFormat::<{ CSHARP5_LITERAL }> {}.is_valid());
2167
2168#[rustfmt::skip]
2171pub const CSHARP5_STRING: u128 = NumberFormatBuilder::new()
2172 .case_sensitive_special(true)
2173 .build();
2174
2175const_assert!(NumberFormat::<{ CSHARP5_STRING }> {}.is_valid());
2176
2177#[rustfmt::skip]
2180pub const CSHARP4_LITERAL: u128 = NumberFormatBuilder::new()
2181 .required_fraction_digits(true)
2182 .no_special(true)
2183 .build();
2184
2185const_assert!(NumberFormat::<{ CSHARP4_LITERAL }> {}.is_valid());
2186
2187#[rustfmt::skip]
2190pub const CSHARP4_STRING: u128 = NumberFormatBuilder::new()
2191 .case_sensitive_special(true)
2192 .build();
2193
2194const_assert!(NumberFormat::<{ CSHARP4_STRING }> {}.is_valid());
2195
2196#[rustfmt::skip]
2199pub const CSHARP3_LITERAL: u128 = NumberFormatBuilder::new()
2200 .required_fraction_digits(true)
2201 .no_special(true)
2202 .build();
2203
2204const_assert!(NumberFormat::<{ CSHARP3_LITERAL }> {}.is_valid());
2205
2206#[rustfmt::skip]
2209pub const CSHARP3_STRING: u128 = NumberFormatBuilder::new()
2210 .case_sensitive_special(true)
2211 .build();
2212
2213const_assert!(NumberFormat::<{ CSHARP3_STRING }> {}.is_valid());
2214
2215#[rustfmt::skip]
2218pub const CSHARP2_LITERAL: u128 = NumberFormatBuilder::new()
2219 .required_fraction_digits(true)
2220 .no_special(true)
2221 .build();
2222
2223const_assert!(NumberFormat::<{ CSHARP2_LITERAL }> {}.is_valid());
2224
2225#[rustfmt::skip]
2228pub const CSHARP2_STRING: u128 = NumberFormatBuilder::new()
2229 .case_sensitive_special(true)
2230 .build();
2231
2232const_assert!(NumberFormat::<{ CSHARP2_STRING }> {}.is_valid());
2233
2234#[rustfmt::skip]
2237pub const CSHARP1_LITERAL: u128 = NumberFormatBuilder::new()
2238 .required_fraction_digits(true)
2239 .no_special(true)
2240 .build();
2241
2242const_assert!(NumberFormat::<{ CSHARP1_LITERAL }> {}.is_valid());
2243
2244#[rustfmt::skip]
2247pub const CSHARP1_STRING: u128 = NumberFormatBuilder::new()
2248 .case_sensitive_special(true)
2249 .build();
2250
2251const_assert!(NumberFormat::<{ CSHARP1_STRING }> {}.is_valid());
2252
2253#[rustfmt::skip]
2256pub const KAWA_LITERAL: u128 = NumberFormatBuilder::new()
2257 .no_special(true)
2258 .build();
2259
2260const_assert!(NumberFormat::<{ KAWA_LITERAL }> {}.is_valid());
2261
2262#[rustfmt::skip]
2265pub const KAWA_STRING: u128 = NumberFormatBuilder::new()
2266 .no_special(true)
2267 .build();
2268
2269const_assert!(NumberFormat::<{ KAWA_STRING }> {}.is_valid());
2270
2271#[rustfmt::skip]
2274pub const GAMBITC_LITERAL: u128 = NumberFormatBuilder::new()
2275 .no_special(true)
2276 .build();
2277
2278const_assert!(NumberFormat::<{ GAMBITC_LITERAL }> {}.is_valid());
2279
2280#[rustfmt::skip]
2283pub const GAMBITC_STRING: u128 = NumberFormatBuilder::new()
2284 .no_special(true)
2285 .build();
2286
2287const_assert!(NumberFormat::<{ GAMBITC_STRING }> {}.is_valid());
2288
2289#[rustfmt::skip]
2292pub const GUILE_LITERAL: u128 = NumberFormatBuilder::new()
2293 .no_special(true)
2294 .build();
2295
2296const_assert!(NumberFormat::<{ GUILE_LITERAL }> {}.is_valid());
2297
2298#[rustfmt::skip]
2301pub const GUILE_STRING: u128 = NumberFormatBuilder::new()
2302 .no_special(true)
2303 .build();
2304
2305const_assert!(NumberFormat::<{ GUILE_STRING }> {}.is_valid());
2306
2307#[rustfmt::skip]
2310pub const CLOJURE_LITERAL: u128 = NumberFormatBuilder::new()
2311 .required_integer_digits(true)
2312 .no_special(true)
2313 .build();
2314
2315const_assert!(NumberFormat::<{ CLOJURE_LITERAL }> {}.is_valid());
2316
2317#[rustfmt::skip]
2320pub const CLOJURE_STRING: u128 = NumberFormatBuilder::new()
2321 .case_sensitive_special(true)
2322 .build();
2323
2324const_assert!(NumberFormat::<{ CLOJURE_STRING }> {}.is_valid());
2325
2326#[rustfmt::skip]
2329pub const ERLANG_LITERAL: u128 = NumberFormatBuilder::new()
2330 .required_digits(true)
2331 .no_exponent_without_fraction(true)
2332 .case_sensitive_special(true)
2333 .build();
2334
2335const_assert!(NumberFormat::<{ ERLANG_LITERAL }> {}.is_valid());
2336
2337#[rustfmt::skip]
2340pub const ERLANG_STRING: u128 = NumberFormatBuilder::new()
2341 .required_digits(true)
2342 .no_exponent_without_fraction(true)
2343 .no_special(true)
2344 .build();
2345
2346const_assert!(NumberFormat::<{ ERLANG_STRING }> {}.is_valid());
2347
2348#[rustfmt::skip]
2351pub const ELM_LITERAL: u128 = NumberFormatBuilder::new()
2352 .required_digits(true)
2353 .no_positive_mantissa_sign(true)
2354 .no_integer_leading_zeros(true)
2355 .no_float_leading_zeros(true)
2356 .no_special(true)
2357 .build();
2358
2359const_assert!(NumberFormat::<{ ELM_LITERAL }> {}.is_valid());
2360
2361#[rustfmt::skip]
2365pub const ELM_STRING: u128 = NumberFormatBuilder::new()
2366 .case_sensitive_special(true)
2367 .build();
2368
2369const_assert!(NumberFormat::<{ ELM_STRING }> {}.is_valid());
2370
2371#[rustfmt::skip]
2374pub const SCALA_LITERAL: u128 = NumberFormatBuilder::new()
2375 .required_digits(true)
2376 .no_special(true)
2377 .no_integer_leading_zeros(true)
2378 .no_float_leading_zeros(true)
2379 .build();
2380
2381const_assert!(NumberFormat::<{ SCALA_LITERAL }> {}.is_valid());
2382
2383#[rustfmt::skip]
2386pub const SCALA_STRING: u128 = NumberFormatBuilder::new()
2387 .case_sensitive_special(true)
2388 .build();
2389
2390const_assert!(NumberFormat::<{ SCALA_STRING }> {}.is_valid());
2391
2392#[rustfmt::skip]
2395pub const ELIXIR_LITERAL: u128 = NumberFormatBuilder::new()
2396 .digit_separator(num::NonZeroU8::new(b'_'))
2397 .required_digits(true)
2398 .no_exponent_without_fraction(true)
2399 .no_special(true)
2400 .internal_digit_separator(true)
2401 .build();
2402
2403const_assert!(NumberFormat::<{ ELIXIR_LITERAL }> {}.is_valid());
2404
2405#[rustfmt::skip]
2408pub const ELIXIR_STRING: u128 = NumberFormatBuilder::new()
2409 .required_digits(true)
2410 .no_exponent_without_fraction(true)
2411 .no_special(true)
2412 .build();
2413
2414const_assert!(NumberFormat::<{ ELIXIR_STRING }> {}.is_valid());
2415
2416#[rustfmt::skip]
2419pub const FORTRAN_LITERAL: u128 = NumberFormatBuilder::new()
2420 .no_special(true)
2421 .build();
2422
2423const_assert!(NumberFormat::<{ FORTRAN_LITERAL }> {}.is_valid());
2424
2425#[rustfmt::skip]
2428pub const FORTRAN_STRING: u128 = NumberFormatBuilder::new().build();
2429const_assert!(NumberFormat::<{ FORTRAN_STRING }> {}.is_valid());
2430
2431#[rustfmt::skip]
2434pub const D_LITERAL: u128 = NumberFormatBuilder::new()
2435 .digit_separator(num::NonZeroU8::new(b'_'))
2436 .no_special(true)
2437 .no_integer_leading_zeros(true)
2438 .internal_digit_separator(true)
2439 .trailing_digit_separator(true)
2440 .consecutive_digit_separator(true)
2441 .build();
2442
2443const_assert!(NumberFormat::<{ D_LITERAL }> {}.is_valid());
2444
2445#[rustfmt::skip]
2448pub const D_STRING: u128 = NumberFormatBuilder::new()
2449 .digit_separator(num::NonZeroU8::new(b'_'))
2450 .integer_internal_digit_separator(true)
2451 .fraction_internal_digit_separator(true)
2452 .integer_trailing_digit_separator(true)
2453 .fraction_trailing_digit_separator(true)
2454 .build();
2455
2456const_assert!(NumberFormat::<{ D_STRING }> {}.is_valid());
2457
2458#[rustfmt::skip]
2461pub const COFFEESCRIPT_LITERAL: u128 = NumberFormatBuilder::new()
2462 .case_sensitive_special(true)
2463 .no_integer_leading_zeros(true)
2464 .no_float_leading_zeros(true)
2465 .build();
2466
2467const_assert!(NumberFormat::<{ COFFEESCRIPT_LITERAL }> {}.is_valid());
2468
2469#[rustfmt::skip]
2472pub const COFFEESCRIPT_STRING: u128 = NumberFormatBuilder::new()
2473 .case_sensitive_special(true)
2474 .build();
2475
2476const_assert!(NumberFormat::<{ COFFEESCRIPT_STRING }> {}.is_valid());
2477
2478#[rustfmt::skip]
2481pub const COBOL_LITERAL: u128 = NumberFormatBuilder::new()
2482 .required_fraction_digits(true)
2483 .no_exponent_without_fraction(true)
2484 .no_special(true)
2485 .build();
2486
2487const_assert!(NumberFormat::<{ COBOL_LITERAL }> {}.is_valid());
2488
2489#[rustfmt::skip]
2492pub const COBOL_STRING: u128 = NumberFormatBuilder::new()
2493 .required_exponent_sign(true)
2494 .no_special(true)
2495 .build();
2496
2497const_assert!(NumberFormat::<{ COBOL_STRING }> {}.is_valid());
2498
2499#[rustfmt::skip]
2502pub const FSHARP_LITERAL: u128 = NumberFormatBuilder::new()
2503 .digit_separator(num::NonZeroU8::new(b'_'))
2504 .required_integer_digits(true)
2505 .required_exponent_digits(true)
2506 .case_sensitive_special(true)
2507 .internal_digit_separator(true)
2508 .consecutive_digit_separator(true)
2509 .build();
2510
2511const_assert!(NumberFormat::<{ FSHARP_LITERAL }> {}.is_valid());
2512
2513#[rustfmt::skip]
2516pub const FSHARP_STRING: u128 = NumberFormatBuilder::new()
2517 .digit_separator(num::NonZeroU8::new(b'_'))
2518 .internal_digit_separator(true)
2519 .leading_digit_separator(true)
2520 .trailing_digit_separator(true)
2521 .consecutive_digit_separator(true)
2522 .special_digit_separator(true)
2523 .build();
2524
2525const_assert!(NumberFormat::<{ FSHARP_STRING }> {}.is_valid());
2526
2527#[rustfmt::skip]
2530pub const VB_LITERAL: u128 = NumberFormatBuilder::new()
2531 .required_fraction_digits(true)
2532 .no_special(true)
2533 .build();
2534
2535const_assert!(NumberFormat::<{ VB_LITERAL }> {}.is_valid());
2536
2537#[rustfmt::skip]
2541pub const VB_STRING: u128 = NumberFormatBuilder::new()
2542 .case_sensitive_special(true)
2543 .build();
2544
2545const_assert!(NumberFormat::<{ VB_STRING }> {}.is_valid());
2546
2547#[rustfmt::skip]
2550pub const OCAML_LITERAL: u128 = NumberFormatBuilder::new()
2551 .digit_separator(num::NonZeroU8::new(b'_'))
2552 .required_integer_digits(true)
2553 .required_exponent_digits(true)
2554 .no_positive_mantissa_sign(true)
2555 .case_sensitive_special(true)
2556 .internal_digit_separator(true)
2557 .fraction_leading_digit_separator(true)
2558 .trailing_digit_separator(true)
2559 .consecutive_digit_separator(true)
2560 .build();
2561
2562const_assert!(NumberFormat::<{ OCAML_LITERAL }> {}.is_valid());
2563
2564#[rustfmt::skip]
2567pub const OCAML_STRING: u128 = NumberFormatBuilder::new()
2568 .digit_separator(num::NonZeroU8::new(b'_'))
2569 .internal_digit_separator(true)
2570 .leading_digit_separator(true)
2571 .trailing_digit_separator(true)
2572 .consecutive_digit_separator(true)
2573 .special_digit_separator(true)
2574 .build();
2575
2576const_assert!(NumberFormat::<{ OCAML_STRING }> {}.is_valid());
2577
2578#[rustfmt::skip]
2581pub const OBJECTIVEC_LITERAL: u128 = NumberFormatBuilder::new()
2582 .no_special(true)
2583 .build();
2584
2585const_assert!(NumberFormat::<{ OBJECTIVEC_LITERAL }> {}.is_valid());
2586
2587#[rustfmt::skip]
2590pub const OBJECTIVEC_STRING: u128 = NumberFormatBuilder::new()
2591 .no_special(true)
2592 .build();
2593
2594const_assert!(NumberFormat::<{ OBJECTIVEC_STRING }> {}.is_valid());
2595
2596#[rustfmt::skip]
2599pub const REASONML_LITERAL: u128 = NumberFormatBuilder::new()
2600 .digit_separator(num::NonZeroU8::new(b'_'))
2601 .required_integer_digits(true)
2602 .required_exponent_digits(true)
2603 .case_sensitive_special(true)
2604 .internal_digit_separator(true)
2605 .fraction_leading_digit_separator(true)
2606 .trailing_digit_separator(true)
2607 .consecutive_digit_separator(true)
2608 .build();
2609
2610const_assert!(NumberFormat::<{ REASONML_LITERAL }> {}.is_valid());
2611
2612#[rustfmt::skip]
2615pub const REASONML_STRING: u128 = NumberFormatBuilder::new()
2616 .digit_separator(num::NonZeroU8::new(b'_'))
2617 .internal_digit_separator(true)
2618 .leading_digit_separator(true)
2619 .trailing_digit_separator(true)
2620 .consecutive_digit_separator(true)
2621 .special_digit_separator(true)
2622 .build();
2623
2624const_assert!(NumberFormat::<{ REASONML_STRING }> {}.is_valid());
2625
2626#[rustfmt::skip]
2630pub const OCTAVE_LITERAL: u128 = NumberFormatBuilder::new()
2631 .digit_separator(num::NonZeroU8::new(b'_'))
2632 .case_sensitive_special(true)
2633 .internal_digit_separator(true)
2634 .fraction_leading_digit_separator(true)
2635 .trailing_digit_separator(true)
2636 .consecutive_digit_separator(true)
2637 .build();
2638
2639const_assert!(NumberFormat::<{ OCTAVE_LITERAL }> {}.is_valid());
2640
2641#[rustfmt::skip]
2644pub const OCTAVE_STRING: u128 = NumberFormatBuilder::new()
2645 .digit_separator(num::NonZeroU8::new(b','))
2646 .internal_digit_separator(true)
2647 .leading_digit_separator(true)
2648 .trailing_digit_separator(true)
2649 .consecutive_digit_separator(true)
2650 .build();
2651
2652const_assert!(NumberFormat::<{ OCTAVE_STRING }> {}.is_valid());
2653
2654#[rustfmt::skip]
2658pub const MATLAB_LITERAL: u128 = NumberFormatBuilder::new()
2659 .digit_separator(num::NonZeroU8::new(b'_'))
2660 .case_sensitive_special(true)
2661 .internal_digit_separator(true)
2662 .fraction_leading_digit_separator(true)
2663 .trailing_digit_separator(true)
2664 .consecutive_digit_separator(true)
2665 .build();
2666
2667const_assert!(NumberFormat::<{ MATLAB_LITERAL }> {}.is_valid());
2668
2669#[rustfmt::skip]
2672pub const MATLAB_STRING: u128 = NumberFormatBuilder::new()
2673 .digit_separator(num::NonZeroU8::new(b','))
2674 .internal_digit_separator(true)
2675 .leading_digit_separator(true)
2676 .trailing_digit_separator(true)
2677 .consecutive_digit_separator(true)
2678 .build();
2679
2680const_assert!(NumberFormat::<{ MATLAB_STRING }> {}.is_valid());
2681
2682#[rustfmt::skip]
2685pub const ZIG_LITERAL: u128 = NumberFormatBuilder::new()
2686 .required_integer_digits(true)
2687 .no_positive_mantissa_sign(true)
2688 .no_special(true)
2689 .build();
2690
2691const_assert!(NumberFormat::<{ ZIG_LITERAL }> {}.is_valid());
2692
2693pub const ZIG_STRING: u128 = PERMISSIVE;
2696
2697#[rustfmt::skip]
2701pub const SAGE_LITERAL: u128 = NumberFormatBuilder::new()
2702 .case_sensitive_special(true)
2703 .build();
2704
2705const_assert!(NumberFormat::<{ SAGE_LITERAL }> {}.is_valid());
2706
2707#[rustfmt::skip]
2710pub const SAGE_STRING: u128 = NumberFormatBuilder::new()
2711 .digit_separator(num::NonZeroU8::new(b'_'))
2712 .internal_digit_separator(true)
2713 .build();
2714
2715const_assert!(NumberFormat::<{ SAGE_STRING }> {}.is_valid());
2716
2717#[rustfmt::skip]
2720pub const JSON: u128 = NumberFormatBuilder::new()
2721 .required_digits(true)
2722 .no_positive_mantissa_sign(true)
2723 .no_special(true)
2724 .no_integer_leading_zeros(true)
2725 .no_float_leading_zeros(true)
2726 .build();
2727
2728const_assert!(NumberFormat::<{ JSON }> {}.is_valid());
2729
2730#[rustfmt::skip]
2733pub const TOML: u128 = NumberFormatBuilder::new()
2734 .digit_separator(num::NonZeroU8::new(b'_'))
2735 .required_digits(false)
2736 .no_special(true)
2737 .no_integer_leading_zeros(true)
2738 .no_float_leading_zeros(true)
2739 .internal_digit_separator(true)
2740 .build();
2741
2742const_assert!(NumberFormat::<{ TOML }> {}.is_valid());
2743
2744pub const YAML: u128 = JSON;
2747
2748#[rustfmt::skip]
2751pub const XML: u128 = NumberFormatBuilder::new()
2752 .required_exponent_digits(false)
2753 .case_sensitive_special(true)
2754 .build();
2755
2756const_assert!(NumberFormat::<{ XML }> {}.is_valid());
2757
2758#[rustfmt::skip]
2761pub const SQLITE: u128 = NumberFormatBuilder::new()
2762 .no_special(true)
2763 .build();
2764
2765const_assert!(NumberFormat::<{ SQLITE }> {}.is_valid());
2766
2767#[rustfmt::skip]
2770pub const POSTGRESQL: u128 = NumberFormatBuilder::new()
2771 .no_special(true)
2772 .build();
2773
2774const_assert!(NumberFormat::<{ POSTGRESQL }> {}.is_valid());
2775
2776#[rustfmt::skip]
2779pub const MYSQL: u128 = NumberFormatBuilder::new()
2780 .no_special(true)
2781 .build();
2782
2783const_assert!(NumberFormat::<{ MYSQL }> {}.is_valid());
2784
2785#[rustfmt::skip]
2788pub const MONGODB: u128 = NumberFormatBuilder::new()
2789 .case_sensitive_special(true)
2790 .no_float_leading_zeros(true)
2791 .build();
2792
2793const_assert!(NumberFormat::<{ MONGODB }> {}.is_valid());
2794
2795#[doc(hidden)]
2799#[rustfmt::skip]
2800pub const PERMISSIVE: u128 = NumberFormatBuilder::new()
2801 .required_exponent_digits(false)
2802 .required_mantissa_digits(false)
2803 .build();
2804
2805const_assert!(NumberFormat::<{ PERMISSIVE }> {}.is_valid());
2806
2807#[doc(hidden)]
2809#[rustfmt::skip]
2810pub const IGNORE: u128 = NumberFormatBuilder::new()
2811 .digit_separator(num::NonZeroU8::new(b'_'))
2812 .digit_separator_flags(true)
2813 .required_exponent_digits(false)
2814 .required_mantissa_digits(false)
2815 .build();
2816
2817const_assert!(NumberFormat::<{ IGNORE }> {}.is_valid());RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4