> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Rust u8
`u8` is a primitive unsigned 8-bit integer type in Rust. It occupies exactly one byte of memory and represents non-negative whole numbers ranging from `0` to `255` inclusive ($2^8 - 1$). Because it is unsigned, it cannot represent negative values; the bit typically reserved for the sign in signed integers is instead utilized to extend the positive magnitude.
## Memory and Bounds
* **Size:** 1 byte (8 bits)
* **Minimum Value:** `u8::MIN` (`0`)
* **Maximum Value:** `u8::MAX` (`255`)
## Syntax and Initialization
Rust allows `u8` initialization through explicit type annotation, literal suffixes, or type inference.
```rust theme={"dark"}
// Explicit type annotation
let a: u8 = 255;
// Literal suffix
let b = 42_u8;
// Type inference (if constrained by later usage)
let mut c = 10;
c = a; // Compiler infers `c` is u8
```
## Literal Representations
A `u8` can be defined using multiple numeric bases and byte literals. Underscores can be used as visual separators to improve readability.
```rust theme={"dark"}
let decimal: u8 = 255;
let hex: u8 = 0xFF;
let octal: u8 = 0o377;
let binary: u8 = 0b1111_1111;
// Byte literal (ASCII character representation)
// The `b` prefix strictly evaluates the character to its u8 ASCII value.
let byte_literal: u8 = b'A'; // Evaluates to 65
```
## Overflow Behavior
Like all primitive integers in Rust, `u8` is subject to strict overflow rules. If an arithmetic operation exceeds `255` or drops below `0`:
* **Debug profile (`cargo build`)**: The compiler inserts integer overflow checks that cause the program to panic at runtime.
* **Release profile (`cargo build --release`)**: The compiler omits panic checks. Instead, the value performs two's complement wrapping (e.g., `255 + 1` wraps to `0`).
To explicitly dictate overflow behavior regardless of the compilation profile, `u8` implements specific standard library methods:
```rust theme={"dark"}
let max = u8::MAX;
// Wrapping: 255 + 1 = 0
let wrapped = max.wrapping_add(1);
// Saturating: 255 + 1 = 255 (clamps to the boundary)
let saturated = max.saturating_add(1);
// Checked: Returns Option::None on overflow, Option::Some(val) otherwise
let checked = max.checked_add(1);
```
## Type Casting
Rust does not perform implicit type coercion for integers. Converting a `u8` to or from another numeric type requires explicit casting using the `as` keyword or the `From`/`Into` traits.
```rust theme={"dark"}
let small_num: u8 = 100;
// Infallible cast to a larger type (zero-extended)
let larger_num: u32 = small_num as u32;
let larger_num_into: u32 = small_num.into();
// Truncating cast from a larger type (retains only the lowest 8 bits)
let large_val: u16 = 257; // Binary: 00000001 00000001
let truncated: u8 = large_val as u8; // Evaluates to 1 (00000001)
```
Tired of Poor Rust Skills? Fix That With Deep Grasping!
Learn More
