Trait otter_api_tests::imports::failure::_core::ops::Add 1.0.0[−][src]
Expand description
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
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.
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
Required methods
Implementations on Foreign Types
impl<'_> Add<&'_ str> for String
[src]
impl<'_> Add<&'_ str> for String
[src]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 String
s 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;
impl Add<LibInBundleI> for usize
[src]
impl Add<LibInBundleI> for usize
[src]impl Add<Duration> for SteadyTime
[src]
impl Add<Duration> for SteadyTime
[src]Implementors
impl Add<usize> for LibInBundleI
[src]
impl Add<usize> for LibInBundleI
[src]impl Add<LibInBundleI> for LibInBundleI
[src]
impl Add<LibInBundleI> for LibInBundleI
[src]impl Add<Duration> for SystemTime
1.8.0[src]
impl Add<Duration> for SystemTime
1.8.0[src]pub fn add(self, dur: Duration) -> SystemTime
[src]
pub fn add(self, dur: Duration) -> SystemTime
[src]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.
type Output = SystemTime
impl Add<Duration> for NaiveDate
[src]
impl Add<Duration> for NaiveDate
[src]An addition of Duration
to NaiveDate
discards the fractional days,
rounding to the closest integral number of days towards Duration::zero()
.
Panics on underflow or overflow.
Use NaiveDate::checked_add_signed
to detect that.
Example
use chrono::{Duration, NaiveDate}; let from_ymd = NaiveDate::from_ymd; assert_eq!(from_ymd(2014, 1, 1) + Duration::zero(), from_ymd(2014, 1, 1)); assert_eq!(from_ymd(2014, 1, 1) + Duration::seconds(86399), from_ymd(2014, 1, 1)); assert_eq!(from_ymd(2014, 1, 1) + Duration::seconds(-86399), from_ymd(2014, 1, 1)); assert_eq!(from_ymd(2014, 1, 1) + Duration::days(1), from_ymd(2014, 1, 2)); assert_eq!(from_ymd(2014, 1, 1) + Duration::days(-1), from_ymd(2013, 12, 31)); assert_eq!(from_ymd(2014, 1, 1) + Duration::days(364), from_ymd(2014, 12, 31)); assert_eq!(from_ymd(2014, 1, 1) + Duration::days(365*4 + 1), from_ymd(2018, 1, 1)); assert_eq!(from_ymd(2014, 1, 1) + Duration::days(365*400 + 97), from_ymd(2414, 1, 1));
impl Add<Duration> for NaiveDateTime
[src]
impl Add<Duration> for NaiveDateTime
[src]An addition of Duration
to NaiveDateTime
yields another NaiveDateTime
.
As a part of Chrono’s leap second handling,
the addition assumes that there is no leap second ever,
except when the NaiveDateTime
itself represents a leap second
in which case the assumption becomes that there is exactly a single leap second ever.
Panics on underflow or overflow.
Use NaiveDateTime::checked_add_signed
to detect that.
Example
use chrono::{Duration, NaiveDate}; let from_ymd = NaiveDate::from_ymd; let d = from_ymd(2016, 7, 8); let hms = |h, m, s| d.and_hms(h, m, s); assert_eq!(hms(3, 5, 7) + Duration::zero(), hms(3, 5, 7)); assert_eq!(hms(3, 5, 7) + Duration::seconds(1), hms(3, 5, 8)); assert_eq!(hms(3, 5, 7) + Duration::seconds(-1), hms(3, 5, 6)); assert_eq!(hms(3, 5, 7) + Duration::seconds(3600 + 60), hms(4, 6, 7)); assert_eq!(hms(3, 5, 7) + Duration::seconds(86_400), from_ymd(2016, 7, 9).and_hms(3, 5, 7)); assert_eq!(hms(3, 5, 7) + Duration::days(365), from_ymd(2017, 7, 8).and_hms(3, 5, 7)); let hmsm = |h, m, s, milli| d.and_hms_milli(h, m, s, milli); assert_eq!(hmsm(3, 5, 7, 980) + Duration::milliseconds(450), hmsm(3, 5, 8, 430));
Leap seconds are handled, but the addition assumes that it is the only leap second happened.
let leap = hmsm(3, 5, 59, 1_300); assert_eq!(leap + Duration::zero(), hmsm(3, 5, 59, 1_300)); assert_eq!(leap + Duration::milliseconds(-500), hmsm(3, 5, 59, 800)); assert_eq!(leap + Duration::milliseconds(500), hmsm(3, 5, 59, 1_800)); assert_eq!(leap + Duration::milliseconds(800), hmsm(3, 6, 0, 100)); assert_eq!(leap + Duration::seconds(10), hmsm(3, 6, 9, 300)); assert_eq!(leap + Duration::seconds(-10), hmsm(3, 5, 50, 300)); assert_eq!(leap + Duration::days(1), from_ymd(2016, 7, 9).and_hms_milli(3, 5, 59, 300));
impl Add<Duration> for NaiveTime
[src]
impl Add<Duration> for NaiveTime
[src]An addition of Duration
to NaiveTime
wraps around and never overflows or underflows.
In particular the addition ignores integral number of days.
As a part of Chrono’s leap second handling,
the addition assumes that there is no leap second ever,
except when the NaiveTime
itself represents a leap second
in which case the assumption becomes that there is exactly a single leap second ever.
Example
use chrono::{Duration, NaiveTime}; let from_hmsm = NaiveTime::from_hms_milli; assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::zero(), from_hmsm(3, 5, 7, 0)); assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::seconds(1), from_hmsm(3, 5, 8, 0)); assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::seconds(-1), from_hmsm(3, 5, 6, 0)); assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::seconds(60 + 4), from_hmsm(3, 6, 11, 0)); assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::seconds(7*60*60 - 6*60), from_hmsm(9, 59, 7, 0)); assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::milliseconds(80), from_hmsm(3, 5, 7, 80)); assert_eq!(from_hmsm(3, 5, 7, 950) + Duration::milliseconds(280), from_hmsm(3, 5, 8, 230)); assert_eq!(from_hmsm(3, 5, 7, 950) + Duration::milliseconds(-980), from_hmsm(3, 5, 6, 970));
The addition wraps around.
assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::seconds(22*60*60), from_hmsm(1, 5, 7, 0)); assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::seconds(-8*60*60), from_hmsm(19, 5, 7, 0)); assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::days(800), from_hmsm(3, 5, 7, 0));
Leap seconds are handled, but the addition assumes that it is the only leap second happened.
let leap = from_hmsm(3, 5, 59, 1_300); assert_eq!(leap + Duration::zero(), from_hmsm(3, 5, 59, 1_300)); assert_eq!(leap + Duration::milliseconds(-500), from_hmsm(3, 5, 59, 800)); assert_eq!(leap + Duration::milliseconds(500), from_hmsm(3, 5, 59, 1_800)); assert_eq!(leap + Duration::milliseconds(800), from_hmsm(3, 6, 0, 100)); assert_eq!(leap + Duration::seconds(10), from_hmsm(3, 6, 9, 300)); assert_eq!(leap + Duration::seconds(-10), from_hmsm(3, 5, 50, 300)); assert_eq!(leap + Duration::days(1), from_hmsm(3, 5, 59, 300));
impl Add<FixedOffset> for NaiveDateTime
[src]
impl Add<FixedOffset> for NaiveDateTime
[src]impl Add<FixedOffset> for NaiveTime
[src]
impl Add<FixedOffset> for NaiveTime
[src]impl<'a, T> Add<&'a &'a OrderedFloat<T>> for &'a OrderedFloat<T> where
&'a T: Add<&'a T>,
impl<'a, T> Add<&'a &'a OrderedFloat<T>> for &'a OrderedFloat<T> where
&'a T: Add<&'a T>,
type Output = OrderedFloat<<&'a T as Add<&'a T>>::Output>
pub fn add(
self,
other: &'a &'a OrderedFloat<T>
) -> <&'a OrderedFloat<T> as Add<&'a &'a OrderedFloat<T>>>::Output
self,
other: &'a &'a OrderedFloat<T>
) -> <&'a OrderedFloat<T> as Add<&'a &'a OrderedFloat<T>>>::Output
impl<'a, T> Add<&'a OrderedFloat<T>> for &'a OrderedFloat<T> where
&'a T: Add<&'a T>,
impl<'a, T> Add<&'a OrderedFloat<T>> for &'a OrderedFloat<T> where
&'a T: Add<&'a T>,
type Output = OrderedFloat<<&'a T as Add<&'a T>>::Output>
pub fn add(
self,
other: &'a OrderedFloat<T>
) -> <&'a OrderedFloat<T> as Add<&'a OrderedFloat<T>>>::Output
self,
other: &'a OrderedFloat<T>
) -> <&'a OrderedFloat<T> as Add<&'a OrderedFloat<T>>>::Output
impl<'a, T> Add<&'a OrderedFloat<T>> for OrderedFloat<T> where
T: Add<&'a T>,
impl<'a, T> Add<&'a OrderedFloat<T>> for OrderedFloat<T> where
T: Add<&'a T>,
type Output = OrderedFloat<<T as Add<&'a T>>::Output>
pub fn add(
self,
other: &'a OrderedFloat<T>
) -> <OrderedFloat<T> as Add<&'a OrderedFloat<T>>>::Output
self,
other: &'a OrderedFloat<T>
) -> <OrderedFloat<T> as Add<&'a OrderedFloat<T>>>::Output
impl<'a, T> Add<&'a T> for OrderedFloat<T> where
T: Add<&'a T>,
impl<'a, T> Add<&'a T> for OrderedFloat<T> where
T: Add<&'a T>,
impl<'a, T> Add<OrderedFloat<T>> for &'a OrderedFloat<T> where
&'a T: Add<T>,
impl<'a, T> Add<OrderedFloat<T>> for &'a OrderedFloat<T> where
&'a T: Add<T>,
type Output = OrderedFloat<<&'a T as Add<T>>::Output>
pub fn add(
self,
other: OrderedFloat<T>
) -> <&'a OrderedFloat<T> as Add<OrderedFloat<T>>>::Output
self,
other: OrderedFloat<T>
) -> <&'a OrderedFloat<T> as Add<OrderedFloat<T>>>::Output
impl<'a, T> Add<T> for &'a OrderedFloat<T> where
&'a T: Add<T>,
impl<'a, T> Add<T> for &'a OrderedFloat<T> where
&'a T: Add<T>,
type Output = OrderedFloat<<&'a T as Add<T>>::Output>
pub fn add(self, other: T) -> <&'a OrderedFloat<T> as Add<T>>::Output
impl<T> Add<OrderedFloat<T>> for OrderedFloat<T> where
T: Add<T>,
impl<T> Add<OrderedFloat<T>> for OrderedFloat<T> where
T: Add<T>,
type Output = OrderedFloat<<T as Add<T>>::Output>
pub fn add(
self,
other: OrderedFloat<T>
) -> <OrderedFloat<T> as Add<OrderedFloat<T>>>::Output
self,
other: OrderedFloat<T>
) -> <OrderedFloat<T> as Add<OrderedFloat<T>>>::Output
impl<T> Add<PosC<T>> for PosC<T> where
T: CheckedArith,
impl<T> Add<PosC<T>> for PosC<T> where
T: CheckedArith,
type Output = Result<PosC<T>, CoordinateOverflow>
pub fn add(self, rhs: PosC<T>) -> Result<PosC<T>, CoordinateOverflow>
impl<T> Add<T> for OrderedFloat<T> where
T: Add<T>,
impl<T> Add<T> for OrderedFloat<T> where
T: Add<T>,
type Output = OrderedFloat<<T as Add<T>>::Output>
pub fn add(self, other: T) -> <OrderedFloat<T> as Add<T>>::Output
impl<T> Add<T> for NotNan<T> where
T: Float,
impl<T> Add<T> for NotNan<T> where
T: Float,
Adds a float directly.
Panics if the provided value is NaN or the computation results in NaN
impl<Tz> Add<FixedOffset> for DateTime<Tz> where
Tz: TimeZone,
[src]
impl<Tz> Add<FixedOffset> for DateTime<Tz> where
Tz: TimeZone,
[src]impl<U> Add<B1> for UInt<U, B1> where
U: Unsigned + Add<B1>,
<U as Add<B1>>::Output: Unsigned,
impl<U> Add<B1> for UInt<U, B1> where
U: Unsigned + Add<B1>,
<U as Add<B1>>::Output: Unsigned,
UInt<U, B1> + B1 = UInt<U + B1, B0>
impl<Ul, Ur> Add<NInt<Ur>> for NInt<Ul> where
Ul: Unsigned + NonZero + Add<Ur>,
Ur: Unsigned + NonZero,
<Ul as Add<Ur>>::Output: Unsigned,
<Ul as Add<Ur>>::Output: NonZero,
impl<Ul, Ur> Add<NInt<Ur>> for NInt<Ul> where
Ul: Unsigned + NonZero + Add<Ur>,
Ur: Unsigned + NonZero,
<Ul as Add<Ur>>::Output: Unsigned,
<Ul as Add<Ur>>::Output: NonZero,
N(Ul) + N(Ur) = N(Ul + Ur)
impl<Ul, Ur> Add<NInt<Ur>> for PInt<Ul> where
Ul: Unsigned + NonZero + Cmp<Ur> + PrivateIntegerAdd<<Ul as Cmp<Ur>>::Output, Ur>,
Ur: Unsigned + NonZero,
impl<Ul, Ur> Add<NInt<Ur>> for PInt<Ul> where
Ul: Unsigned + NonZero + Cmp<Ur> + PrivateIntegerAdd<<Ul as Cmp<Ur>>::Output, Ur>,
Ur: Unsigned + NonZero,
P(Ul) + N(Ur)
: We resolve this with our PrivateAdd
impl<Ul, Ur> Add<PInt<Ur>> for NInt<Ul> where
Ul: Unsigned + NonZero,
Ur: Unsigned + NonZero + Cmp<Ul> + PrivateIntegerAdd<<Ur as Cmp<Ul>>::Output, Ul>,
impl<Ul, Ur> Add<PInt<Ur>> for NInt<Ul> where
Ul: Unsigned + NonZero,
Ur: Unsigned + NonZero + Cmp<Ul> + PrivateIntegerAdd<<Ur as Cmp<Ul>>::Output, Ul>,
N(Ul) + P(Ur)
: We resolve this with our PrivateAdd
impl<Ul, Ur> Add<PInt<Ur>> for PInt<Ul> where
Ul: Unsigned + NonZero + Add<Ur>,
Ur: Unsigned + NonZero,
<Ul as Add<Ur>>::Output: Unsigned,
<Ul as Add<Ur>>::Output: NonZero,
impl<Ul, Ur> Add<PInt<Ur>> for PInt<Ul> where
Ul: Unsigned + NonZero + Add<Ur>,
Ur: Unsigned + NonZero,
<Ul as Add<Ur>>::Output: Unsigned,
<Ul as Add<Ur>>::Output: NonZero,
P(Ul) + P(Ur) = P(Ul + Ur)
impl<Ul, Ur> Add<UInt<Ur, B0>> for UInt<Ul, B0> where
Ul: Unsigned + Add<Ur>,
Ur: Unsigned,
impl<Ul, Ur> Add<UInt<Ur, B0>> for UInt<Ul, B0> where
Ul: Unsigned + Add<Ur>,
Ur: Unsigned,
UInt<Ul, B0> + UInt<Ur, B0> = UInt<Ul + Ur, B0>
impl<Ul, Ur> Add<UInt<Ur, B0>> for UInt<Ul, B1> where
Ul: Unsigned + Add<Ur>,
Ur: Unsigned,
impl<Ul, Ur> Add<UInt<Ur, B0>> for UInt<Ul, B1> where
Ul: Unsigned + Add<Ur>,
Ur: Unsigned,
UInt<Ul, B1> + UInt<Ur, B0> = UInt<Ul + Ur, B1>
impl<Ul, Ur> Add<UInt<Ur, B1>> for UInt<Ul, B0> where
Ul: Unsigned + Add<Ur>,
Ur: Unsigned,
impl<Ul, Ur> Add<UInt<Ur, B1>> for UInt<Ul, B0> where
Ul: Unsigned + Add<Ur>,
Ur: Unsigned,
UInt<Ul, B0> + UInt<Ur, B1> = UInt<Ul + Ur, B1>