Struct SignedDuration 

pub struct SignedDuration { /* private fields */ }

A span of time with nanosecond precision.

Each SignedDuration is composed of a whole number of seconds and a fractional part represented in nanoseconds.

This implementation allows for negative durations, unlike core::time::Duration.

Implementations

impl SignedDuration

pub const ZERO: Self

Equivalent to 0.seconds().

assert_eq!(SignedDuration::ZERO, 0.seconds());

pub const NANOSECOND: Self

Equivalent to 1.nanoseconds().

assert_eq!(SignedDuration::NANOSECOND, 1.nanoseconds());

pub const MICROSECOND: Self

Equivalent to 1.microseconds().

assert_eq!(SignedDuration::MICROSECOND, 1.microseconds());

pub const MILLISECOND: Self

Equivalent to 1.milliseconds().

assert_eq!(SignedDuration::MILLISECOND, 1.milliseconds());

pub const SECOND: Self

Equivalent to 1.seconds().

assert_eq!(SignedDuration::SECOND, 1.seconds());

pub const MINUTE: Self

Equivalent to 1.minutes().

assert_eq!(SignedDuration::MINUTE, 1.minutes());

pub const HOUR: Self

Equivalent to 1.hours().

assert_eq!(SignedDuration::HOUR, 1.hours());

pub const DAY: Self

Equivalent to 1.days().

assert_eq!(SignedDuration::DAY, 1.days());

pub const WEEK: Self

Equivalent to 1.weeks().

assert_eq!(SignedDuration::WEEK, 1.weeks());

pub const MIN: Self

The minimum possible duration. Adding any negative duration to this will cause an overflow.

pub const MAX: Self

The maximum possible duration. Adding any positive duration to this will cause an overflow.

pub const fn is_zero(self) -> bool

Check if a duration is exactly zero.

assert!(0.seconds().is_zero());
assert!(!1.nanoseconds().is_zero());

pub const fn is_negative(self) -> bool

Check if a duration is negative.

assert!((-1).seconds().is_negative());
assert!(!0.seconds().is_negative());
assert!(!1.seconds().is_negative());

pub const fn is_positive(self) -> bool

Check if a duration is positive.

assert!(1.seconds().is_positive());
assert!(!0.seconds().is_positive());
assert!(!(-1).seconds().is_positive());

pub const fn abs(self) -> Self

Get the absolute value of the duration.

This method saturates the returned value if it would otherwise overflow.

assert_eq!(1.seconds().abs(), 1.seconds());
assert_eq!(0.seconds().abs(), 0.seconds());
assert_eq!((-1).seconds().abs(), 1.seconds());

pub const fn unsigned_abs(self) -> StdDuration

Convert the existing SignedDuration to a std::time::Duration and its sign. This returns a std::time::Duration and does not saturate the returned value (unlike SignedDuration::abs).

assert_eq!(1.seconds().unsigned_abs(), 1.std_seconds());
assert_eq!(0.seconds().unsigned_abs(), 0.std_seconds());
assert_eq!((-1).seconds().unsigned_abs(), 1.std_seconds());

pub const fn new(seconds: i64, nanoseconds: i32) -> Self

Create a new SignedDuration with the provided seconds and nanoseconds. If nanoseconds is at least ±10⁹, it will wrap to the number of seconds.

assert_eq!(SignedDuration::new(1, 0), 1.seconds());
assert_eq!(SignedDuration::new(-1, 0), (-1).seconds());
assert_eq!(SignedDuration::new(1, 2_000_000_000), 3.seconds());

Panics

This may panic if an overflow occurs.

pub const fn weeks(weeks: i64) -> Self

Create a new SignedDuration with the given number of weeks. Equivalent to SignedDuration::seconds(weeks * 604_800).

assert_eq!(SignedDuration::weeks(1), 604_800.seconds());

Panics

This may panic if an overflow occurs.

pub const fn days(days: i64) -> Self

Create a new SignedDuration with the given number of days. Equivalent to SignedDuration::seconds(days * 86_400).

assert_eq!(SignedDuration::days(1), 86_400.seconds());

Panics

This may panic if an overflow occurs.

pub const fn hours(hours: i64) -> Self

Create a new SignedDuration with the given number of hours. Equivalent to SignedDuration::seconds(hours * 3_600).

assert_eq!(SignedDuration::hours(1), 3_600.seconds());

Panics

This may panic if an overflow occurs.

pub const fn minutes(minutes: i64) -> Self

Create a new SignedDuration with the given number of minutes. Equivalent to SignedDuration::seconds(minutes * 60).

assert_eq!(SignedDuration::minutes(1), 60.seconds());

Panics

This may panic if an overflow occurs.

pub const fn seconds(seconds: i64) -> Self

Create a new SignedDuration with the given number of seconds.

assert_eq!(SignedDuration::seconds(1), 1_000.milliseconds());

pub const fn seconds_f64(seconds: f64) -> Self

Creates a new SignedDuration from the specified number of seconds represented as f64.

assert_eq!(SignedDuration::seconds_f64(0.5), 0.5.seconds());
assert_eq!(SignedDuration::seconds_f64(-0.5), (-0.5).seconds());

Panics

This may panic if seconds is NaN or overflows the representable range of SignedDuration.

pub const fn seconds_f32(seconds: f32) -> Self

Creates a new SignedDuration from the specified number of seconds represented as f32.

assert_eq!(SignedDuration::seconds_f32(0.5), 0.5.seconds());
assert_eq!(SignedDuration::seconds_f32(-0.5), (-0.5).seconds());

Panics

This may panic if seconds is NaN or overflows the representable range of SignedDuration.

pub const fn saturating_seconds_f64(seconds: f64) -> Self

Creates a new SignedDuration from the specified number of seconds represented as f64. Any values that are out of bounds are saturated at the minimum or maximum respectively. NaN gets turned into a SignedDuration of 0 seconds.

assert_eq!(SignedDuration::saturating_seconds_f64(0.5), 0.5.seconds());
assert_eq!(
    SignedDuration::saturating_seconds_f64(-0.5),
    (-0.5).seconds()
);
assert_eq!(
    SignedDuration::saturating_seconds_f64(f64::NAN),
    SignedDuration::new(0, 0),
);
assert_eq!(
    SignedDuration::saturating_seconds_f64(f64::NEG_INFINITY),
    SignedDuration::MIN,
);
assert_eq!(
    SignedDuration::saturating_seconds_f64(f64::INFINITY),
    SignedDuration::MAX,
);

pub const fn saturating_seconds_f32(seconds: f32) -> Self

Creates a new SignedDuration from the specified number of seconds represented as f32. Any values that are out of bounds are saturated at the minimum or maximum respectively. NaN gets turned into a SignedDuration of 0 seconds.

assert_eq!(SignedDuration::saturating_seconds_f32(0.5), 0.5.seconds());
assert_eq!(
    SignedDuration::saturating_seconds_f32(-0.5),
    (-0.5).seconds()
);
assert_eq!(
    SignedDuration::saturating_seconds_f32(f32::NAN),
    SignedDuration::new(0, 0),
);
assert_eq!(
    SignedDuration::saturating_seconds_f32(f32::NEG_INFINITY),
    SignedDuration::MIN,
);
assert_eq!(
    SignedDuration::saturating_seconds_f32(f32::INFINITY),
    SignedDuration::MAX,
);

pub const fn checked_seconds_f64(seconds: f64) -> Option<Self>

Creates a new SignedDuration from the specified number of seconds represented as f64. Returns None if the SignedDuration can’t be represented.

assert_eq!(
    SignedDuration::checked_seconds_f64(0.5),
    Some(0.5.seconds())
);
assert_eq!(
    SignedDuration::checked_seconds_f64(-0.5),
    Some((-0.5).seconds())
);
assert_eq!(SignedDuration::checked_seconds_f64(f64::NAN), None);
assert_eq!(SignedDuration::checked_seconds_f64(f64::NEG_INFINITY), None);
assert_eq!(SignedDuration::checked_seconds_f64(f64::INFINITY), None);

pub const fn checked_seconds_f32(seconds: f32) -> Option<Self>

Creates a new SignedDuration from the specified number of seconds represented as f32. Returns None if the SignedDuration can’t be represented.

assert_eq!(
    SignedDuration::checked_seconds_f32(0.5),
    Some(0.5.seconds())
);
assert_eq!(
    SignedDuration::checked_seconds_f32(-0.5),
    Some((-0.5).seconds())
);
assert_eq!(SignedDuration::checked_seconds_f32(f32::NAN), None);
assert_eq!(SignedDuration::checked_seconds_f32(f32::NEG_INFINITY), None);
assert_eq!(SignedDuration::checked_seconds_f32(f32::INFINITY), None);

pub const fn milliseconds(milliseconds: i64) -> Self

Create a new SignedDuration with the given number of milliseconds.

assert_eq!(SignedDuration::milliseconds(1), 1_000.microseconds());
assert_eq!(SignedDuration::milliseconds(-1), (-1_000).microseconds());

pub const fn microseconds(microseconds: i64) -> Self

Create a new SignedDuration with the given number of microseconds.

assert_eq!(SignedDuration::microseconds(1), 1_000.nanoseconds());
assert_eq!(SignedDuration::microseconds(-1), (-1_000).nanoseconds());

pub const fn nanoseconds(nanoseconds: i64) -> Self

Create a new SignedDuration with the given number of nanoseconds.

assert_eq!(SignedDuration::nanoseconds(1), 1.microseconds() / 1_000);
assert_eq!(SignedDuration::nanoseconds(-1), (-1).microseconds() / 1_000);

pub const fn nanoseconds_i128(nanoseconds: i128) -> Self

Create a new SignedDuration with the given number of nanoseconds.

assert_eq!(
    SignedDuration::nanoseconds_i128(1_234_567_890),
    1.seconds() + 234_567_890.nanoseconds()
);

Panics

This may panic if an overflow occurs. This may happen because the input range cannot be fully mapped to the output.

pub const fn whole_weeks(self) -> i64

Get the number of whole weeks in the duration.

assert_eq!(1.weeks().whole_weeks(), 1);
assert_eq!((-1).weeks().whole_weeks(), -1);
assert_eq!(6.days().whole_weeks(), 0);
assert_eq!((-6).days().whole_weeks(), 0);

pub const fn whole_days(self) -> i64

Get the number of whole days in the duration.

assert_eq!(1.days().whole_days(), 1);
assert_eq!((-1).days().whole_days(), -1);
assert_eq!(23.hours().whole_days(), 0);
assert_eq!((-23).hours().whole_days(), 0);

pub const fn whole_hours(self) -> i64

Get the number of whole hours in the duration.

assert_eq!(1.hours().whole_hours(), 1);
assert_eq!((-1).hours().whole_hours(), -1);
assert_eq!(59.minutes().whole_hours(), 0);
assert_eq!((-59).minutes().whole_hours(), 0);

pub const fn whole_minutes(self) -> i64

Get the number of whole minutes in the duration.

assert_eq!(1.minutes().whole_minutes(), 1);
assert_eq!((-1).minutes().whole_minutes(), -1);
assert_eq!(59.seconds().whole_minutes(), 0);
assert_eq!((-59).seconds().whole_minutes(), 0);

pub const fn whole_seconds(self) -> i64

Get the number of whole seconds in the duration.

assert_eq!(1.seconds().whole_seconds(), 1);
assert_eq!((-1).seconds().whole_seconds(), -1);
assert_eq!(1.minutes().whole_seconds(), 60);
assert_eq!((-1).minutes().whole_seconds(), -60);

pub const fn as_seconds_f64(self) -> f64

Get the number of fractional seconds in the duration.

assert_eq!(1.5.seconds().as_seconds_f64(), 1.5);
assert_eq!((-1.5).seconds().as_seconds_f64(), -1.5);

pub const fn as_seconds_f32(self) -> f32

Get the number of fractional seconds in the duration.

assert_eq!(1.5.seconds().as_seconds_f32(), 1.5);
assert_eq!((-1.5).seconds().as_seconds_f32(), -1.5);

pub const fn whole_milliseconds(self) -> i128

Get the number of whole milliseconds in the duration.

assert_eq!(1.seconds().whole_milliseconds(), 1_000);
assert_eq!((-1).seconds().whole_milliseconds(), -1_000);
assert_eq!(1.milliseconds().whole_milliseconds(), 1);
assert_eq!((-1).milliseconds().whole_milliseconds(), -1);

pub const fn subsec_milliseconds(self) -> i16

Get the number of milliseconds past the number of whole seconds.

Always in the range -999..=999.

assert_eq!(1.4.seconds().subsec_milliseconds(), 400);
assert_eq!((-1.4).seconds().subsec_milliseconds(), -400);

pub const fn whole_microseconds(self) -> i128

Get the number of whole microseconds in the duration.

assert_eq!(1.milliseconds().whole_microseconds(), 1_000);
assert_eq!((-1).milliseconds().whole_microseconds(), -1_000);
assert_eq!(1.microseconds().whole_microseconds(), 1);
assert_eq!((-1).microseconds().whole_microseconds(), -1);

pub const fn subsec_microseconds(self) -> i32

Get the number of microseconds past the number of whole seconds.

Always in the range -999_999..=999_999.

assert_eq!(1.0004.seconds().subsec_microseconds(), 400);
assert_eq!((-1.0004).seconds().subsec_microseconds(), -400);

pub const fn whole_nanoseconds(self) -> i128

Get the number of nanoseconds in the duration.

assert_eq!(1.microseconds().whole_nanoseconds(), 1_000);
assert_eq!((-1).microseconds().whole_nanoseconds(), -1_000);
assert_eq!(1.nanoseconds().whole_nanoseconds(), 1);
assert_eq!((-1).nanoseconds().whole_nanoseconds(), -1);

pub const fn subsec_nanoseconds(self) -> i32

Get the number of nanoseconds past the number of whole seconds.

The returned value will always be in the range -999_999_999..=999_999_999.

assert_eq!(1.000_000_400.seconds().subsec_nanoseconds(), 400);
assert_eq!((-1.000_000_400).seconds().subsec_nanoseconds(), -400);

pub const fn checked_add(self, rhs: Self) -> Option<Self>

Computes self + rhs, returning None if an overflow occurred.

assert_eq!(5.seconds().checked_add(5.seconds()), Some(10.seconds()));
assert_eq!(SignedDuration::MAX.checked_add(1.nanoseconds()), None);
assert_eq!((-5).seconds().checked_add(5.seconds()), Some(0.seconds()));

pub const fn checked_sub(self, rhs: Self) -> Option<Self>

Computes self - rhs, returning None if an overflow occurred.

assert_eq!(
    5.seconds().checked_sub(5.seconds()),
    Some(SignedDuration::ZERO)
);
assert_eq!(SignedDuration::MIN.checked_sub(1.nanoseconds()), None);
assert_eq!(5.seconds().checked_sub(10.seconds()), Some((-5).seconds()));

pub const fn checked_mul(self, rhs: i32) -> Option<Self>

Computes self * rhs, returning None if an overflow occurred.

assert_eq!(5.seconds().checked_mul(2), Some(10.seconds()));
assert_eq!(5.seconds().checked_mul(-2), Some((-10).seconds()));
assert_eq!(5.seconds().checked_mul(0), Some(0.seconds()));
assert_eq!(SignedDuration::MAX.checked_mul(2), None);
assert_eq!(SignedDuration::MIN.checked_mul(2), None);

pub const fn checked_div(self, rhs: i32) -> Option<Self>

Computes self / rhs, returning None if rhs == 0 or if the result would overflow.

assert_eq!(10.seconds().checked_div(2), Some(5.seconds()));
assert_eq!(10.seconds().checked_div(-2), Some((-5).seconds()));
assert_eq!(1.seconds().checked_div(0), None);

pub const fn checked_neg(self) -> Option<Self>

Computes -self, returning None if the result would overflow.

assert_eq!(5.seconds().checked_neg(), Some((-5).seconds()));
assert_eq!(SignedDuration::MIN.checked_neg(), None);

pub const fn saturating_add(self, rhs: Self) -> Self

Computes self + rhs, saturating if an overflow occurred.

assert_eq!(5.seconds().saturating_add(5.seconds()), 10.seconds());
assert_eq!(
    SignedDuration::MAX.saturating_add(1.nanoseconds()),
    SignedDuration::MAX
);
assert_eq!(
    SignedDuration::MIN.saturating_add((-1).nanoseconds()),
    SignedDuration::MIN
);
assert_eq!(
    (-5).seconds().saturating_add(5.seconds()),
    SignedDuration::ZERO
);

pub const fn saturating_sub(self, rhs: Self) -> Self

Computes self - rhs, saturating if an overflow occurred.

assert_eq!(
    5.seconds().saturating_sub(5.seconds()),
    SignedDuration::ZERO
);
assert_eq!(
    SignedDuration::MIN.saturating_sub(1.nanoseconds()),
    SignedDuration::MIN
);
assert_eq!(
    SignedDuration::MAX.saturating_sub((-1).nanoseconds()),
    SignedDuration::MAX
);
assert_eq!(5.seconds().saturating_sub(10.seconds()), (-5).seconds());

pub const fn saturating_mul(self, rhs: i32) -> Self

Computes self * rhs, saturating if an overflow occurred.

assert_eq!(5.seconds().saturating_mul(2), 10.seconds());
assert_eq!(5.seconds().saturating_mul(-2), (-10).seconds());
assert_eq!(5.seconds().saturating_mul(0), SignedDuration::ZERO);
assert_eq!(SignedDuration::MAX.saturating_mul(2), SignedDuration::MAX);
assert_eq!(SignedDuration::MIN.saturating_mul(2), SignedDuration::MIN);
assert_eq!(SignedDuration::MAX.saturating_mul(-2), SignedDuration::MIN);
assert_eq!(SignedDuration::MIN.saturating_mul(-2), SignedDuration::MAX);

Trait Implementations

impl Add for SignedDuration

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

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the + operator.

impl Add<Duration> for SignedDuration

fn add(self, std_duration: StdDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the + operator.

impl Add<SignedDuration> for Date

fn add(self, duration: SignedDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = Date

The resulting type after applying the + operator.

impl Add<SignedDuration> for Instant

Available on crate feature std only.

fn add(self, duration: SignedDuration) -> Self::Output

Panics

This function may panic if the resulting point in time cannot be represented by the underlying data structure.

type Output = Instant

The resulting type after applying the + operator.

impl Add<SignedDuration> for OffsetDateTime

fn add(self, duration: SignedDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = OffsetDateTime

The resulting type after applying the + operator.

impl Add<SignedDuration> for PlainDateTime

fn add(self, duration: SignedDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = PlainDateTime

The resulting type after applying the + operator.

impl Add<SignedDuration> for Duration

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

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the + operator.

impl Add<SignedDuration> for SystemTime

Available on crate feature std only.

fn add(self, duration: SignedDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = SystemTime

The resulting type after applying the + operator.

impl Add<SignedDuration> for Time

fn add(self, duration: SignedDuration) -> Self::Output

Add the sub-day time of the SignedDuration to the Time. Wraps on overflow.

assert_eq!(time!(12:00) + 2.hours(), time!(14:00));
assert_eq!(time!(0:00:01) + (-2).seconds(), time!(23:59:59));

type Output = Time

The resulting type after applying the + operator.

impl Add<SignedDuration> for Timestamp

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

Panics

This may panic if an overflow occurs.

type Output = Timestamp

The resulting type after applying the + operator.

impl Add<SignedDuration> for UtcDateTime

fn add(self, duration: SignedDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = UtcDateTime

The resulting type after applying the + operator.

impl AddAssign for SignedDuration

fn add_assign(&mut self, rhs: Self)

Panics

This may panic if an overflow occurs.

impl AddAssign<Duration> for SignedDuration

fn add_assign(&mut self, rhs: StdDuration)

Panics

This may panic if an overflow occurs.

impl AddAssign<SignedDuration> for Date

fn add_assign(&mut self, rhs: SignedDuration)

Panics

This may panic if an overflow occurs.

impl AddAssign<SignedDuration> for Instant

Available on crate feature std only.

fn add_assign(&mut self, rhs: SignedDuration)

Panics

This function may panic if the resulting point in time cannot be represented by the underlying data structure.

impl AddAssign<SignedDuration> for OffsetDateTime

fn add_assign(&mut self, rhs: SignedDuration)

Panics

This may panic if an overflow occurs.

impl AddAssign<SignedDuration> for PlainDateTime

fn add_assign(&mut self, duration: SignedDuration)

Panics

This may panic if an overflow occurs.

impl AddAssign<SignedDuration> for Duration

fn add_assign(&mut self, rhs: SignedDuration)

Panics

This may panic if the resulting addition cannot be represented.

impl AddAssign<SignedDuration> for SystemTime

Available on crate feature std only.

fn add_assign(&mut self, rhs: SignedDuration)

Panics

This may panic if an overflow occurs.

impl AddAssign<SignedDuration> for Time

fn add_assign(&mut self, rhs: SignedDuration)

Performs the += operation.

impl AddAssign<SignedDuration> for Timestamp

fn add_assign(&mut self, rhs: SignedDuration)

Panics

This may panic if an overflow occurs.

impl AddAssign<SignedDuration> for UtcDateTime

fn add_assign(&mut self, rhs: SignedDuration)

Panics

This may panic if an overflow occurs.

impl Arbitrary for SignedDuration

Available on crate feature quickcheck only.

fn arbitrary(g: &mut Gen) -> Self

Return an arbitrary value.

fn shrink(&self) -> Box<dyn Iterator<Item = Self>>

Return an iterator of values that are smaller than itself.

impl Clone for SignedDuration

fn clone(&self) -> SignedDuration

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for SignedDuration

impl Debug for SignedDuration

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for SignedDuration

fn default() -> Self

Returns the “default value” for a type.

impl<'a> Deserialize<'a> for SignedDuration

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'a>,

Deserialize this value from the given Serde deserializer.

impl Display for SignedDuration

The format returned by this implementation is not stable and must not be relied upon.

By default this produces an exact, full-precision printout of the duration. For a concise, rounded printout instead, you can use the .N format specifier:

let duration = SignedDuration::new(123456, 789011223);
println!("{duration:.3}");

For the purposes of this implementation, a day is exactly 24 hours and a minute is exactly 60 seconds.

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Distribution<SignedDuration> for StandardUniform

Available on crate feature rand010 only.

fn sample<R>(&self, rng: &mut R) -> SignedDuration

where R: Rng + ?Sized,

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> Iter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> Map<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Map sampled values to type S

impl Distribution<SignedDuration> for Standard

Available on crate feature rand08 only.

fn sample<R>(&self, rng: &mut R) -> SignedDuration

where R: Rng + ?Sized,

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl Distribution<SignedDuration> for StandardUniform

Available on crate feature rand09 only.

fn sample<R>(&self, rng: &mut R) -> SignedDuration

where R: Rng + ?Sized,

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> Iter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> Map<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Map sampled values to type S

impl Div for SignedDuration

fn div(self, rhs: Self) -> Self::Output

Panics

This may panic if rhs == SignedDuration::ZERO.

type Output = f64

The resulting type after applying the / operator.

impl Div<Duration> for SignedDuration

fn div(self, rhs: StdDuration) -> Self::Output

Panics

This may panic if rhs == SignedDuration::ZERO.

type Output = f64

The resulting type after applying the / operator.

impl Div<SignedDuration> for Duration

fn div(self, rhs: SignedDuration) -> Self::Output

Panics

This may panic if rhs == SignedDuration::ZERO.

type Output = f64

The resulting type after applying the / operator.

impl Div<f32> for SignedDuration

fn div(self, rhs: f32) -> Self::Output

Panics

This may panic if an overflow occurs or if rhs == 0.

type Output = SignedDuration

The resulting type after applying the / operator.

impl Div<f64> for SignedDuration

fn div(self, rhs: f64) -> Self::Output

Panics

This may panic if an overflow occurs or if rhs == 0.

type Output = SignedDuration

The resulting type after applying the / operator.

impl Div<i8> for SignedDuration

fn div(self, rhs: i8) -> Self::Output

Panics

This may panic if an overflow occurs or if rhs == 0.

type Output = SignedDuration

The resulting type after applying the / operator.

impl Div<i16> for SignedDuration

fn div(self, rhs: i16) -> Self::Output

Panics

This may panic if an overflow occurs or if rhs == 0.

type Output = SignedDuration

The resulting type after applying the / operator.

impl Div<i32> for SignedDuration

fn div(self, rhs: i32) -> Self::Output

Panics

This may panic if an overflow occurs or if rhs == 0.

type Output = SignedDuration

The resulting type after applying the / operator.

impl Div<u8> for SignedDuration

fn div(self, rhs: u8) -> Self::Output

Panics

This may panic if an overflow occurs or if rhs == 0.

type Output = SignedDuration

The resulting type after applying the / operator.

impl Div<u16> for SignedDuration

fn div(self, rhs: u16) -> Self::Output

Panics

This may panic if an overflow occurs or if rhs == 0.

type Output = SignedDuration

The resulting type after applying the / operator.

impl Div<u32> for SignedDuration

fn div(self, rhs: u32) -> Self::Output

Panics

This may panic if an overflow occurs or if rhs == 0.

type Output = SignedDuration

The resulting type after applying the / operator.

impl DivAssign<f32> for SignedDuration

fn div_assign(&mut self, rhs: f32)

Panics

This may panic if an overflow occurs or if rhs == 0.

impl DivAssign<f64> for SignedDuration

fn div_assign(&mut self, rhs: f64)

Panics

This may panic if an overflow occurs or if rhs == 0.

impl DivAssign<i8> for SignedDuration

fn div_assign(&mut self, rhs: i8)

Panics

This may panic if an overflow occurs or if rhs == 0.

impl DivAssign<i16> for SignedDuration

fn div_assign(&mut self, rhs: i16)

Panics

This may panic if an overflow occurs or if rhs == 0.

impl DivAssign<i32> for SignedDuration

fn div_assign(&mut self, rhs: i32)

Panics

This may panic if an overflow occurs or if rhs == 0.

impl DivAssign<u8> for SignedDuration

fn div_assign(&mut self, rhs: u8)

Panics

This may panic if an overflow occurs or if rhs == 0.

impl DivAssign<u16> for SignedDuration

fn div_assign(&mut self, rhs: u16)

Panics

This may panic if an overflow occurs or if rhs == 0.

impl DivAssign<u32> for SignedDuration

fn div_assign(&mut self, rhs: u32)

Panics

This may panic if an overflow occurs or if rhs == 0.

impl Eq for SignedDuration

impl Hash for SignedDuration

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Mul<SignedDuration> for i8

fn mul(self, rhs: SignedDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the * operator.

impl Mul<SignedDuration> for i16

fn mul(self, rhs: SignedDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the * operator.

impl Mul<SignedDuration> for i32

fn mul(self, rhs: SignedDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the * operator.

impl Mul<SignedDuration> for u8

fn mul(self, rhs: SignedDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the * operator.

impl Mul<SignedDuration> for u16

fn mul(self, rhs: SignedDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the * operator.

impl Mul<SignedDuration> for u32

fn mul(self, rhs: SignedDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the * operator.

impl Mul<SignedDuration> for f32

fn mul(self, rhs: SignedDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the * operator.

impl Mul<SignedDuration> for f64

fn mul(self, rhs: SignedDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the * operator.

impl Mul<f32> for SignedDuration

fn mul(self, rhs: f32) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the * operator.

impl Mul<f64> for SignedDuration

fn mul(self, rhs: f64) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the * operator.

impl Mul<i8> for SignedDuration

fn mul(self, rhs: i8) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the * operator.

impl Mul<i16> for SignedDuration

fn mul(self, rhs: i16) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the * operator.

impl Mul<i32> for SignedDuration

fn mul(self, rhs: i32) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the * operator.

impl Mul<u8> for SignedDuration

fn mul(self, rhs: u8) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the * operator.

impl Mul<u16> for SignedDuration

fn mul(self, rhs: u16) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the * operator.

impl Mul<u32> for SignedDuration

fn mul(self, rhs: u32) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the * operator.

impl MulAssign<f32> for SignedDuration

fn mul_assign(&mut self, rhs: f32)

Panics

This may panic if an overflow occurs.

impl MulAssign<f64> for SignedDuration

fn mul_assign(&mut self, rhs: f64)

Panics

This may panic if an overflow occurs.

impl MulAssign<i8> for SignedDuration

fn mul_assign(&mut self, rhs: i8)

Panics

This may panic if an overflow occurs.

impl MulAssign<i16> for SignedDuration

fn mul_assign(&mut self, rhs: i16)

Panics

This may panic if an overflow occurs.

impl MulAssign<i32> for SignedDuration

fn mul_assign(&mut self, rhs: i32)

Panics

This may panic if an overflow occurs.

impl MulAssign<u8> for SignedDuration

fn mul_assign(&mut self, rhs: u8)

Panics

This may panic if an overflow occurs.

impl MulAssign<u16> for SignedDuration

fn mul_assign(&mut self, rhs: u16)

Panics

This may panic if an overflow occurs.

impl MulAssign<u32> for SignedDuration

fn mul_assign(&mut self, rhs: u32)

Panics

This may panic if an overflow occurs.

impl Neg for SignedDuration

fn neg(self) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the - operator.

impl Ord for SignedDuration

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for SignedDuration

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialEq<Duration> for SignedDuration

fn eq(&self, rhs: &StdDuration) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialEq<SignedDuration> for Duration

fn eq(&self, rhs: &SignedDuration) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for SignedDuration

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Duration> for SignedDuration

fn partial_cmp(&self, rhs: &StdDuration) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<SignedDuration> for Duration

fn partial_cmp(&self, rhs: &SignedDuration) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for SignedDuration

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub for SignedDuration

fn sub(self, rhs: Self) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the - operator.

impl Sub<Duration> for SignedDuration

fn sub(self, rhs: StdDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the - operator.

impl Sub<SignedDuration> for Date

fn sub(self, duration: SignedDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = Date

The resulting type after applying the - operator.

impl Sub<SignedDuration> for Instant

Available on crate feature std only.

fn sub(self, duration: SignedDuration) -> Self::Output

Panics

This function may panic if the resulting point in time cannot be represented by the underlying data structure.

type Output = Instant

The resulting type after applying the - operator.

impl Sub<SignedDuration> for OffsetDateTime

fn sub(self, rhs: SignedDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = OffsetDateTime

The resulting type after applying the - operator.

impl Sub<SignedDuration> for PlainDateTime

fn sub(self, duration: SignedDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = PlainDateTime

The resulting type after applying the - operator.

impl Sub<SignedDuration> for Duration

fn sub(self, rhs: SignedDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the - operator.

impl Sub<SignedDuration> for SystemTime

Available on crate feature std only.

type Output = SystemTime

The resulting type after applying the - operator.

fn sub(self, duration: SignedDuration) -> Self::Output

Performs the - operation.

impl Sub<SignedDuration> for Time

fn sub(self, duration: SignedDuration) -> Self::Output

Subtract the sub-day time of the SignedDuration from the Time. Wraps on overflow.

assert_eq!(time!(14:00) - 2.hours(), time!(12:00));
assert_eq!(time!(23:59:59) - (-2).seconds(), time!(0:00:01));

type Output = Time

The resulting type after applying the - operator.

impl Sub<SignedDuration> for Timestamp

fn sub(self, rhs: SignedDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = Timestamp

The resulting type after applying the - operator.

impl Sub<SignedDuration> for UtcDateTime

fn sub(self, rhs: SignedDuration) -> Self::Output

Panics

This may panic if an overflow occurs.

type Output = UtcDateTime

The resulting type after applying the - operator.

impl SubAssign for SignedDuration

fn sub_assign(&mut self, rhs: Self)

Panics

This may panic if an overflow occurs.

impl SubAssign<Duration> for SignedDuration

fn sub_assign(&mut self, rhs: StdDuration)

Panics

This may panic if an overflow occurs.

impl SubAssign<SignedDuration> for Date

fn sub_assign(&mut self, rhs: SignedDuration)

Panics

This may panic if an overflow occurs.

impl SubAssign<SignedDuration> for Instant

Available on crate feature std only.

fn sub_assign(&mut self, rhs: SignedDuration)

Panics

This function may panic if the resulting point in time cannot be represented by the underlying data structure.

impl SubAssign<SignedDuration> for OffsetDateTime

fn sub_assign(&mut self, rhs: SignedDuration)

Panics

This may panic if an overflow occurs.

impl SubAssign<SignedDuration> for PlainDateTime

fn sub_assign(&mut self, duration: SignedDuration)

Panics

This may panic if an overflow occurs.

impl SubAssign<SignedDuration> for Duration

fn sub_assign(&mut self, rhs: SignedDuration)

Panics

This may panic if the resulting subtraction can not be represented.

impl SubAssign<SignedDuration> for SystemTime

Available on crate feature std only.

fn sub_assign(&mut self, rhs: SignedDuration)

Panics

This may panic if an overflow occurs.

impl SubAssign<SignedDuration> for Time

fn sub_assign(&mut self, rhs: SignedDuration)

Performs the -= operation.

impl SubAssign<SignedDuration> for Timestamp

fn sub_assign(&mut self, rhs: SignedDuration)

Panics

This may panic if an overflow occurs.

impl SubAssign<SignedDuration> for UtcDateTime

fn sub_assign(&mut self, rhs: SignedDuration)

Panics

This may panic if an overflow occurs.

impl Sum for SignedDuration

fn sum<I>(iter: I) -> Self

where I: Iterator<Item = Self>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a> Sum<&'a SignedDuration> for SignedDuration

fn sum<I>(iter: I) -> Self

where I: Iterator<Item = &'a Self>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl TryFrom<Duration> for SignedDuration

type Error = ConversionRange

The type returned in the event of a conversion error.

fn try_from(original: StdDuration) -> Result<Self, ConversionRange>

Performs the conversion.

impl TryFrom<SignedDuration> for Duration

type Error = ConversionRange

The type returned in the event of a conversion error.

fn try_from(duration: SignedDuration) -> Result<Self, ConversionRange>

Performs the conversion.