```
pub trait Binary {
// Required method
fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
}
```

## Expand description

`b`

formatting.

The `Binary`

trait should format its output as a number in binary.

For primitive signed integers (`i8`

to `i128`

, and `isize`

),
negative values are formatted as the two’s complement representation.

The alternate flag, `#`

, adds a `0b`

in front of the output.

For more information on formatters, see the module-level documentation.

## §Examples

Basic usage with `i32`

:

```
let x = 42; // 42 is '101010' in binary
assert_eq!(format!("{x:b}"), "101010");
assert_eq!(format!("{x:#b}"), "0b101010");
assert_eq!(format!("{:b}", -16), "11111111111111111111111111110000");
```

Implementing `Binary`

on a type:

```
use std::fmt;
struct Length(i32);
impl fmt::Binary for Length {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let val = self.0;
fmt::Binary::fmt(&val, f) // delegate to i32's implementation
}
}
let l = Length(107);
assert_eq!(format!("l as binary is: {l:b}"), "l as binary is: 1101011");
assert_eq!(
// Note that the `0b` prefix added by `#` is included in the total width, so we
// need to add two to correctly display all 32 bits.
format!("l as binary is: {l:#034b}"),
"l as binary is: 0b00000000000000000000000001101011"
);
```

## Required Methods§

## Implementors§

### impl Binary for i8

### impl Binary for i16

### impl Binary for i32

### impl Binary for i64

### impl Binary for i128

### impl Binary for isize

### impl Binary for u8

### impl Binary for u16

### impl Binary for u32

### impl Binary for u64

### impl Binary for u128

### impl Binary for usize

### impl Binary for NonZeroI8

### impl Binary for NonZeroI16

### impl Binary for NonZeroI32

### impl Binary for NonZeroI64

### impl Binary for NonZeroI128

### impl Binary for NonZeroIsize

### impl Binary for NonZeroU8

### impl Binary for NonZeroU16

### impl Binary for NonZeroU32

### impl Binary for NonZeroU64

### impl Binary for NonZeroU128

### impl Binary for NonZeroUsize

### impl<'a, T, O> Binary for Domain<'a, Const, T, O>where
O: BitOrder,
T: BitStore,

### impl<A, O> Binary for BitArray<A, O>where
O: BitOrder,
A: BitViewSized,

### impl<R> Binary for BitEnd<R>where
R: BitRegister,

### impl<R> Binary for BitIdx<R>where
R: BitRegister,

### impl<R> Binary for BitMask<R>where
R: BitRegister,

### impl<R> Binary for BitPos<R>where
R: BitRegister,

### impl<R> Binary for BitSel<R>where
R: BitRegister,

### impl<T> Binary for &T

### impl<T> Binary for &mut T

### impl<T> Binary for Saturating<T>where
T: Binary,

### impl<T> Binary for Wrapping<T>where
T: Binary,

### impl<T> Binary for FmtBinary<T>where
T: Binary,

### impl<T> Binary for FmtDisplay<T>

### impl<T> Binary for FmtList<T>

### impl<T> Binary for FmtLowerExp<T>

### impl<T> Binary for FmtLowerHex<T>

### impl<T> Binary for FmtOctal<T>

### impl<T> Binary for FmtPointer<T>

### impl<T> Binary for FmtUpperExp<T>

### impl<T> Binary for FmtUpperHex<T>

### impl<T, O> Binary for BitBox<T, O>where
O: BitOrder,
T: BitStore,

### impl<T, O> Binary for BitSlice<T, O>where
T: BitStore,
O: BitOrder,

#### §Bit-Slice Rendering

This implementation prints the contents of a `&BitSlice`

in one of binary,
octal, or hexadecimal. It is important to note that this does *not* render the
raw underlying memory! They render the semantically-ordered contents of the
bit-slice as numerals. This distinction matters if you use type parameters that
differ from those presumed by your debugger (which is usually `<u8, Msb0>`

).

The output separates the `T`

elements as individual list items, and renders each
element as a base- 2, 8, or 16 numeric string. When walking an element, the bits
traversed by the bit-slice are considered to be stored in
most-significant-bit-first ordering. This means that index `[0]`

is the high bit
of the left-most digit, and index `[n]`

is the low bit of the right-most digit,
in a given printed word.

In order to render according to expectations of the Arabic numeral system, an
element being transcribed is chunked into digits from the least-significant end
of its rendered form. This is most noticeable in octal, which will always have a
smaller ceiling on the left-most digit in a printed word, while the right-most
digit in that word is able to use the full `0 ..= 7`

numeral range.

##### §Examples

```
use bitvec::prelude::*;
let data = [
0b000000_10u8,
// digits print LTR
0b10_001_101,
// significance is computed RTL
0b01_000000,
];
let bits = &data.view_bits::<Msb0>()[6 .. 18];
assert_eq!(format!("{:b}", bits), "[10, 10001101, 01]");
assert_eq!(format!("{:o}", bits), "[2, 215, 1]");
assert_eq!(format!("{:X}", bits), "[2, 8D, 1]");
```

The `{:#}`

format modifier causes the standard `0b`

, `0o`

, or `0x`

prefix to be
applied to each printed word. The other format specifiers are not interpreted by
this implementation, and apply to the entire rendered text, not to individual
words.