> ## 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 Division Assignment The `/=` operator is the compound division assignment operator. It divides a mutable left-hand operand by a right-hand operand and assigns the quotient back to the left-hand operand. Unlike in C or C++, Rust does not desugar `a /= b` to `a = a / b`. Instead, it desugars directly to a method call on the `std::ops::DivAssign` trait: `DivAssign::div_assign(&mut a, b)`. ```rust theme={"dark"} left_operand /= right_operand; ``` ## Trait Implementation The `/=` operator is strictly powered by the `DivAssign` trait. If a custom type implements the `Div` trait but omits `DivAssign`, attempting to use `/=` will result in a compilation error; the compiler will not automatically fall back to `a = a / b`. ```rust theme={"dark"} pub trait DivAssign { fn div_assign(&mut self, rhs: Rhs); } ``` Because `div_assign` takes `&mut self`, the left-hand operand must be a *mutable place expression*. This can be a variable declared with the `mut` keyword, or a dereferenced mutable reference (e.g., `*x /= 2` where `x` is `&mut i32`). The operation modifies the left operand in place rather than allocating a new value, provided the type's implementation is optimized to do so. ## Execution Mechanics The behavior of `/=` depends strictly on the types of the operands: **Integer Types (`i32`, `u64`, etc.)** * **Truncation:** Integer division truncates the result towards zero. There is no rounding. * **Division by Zero:** Attempting to divide an integer by zero (e.g., `x /= 0`) will trigger a runtime `panic!`. * **Overflow:** Dividing the minimum representable value of a signed integer by `-1` causes an arithmetic overflow. For example, if `x` is `i8::MIN`, executing `x /= -1` is considered a hard error and will **always panic** at runtime in both debug and release profiles. **Floating-Point Types (`f32`, `f64`)** * **IEEE 754 Semantics:** Floating-point division adheres strictly to the IEEE 754 standard. * **Division by Zero:** Dividing a non-zero float by zero does not panic. If `x` is `5.0`, executing `x /= 0.0` mutates `x` to `Infinity` (`inf`) or `-Infinity` (`-inf`) depending on the sign. * **NaN:** Dividing zero by zero, such as `x /= 0.0` where `x` is `0.0`, mutates the left operand to `NaN` (Not a Number). ## Syntax Visualization ```rust theme={"dark"} // Integer division (truncates towards zero) let mut a: i32 = 14; a /= 3; // a == 4 // Mutable place expression via dereferenced mutable reference let mut value = 10; let ptr = &mut value; *ptr /= 2; // value == 5 // Integer overflow (always panics) // let mut overflow: i8 = i8::MIN; // overflow /= -1; // PANIC in both debug and release builds // Floating-point division let mut b: f64 = 14.0; b /= 3.0; // b == 4.666666666666667 // Floating-point division by zero (IEEE 754) let mut c: f32 = 5.0; c /= 0.0; // c == inf // Floating-point zero divided by zero let mut d: f32 = 0.0; d /= 0.0; // d is NaN ```

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