Rust i8

The i8 type in Rust is a primitive data type representing an 8-bit signed integer. It occupies exactly one byte of memory and encodes values using two’s complement binary representation, allowing it to represent both positive and negative whole numbers.

Technical Specifications

Memory Size: 8 bits (1 byte)
Minimum Value (i8::MIN): -128 (-2⁷)
Maximum Value (i8::MAX): 127 (2⁷ - 1)
Encoding: Two’s complement

Syntax and Initialization

You can declare an i8 using explicit type annotations or literal suffixes. Rust allows the use of underscores for visual separation, as well as hexadecimal, octal, and binary literal formats.

// Explicit type annotation
let decimal: i8 = 42;
let negative: i8 = -128;

// Literal suffix
let suffixed = 100i8;

// Alternative base literals
let hex: i8 = 0x7F;        // 127 in hexadecimal
let oct: i8 = 0o177;       // 127 in octal
let bin: i8 = 0b0111_1111; // 127 in binary

Overflow Behavior

Because i8 has a strict upper and lower bound, arithmetic operations that exceed these bounds result in integer overflow. Rust handles overflow differently depending on the compilation profile:

Debug mode: Integer overflow causes the program to panic.
Release mode: Integer overflow performs two’s complement wrapping (e.g., 127 + 1 becomes -128).

To explicitly control overflow behavior regardless of the compilation profile, Rust provides dedicated methods on the i8 type:

let max: i8 = 127;

// Explicit wrapping (returns -128)
let wrapped = max.wrapping_add(1);

// Checked addition (returns Option::None on overflow)
let checked = max.checked_add(1);

// Saturating addition (clamps to i8::MAX, returns 127)
let saturated = max.saturating_add(1);

// Overflowing addition (returns a tuple: (-128, true))
let (result, did_overflow) = max.overflowing_add(1);

Type Conversion

Rust enforces explicit type conversion. The method of conversion depends on whether the operation is lossless, fallible, or lossy.

Lossless Promotion: Converting i8 to a wider signed integer (e.g., i16, i32) performs sign extension. Rust strongly encourages using the From and Into traits for these infallible conversions.
Fallible Conversion: Converting from a wider integer to i8 can fail if the value is out of bounds. This is handled safely using the TryFrom and TryInto traits, which return a Result.
Lossy Truncation and Sign Casting: The as keyword is strictly required when intentionally performing lossy conversions (truncating higher-order bits) or reinterpreting the exact bit pattern (casting between i8 and u8).

let val: i8 = -5;

// Lossless promotion using Into/From (Sign extension)
let wider: i32 = val.into(); 
let wider_explicit = i32::from(val);

// Fallible conversion using TryInto (Returns Result)
let large_val: i32 = 300;
let checked_narrow: Result<i8, _> = large_val.try_into(); // Err(TryFromIntError)

// Lossy truncation using `as`
let truncated: i8 = large_val as i8; // 44 (keeps only the lowest 8 bits)

// Bit-pattern reinterpretation using `as` (Sign casting)
let unsigned: u8 = val as u8; // 251 (0b1111_1011)

Tired of Poor Rust Skills? Fix That With Deep Grasping!Learn More

Functions

Traits

Closures

Generics

Enums

Pattern Matching

Structs

Macros

Lifetimes

Error Handling

Variables

Control Flow

Loops

Modules

Compound Types

Collection Types

Numeric Types

Text & Boolean Types

Attributes

Comments

Assignment Operators

Arithmetic Operators

Comparison Operators

Logical Operators

Unary Operators

Reference Operators

Access & Path Operators

Range Operators

Bitwise Operators

Type Cast Operators

Technical Specifications

Syntax and Initialization

Overflow Behavior

Type Conversion

​Technical Specifications

​Syntax and Initialization

​Overflow Behavior

​Type Conversion

Technical Specifications

Syntax and Initialization

Overflow Behavior

Type Conversion