Trait tract_hir::internal::tract_downcast_rs::__std::ops::Add

#[lang = "add"]pub trait Add<Rhs = Self> {
    type Output;
#[must_use]    fn add(self, rhs: Rhs) -> Self::Output;
}

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.

Examples

Addable 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.

use std::ops::Add;

#[derive(Debug, Copy, Clone, PartialEq)]
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> {
    type Output = Self;

    fn add(self, other: Self) -> Self::Output {
        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 });

Associated Types

type Output

The resulting type after applying the + operator.

Loading content...

Required methods

#[must_use]fn add(self, rhs: Rhs) -> Self::Output

Performs the + operation.

Loading content...

Implementations on Foreign Types

impl<'a> Add<u32> for &'a u32

type Output = <u32 as Add<u32>>::Output

fn add(self, other: u32) -> <u32 as Add<u32>>::Output

impl<'_> Add<&'_ f32> for f32

type Output = <f32 as Add<f32>>::Output

fn add(self, other: &f32) -> <f32 as Add<f32>>::Output

impl<'_, '_> Add<&'_ usize> for &'_ usize

type Output = <usize as Add<usize>>::Output

fn add(self, other: &usize) -> <usize as Add<usize>>::Output

impl<'a> Add<usize> for &'a usize

type Output = <usize as Add<usize>>::Output

fn add(self, other: usize) -> <usize as Add<usize>>::Output

impl Add<u32> for u32

type Output = u32

fn add(self, other: u32) -> u32

impl<'a> Add<u16> for &'a u16

type Output = <u16 as Add<u16>>::Output

fn add(self, other: u16) -> <u16 as Add<u16>>::Output

impl Add<i128> for i128

type Output = i128

fn add(self, other: i128) -> i128

impl<'_> Add<&'_ f64> for f64

type Output = <f64 as Add<f64>>::Output

fn add(self, other: &f64) -> <f64 as Add<f64>>::Output

impl<'a> Add<isize> for &'a isize

type Output = <isize as Add<isize>>::Output

fn add(self, other: isize) -> <isize as Add<isize>>::Output

impl<'a> Add<u8> for &'a u8

type Output = <u8 as Add<u8>>::Output

fn add(self, other: u8) -> <u8 as Add<u8>>::Output

impl<'_> Add<&'_ u16> for u16

type Output = <u16 as Add<u16>>::Output

fn add(self, other: &u16) -> <u16 as Add<u16>>::Output

impl Add<i16> for i16

type Output = i16

fn add(self, other: i16) -> i16

impl<'_, '_> Add<&'_ i8> for &'_ i8

type Output = <i8 as Add<i8>>::Output

fn add(self, other: &i8) -> <i8 as Add<i8>>::Output

impl Add<i64> for i64

type Output = i64

fn add(self, other: i64) -> i64

impl<'_> Add<&'_ usize> for usize

type Output = <usize as Add<usize>>::Output

fn add(self, other: &usize) -> <usize as Add<usize>>::Output

impl<'_> Add<&'_ isize> for isize

type Output = <isize as Add<isize>>::Output

fn add(self, other: &isize) -> <isize as Add<isize>>::Output

impl<'_, '_> Add<&'_ i16> for &'_ i16

type Output = <i16 as Add<i16>>::Output

fn add(self, other: &i16) -> <i16 as Add<i16>>::Output

impl<'a> Add<i32> for &'a i32

type Output = <i32 as Add<i32>>::Output

fn add(self, other: i32) -> <i32 as Add<i32>>::Output

impl<'_> Add<&'_ u8> for u8

type Output = <u8 as Add<u8>>::Output

fn add(self, other: &u8) -> <u8 as Add<u8>>::Output

impl<'a> Add<u64> for &'a u64

type Output = <u64 as Add<u64>>::Output

fn add(self, other: u64) -> <u64 as Add<u64>>::Output

impl Add<usize> for usize

type Output = usize

fn add(self, other: usize) -> usize

impl<'_> Add<&'_ u128> for u128

type Output = <u128 as Add<u128>>::Output

fn add(self, other: &u128) -> <u128 as Add<u128>>::Output

impl Add<isize> for isize

type Output = isize

fn add(self, other: isize) -> isize

impl Add<u128> for u128

type Output = u128

fn add(self, other: u128) -> u128

impl Add<f32> for f32

type Output = f32

fn add(self, other: f32) -> f32

impl<'a> Add<f64> for &'a f64

type Output = <f64 as Add<f64>>::Output

fn add(self, other: f64) -> <f64 as Add<f64>>::Output

impl Add<u16> for u16

type Output = u16

fn add(self, other: u16) -> u16

impl<'a> Add<i64> for &'a i64

type Output = <i64 as Add<i64>>::Output

fn add(self, other: i64) -> <i64 as Add<i64>>::Output

impl<'a> Add<i16> for &'a i16

type Output = <i16 as Add<i16>>::Output

fn add(self, other: i16) -> <i16 as Add<i16>>::Output

impl Add<i8> for i8

type Output = i8

fn add(self, other: i8) -> i8

impl<'_> Add<&'_ i128> for i128

type Output = <i128 as Add<i128>>::Output

fn add(self, other: &i128) -> <i128 as Add<i128>>::Output

impl<'_> Add<&'_ u32> for u32

type Output = <u32 as Add<u32>>::Output

fn add(self, other: &u32) -> <u32 as Add<u32>>::Output

impl<'a> Add<i8> for &'a i8

type Output = <i8 as Add<i8>>::Output

fn add(self, other: i8) -> <i8 as Add<i8>>::Output

impl Add<u64> for u64

type Output = u64

fn add(self, other: u64) -> u64

impl<'_, '_> Add<&'_ f64> for &'_ f64

type Output = <f64 as Add<f64>>::Output

fn add(self, other: &f64) -> <f64 as Add<f64>>::Output

impl Add<u8> for u8

type Output = u8

fn add(self, other: u8) -> u8

impl<'_, '_> Add<&'_ u16> for &'_ u16

type Output = <u16 as Add<u16>>::Output

fn add(self, other: &u16) -> <u16 as Add<u16>>::Output

impl<'_, '_> Add<&'_ i32> for &'_ i32

type Output = <i32 as Add<i32>>::Output

fn add(self, other: &i32) -> <i32 as Add<i32>>::Output

impl<'_> Add<&'_ i32> for i32

type Output = <i32 as Add<i32>>::Output

fn add(self, other: &i32) -> <i32 as Add<i32>>::Output

impl<'_, '_> Add<&'_ u32> for &'_ u32

type Output = <u32 as Add<u32>>::Output

fn add(self, other: &u32) -> <u32 as Add<u32>>::Output

impl Add<i32> for i32

type Output = i32

fn add(self, other: i32) -> i32

impl<'_> Add<&'_ u64> for u64

type Output = <u64 as Add<u64>>::Output

fn add(self, other: &u64) -> <u64 as Add<u64>>::Output

impl<'a> Add<f32> for &'a f32

type Output = <f32 as Add<f32>>::Output

fn add(self, other: f32) -> <f32 as Add<f32>>::Output

impl<'a> Add<i128> for &'a i128

type Output = <i128 as Add<i128>>::Output

fn add(self, other: i128) -> <i128 as Add<i128>>::Output

impl<'a> Add<u128> for &'a u128

type Output = <u128 as Add<u128>>::Output

fn add(self, other: u128) -> <u128 as Add<u128>>::Output

impl<'_> Add<&'_ i16> for i16

type Output = <i16 as Add<i16>>::Output

fn add(self, other: &i16) -> <i16 as Add<i16>>::Output

impl<'_, '_> Add<&'_ u8> for &'_ u8

type Output = <u8 as Add<u8>>::Output

fn add(self, other: &u8) -> <u8 as Add<u8>>::Output

impl<'_, '_> Add<&'_ f32> for &'_ f32

type Output = <f32 as Add<f32>>::Output

fn add(self, other: &f32) -> <f32 as Add<f32>>::Output

impl<'_, '_> Add<&'_ u64> for &'_ u64

type Output = <u64 as Add<u64>>::Output

fn add(self, other: &u64) -> <u64 as Add<u64>>::Output

impl<'_> Add<&'_ i8> for i8

type Output = <i8 as Add<i8>>::Output

fn add(self, other: &i8) -> <i8 as Add<i8>>::Output

impl Add<f64> for f64

type Output = f64

fn add(self, other: f64) -> f64

impl<'_> Add<&'_ i64> for i64

type Output = <i64 as Add<i64>>::Output

fn add(self, other: &i64) -> <i64 as Add<i64>>::Output

impl<'_, '_> Add<&'_ i64> for &'_ i64

type Output = <i64 as Add<i64>>::Output

fn add(self, other: &i64) -> <i64 as Add<i64>>::Output

impl<'_, '_> Add<&'_ isize> for &'_ isize

type Output = <isize as Add<isize>>::Output

fn add(self, other: &isize) -> <isize as Add<isize>>::Output

impl<'_, '_> Add<&'_ i128> for &'_ i128

type Output = <i128 as Add<i128>>::Output

fn add(self, other: &i128) -> <i128 as Add<i128>>::Output

impl<'_, '_> Add<&'_ u128> for &'_ u128

type Output = <u128 as Add<u128>>::Output

fn add(self, other: &u128) -> <u128 as Add<u128>>::Output

impl<S, D> Add<ArrayBase<S, D>> for f32 where
    D: Dimension,
    S: DataOwned<Elem = f32> + DataMut, 

type Output = ArrayBase<S, D>

fn add(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<S, D> Add<ArrayBase<S, D>> for u64 where
    D: Dimension,
    S: DataOwned<Elem = u64> + DataMut, 

type Output = ArrayBase<S, D>

fn add(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<'a, S, D> Add<&'a ArrayBase<S, D>> for i32 where
    D: Dimension,
    S: Data<Elem = i32>, 

type Output = ArrayBase<OwnedRepr<i32>, D>

fn add(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i32>, D>

impl<'a, S, D> Add<&'a ArrayBase<S, D>> for u8 where
    D: Dimension,
    S: Data<Elem = u8>, 

type Output = ArrayBase<OwnedRepr<u8>, D>

fn add(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u8>, D>

impl<'a, S, D> Add<&'a ArrayBase<S, D>> for u128 where
    D: Dimension,
    S: Data<Elem = u128>, 

type Output = ArrayBase<OwnedRepr<u128>, D>

fn add(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u128>, D>

impl<S, D> Add<ArrayBase<S, D>> for u32 where
    D: Dimension,
    S: DataOwned<Elem = u32> + DataMut, 

type Output = ArrayBase<S, D>

fn add(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<S, D> Add<ArrayBase<S, D>> for f64 where
    D: Dimension,
    S: DataOwned<Elem = f64> + DataMut, 

type Output = ArrayBase<S, D>

fn add(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<'a, S, D> Add<&'a ArrayBase<S, D>> for i8 where
    D: Dimension,
    S: Data<Elem = i8>, 

type Output = ArrayBase<OwnedRepr<i8>, D>

fn add(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i8>, D>

impl<S, D> Add<ArrayBase<S, D>> for Complex<f64> where
    D: Dimension,
    S: DataOwned<Elem = Complex<f64>> + DataMut, 

type Output = ArrayBase<S, D>

fn add(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<'a, S, D> Add<&'a ArrayBase<S, D>> for f64 where
    D: Dimension,
    S: Data<Elem = f64>, 

type Output = ArrayBase<OwnedRepr<f64>, D>

fn add(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<f64>, D>

impl<S, D> Add<ArrayBase<S, D>> for i32 where
    D: Dimension,
    S: DataOwned<Elem = i32> + DataMut, 

type Output = ArrayBase<S, D>

fn add(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<S, D> Add<ArrayBase<S, D>> for i64 where
    D: Dimension,
    S: DataOwned<Elem = i64> + DataMut, 

type Output = ArrayBase<S, D>

fn add(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<'a, S, D> Add<&'a ArrayBase<S, D>> for i64 where
    D: Dimension,
    S: Data<Elem = i64>, 

type Output = ArrayBase<OwnedRepr<i64>, D>

fn add(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i64>, D>

impl<'a, S, D> Add<&'a ArrayBase<S, D>> for f32 where
    D: Dimension,
    S: Data<Elem = f32>, 

type Output = ArrayBase<OwnedRepr<f32>, D>

fn add(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<f32>, D>

impl<S, D> Add<ArrayBase<S, D>> for u16 where
    D: Dimension,
    S: DataOwned<Elem = u16> + DataMut, 

type Output = ArrayBase<S, D>

fn add(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<S, D> Add<ArrayBase<S, D>> for u128 where
    D: Dimension,
    S: DataOwned<Elem = u128> + DataMut, 

type Output = ArrayBase<S, D>

fn add(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<S, D> Add<ArrayBase<S, D>> for i128 where
    D: Dimension,
    S: DataOwned<Elem = i128> + DataMut, 

type Output = ArrayBase<S, D>

fn add(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<S, D> Add<ArrayBase<S, D>> for Complex<f32> where
    D: Dimension,
    S: DataOwned<Elem = Complex<f32>> + DataMut, 

type Output = ArrayBase<S, D>

fn add(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<'a, S, D> Add<&'a ArrayBase<S, D>> for u64 where
    D: Dimension,
    S: Data<Elem = u64>, 

type Output = ArrayBase<OwnedRepr<u64>, D>

fn add(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u64>, D>

impl<S, D> Add<ArrayBase<S, D>> for u8 where
    D: Dimension,
    S: DataOwned<Elem = u8> + DataMut, 

type Output = ArrayBase<S, D>

fn add(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<'a, S, D> Add<&'a ArrayBase<S, D>> for Complex<f64> where
    D: Dimension,
    S: Data<Elem = Complex<f64>>, 

type Output = ArrayBase<OwnedRepr<Complex<f64>>, D>

fn add(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<Complex<f64>>, D>

impl<'a, S, D> Add<&'a ArrayBase<S, D>> for u16 where
    D: Dimension,
    S: Data<Elem = u16>, 

type Output = ArrayBase<OwnedRepr<u16>, D>

fn add(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u16>, D>

impl<'a, S, D> Add<&'a ArrayBase<S, D>> for u32 where
    D: Dimension,
    S: Data<Elem = u32>, 

type Output = ArrayBase<OwnedRepr<u32>, D>

fn add(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u32>, D>

impl<'a, S, D> Add<&'a ArrayBase<S, D>> for i16 where
    D: Dimension,
    S: Data<Elem = i16>, 

type Output = ArrayBase<OwnedRepr<i16>, D>

fn add(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i16>, D>

impl<S, D> Add<ArrayBase<S, D>> for i8 where
    D: Dimension,
    S: DataOwned<Elem = i8> + DataMut, 

type Output = ArrayBase<S, D>

fn add(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<'a, S, D> Add<&'a ArrayBase<S, D>> for i128 where
    D: Dimension,
    S: Data<Elem = i128>, 

type Output = ArrayBase<OwnedRepr<i128>, D>

fn add(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i128>, D>

impl<S, D> Add<ArrayBase<S, D>> for i16 where
    D: Dimension,
    S: DataOwned<Elem = i16> + DataMut, 

type Output = ArrayBase<S, D>

fn add(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<'a, S, D> Add<&'a ArrayBase<S, D>> for Complex<f32> where
    D: Dimension,
    S: Data<Elem = Complex<f32>>, 

type Output = ArrayBase<OwnedRepr<Complex<f32>>, D>

fn add(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<Complex<f32>>, D>

impl<T> Add<T> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

fn add(self, other: T) -> <Complex<T> as Add<T>>::Output

impl<'a> Add<Complex<isize>> for &'a isize

type Output = Complex<isize>

fn add(self, other: Complex<isize>) -> Complex<isize>

impl<'a, 'b, T> Add<&'a T> for &'b Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

fn add(self, other: &T) -> <&'b Complex<T> as Add<&'a T>>::Output

impl Add<Complex<u32>> for u32

type Output = Complex<u32>

fn add(self, other: Complex<u32>) -> <u32 as Add<Complex<u32>>>::Output

impl<'a, T> Add<&'a T> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

fn add(self, other: &T) -> <Complex<T> as Add<&'a T>>::Output

impl<'a, 'b> Add<&'a Complex<i16>> for &'b i16

type Output = Complex<i16>

fn add(self, other: &Complex<i16>) -> Complex<i16>

impl<'a> Add<&'a Complex<u64>> for u64

type Output = Complex<u64>

fn add(self, other: &Complex<u64>) -> Complex<u64>

impl<'a> Add<Complex<u32>> for &'a u32

type Output = Complex<u32>

fn add(self, other: Complex<u32>) -> Complex<u32>

impl<'a> Add<Complex<f64>> for &'a f64

type Output = Complex<f64>

fn add(self, other: Complex<f64>) -> Complex<f64>

impl Add<Complex<u128>> for u128

type Output = Complex<u128>

fn add(self, other: Complex<u128>) -> <u128 as Add<Complex<u128>>>::Output

impl Add<Complex<i8>> for i8

type Output = Complex<i8>

fn add(self, other: Complex<i8>) -> <i8 as Add<Complex<i8>>>::Output

impl Add<Complex<usize>> for usize

type Output = Complex<usize>

fn add(self, other: Complex<usize>) -> <usize as Add<Complex<usize>>>::Output

impl Add<Complex<f64>> for f64

type Output = Complex<f64>

fn add(self, other: Complex<f64>) -> <f64 as Add<Complex<f64>>>::Output

impl<'a> Add<&'a Complex<u128>> for u128

type Output = Complex<u128>

fn add(self, other: &Complex<u128>) -> Complex<u128>

impl<'a> Add<Complex<i64>> for &'a i64

type Output = Complex<i64>

fn add(self, other: Complex<i64>) -> Complex<i64>

impl<'a> Add<&'a Complex<u32>> for u32

type Output = Complex<u32>

fn add(self, other: &Complex<u32>) -> Complex<u32>

impl<'a> Add<&'a Complex<u8>> for u8

type Output = Complex<u8>

fn add(self, other: &Complex<u8>) -> Complex<u8>

impl<'a, 'b> Add<&'a Complex<i32>> for &'b i32

type Output = Complex<i32>

fn add(self, other: &Complex<i32>) -> Complex<i32>

impl<'a, 'b> Add<&'a Complex<u8>> for &'b u8

type Output = Complex<u8>

fn add(self, other: &Complex<u8>) -> Complex<u8>

impl Add<Complex<i64>> for i64

type Output = Complex<i64>

fn add(self, other: Complex<i64>) -> <i64 as Add<Complex<i64>>>::Output

impl<'a> Add<&'a Complex<f64>> for f64

type Output = Complex<f64>

fn add(self, other: &Complex<f64>) -> Complex<f64>

impl<'a> Add<Complex<usize>> for &'a usize

type Output = Complex<usize>

fn add(self, other: Complex<usize>) -> Complex<usize>

impl<'a> Add<&'a Complex<usize>> for usize

type Output = Complex<usize>

fn add(self, other: &Complex<usize>) -> Complex<usize>

impl<'a> Add<Complex<i32>> for &'a i32

type Output = Complex<i32>

fn add(self, other: Complex<i32>) -> Complex<i32>

impl<'a, 'b> Add<&'a Complex<usize>> for &'b usize

type Output = Complex<usize>

fn add(self, other: &Complex<usize>) -> Complex<usize>

impl<'a> Add<Complex<u128>> for &'a u128

type Output = Complex<u128>

fn add(self, other: Complex<u128>) -> Complex<u128>

impl Add<Complex<i128>> for i128

type Output = Complex<i128>

fn add(self, other: Complex<i128>) -> <i128 as Add<Complex<i128>>>::Output

impl<'a> Add<Complex<i128>> for &'a i128

type Output = Complex<i128>

fn add(self, other: Complex<i128>) -> Complex<i128>

impl<'a> Add<Complex<i8>> for &'a i8

type Output = Complex<i8>

fn add(self, other: Complex<i8>) -> Complex<i8>

impl Add<Complex<i32>> for i32

type Output = Complex<i32>

fn add(self, other: Complex<i32>) -> <i32 as Add<Complex<i32>>>::Output

impl Add<Complex<u8>> for u8

type Output = Complex<u8>

fn add(self, other: Complex<u8>) -> <u8 as Add<Complex<u8>>>::Output

impl<'a> Add<&'a Complex<u16>> for u16

type Output = Complex<u16>

fn add(self, other: &Complex<u16>) -> Complex<u16>

impl<'a, 'b> Add<&'a Complex<f64>> for &'b f64

type Output = Complex<f64>

fn add(self, other: &Complex<f64>) -> Complex<f64>

impl<'a> Add<&'a Complex<i64>> for i64

type Output = Complex<i64>

fn add(self, other: &Complex<i64>) -> Complex<i64>

impl<'a, T> Add<&'a Complex<T>> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

fn add(self, other: &Complex<T>) -> <Complex<T> as Add<&'a Complex<T>>>::Output

impl<'a> Add<Complex<f32>> for &'a f32

type Output = Complex<f32>

fn add(self, other: Complex<f32>) -> Complex<f32>

impl<T> Add<Complex<T>> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

fn add(self, other: Complex<T>) -> <Complex<T> as Add<Complex<T>>>::Output

impl<'a> Add<&'a Complex<i128>> for i128

type Output = Complex<i128>

fn add(self, other: &Complex<i128>) -> Complex<i128>

impl<'a, T> Add<T> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

fn add(self, other: T) -> <&'a Complex<T> as Add<T>>::Output

impl<'a, 'b> Add<&'a Complex<isize>> for &'b isize

type Output = Complex<isize>

fn add(self, other: &Complex<isize>) -> Complex<isize>

impl Add<Complex<isize>> for isize

type Output = Complex<isize>

fn add(self, other: Complex<isize>) -> <isize as Add<Complex<isize>>>::Output

impl<'a, 'b> Add<&'a Complex<u16>> for &'b u16

type Output = Complex<u16>

fn add(self, other: &Complex<u16>) -> Complex<u16>

impl<'a> Add<Complex<i16>> for &'a i16

type Output = Complex<i16>

fn add(self, other: Complex<i16>) -> Complex<i16>

impl<'a> Add<&'a Complex<f32>> for f32

type Output = Complex<f32>

fn add(self, other: &Complex<f32>) -> Complex<f32>

impl<'a, 'b> Add<&'a Complex<i64>> for &'b i64

type Output = Complex<i64>

fn add(self, other: &Complex<i64>) -> Complex<i64>

impl Add<Complex<f32>> for f32

type Output = Complex<f32>

fn add(self, other: Complex<f32>) -> <f32 as Add<Complex<f32>>>::Output

impl<'a> Add<&'a Complex<i32>> for i32

type Output = Complex<i32>

fn add(self, other: &Complex<i32>) -> Complex<i32>

impl Add<Complex<u64>> for u64

type Output = Complex<u64>

fn add(self, other: Complex<u64>) -> <u64 as Add<Complex<u64>>>::Output

impl<'a> Add<Complex<u64>> for &'a u64

type Output = Complex<u64>

fn add(self, other: Complex<u64>) -> Complex<u64>

impl<'a, 'b, T> Add<&'b Complex<T>> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

fn add(
    self,
    other: &Complex<T>
) -> <&'a Complex<T> as Add<&'b Complex<T>>>::Output

impl<'a, 'b> Add<&'a Complex<i128>> for &'b i128

type Output = Complex<i128>

fn add(self, other: &Complex<i128>) -> Complex<i128>

impl<'a, 'b> Add<&'a Complex<f32>> for &'b f32

type Output = Complex<f32>

fn add(self, other: &Complex<f32>) -> Complex<f32>

impl<'a, 'b> Add<&'a Complex<u32>> for &'b u32

type Output = Complex<u32>

fn add(self, other: &Complex<u32>) -> Complex<u32>

impl<'a, 'b> Add<&'a Complex<u64>> for &'b u64

type Output = Complex<u64>

fn add(self, other: &Complex<u64>) -> Complex<u64>

impl<'a> Add<&'a Complex<i8>> for i8

type Output = Complex<i8>

fn add(self, other: &Complex<i8>) -> Complex<i8>

impl<'a, 'b> Add<&'a Complex<i8>> for &'b i8

type Output = Complex<i8>

fn add(self, other: &Complex<i8>) -> Complex<i8>

impl<'a> Add<&'a Complex<i16>> for i16

type Output = Complex<i16>

fn add(self, other: &Complex<i16>) -> Complex<i16>

impl<'a> Add<Complex<u8>> for &'a u8

type Output = Complex<u8>

fn add(self, other: Complex<u8>) -> Complex<u8>

impl<'a, T> Add<Complex<T>> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

fn add(self, other: Complex<T>) -> <&'a Complex<T> as Add<Complex<T>>>::Output

impl<'a> Add<&'a Complex<isize>> for isize

type Output = Complex<isize>

fn add(self, other: &Complex<isize>) -> Complex<isize>

impl<'a, 'b> Add<&'a Complex<u128>> for &'b u128

type Output = Complex<u128>

fn add(self, other: &Complex<u128>) -> Complex<u128>

impl<'a> Add<Complex<u16>> for &'a u16

type Output = Complex<u16>

fn add(self, other: Complex<u16>) -> Complex<u16>

impl Add<Complex<u16>> for u16

type Output = Complex<u16>

fn add(self, other: Complex<u16>) -> <u16 as Add<Complex<u16>>>::Output

impl Add<Complex<i16>> for i16

type Output = Complex<i16>

fn add(self, other: Complex<i16>) -> <i16 as Add<Complex<i16>>>::Output

Loading content...

Implementors

impl Add<usize> for Dim<[usize; 1]>

type Output = Dim<[usize; 1]>

fn add(self, rhs: usize) -> Dim<[usize; 1]>

impl Add<Wrapping<i8>> for Wrapping<i8>

type Output = Wrapping<i8>

fn add(self, other: Wrapping<i8>) -> Wrapping<i8>

impl Add<Wrapping<i16>> for Wrapping<i16>

type Output = Wrapping<i16>

fn add(self, other: Wrapping<i16>) -> Wrapping<i16>

impl Add<Wrapping<i32>> for Wrapping<i32>

type Output = Wrapping<i32>

fn add(self, other: Wrapping<i32>) -> Wrapping<i32>

impl Add<Wrapping<i64>> for Wrapping<i64>

type Output = Wrapping<i64>

fn add(self, other: Wrapping<i64>) -> Wrapping<i64>

impl Add<Wrapping<i128>> for Wrapping<i128>

type Output = Wrapping<i128>

fn add(self, other: Wrapping<i128>) -> Wrapping<i128>

impl Add<Wrapping<isize>> for Wrapping<isize>

type Output = Wrapping<isize>

fn add(self, other: Wrapping<isize>) -> Wrapping<isize>

impl Add<Wrapping<u8>> for Wrapping<u8>

type Output = Wrapping<u8>

fn add(self, other: Wrapping<u8>) -> Wrapping<u8>

impl Add<Wrapping<u16>> for Wrapping<u16>

type Output = Wrapping<u16>

fn add(self, other: Wrapping<u16>) -> Wrapping<u16>

impl Add<Wrapping<u32>> for Wrapping<u32>

type Output = Wrapping<u32>

fn add(self, other: Wrapping<u32>) -> Wrapping<u32>

impl Add<Wrapping<u64>> for Wrapping<u64>

type Output = Wrapping<u64>

fn add(self, other: Wrapping<u64>) -> Wrapping<u64>

impl Add<Wrapping<u128>> for Wrapping<u128>

type Output = Wrapping<u128>

fn add(self, other: Wrapping<u128>) -> Wrapping<u128>

impl Add<Wrapping<usize>> for Wrapping<usize>

type Output = Wrapping<usize>

fn add(self, other: Wrapping<usize>) -> Wrapping<usize>

impl Add<Duration> for Duration

type Output = Duration

fn add(self, rhs: Duration) -> Duration

impl Add<Duration> for Instant

type Output = Instant

fn add(self, other: Duration) -> Instant

Panics

This function may panic if the resulting point in time cannot be represented by the underlying data structure. See Instant::checked_add for a version without panic.

impl Add<Duration> for SystemTime

type Output = SystemTime

fn add(self, dur: Duration) -> SystemTime

Panics

This function may panic if the resulting point in time cannot be represented by the underlying data structure. See SystemTime::checked_add for a version without panic.

impl Add<f16> for f16

type Output = f16

fn add(self, other: f16) -> f16

impl<'_> Add<&'_ str> for String

Implements the + operator for concatenating two strings.

This consumes the String on the left-hand side and re-uses its buffer (growing it if necessary). This is done to avoid allocating a new String and copying the entire contents on every operation, which would lead to O(n^2) running time when building an n-byte string by repeated concatenation.

The string on the right-hand side is only borrowed; its contents are copied into the returned String.

Examples

Concatenating two Strings takes the first by value and borrows the second:

let a = String::from("hello");
let b = String::from(" world");
let c = a + &b;
// `a` is moved and can no longer be used here.

If you want to keep using the first String, you can clone it and append to the clone instead:

let a = String::from("hello");
let b = String::from(" world");
let c = a.clone() + &b;
// `a` is still valid here.

Concatenating &str slices can be done by converting the first to a String:

let a = "hello";
let b = " world";
let c = a.to_string() + b;

type Output = String

fn add(self, other: &str) -> String

impl<'_> Add<&'_ Wrapping<i8>> for Wrapping<i8>

type Output = <Wrapping<i8> as Add<Wrapping<i8>>>::Output

fn add(
    self,
    other: &Wrapping<i8>
) -> <Wrapping<i8> as Add<Wrapping<i8>>>::Output

impl<'_> Add<&'_ Wrapping<i16>> for Wrapping<i16>

type Output = <Wrapping<i16> as Add<Wrapping<i16>>>::Output

fn add(
    self,
    other: &Wrapping<i16>
) -> <Wrapping<i16> as Add<Wrapping<i16>>>::Output

impl<'_> Add<&'_ Wrapping<i32>> for Wrapping<i32>

type Output = <Wrapping<i32> as Add<Wrapping<i32>>>::Output

fn add(
    self,
    other: &Wrapping<i32>
) -> <Wrapping<i32> as Add<Wrapping<i32>>>::Output

impl<'_> Add<&'_ Wrapping<i64>> for Wrapping<i64>

type Output = <Wrapping<i64> as Add<Wrapping<i64>>>::Output

fn add(
    self,
    other: &Wrapping<i64>
) -> <Wrapping<i64> as Add<Wrapping<i64>>>::Output

impl<'_> Add<&'_ Wrapping<i128>> for Wrapping<i128>

type Output = <Wrapping<i128> as Add<Wrapping<i128>>>::Output

fn add(
    self,
    other: &Wrapping<i128>
) -> <Wrapping<i128> as Add<Wrapping<i128>>>::Output

impl<'_> Add<&'_ Wrapping<isize>> for Wrapping<isize>

type Output = <Wrapping<isize> as Add<Wrapping<isize>>>::Output

fn add(
    self,
    other: &Wrapping<isize>
) -> <Wrapping<isize> as Add<Wrapping<isize>>>::Output

impl<'_> Add<&'_ Wrapping<u8>> for Wrapping<u8>

type Output = <Wrapping<u8> as Add<Wrapping<u8>>>::Output

fn add(
    self,
    other: &Wrapping<u8>
) -> <Wrapping<u8> as Add<Wrapping<u8>>>::Output

impl<'_> Add<&'_ Wrapping<u16>> for Wrapping<u16>

type Output = <Wrapping<u16> as Add<Wrapping<u16>>>::Output

fn add(
    self,
    other: &Wrapping<u16>
) -> <Wrapping<u16> as Add<Wrapping<u16>>>::Output

impl<'_> Add<&'_ Wrapping<u32>> for Wrapping<u32>

type Output = <Wrapping<u32> as Add<Wrapping<u32>>>::Output

fn add(
    self,
    other: &Wrapping<u32>
) -> <Wrapping<u32> as Add<Wrapping<u32>>>::Output

impl<'_> Add<&'_ Wrapping<u64>> for Wrapping<u64>

type Output = <Wrapping<u64> as Add<Wrapping<u64>>>::Output

fn add(
    self,
    other: &Wrapping<u64>
) -> <Wrapping<u64> as Add<Wrapping<u64>>>::Output

impl<'_> Add<&'_ Wrapping<u128>> for Wrapping<u128>

type Output = <Wrapping<u128> as Add<Wrapping<u128>>>::Output

fn add(
    self,
    other: &Wrapping<u128>
) -> <Wrapping<u128> as Add<Wrapping<u128>>>::Output

impl<'_> Add<&'_ Wrapping<usize>> for Wrapping<usize>

type Output = <Wrapping<usize> as Add<Wrapping<usize>>>::Output

fn add(
    self,
    other: &Wrapping<usize>
) -> <Wrapping<usize> as Add<Wrapping<usize>>>::Output

impl<'_> Add<&'_ f16> for f16

type Output = f16

fn add(self, other: &f16) -> f16

impl<'_, '_> Add<&'_ Wrapping<i8>> for &'_ Wrapping<i8>

type Output = <Wrapping<i8> as Add<Wrapping<i8>>>::Output

fn add(
    self,
    other: &Wrapping<i8>
) -> <Wrapping<i8> as Add<Wrapping<i8>>>::Output

impl<'_, '_> Add<&'_ Wrapping<i16>> for &'_ Wrapping<i16>

type Output = <Wrapping<i16> as Add<Wrapping<i16>>>::Output

fn add(
    self,
    other: &Wrapping<i16>
) -> <Wrapping<i16> as Add<Wrapping<i16>>>::Output

impl<'_, '_> Add<&'_ Wrapping<i32>> for &'_ Wrapping<i32>

type Output = <Wrapping<i32> as Add<Wrapping<i32>>>::Output

fn add(
    self,
    other: &Wrapping<i32>
) -> <Wrapping<i32> as Add<Wrapping<i32>>>::Output

impl<'_, '_> Add<&'_ Wrapping<i64>> for &'_ Wrapping<i64>

type Output = <Wrapping<i64> as Add<Wrapping<i64>>>::Output

fn add(
    self,
    other: &Wrapping<i64>
) -> <Wrapping<i64> as Add<Wrapping<i64>>>::Output

impl<'_, '_> Add<&'_ Wrapping<i128>> for &'_ Wrapping<i128>

type Output = <Wrapping<i128> as Add<Wrapping<i128>>>::Output

fn add(
    self,
    other: &Wrapping<i128>
) -> <Wrapping<i128> as Add<Wrapping<i128>>>::Output

impl<'_, '_> Add<&'_ Wrapping<isize>> for &'_ Wrapping<isize>

type Output = <Wrapping<isize> as Add<Wrapping<isize>>>::Output

fn add(
    self,
    other: &Wrapping<isize>
) -> <Wrapping<isize> as Add<Wrapping<isize>>>::Output

impl<'_, '_> Add<&'_ Wrapping<u8>> for &'_ Wrapping<u8>

type Output = <Wrapping<u8> as Add<Wrapping<u8>>>::Output

fn add(
    self,
    other: &Wrapping<u8>
) -> <Wrapping<u8> as Add<Wrapping<u8>>>::Output

impl<'_, '_> Add<&'_ Wrapping<u16>> for &'_ Wrapping<u16>

type Output = <Wrapping<u16> as Add<Wrapping<u16>>>::Output

fn add(
    self,
    other: &Wrapping<u16>
) -> <Wrapping<u16> as Add<Wrapping<u16>>>::Output

impl<'_, '_> Add<&'_ Wrapping<u32>> for &'_ Wrapping<u32>

type Output = <Wrapping<u32> as Add<Wrapping<u32>>>::Output

fn add(
    self,
    other: &Wrapping<u32>
) -> <Wrapping<u32> as Add<Wrapping<u32>>>::Output

impl<'_, '_> Add<&'_ Wrapping<u64>> for &'_ Wrapping<u64>

type Output = <Wrapping<u64> as Add<Wrapping<u64>>>::Output

fn add(
    self,
    other: &Wrapping<u64>
) -> <Wrapping<u64> as Add<Wrapping<u64>>>::Output

impl<'_, '_> Add<&'_ Wrapping<u128>> for &'_ Wrapping<u128>

type Output = <Wrapping<u128> as Add<Wrapping<u128>>>::Output

fn add(
    self,
    other: &Wrapping<u128>
) -> <Wrapping<u128> as Add<Wrapping<u128>>>::Output

impl<'_, '_> Add<&'_ Wrapping<usize>> for &'_ Wrapping<usize>

type Output = <Wrapping<usize> as Add<Wrapping<usize>>>::Output

fn add(
    self,
    other: &Wrapping<usize>
) -> <Wrapping<usize> as Add<Wrapping<usize>>>::Output

impl<'a> Add<&'a TDim> for TDim

type Output = TDim

fn add(self, rhs: &'a TDim) -> TDim

impl<'a> Add<&'a str> for Cow<'a, str>

type Output = Cow<'a, str>

fn add(self, rhs: &'a str) -> <Cow<'a, str> as Add<&'a str>>::Output

impl<'a> Add<Cow<'a, str>> for Cow<'a, str>

type Output = Cow<'a, str>

fn add(self, rhs: Cow<'a, str>) -> <Cow<'a, str> as Add<Cow<'a, str>>>::Output

impl<'a> Add<Wrapping<i8>> for &'a Wrapping<i8>

type Output = <Wrapping<i8> as Add<Wrapping<i8>>>::Output

fn add(self, other: Wrapping<i8>) -> <Wrapping<i8> as Add<Wrapping<i8>>>::Output

impl<'a> Add<Wrapping<i16>> for &'a Wrapping<i16>

type Output = <Wrapping<i16> as Add<Wrapping<i16>>>::Output

fn add(
    self,
    other: Wrapping<i16>
) -> <Wrapping<i16> as Add<Wrapping<i16>>>::Output

impl<'a> Add<Wrapping<i32>> for &'a Wrapping<i32>

type Output = <Wrapping<i32> as Add<Wrapping<i32>>>::Output

fn add(
    self,
    other: Wrapping<i32>
) -> <Wrapping<i32> as Add<Wrapping<i32>>>::Output

impl<'a> Add<Wrapping<i64>> for &'a Wrapping<i64>

type Output = <Wrapping<i64> as Add<Wrapping<i64>>>::Output

fn add(
    self,
    other: Wrapping<i64>
) -> <Wrapping<i64> as Add<Wrapping<i64>>>::Output

impl<'a> Add<Wrapping<i128>> for &'a Wrapping<i128>

type Output = <Wrapping<i128> as Add<Wrapping<i128>>>::Output

fn add(
    self,
    other: Wrapping<i128>
) -> <Wrapping<i128> as Add<Wrapping<i128>>>::Output

impl<'a> Add<Wrapping<isize>> for &'a Wrapping<isize>

type Output = <Wrapping<isize> as Add<Wrapping<isize>>>::Output

fn add(
    self,
    other: Wrapping<isize>
) -> <Wrapping<isize> as Add<Wrapping<isize>>>::Output

impl<'a> Add<Wrapping<u8>> for &'a Wrapping<u8>

type Output = <Wrapping<u8> as Add<Wrapping<u8>>>::Output

fn add(self, other: Wrapping<u8>) -> <Wrapping<u8> as Add<Wrapping<u8>>>::Output

impl<'a> Add<Wrapping<u16>> for &'a Wrapping<u16>

type Output = <Wrapping<u16> as Add<Wrapping<u16>>>::Output

fn add(
    self,
    other: Wrapping<u16>
) -> <Wrapping<u16> as Add<Wrapping<u16>>>::Output

impl<'a> Add<Wrapping<u32>> for &'a Wrapping<u32>

type Output = <Wrapping<u32> as Add<Wrapping<u32>>>::Output

fn add(
    self,
    other: Wrapping<u32>
) -> <Wrapping<u32> as Add<Wrapping<u32>>>::Output

impl<'a> Add<Wrapping<u64>> for &'a Wrapping<u64>

type Output = <Wrapping<u64> as Add<Wrapping<u64>>>::Output

fn add(
    self,
    other: Wrapping<u64>
) -> <Wrapping<u64> as Add<Wrapping<u64>>>::Output

impl<'a> Add<Wrapping<u128>> for &'a Wrapping<u128>

type Output = <Wrapping<u128> as Add<Wrapping<u128>>>::Output

fn add(
    self,
    other: Wrapping<u128>
) -> <Wrapping<u128> as Add<Wrapping<u128>>>::Output

impl<'a> Add<Wrapping<usize>> for &'a Wrapping<usize>

type Output = <Wrapping<usize> as Add<Wrapping<usize>>>::Output

fn add(
    self,
    other: Wrapping<usize>
) -> <Wrapping<usize> as Add<Wrapping<usize>>>::Output

impl<'a, A, B, S, S2, D, E> Add<&'a ArrayBase<S2, E>> for &'a ArrayBase<S, D> where
    A: Clone + Add<B, Output = A>,
    B: Clone,
    D: Dimension,
    E: Dimension,
    S: Data<Elem = A>,
    S2: Data<Elem = B>, 

Perform elementwise addition between references self and rhs, and return the result as a new Array.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<OwnedRepr<A>, D>

fn add(self, rhs: &'a ArrayBase<S2, E>) -> ArrayBase<OwnedRepr<A>, D>

impl<'a, A, B, S, S2, D, E> Add<&'a ArrayBase<S2, E>> for ArrayBase<S, D> where
    A: Clone + Add<B, Output = A>,
    B: Clone,
    D: Dimension,
    E: Dimension,
    S: DataOwned<Elem = A> + DataMut,
    S2: Data<Elem = B>, 

Perform elementwise addition between self and reference rhs, and return the result (based on self).

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

fn add(self, rhs: &ArrayBase<S2, E>) -> ArrayBase<S, D>

impl<'a, A, S, D, B> Add<B> for &'a ArrayBase<S, D> where
    A: Clone + Add<B, Output = A>,
    B: ScalarOperand,
    D: Dimension,
    S: Data<Elem = A>, 

Perform elementwise addition between the reference self and the scalar x, and return the result as a new Array.

type Output = ArrayBase<OwnedRepr<A>, D>

fn add(self, x: B) -> ArrayBase<OwnedRepr<A>, D>

impl<A, B, S, S2, D, E> Add<ArrayBase<S2, E>> for ArrayBase<S, D> where
    A: Clone + Add<B, Output = A>,
    B: Clone,
    D: Dimension,
    E: Dimension,
    S: DataOwned<Elem = A> + DataMut,
    S2: Data<Elem = B>, 

Perform elementwise addition between self and rhs, and return the result (based on self).

self must be an Array or ArcArray.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

fn add(self, rhs: ArrayBase<S2, E>) -> ArrayBase<S, D>

impl<A, S, D, B> Add<B> for ArrayBase<S, D> where
    A: Clone + Add<B, Output = A>,
    B: ScalarOperand,
    D: Dimension,
    S: DataOwned<Elem = A> + DataMut, 

Perform elementwise addition between self and the scalar x, and return the result (based on self).

self must be an Array or ArcArray.

type Output = ArrayBase<S, D>

fn add(self, x: B) -> ArrayBase<S, D>

impl<I> Add<Dim<I>> for Dim<I> where
    Dim<I>: Dimension, 

type Output = Dim<I>

fn add(self, rhs: Dim<I>) -> Dim<I>

impl<I> Add<I> for TDim where
    I: Into<TDim>, 

type Output = TDim

fn add(self, rhs: I) -> TDim

impl<IE: IntoExp<DimFact>> Add<IE> for Exp<DimFact>

type Output = Exp<DimFact>

fn add(self, other: IE) -> Exp<DimFact>

impl<IE: IntoExp<IntFactoid>> Add<IE> for Exp<IntFactoid>

type Output = Exp<IntFactoid>

fn add(self, other: IE) -> Exp<IntFactoid>

impl<T, I> Add<I> for GenericFactoid<T> where
    T: Add<T, Output = T> + PartialEq + Clone + Debug + Hash,
    I: Into<GenericFactoid<T>>, 

type Output = GenericFactoid<T>

fn add(self, rhs: I) -> Self::Output

Loading content...