(index<- ) ./libstd/fmt/num.rs
git branch: * master 5200215 auto merge of #14035 : alexcrichton/rust/experimental, r=huonw
modified: Fri May 9 13:02:28 2014
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
4 //
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
10
11 //! Integer and floating-point number formatting
12
13 // FIXME: #6220 Implement floating point formatting
14
15 #![allow(unsigned_negate)]
16
17 use container::Container;
18 use fmt;
19 use iter::{Iterator, DoubleEndedIterator};
20 use num::{Int, cast, zero};
21 use option::{Some, None};
22 use slice::{ImmutableVector, MutableVector};
23
24 /// A type that represents a specific radix
25 trait GenericRadix {
26 /// The number of digits.
27 fn base(&self) -> u8;
28
29 /// A radix-specific prefix string.
30 fn prefix(&self) -> &'static str { "" }
31
32 /// Converts an integer to corresponding radix digit.
33 fn digit(&self, x: u8) -> u8;
34
35 /// Format an integer using the radix using a formatter.
36 fn fmt_int<T: Int>(&self, mut x: T, f: &mut fmt::Formatter) -> fmt::Result {
37 // The radix can be as low as 2, so we need a buffer of at least 64
38 // characters for a base 2 number.
39 let mut buf = [0u8, ..64];
40 let base = cast(self.base()).unwrap();
41 let mut curr = buf.len();
42 let is_positive = x >= zero();
43 if is_positive {
44 // Accumulate each digit of the number from the least significant
45 // to the most significant figure.
46 for byte in buf.mut_iter().rev() {
47 let n = x % base; // Get the current place value.
48 x = x / base; // Deaccumulate the number.
49 *byte = self.digit(cast(n).unwrap()); // Store the digit in the buffer.
50 curr -= 1;
51 if x == zero() { break; } // No more digits left to accumulate.
52 }
53 } else {
54 // Do the same as above, but accounting for two's complement.
55 for byte in buf.mut_iter().rev() {
56 let n = -(x % base); // Get the current place value.
57 x = x / base; // Deaccumulate the number.
58 *byte = self.digit(cast(n).unwrap()); // Store the digit in the buffer.
59 curr -= 1;
60 if x == zero() { break; } // No more digits left to accumulate.
61 }
62 }
63 f.pad_integral(is_positive, self.prefix(), buf.slice_from(curr))
64 }
65 }
66
67 /// A binary (base 2) radix
68 #[deriving(Clone, Eq)]
69 struct Binary;
70
71 /// An octal (base 8) radix
72 #[deriving(Clone, Eq)]
73 struct Octal;
74
75 /// A decimal (base 10) radix
76 #[deriving(Clone, Eq)]
77 struct Decimal;
78
79 /// A hexadecimal (base 16) radix, formatted with lower-case characters
80 #[deriving(Clone, Eq)]
81 struct LowerHex;
82
83 /// A hexadecimal (base 16) radix, formatted with upper-case characters
84 #[deriving(Clone, Eq)]
85 pub struct UpperHex;
86
87 macro_rules! radix {
88 ($T:ident, $base:expr, $prefix:expr, $($x:pat => $conv:expr),+) => {
89 impl GenericRadix for $T {
90 fn base(&self) -> u8 { $base }
91 fn prefix(&self) -> &'static str { $prefix }
92 fn digit(&self, x: u8) -> u8 {
93 match x {
94 $($x => $conv,)+
95 x => fail!("number not in the range 0..{}: {}", self.base() - 1, x),
96 }
97 }
98 }
99 }
100 }
101
102 radix!(Binary, 2, "0b", x @ 0 .. 2 => '0' as u8 + x)
103 radix!(Octal, 8, "0o", x @ 0 .. 7 => '0' as u8 + x)
104 radix!(Decimal, 10, "", x @ 0 .. 9 => '0' as u8 + x)
105 radix!(LowerHex, 16, "0x", x @ 0 .. 9 => '0' as u8 + x,
106 x @ 10 ..15 => 'a' as u8 + (x - 10))
107 radix!(UpperHex, 16, "0x", x @ 0 .. 9 => '0' as u8 + x,
108 x @ 10 ..15 => 'A' as u8 + (x - 10))
109
110 /// A radix with in the range of `2..36`.
111 #[deriving(Clone, Eq)]
112 pub struct Radix {
113 base: u8,
114 }
115
116 impl Radix {
117 fn new(base: u8) -> Radix {
118 assert!(2 <= base && base <= 36, "the base must be in the range of 0..36: {}", base);
119 Radix { base: base }
120 }
121 }
122
123 impl GenericRadix for Radix {
124 fn base(&self) -> u8 { self.base }
125 fn digit(&self, x: u8) -> u8 {
126 match x {
127 x @ 0 ..9 => '0' as u8 + x,
128 x if x < self.base() => 'a' as u8 + (x - 10),
129 x => fail!("number not in the range 0..{}: {}", self.base() - 1, x),
130 }
131 }
132 }
133
134 /// A helper type for formatting radixes.
135 pub struct RadixFmt<T, R>(T, R);
136
137 /// Constructs a radix formatter in the range of `2..36`.
138 ///
139 /// # Example
140 ///
141 /// ~~~
142 /// use std::fmt::radix;
143 /// assert_eq!(format!("{}", radix(55, 36)), "1j".to_owned());
144 /// ~~~
145 pub fn radix<T>(x: T, base: u8) -> RadixFmt<T, Radix> {
146 RadixFmt(x, Radix::new(base))
147 }
148
149 macro_rules! radix_fmt {
150 ($T:ty as $U:ty, $fmt:ident) => {
151 impl fmt::Show for RadixFmt<$T, Radix> {
152 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
153 match *self { RadixFmt(ref x, radix) => radix.$fmt(*x as $U, f) }
154 }
155 }
156 }
157 }
158 macro_rules! int_base {
159 ($Trait:ident for $T:ident as $U:ident -> $Radix:ident) => {
160 impl fmt::$Trait for $T {
161 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
162 $Radix.fmt_int(*self as $U, f)
163 }
164 }
165 }
166 }
167 macro_rules! integer {
168 ($Int:ident, $Uint:ident) => {
169 int_base!(Show for $Int as $Int -> Decimal)
170 int_base!(Signed for $Int as $Int -> Decimal)
171 int_base!(Binary for $Int as $Uint -> Binary)
172 int_base!(Octal for $Int as $Uint -> Octal)
173 int_base!(LowerHex for $Int as $Uint -> LowerHex)
174 int_base!(UpperHex for $Int as $Uint -> UpperHex)
175 radix_fmt!($Int as $Uint, fmt_int)
176
177 int_base!(Show for $Uint as $Uint -> Decimal)
178 int_base!(Unsigned for $Uint as $Uint -> Decimal)
179 int_base!(Binary for $Uint as $Uint -> Binary)
180 int_base!(Octal for $Uint as $Uint -> Octal)
181 int_base!(LowerHex for $Uint as $Uint -> LowerHex)
182 int_base!(UpperHex for $Uint as $Uint -> UpperHex)
183 radix_fmt!($Uint as $Uint, fmt_int)
184 }
185 }
186 integer!(int, uint)
187 integer!(i8, u8)
188 integer!(i16, u16)
189 integer!(i32, u32)
190 integer!(i64, u64)
191
192 #[cfg(test)]
193 mod tests {
194 use fmt::radix;
195 use super::{Binary, Octal, Decimal, LowerHex, UpperHex};
196 use super::{GenericRadix, Radix};
197 use str::StrAllocating;
198
199 #[test]
200 fn test_radix_base() {
201 assert_eq!(Binary.base(), 2);
202 assert_eq!(Octal.base(), 8);
203 assert_eq!(Decimal.base(), 10);
204 assert_eq!(LowerHex.base(), 16);
205 assert_eq!(UpperHex.base(), 16);
206 assert_eq!(Radix { base: 36 }.base(), 36);
207 }
208
209 #[test]
210 fn test_radix_prefix() {
211 assert_eq!(Binary.prefix(), "0b");
212 assert_eq!(Octal.prefix(), "0o");
213 assert_eq!(Decimal.prefix(), "");
214 assert_eq!(LowerHex.prefix(), "0x");
215 assert_eq!(UpperHex.prefix(), "0x");
216 assert_eq!(Radix { base: 36 }.prefix(), "");
217 }
218
219 #[test]
220 fn test_radix_digit() {
221 assert_eq!(Binary.digit(0), '0' as u8);
222 assert_eq!(Binary.digit(2), '2' as u8);
223 assert_eq!(Octal.digit(0), '0' as u8);
224 assert_eq!(Octal.digit(7), '7' as u8);
225 assert_eq!(Decimal.digit(0), '0' as u8);
226 assert_eq!(Decimal.digit(9), '9' as u8);
227 assert_eq!(LowerHex.digit(0), '0' as u8);
228 assert_eq!(LowerHex.digit(10), 'a' as u8);
229 assert_eq!(LowerHex.digit(15), 'f' as u8);
230 assert_eq!(UpperHex.digit(0), '0' as u8);
231 assert_eq!(UpperHex.digit(10), 'A' as u8);
232 assert_eq!(UpperHex.digit(15), 'F' as u8);
233 assert_eq!(Radix { base: 36 }.digit(0), '0' as u8);
234 assert_eq!(Radix { base: 36 }.digit(15), 'f' as u8);
235 assert_eq!(Radix { base: 36 }.digit(35), 'z' as u8);
236 }
237
238 #[test]
239 #[should_fail]
240 fn test_hex_radix_digit_overflow() {
241 let _ = LowerHex.digit(16);
242 }
243
244 #[test]
245 fn test_format_int() {
246 // Formatting integers should select the right implementation based off
247 // the type of the argument. Also, hex/octal/binary should be defined
248 // for integers, but they shouldn't emit the negative sign.
249 assert_eq!(format!("{}", 1i), "1".to_owned());
250 assert_eq!(format!("{}", 1i8), "1".to_owned());
251 assert_eq!(format!("{}", 1i16), "1".to_owned());
252 assert_eq!(format!("{}", 1i32), "1".to_owned());
253 assert_eq!(format!("{}", 1i64), "1".to_owned());
254 assert_eq!(format!("{:d}", -1i), "-1".to_owned());
255 assert_eq!(format!("{:d}", -1i8), "-1".to_owned());
256 assert_eq!(format!("{:d}", -1i16), "-1".to_owned());
257 assert_eq!(format!("{:d}", -1i32), "-1".to_owned());
258 assert_eq!(format!("{:d}", -1i64), "-1".to_owned());
259 assert_eq!(format!("{:t}", 1i), "1".to_owned());
260 assert_eq!(format!("{:t}", 1i8), "1".to_owned());
261 assert_eq!(format!("{:t}", 1i16), "1".to_owned());
262 assert_eq!(format!("{:t}", 1i32), "1".to_owned());
263 assert_eq!(format!("{:t}", 1i64), "1".to_owned());
264 assert_eq!(format!("{:x}", 1i), "1".to_owned());
265 assert_eq!(format!("{:x}", 1i8), "1".to_owned());
266 assert_eq!(format!("{:x}", 1i16), "1".to_owned());
267 assert_eq!(format!("{:x}", 1i32), "1".to_owned());
268 assert_eq!(format!("{:x}", 1i64), "1".to_owned());
269 assert_eq!(format!("{:X}", 1i), "1".to_owned());
270 assert_eq!(format!("{:X}", 1i8), "1".to_owned());
271 assert_eq!(format!("{:X}", 1i16), "1".to_owned());
272 assert_eq!(format!("{:X}", 1i32), "1".to_owned());
273 assert_eq!(format!("{:X}", 1i64), "1".to_owned());
274 assert_eq!(format!("{:o}", 1i), "1".to_owned());
275 assert_eq!(format!("{:o}", 1i8), "1".to_owned());
276 assert_eq!(format!("{:o}", 1i16), "1".to_owned());
277 assert_eq!(format!("{:o}", 1i32), "1".to_owned());
278 assert_eq!(format!("{:o}", 1i64), "1".to_owned());
279
280 assert_eq!(format!("{}", 1u), "1".to_owned());
281 assert_eq!(format!("{}", 1u8), "1".to_owned());
282 assert_eq!(format!("{}", 1u16), "1".to_owned());
283 assert_eq!(format!("{}", 1u32), "1".to_owned());
284 assert_eq!(format!("{}", 1u64), "1".to_owned());
285 assert_eq!(format!("{:u}", 1u), "1".to_owned());
286 assert_eq!(format!("{:u}", 1u8), "1".to_owned());
287 assert_eq!(format!("{:u}", 1u16), "1".to_owned());
288 assert_eq!(format!("{:u}", 1u32), "1".to_owned());
289 assert_eq!(format!("{:u}", 1u64), "1".to_owned());
290 assert_eq!(format!("{:t}", 1u), "1".to_owned());
291 assert_eq!(format!("{:t}", 1u8), "1".to_owned());
292 assert_eq!(format!("{:t}", 1u16), "1".to_owned());
293 assert_eq!(format!("{:t}", 1u32), "1".to_owned());
294 assert_eq!(format!("{:t}", 1u64), "1".to_owned());
295 assert_eq!(format!("{:x}", 1u), "1".to_owned());
296 assert_eq!(format!("{:x}", 1u8), "1".to_owned());
297 assert_eq!(format!("{:x}", 1u16), "1".to_owned());
298 assert_eq!(format!("{:x}", 1u32), "1".to_owned());
299 assert_eq!(format!("{:x}", 1u64), "1".to_owned());
300 assert_eq!(format!("{:X}", 1u), "1".to_owned());
301 assert_eq!(format!("{:X}", 1u8), "1".to_owned());
302 assert_eq!(format!("{:X}", 1u16), "1".to_owned());
303 assert_eq!(format!("{:X}", 1u32), "1".to_owned());
304 assert_eq!(format!("{:X}", 1u64), "1".to_owned());
305 assert_eq!(format!("{:o}", 1u), "1".to_owned());
306 assert_eq!(format!("{:o}", 1u8), "1".to_owned());
307 assert_eq!(format!("{:o}", 1u16), "1".to_owned());
308 assert_eq!(format!("{:o}", 1u32), "1".to_owned());
309 assert_eq!(format!("{:o}", 1u64), "1".to_owned());
310
311 // Test a larger number
312 assert_eq!(format!("{:t}", 55), "110111".to_owned());
313 assert_eq!(format!("{:o}", 55), "67".to_owned());
314 assert_eq!(format!("{:d}", 55), "55".to_owned());
315 assert_eq!(format!("{:x}", 55), "37".to_owned());
316 assert_eq!(format!("{:X}", 55), "37".to_owned());
317 }
318
319 #[test]
320 fn test_format_int_zero() {
321 assert_eq!(format!("{}", 0i), "0".to_owned());
322 assert_eq!(format!("{:d}", 0i), "0".to_owned());
323 assert_eq!(format!("{:t}", 0i), "0".to_owned());
324 assert_eq!(format!("{:o}", 0i), "0".to_owned());
325 assert_eq!(format!("{:x}", 0i), "0".to_owned());
326 assert_eq!(format!("{:X}", 0i), "0".to_owned());
327
328 assert_eq!(format!("{}", 0u), "0".to_owned());
329 assert_eq!(format!("{:u}", 0u), "0".to_owned());
330 assert_eq!(format!("{:t}", 0u), "0".to_owned());
331 assert_eq!(format!("{:o}", 0u), "0".to_owned());
332 assert_eq!(format!("{:x}", 0u), "0".to_owned());
333 assert_eq!(format!("{:X}", 0u), "0".to_owned());
334 }
335
336 #[test]
337 fn test_format_int_flags() {
338 assert_eq!(format!("{:3d}", 1), " 1".to_owned());
339 assert_eq!(format!("{:>3d}", 1), " 1".to_owned());
340 assert_eq!(format!("{:>+3d}", 1), " +1".to_owned());
341 assert_eq!(format!("{:<3d}", 1), "1 ".to_owned());
342 assert_eq!(format!("{:#d}", 1), "1".to_owned());
343 assert_eq!(format!("{:#x}", 10), "0xa".to_owned());
344 assert_eq!(format!("{:#X}", 10), "0xA".to_owned());
345 assert_eq!(format!("{:#5x}", 10), " 0xa".to_owned());
346 assert_eq!(format!("{:#o}", 10), "0o12".to_owned());
347 assert_eq!(format!("{:08x}", 10), "0000000a".to_owned());
348 assert_eq!(format!("{:8x}", 10), " a".to_owned());
349 assert_eq!(format!("{:<8x}", 10), "a ".to_owned());
350 assert_eq!(format!("{:>8x}", 10), " a".to_owned());
351 assert_eq!(format!("{:#08x}", 10), "0x00000a".to_owned());
352 assert_eq!(format!("{:08d}", -10), "-0000010".to_owned());
353 assert_eq!(format!("{:x}", -1u8), "ff".to_owned());
354 assert_eq!(format!("{:X}", -1u8), "FF".to_owned());
355 assert_eq!(format!("{:t}", -1u8), "11111111".to_owned());
356 assert_eq!(format!("{:o}", -1u8), "377".to_owned());
357 assert_eq!(format!("{:#x}", -1u8), "0xff".to_owned());
358 assert_eq!(format!("{:#X}", -1u8), "0xFF".to_owned());
359 assert_eq!(format!("{:#t}", -1u8), "0b11111111".to_owned());
360 assert_eq!(format!("{:#o}", -1u8), "0o377".to_owned());
361 }
362
363 #[test]
364 fn test_format_int_sign_padding() {
365 assert_eq!(format!("{:+5d}", 1), " +1".to_owned());
366 assert_eq!(format!("{:+5d}", -1), " -1".to_owned());
367 assert_eq!(format!("{:05d}", 1), "00001".to_owned());
368 assert_eq!(format!("{:05d}", -1), "-0001".to_owned());
369 assert_eq!(format!("{:+05d}", 1), "+0001".to_owned());
370 assert_eq!(format!("{:+05d}", -1), "-0001".to_owned());
371 }
372
373 #[test]
374 fn test_format_int_twos_complement() {
375 use {i8, i16, i32, i64};
376 assert_eq!(format!("{}", i8::MIN), "-128".to_owned());
377 assert_eq!(format!("{}", i16::MIN), "-32768".to_owned());
378 assert_eq!(format!("{}", i32::MIN), "-2147483648".to_owned());
379 assert_eq!(format!("{}", i64::MIN), "-9223372036854775808".to_owned());
380 }
381
382 #[test]
383 fn test_format_radix() {
384 assert_eq!(format!("{:04}", radix(3, 2)), "0011".to_owned());
385 assert_eq!(format!("{}", radix(55, 36)), "1j".to_owned());
386 }
387
388 #[test]
389 #[should_fail]
390 fn test_radix_base_too_large() {
391 let _ = radix(55, 37);
392 }
393 }
394
395 #[cfg(test)]
396 mod bench {
397 extern crate test;
398
399 mod uint {
400 use super::test::Bencher;
401 use fmt::radix;
402 use rand::{XorShiftRng, Rng};
403 use realstd::result::ResultUnwrap;
404
405 #[bench]
406 fn format_bin(b: &mut Bencher) {
407 let mut rng = XorShiftRng::new().unwrap();
408 b.iter(|| { format!("{:t}", rng.gen::<uint>()); })
409 }
410
411 #[bench]
412 fn format_oct(b: &mut Bencher) {
413 let mut rng = XorShiftRng::new().unwrap();
414 b.iter(|| { format!("{:o}", rng.gen::<uint>()); })
415 }
416
417 #[bench]
418 fn format_dec(b: &mut Bencher) {
419 let mut rng = XorShiftRng::new().unwrap();
420 b.iter(|| { format!("{:u}", rng.gen::<uint>()); })
421 }
422
423 #[bench]
424 fn format_hex(b: &mut Bencher) {
425 let mut rng = XorShiftRng::new().unwrap();
426 b.iter(|| { format!("{:x}", rng.gen::<uint>()); })
427 }
428
429 #[bench]
430 fn format_base_36(b: &mut Bencher) {
431 let mut rng = XorShiftRng::new().unwrap();
432 b.iter(|| { format!("{}", radix(rng.gen::<uint>(), 36)); })
433 }
434 }
435
436 mod int {
437 use super::test::Bencher;
438 use fmt::radix;
439 use rand::{XorShiftRng, Rng};
440 use realstd::result::ResultUnwrap;
441
442 #[bench]
443 fn format_bin(b: &mut Bencher) {
444 let mut rng = XorShiftRng::new().unwrap();
445 b.iter(|| { format!("{:t}", rng.gen::<int>()); })
446 }
447
448 #[bench]
449 fn format_oct(b: &mut Bencher) {
450 let mut rng = XorShiftRng::new().unwrap();
451 b.iter(|| { format!("{:o}", rng.gen::<int>()); })
452 }
453
454 #[bench]
455 fn format_dec(b: &mut Bencher) {
456 let mut rng = XorShiftRng::new().unwrap();
457 b.iter(|| { format!("{:d}", rng.gen::<int>()); })
458 }
459
460 #[bench]
461 fn format_hex(b: &mut Bencher) {
462 let mut rng = XorShiftRng::new().unwrap();
463 b.iter(|| { format!("{:x}", rng.gen::<int>()); })
464 }
465
466 #[bench]
467 fn format_base_36(b: &mut Bencher) {
468 let mut rng = XorShiftRng::new().unwrap();
469 b.iter(|| { format!("{}", radix(rng.gen::<int>(), 36)); })
470 }
471 }
472 }
libstd/fmt/num.rs:68:23-68:23 -struct- definition:
struct Binary;
/// An octal (base 8) radix
struct Octal;
references:- 667: /// A binary (base 2) radix
69: struct Binary;
--
88: ($T:ident, $base:expr, $prefix:expr, $($x:pat => $conv:expr),+) => {
89: impl GenericRadix for $T {
90: fn base(&self) -> u8 { $base }
libstd/fmt/num.rs:72:23-72:23 -struct- definition:
struct Octal;
/// A decimal (base 10) radix
struct Decimal;
references:- 671: /// An octal (base 8) radix
73: struct Octal;
--
88: ($T:ident, $base:expr, $prefix:expr, $($x:pat => $conv:expr),+) => {
89: impl GenericRadix for $T {
90: fn base(&self) -> u8 { $base }
libstd/fmt/num.rs:24:44-24:44 -trait- definition:
/// A type that represents a specific radix
trait GenericRadix {
/// The number of digits.
references:- 688: ($T:ident, $base:expr, $prefix:expr, $($x:pat => $conv:expr),+) => {
89: impl GenericRadix for $T {
90: fn base(&self) -> u8 { $base }
--
123: impl GenericRadix for Radix {
124: fn base(&self) -> u8 { self.base }
libstd/fmt/num.rs:134:42-134:42 -struct- definition:
/// A helper type for formatting radixes.
pub struct RadixFmt<T, R>(T, R);
/// Constructs a radix formatter in the range of `2..36`.
references:- 11150: ($T:ty as $U:ty, $fmt:ident) => {
151: impl fmt::Show for RadixFmt<$T, Radix> {
152: fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
libstd/fmt/num.rs:80:23-80:23 -struct- definition:
struct LowerHex;
/// A hexadecimal (base 16) radix, formatted with upper-case characters
pub struct UpperHex;
references:- 679: /// A hexadecimal (base 16) radix, formatted with lower-case characters
81: struct LowerHex;
--
88: ($T:ident, $base:expr, $prefix:expr, $($x:pat => $conv:expr),+) => {
89: impl GenericRadix for $T {
90: fn base(&self) -> u8 { $base }
libstd/fmt/num.rs:84:23-84:23 -struct- definition:
pub struct UpperHex;
macro_rules! radix {
($T:ident, $base:expr, $prefix:expr, $($x:pat => $conv:expr),+) => {
references:- 683: /// A hexadecimal (base 16) radix, formatted with upper-case characters
85: pub struct UpperHex;
--
88: ($T:ident, $base:expr, $prefix:expr, $($x:pat => $conv:expr),+) => {
89: impl GenericRadix for $T {
90: fn base(&self) -> u8 { $base }
libstd/fmt/num.rs:111:23-111:23 -struct- definition:
pub struct Radix {
base: u8,
}
references:- 26110: /// A radix with in the range of `2..36`.
112: pub struct Radix {
--
150: ($T:ty as $U:ty, $fmt:ident) => {
151: impl fmt::Show for RadixFmt<$T, Radix> {
152: fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
libstd/fmt/num.rs:76:23-76:23 -struct- definition:
struct Decimal;
/// A hexadecimal (base 16) radix, formatted with lower-case characters
struct LowerHex;
references:- 675: /// A decimal (base 10) radix
77: struct Decimal;
--
88: ($T:ident, $base:expr, $prefix:expr, $($x:pat => $conv:expr),+) => {
89: impl GenericRadix for $T {
90: fn base(&self) -> u8 { $base }