Lines
100 %
Functions
/// The addition operator `+`.
///
/// Note that `Rhs` is `Self` by default, but this is not mandatory. For
/// example, [`std::time::SystemTime`] implements `Add<Duration>`, which permits
/// operations of the form `SystemTime = SystemTime + Duration`.
/// [`std::time::SystemTime`]: ../../std/time/struct.SystemTime.html
/// # Examples
/// ## `Add`able points
/// ```
/// use std::ops::Add;
/// #[derive(Debug, Copy, Clone, PartialEq)]
/// struct Point {
/// x: i32,
/// y: i32,
/// }
/// impl Add for Point {
/// type Output = Self;
/// fn add(self, other: Self) -> Self {
/// Self {
/// x: self.x + other.x,
/// y: self.y + other.y,
/// assert_eq!(Point { x: 1, y: 0 } + Point { x: 2, y: 3 },
/// Point { x: 3, y: 3 });
/// ## Implementing `Add` with generics
/// Here is an example of the same `Point` struct implementing the `Add` trait
/// using generics.
/// struct Point<T> {
/// x: T,
/// y: T,
/// // Notice that the implementation uses the associated type `Output`.
/// impl<T: Add<Output = T>> Add for Point<T> {
/// fn add(self, other: Self) -> Self::Output {
#[lang = "add"]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_ops", issue = "143802")]
#[rustc_on_unimplemented(
on(all(Self = "{integer}", Rhs = "{float}"), message = "cannot add a float to an integer",),
on(all(Self = "{float}", Rhs = "{integer}"), message = "cannot add an integer to a float",),
message = "cannot add `{Rhs}` to `{Self}`",
label = "no implementation for `{Self} + {Rhs}`",
append_const_msg
)]
#[doc(alias = "+")]
#[const_trait]
pub trait Add<Rhs = Self> {
/// The resulting type after applying the `+` operator.
type Output;
/// Performs the `+` operation.
/// # Example
/// assert_eq!(12 + 1, 13);
#[must_use = "this returns the result of the operation, without modifying the original"]
#[rustc_diagnostic_item = "add"]
fn add(self, rhs: Rhs) -> Self::Output;
}
macro_rules! add_impl {
($($t:ty)*) => ($(
impl const Add for $t {
type Output = $t;
#[inline]
#[track_caller]
#[rustc_inherit_overflow_checks]
fn add(self, other: $t) -> $t { self + other }
forward_ref_binop! { impl Add, add for $t, $t,
#[rustc_const_unstable(feature = "const_ops", issue = "143802")] }
)*)
#[cfg(not(feature = "ferrocene_certified"))]
add_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f16 f32 f64 f128 }
#[cfg(feature = "ferrocene_certified")]
add_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
/// The subtraction operator `-`.
/// example, [`std::time::SystemTime`] implements `Sub<Duration>`, which permits
/// operations of the form `SystemTime = SystemTime - Duration`.
/// ## `Sub`tractable points
/// use std::ops::Sub;
/// impl Sub for Point {
/// fn sub(self, other: Self) -> Self::Output {
/// x: self.x - other.x,
/// y: self.y - other.y,
/// assert_eq!(Point { x: 3, y: 3 } - Point { x: 2, y: 3 },
/// Point { x: 1, y: 0 });
/// ## Implementing `Sub` with generics
/// Here is an example of the same `Point` struct implementing the `Sub` trait
/// #[derive(Debug, PartialEq)]
/// impl<T: Sub<Output = T>> Sub for Point<T> {
/// Point {
/// assert_eq!(Point { x: 2, y: 3 } - Point { x: 1, y: 0 },
/// Point { x: 1, y: 3 });
#[lang = "sub"]
message = "cannot subtract `{Rhs}` from `{Self}`",
label = "no implementation for `{Self} - {Rhs}`",
#[doc(alias = "-")]
pub trait Sub<Rhs = Self> {
/// The resulting type after applying the `-` operator.
/// Performs the `-` operation.
/// assert_eq!(12 - 1, 11);
#[rustc_diagnostic_item = "sub"]
fn sub(self, rhs: Rhs) -> Self::Output;
macro_rules! sub_impl {
impl const Sub for $t {
fn sub(self, other: $t) -> $t { self - other }
forward_ref_binop! { impl Sub, sub for $t, $t,
sub_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f16 f32 f64 f128 }
sub_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
/// The multiplication operator `*`.
/// Note that `Rhs` is `Self` by default, but this is not mandatory.
/// ## `Mul`tipliable rational numbers
/// use std::ops::Mul;
/// // By the fundamental theorem of arithmetic, rational numbers in lowest
/// // terms are unique. So, by keeping `Rational`s in reduced form, we can
/// // derive `Eq` and `PartialEq`.
/// #[derive(Debug, Eq, PartialEq)]
/// struct Rational {
/// numerator: usize,
/// denominator: usize,
/// impl Rational {
/// fn new(numerator: usize, denominator: usize) -> Self {
/// if denominator == 0 {
/// panic!("Zero is an invalid denominator!");
/// // Reduce to lowest terms by dividing by the greatest common
/// // divisor.
/// let gcd = gcd(numerator, denominator);
/// numerator: numerator / gcd,
/// denominator: denominator / gcd,
/// impl Mul for Rational {
/// // The multiplication of rational numbers is a closed operation.
/// fn mul(self, rhs: Self) -> Self {
/// let numerator = self.numerator * rhs.numerator;
/// let denominator = self.denominator * rhs.denominator;
/// Self::new(numerator, denominator)
/// // Euclid's two-thousand-year-old algorithm for finding the greatest common
/// fn gcd(x: usize, y: usize) -> usize {
/// let mut x = x;
/// let mut y = y;
/// while y != 0 {
/// let t = y;
/// y = x % y;
/// x = t;
/// x
/// assert_eq!(Rational::new(1, 2), Rational::new(2, 4));
/// assert_eq!(Rational::new(2, 3) * Rational::new(3, 4),
/// Rational::new(1, 2));
/// ## Multiplying vectors by scalars as in linear algebra
/// struct Scalar { value: usize }
/// struct Vector { value: Vec<usize> }
/// impl Mul<Scalar> for Vector {
/// fn mul(self, rhs: Scalar) -> Self::Output {
/// Self { value: self.value.iter().map(|v| v * rhs.value).collect() }
/// let vector = Vector { value: vec![2, 4, 6] };
/// let scalar = Scalar { value: 3 };
/// assert_eq!(vector * scalar, Vector { value: vec![6, 12, 18] });
#[lang = "mul"]
#[diagnostic::on_unimplemented(
message = "cannot multiply `{Self}` by `{Rhs}`",
label = "no implementation for `{Self} * {Rhs}`"
#[doc(alias = "*")]
pub trait Mul<Rhs = Self> {
/// The resulting type after applying the `*` operator.
/// Performs the `*` operation.
/// assert_eq!(12 * 2, 24);
#[rustc_diagnostic_item = "mul"]
fn mul(self, rhs: Rhs) -> Self::Output;
macro_rules! mul_impl {
impl const Mul for $t {
fn mul(self, other: $t) -> $t { self * other }
forward_ref_binop! { impl Mul, mul for $t, $t,
mul_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f16 f32 f64 f128 }
mul_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
/// The division operator `/`.
/// ## `Div`idable rational numbers
/// use std::ops::Div;
/// impl Div for Rational {
/// // The division of rational numbers is a closed operation.
/// fn div(self, rhs: Self) -> Self::Output {
/// if rhs.numerator == 0 {
/// panic!("Cannot divide by zero-valued `Rational`!");
/// let numerator = self.numerator * rhs.denominator;
/// let denominator = self.denominator * rhs.numerator;
/// assert_eq!(Rational::new(1, 2) / Rational::new(3, 4),
/// Rational::new(2, 3));
/// ## Dividing vectors by scalars as in linear algebra
/// struct Scalar { value: f32 }
/// struct Vector { value: Vec<f32> }
/// impl Div<Scalar> for Vector {
/// fn div(self, rhs: Scalar) -> Self::Output {
/// Self { value: self.value.iter().map(|v| v / rhs.value).collect() }
/// let scalar = Scalar { value: 2f32 };
/// let vector = Vector { value: vec![2f32, 4f32, 6f32] };
/// assert_eq!(vector / scalar, Vector { value: vec![1f32, 2f32, 3f32] });
#[lang = "div"]
message = "cannot divide `{Self}` by `{Rhs}`",
label = "no implementation for `{Self} / {Rhs}`"
#[doc(alias = "/")]
pub trait Div<Rhs = Self> {
/// The resulting type after applying the `/` operator.
/// Performs the `/` operation.
/// assert_eq!(12 / 2, 6);
#[rustc_diagnostic_item = "div"]
fn div(self, rhs: Rhs) -> Self::Output;
macro_rules! div_impl_integer {
($(($($t:ty)*) => $panic:expr),*) => ($($(
/// This operation rounds towards zero, truncating any
/// fractional part of the exact result.
/// # Panics
#[doc = $panic]
impl const Div for $t {
fn div(self, other: $t) -> $t { self / other }
forward_ref_binop! { impl Div, div for $t, $t,
)*)*)
div_impl_integer! {
(usize u8 u16 u32 u64 u128) => "This operation will panic if `other == 0`.",
(isize i8 i16 i32 i64 i128) => "This operation will panic if `other == 0` or the division results in overflow."
macro_rules! div_impl_float {
div_impl_float! { f16 f32 f64 f128 }
div_impl_float! { f32 f64 }
/// The remainder operator `%`.
/// This example implements `Rem` on a `SplitSlice` object. After `Rem` is
/// implemented, one can use the `%` operator to find out what the remaining
/// elements of the slice would be after splitting it into equal slices of a
/// given length.
/// use std::ops::Rem;
/// #[derive(PartialEq, Debug)]
/// struct SplitSlice<'a, T> {
/// slice: &'a [T],
/// impl<'a, T> Rem<usize> for SplitSlice<'a, T> {
/// fn rem(self, modulus: usize) -> Self::Output {
/// let len = self.slice.len();
/// let rem = len % modulus;
/// let start = len - rem;
/// Self {slice: &self.slice[start..]}
/// // If we were to divide &[0, 1, 2, 3, 4, 5, 6, 7] into slices of size 3,
/// // the remainder would be &[6, 7].
/// assert_eq!(SplitSlice { slice: &[0, 1, 2, 3, 4, 5, 6, 7] } % 3,
/// SplitSlice { slice: &[6, 7] });
#[lang = "rem"]
message = "cannot calculate the remainder of `{Self}` divided by `{Rhs}`",
label = "no implementation for `{Self} % {Rhs}`"
#[doc(alias = "%")]
pub trait Rem<Rhs = Self> {
/// The resulting type after applying the `%` operator.
/// Performs the `%` operation.
/// assert_eq!(12 % 10, 2);
#[rustc_diagnostic_item = "rem"]
fn rem(self, rhs: Rhs) -> Self::Output;
macro_rules! rem_impl_integer {
/// This operation satisfies `n % d == n - (n / d) * d`. The
/// result has the same sign as the left operand.
impl const Rem for $t {
fn rem(self, other: $t) -> $t { self % other }
forward_ref_binop! { impl Rem, rem for $t, $t,
rem_impl_integer! {
(isize i8 i16 i32 i64 i128) => "This operation will panic if `other == 0` or if `self / other` results in overflow."
macro_rules! rem_impl_float {
/// The remainder from the division of two floats.
/// The remainder has the same sign as the dividend and is computed as:
/// `x - (x / y).trunc() * y`.
/// let x: f32 = 50.50;
/// let y: f32 = 8.125;
/// let remainder = x - (x / y).trunc() * y;
/// // The answer to both operations is 1.75
/// assert_eq!(x % y, remainder);
rem_impl_float! { f16 f32 f64 f128 }
rem_impl_float! { f32 f64 }
/// The unary negation operator `-`.
/// An implementation of `Neg` for `Sign`, which allows the use of `-` to
/// negate its value.
/// use std::ops::Neg;
/// enum Sign {
/// Negative,
/// Zero,
/// Positive,
/// impl Neg for Sign {
/// fn neg(self) -> Self::Output {
/// match self {
/// Sign::Negative => Sign::Positive,
/// Sign::Zero => Sign::Zero,
/// Sign::Positive => Sign::Negative,
/// // A negative positive is a negative.
/// assert_eq!(-Sign::Positive, Sign::Negative);
/// // A double negative is a positive.
/// assert_eq!(-Sign::Negative, Sign::Positive);
/// // Zero is its own negation.
/// assert_eq!(-Sign::Zero, Sign::Zero);
#[lang = "neg"]
pub trait Neg {
/// Performs the unary `-` operation.
/// let x: i32 = 12;
/// assert_eq!(-x, -12);
#[rustc_diagnostic_item = "neg"]
fn neg(self) -> Self::Output;
macro_rules! neg_impl {
impl const Neg for $t {
fn neg(self) -> $t { -self }
forward_ref_unop! { impl Neg, neg for $t,
neg_impl! { isize i8 i16 i32 i64 i128 f16 f32 f64 f128 }
neg_impl! { isize i8 i16 i32 i64 i128 f32 f64 }
/// The addition assignment operator `+=`.
/// This example creates a `Point` struct that implements the `AddAssign`
/// trait, and then demonstrates add-assigning to a mutable `Point`.
/// use std::ops::AddAssign;
/// impl AddAssign for Point {
/// fn add_assign(&mut self, other: Self) {
/// *self = Self {
/// };
/// let mut point = Point { x: 1, y: 0 };
/// point += Point { x: 2, y: 3 };
/// assert_eq!(point, Point { x: 3, y: 3 });
#[lang = "add_assign"]
#[stable(feature = "op_assign_traits", since = "1.8.0")]
message = "cannot add-assign `{Rhs}` to `{Self}`",
label = "no implementation for `{Self} += {Rhs}`"
#[doc(alias = "+=")]
pub trait AddAssign<Rhs = Self> {
/// Performs the `+=` operation.
/// let mut x: u32 = 12;
/// x += 1;
/// assert_eq!(x, 13);
fn add_assign(&mut self, rhs: Rhs);
macro_rules! add_assign_impl {
($($t:ty)+) => ($(
impl const AddAssign for $t {
fn add_assign(&mut self, other: $t) { *self += other }
forward_ref_op_assign! { impl AddAssign, add_assign for $t, $t,
#[stable(feature = "op_assign_builtins_by_ref", since = "1.22.0")]
)+)
add_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f16 f32 f64 f128 }
add_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
/// The subtraction assignment operator `-=`.
/// This example creates a `Point` struct that implements the `SubAssign`
/// trait, and then demonstrates sub-assigning to a mutable `Point`.
/// use std::ops::SubAssign;
/// impl SubAssign for Point {
/// fn sub_assign(&mut self, other: Self) {
/// let mut point = Point { x: 3, y: 3 };
/// point -= Point { x: 2, y: 3 };
/// assert_eq!(point, Point {x: 1, y: 0});
#[lang = "sub_assign"]
message = "cannot subtract-assign `{Rhs}` from `{Self}`",
label = "no implementation for `{Self} -= {Rhs}`"
#[doc(alias = "-=")]
pub trait SubAssign<Rhs = Self> {
/// Performs the `-=` operation.
/// x -= 1;
/// assert_eq!(x, 11);
fn sub_assign(&mut self, rhs: Rhs);
macro_rules! sub_assign_impl {
impl const SubAssign for $t {
fn sub_assign(&mut self, other: $t) { *self -= other }
forward_ref_op_assign! { impl SubAssign, sub_assign for $t, $t,
sub_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f16 f32 f64 f128 }
sub_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
/// The multiplication assignment operator `*=`.
/// use std::ops::MulAssign;
/// struct Frequency { hertz: f64 }
/// impl MulAssign<f64> for Frequency {
/// fn mul_assign(&mut self, rhs: f64) {
/// self.hertz *= rhs;
/// let mut frequency = Frequency { hertz: 50.0 };
/// frequency *= 4.0;
/// assert_eq!(Frequency { hertz: 200.0 }, frequency);
#[lang = "mul_assign"]
message = "cannot multiply-assign `{Self}` by `{Rhs}`",
label = "no implementation for `{Self} *= {Rhs}`"
#[doc(alias = "*=")]
pub trait MulAssign<Rhs = Self> {
/// Performs the `*=` operation.
/// x *= 2;
/// assert_eq!(x, 24);
fn mul_assign(&mut self, rhs: Rhs);
macro_rules! mul_assign_impl {
impl const MulAssign for $t {
fn mul_assign(&mut self, other: $t) { *self *= other }
forward_ref_op_assign! { impl MulAssign, mul_assign for $t, $t,
mul_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f16 f32 f64 f128 }
mul_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
/// The division assignment operator `/=`.
/// use std::ops::DivAssign;
/// impl DivAssign<f64> for Frequency {
/// fn div_assign(&mut self, rhs: f64) {
/// self.hertz /= rhs;
/// let mut frequency = Frequency { hertz: 200.0 };
/// frequency /= 4.0;
/// assert_eq!(Frequency { hertz: 50.0 }, frequency);
#[lang = "div_assign"]
message = "cannot divide-assign `{Self}` by `{Rhs}`",
label = "no implementation for `{Self} /= {Rhs}`"
#[doc(alias = "/=")]
pub trait DivAssign<Rhs = Self> {
/// Performs the `/=` operation.
/// x /= 2;
/// assert_eq!(x, 6);
fn div_assign(&mut self, rhs: Rhs);
macro_rules! div_assign_impl {
impl const DivAssign for $t {
fn div_assign(&mut self, other: $t) { *self /= other }
forward_ref_op_assign! { impl DivAssign, div_assign for $t, $t,
div_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f16 f32 f64 f128 }
div_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
/// The remainder assignment operator `%=`.
/// use std::ops::RemAssign;
/// struct CookieJar { cookies: u32 }
/// impl RemAssign<u32> for CookieJar {
/// fn rem_assign(&mut self, piles: u32) {
/// self.cookies %= piles;
/// let mut jar = CookieJar { cookies: 31 };
/// let piles = 4;
/// println!("Splitting up {} cookies into {} even piles!", jar.cookies, piles);
/// jar %= piles;
/// println!("{} cookies remain in the cookie jar!", jar.cookies);
#[lang = "rem_assign"]
message = "cannot calculate and assign the remainder of `{Self}` divided by `{Rhs}`",
label = "no implementation for `{Self} %= {Rhs}`"
#[doc(alias = "%=")]
pub trait RemAssign<Rhs = Self> {
/// Performs the `%=` operation.
/// x %= 10;
/// assert_eq!(x, 2);
fn rem_assign(&mut self, rhs: Rhs);
macro_rules! rem_assign_impl {
impl const RemAssign for $t {
fn rem_assign(&mut self, other: $t) { *self %= other }
forward_ref_op_assign! { impl RemAssign, rem_assign for $t, $t,
rem_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f16 f32 f64 f128 }
rem_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }