impl Duration

const fn is_zero(self: Self) -> bool

Check if a duration is exactly zero.

# use time::ext::NumericalDuration;
assert!(0.seconds().is_zero());
assert!(!1.nanoseconds().is_zero());

const fn is_negative(self: Self) -> bool

Check if a duration is negative.

# use time::ext::NumericalDuration;
assert!((-1).seconds().is_negative());
assert!(!0.seconds().is_negative());
assert!(!1.seconds().is_negative());

const fn is_positive(self: Self) -> bool

Check if a duration is positive.

# use time::ext::NumericalDuration;
assert!(1.seconds().is_positive());
assert!(!0.seconds().is_positive());
assert!(!(-1).seconds().is_positive());

const fn abs(self: Self) -> Self

Get the absolute value of the duration.

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

# use time::ext::NumericalDuration;
assert_eq!(1.seconds().abs(), 1.seconds());
assert_eq!(0.seconds().abs(), 0.seconds());
assert_eq!((-1).seconds().abs(), 1.seconds());

const fn unsigned_abs(self: Self) -> StdDuration

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

# use time::ext::{NumericalDuration, NumericalStdDuration};
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());

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

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

# use time::{Duration, ext::NumericalDuration};
assert_eq!(Duration::new(1, 0), 1.seconds());
assert_eq!(Duration::new(-1, 0), (-1).seconds());
assert_eq!(Duration::new(1, 2_000_000_000), 3.seconds());

Panics

This may panic if an overflow occurs.

const fn weeks(weeks: i64) -> Self

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

# use time::{Duration, ext::NumericalDuration};
assert_eq!(Duration::weeks(1), 604_800.seconds());

Panics

This may panic if an overflow occurs.

const fn days(days: i64) -> Self

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

# use time::{Duration, ext::NumericalDuration};
assert_eq!(Duration::days(1), 86_400.seconds());

Panics

This may panic if an overflow occurs.

const fn hours(hours: i64) -> Self

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

# use time::{Duration, ext::NumericalDuration};
assert_eq!(Duration::hours(1), 3_600.seconds());

Panics

This may panic if an overflow occurs.

const fn minutes(minutes: i64) -> Self

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

# use time::{Duration, ext::NumericalDuration};
assert_eq!(Duration::minutes(1), 60.seconds());

Panics

This may panic if an overflow occurs.

const fn seconds(seconds: i64) -> Self

Create a new Duration with the given number of seconds.

# use time::{Duration, ext::NumericalDuration};
assert_eq!(Duration::seconds(1), 1_000.milliseconds());

const fn seconds_f64(seconds: f64) -> Self

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

# use time::{Duration, ext::NumericalDuration};
assert_eq!(Duration::seconds_f64(0.5), 0.5.seconds());
assert_eq!(Duration::seconds_f64(-0.5), (-0.5).seconds());

const fn seconds_f32(seconds: f32) -> Self

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

# use time::{Duration, ext::NumericalDuration};
assert_eq!(Duration::seconds_f32(0.5), 0.5.seconds());
assert_eq!(Duration::seconds_f32(-0.5), (-0.5).seconds());

const fn saturating_seconds_f64(seconds: f64) -> Self

Creates a new Duration 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 Duration of 0 seconds.

# use time::{Duration, ext::NumericalDuration};
assert_eq!(Duration::saturating_seconds_f64(0.5), 0.5.seconds());
assert_eq!(Duration::saturating_seconds_f64(-0.5), (-0.5).seconds());
assert_eq!(
    Duration::saturating_seconds_f64(f64::NAN),
    Duration::new(0, 0),
);
assert_eq!(
    Duration::saturating_seconds_f64(f64::NEG_INFINITY),
    Duration::MIN,
);
assert_eq!(
    Duration::saturating_seconds_f64(f64::INFINITY),
    Duration::MAX,
);

const fn saturating_seconds_f32(seconds: f32) -> Self

Creates a new Duration 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 Duration of 0 seconds.

# use time::{Duration, ext::NumericalDuration};
assert_eq!(Duration::saturating_seconds_f32(0.5), 0.5.seconds());
assert_eq!(Duration::saturating_seconds_f32(-0.5), (-0.5).seconds());
assert_eq!(
    Duration::saturating_seconds_f32(f32::NAN),
    Duration::new(0, 0),
);
assert_eq!(
    Duration::saturating_seconds_f32(f32::NEG_INFINITY),
    Duration::MIN,
);
assert_eq!(
    Duration::saturating_seconds_f32(f32::INFINITY),
    Duration::MAX,
);

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

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

# use time::{Duration, ext::NumericalDuration};
assert_eq!(Duration::checked_seconds_f64(0.5), Some(0.5.seconds()));
assert_eq!(Duration::checked_seconds_f64(-0.5), Some((-0.5).seconds()));
assert_eq!(Duration::checked_seconds_f64(f64::NAN), None);
assert_eq!(Duration::checked_seconds_f64(f64::NEG_INFINITY), None);
assert_eq!(Duration::checked_seconds_f64(f64::INFINITY), None);

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

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

# use time::{Duration, ext::NumericalDuration};
assert_eq!(Duration::checked_seconds_f32(0.5), Some(0.5.seconds()));
assert_eq!(Duration::checked_seconds_f32(-0.5), Some((-0.5).seconds()));
assert_eq!(Duration::checked_seconds_f32(f32::NAN), None);
assert_eq!(Duration::checked_seconds_f32(f32::NEG_INFINITY), None);
assert_eq!(Duration::checked_seconds_f32(f32::INFINITY), None);

const fn milliseconds(milliseconds: i64) -> Self

Create a new Duration with the given number of milliseconds.

# use time::{Duration, ext::NumericalDuration};
assert_eq!(Duration::milliseconds(1), 1_000.microseconds());
assert_eq!(Duration::milliseconds(-1), (-1_000).microseconds());

const fn microseconds(microseconds: i64) -> Self

Create a new Duration with the given number of microseconds.

# use time::{Duration, ext::NumericalDuration};
assert_eq!(Duration::microseconds(1), 1_000.nanoseconds());
assert_eq!(Duration::microseconds(-1), (-1_000).nanoseconds());

const fn nanoseconds(nanoseconds: i64) -> Self

Create a new Duration with the given number of nanoseconds.

# use time::{Duration, ext::NumericalDuration};
assert_eq!(Duration::nanoseconds(1), 1.microseconds() / 1_000);
assert_eq!(Duration::nanoseconds(-1), (-1).microseconds() / 1_000);

const fn nanoseconds_i128(nanoseconds: i128) -> Self

Create a new Duration with the given number of nanoseconds.

# use time::{Duration, ext::NumericalDuration};
assert_eq!(
    Duration::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.

const fn whole_weeks(self: Self) -> i64

Get the number of whole weeks in the duration.

# use time::ext::NumericalDuration;
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);

const fn whole_days(self: Self) -> i64

Get the number of whole days in the duration.

# use time::ext::NumericalDuration;
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);

const fn whole_hours(self: Self) -> i64

Get the number of whole hours in the duration.

# use time::ext::NumericalDuration;
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);

const fn whole_minutes(self: Self) -> i64

Get the number of whole minutes in the duration.

# use time::ext::NumericalDuration;
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);

const fn whole_seconds(self: Self) -> i64

Get the number of whole seconds in the duration.

# use time::ext::NumericalDuration;
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);

const fn as_seconds_f64(self: Self) -> f64

Get the number of fractional seconds in the duration.

# use time::ext::NumericalDuration;
assert_eq!(1.5.seconds().as_seconds_f64(), 1.5);
assert_eq!((-1.5).seconds().as_seconds_f64(), -1.5);

const fn as_seconds_f32(self: Self) -> f32

Get the number of fractional seconds in the duration.

# use time::ext::NumericalDuration;
assert_eq!(1.5.seconds().as_seconds_f32(), 1.5);
assert_eq!((-1.5).seconds().as_seconds_f32(), -1.5);

const fn whole_milliseconds(self: Self) -> i128

Get the number of whole milliseconds in the duration.

# use time::ext::NumericalDuration;
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);

const fn subsec_milliseconds(self: Self) -> i16

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

Always in the range -999..=999.

# use time::ext::NumericalDuration;
assert_eq!(1.4.seconds().subsec_milliseconds(), 400);
assert_eq!((-1.4).seconds().subsec_milliseconds(), -400);

const fn whole_microseconds(self: Self) -> i128

Get the number of whole microseconds in the duration.

# use time::ext::NumericalDuration;
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);

const fn subsec_microseconds(self: Self) -> i32

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

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

# use time::ext::NumericalDuration;
assert_eq!(1.0004.seconds().subsec_microseconds(), 400);
assert_eq!((-1.0004).seconds().subsec_microseconds(), -400);

const fn whole_nanoseconds(self: Self) -> i128

Get the number of nanoseconds in the duration.

# use time::ext::NumericalDuration;
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);

const fn subsec_nanoseconds(self: 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.

# use time::ext::NumericalDuration;
assert_eq!(1.000_000_400.seconds().subsec_nanoseconds(), 400);
assert_eq!((-1.000_000_400).seconds().subsec_nanoseconds(), -400);

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

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

# use time::{Duration, ext::NumericalDuration};
assert_eq!(5.seconds().checked_add(5.seconds()), Some(10.seconds()));
assert_eq!(Duration::MAX.checked_add(1.nanoseconds()), None);
assert_eq!((-5).seconds().checked_add(5.seconds()), Some(0.seconds()));

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

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

# use time::{Duration, ext::NumericalDuration};
assert_eq!(5.seconds().checked_sub(5.seconds()), Some(Duration::ZERO));
assert_eq!(Duration::MIN.checked_sub(1.nanoseconds()), None);
assert_eq!(5.seconds().checked_sub(10.seconds()), Some((-5).seconds()));

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

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

# use time::{Duration, ext::NumericalDuration};
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!(Duration::MAX.checked_mul(2), None);
assert_eq!(Duration::MIN.checked_mul(2), None);

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

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

# use time::ext::NumericalDuration;
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);

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

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

# use time::ext::NumericalDuration;
# use time::Duration;
assert_eq!(5.seconds().checked_neg(), Some((-5).seconds()));
assert_eq!(Duration::MIN.checked_neg(), None);

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

Computes self + rhs, saturating if an overflow occurred.

# use time::{Duration, ext::NumericalDuration};
assert_eq!(5.seconds().saturating_add(5.seconds()), 10.seconds());
assert_eq!(Duration::MAX.saturating_add(1.nanoseconds()), Duration::MAX);
assert_eq!(
    Duration::MIN.saturating_add((-1).nanoseconds()),
    Duration::MIN
);
assert_eq!((-5).seconds().saturating_add(5.seconds()), Duration::ZERO);

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

Computes self - rhs, saturating if an overflow occurred.

# use time::{Duration, ext::NumericalDuration};
assert_eq!(5.seconds().saturating_sub(5.seconds()), Duration::ZERO);
assert_eq!(Duration::MIN.saturating_sub(1.nanoseconds()), Duration::MIN);
assert_eq!(
    Duration::MAX.saturating_sub((-1).nanoseconds()),
    Duration::MAX
);
assert_eq!(5.seconds().saturating_sub(10.seconds()), (-5).seconds());

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

Computes self * rhs, saturating if an overflow occurred.

# use time::{Duration, ext::NumericalDuration};
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), Duration::ZERO);
assert_eq!(Duration::MAX.saturating_mul(2), Duration::MAX);
assert_eq!(Duration::MIN.saturating_mul(2), Duration::MIN);
assert_eq!(Duration::MAX.saturating_mul(-2), Duration::MIN);
assert_eq!(Duration::MIN.saturating_mul(-2), Duration::MAX);

impl Add for Duration

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

Panics

This may panic if an overflow occurs.

impl Add for Duration

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

Panics

This may panic if an overflow occurs.

impl AddAssign for Duration

fn add_assign(self: &mut Self, rhs: StdDuration)

Panics

This may panic if an overflow occurs.

impl AddAssign for Duration

fn add_assign(self: &mut Self, rhs: Self)

Panics

This may panic if an overflow occurs.

impl Clone for Duration

fn clone(self: &Self) -> Duration

impl Copy for Duration

impl Debug for Duration

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

impl Default for Duration

fn default() -> Self

impl Display for Duration

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

impl Div for Duration

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

impl Div for Duration

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

Panics

This may panic if an overflow occurs.

impl Div for Duration

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

Panics

This may panic if an overflow occurs.

impl Div for Duration

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

Panics

This may panic if an overflow occurs.

impl Div for Duration

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

impl Div for Duration

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

Panics

This may panic if an overflow occurs.

impl Div for Duration

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

Panics

This may panic if an overflow occurs.

impl Div for Duration

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

Panics

This may panic if an overflow occurs.

impl Div for Duration

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

Panics

This may panic if an overflow occurs.

impl Div for Duration

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

Panics

This may panic if an overflow occurs.

impl DivAssign for Duration

fn div_assign(self: &mut Self, rhs: u32)

Panics

This may panic if an overflow occurs.

impl DivAssign for Duration

fn div_assign(self: &mut Self, rhs: f32)

Panics

This may panic if an overflow occurs.

impl DivAssign for Duration

fn div_assign(self: &mut Self, rhs: u8)

Panics

This may panic if an overflow occurs.

impl DivAssign for Duration

fn div_assign(self: &mut Self, rhs: i16)

Panics

This may panic if an overflow occurs.

impl DivAssign for Duration

fn div_assign(self: &mut Self, rhs: i8)

Panics

This may panic if an overflow occurs.

impl DivAssign for Duration

fn div_assign(self: &mut Self, rhs: u16)

Panics

This may panic if an overflow occurs.

impl DivAssign for Duration

fn div_assign(self: &mut Self, rhs: i32)

Panics

This may panic if an overflow occurs.

impl DivAssign for Duration

fn div_assign(self: &mut Self, rhs: f64)

Panics

This may panic if an overflow occurs.

impl Eq for Duration

impl Freeze for Duration

impl Hash for Duration

fn hash<__H: $crate::hash::Hasher>(self: &Self, state: &mut __H)

impl Mul for Duration

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

Panics

This may panic if an overflow occurs.

impl Mul for Duration

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

Panics

This may panic if an overflow occurs.

impl Mul for Duration

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

Panics

This may panic if an overflow occurs.

impl Mul for Duration

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

Panics

This may panic if an overflow occurs.

impl Mul for Duration

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

Panics

This may panic if an overflow occurs.

impl Mul for Duration

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

Panics

This may panic if an overflow occurs.

impl Mul for Duration

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

Panics

This may panic if an overflow occurs.

impl Mul for Duration

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

Panics

This may panic if an overflow occurs.

impl MulAssign for Duration

fn mul_assign(self: &mut Self, rhs: u8)

Panics

This may panic if an overflow occurs.

impl MulAssign for Duration

fn mul_assign(self: &mut Self, rhs: i16)

Panics

This may panic if an overflow occurs.

impl MulAssign for Duration

fn mul_assign(self: &mut Self, rhs: u16)

Panics

This may panic if an overflow occurs.

impl MulAssign for Duration

fn mul_assign(self: &mut Self, rhs: i8)

Panics

This may panic if an overflow occurs.

impl MulAssign for Duration

fn mul_assign(self: &mut Self, rhs: i32)

Panics

This may panic if an overflow occurs.

impl MulAssign for Duration

fn mul_assign(self: &mut Self, rhs: f64)

Panics

This may panic if an overflow occurs.

impl MulAssign for Duration

fn mul_assign(self: &mut Self, rhs: f32)

Panics

This may panic if an overflow occurs.

impl MulAssign for Duration

fn mul_assign(self: &mut Self, rhs: u32)

Panics

This may panic if an overflow occurs.

impl Neg for Duration

fn neg(self: Self) -> <Self as >::Output

Panics

This may panic if an overflow occurs.

impl Ord for Duration

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

impl PartialEq for Duration

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

impl PartialEq for Duration

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

impl PartialOrd for Duration

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

impl PartialOrd for Duration

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

impl RefUnwindSafe for Duration

impl Send for Duration

impl StructuralPartialEq for Duration

impl Sub for Duration

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

Panics

This may panic if an overflow occurs.

impl Sub for Duration

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

Panics

This may panic if an overflow occurs.

impl SubAssign for Duration

fn sub_assign(self: &mut Self, rhs: Self)

Panics

This may panic if an overflow occurs.

impl SubAssign for Duration

fn sub_assign(self: &mut Self, rhs: StdDuration)

Panics

This may panic if an overflow occurs.

impl Sum for Duration

fn sum<I>(iter: I) -> Self
where
    I: Iterator<Item = Self>

impl Sync for Duration

impl TryFrom for Duration

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

impl Unpin for Duration

impl UnsafeUnpin for Duration

impl UnwindSafe for Duration

impl<'a> Sum for Duration

fn sum<I>(iter: I) -> Self
where
    I: Iterator<Item = &'a Self>

impl<T> Any for Duration

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for Duration

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for Duration

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> CloneToUninit for Duration

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

impl<T> From for Duration

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for Duration

fn to_owned(self: &Self) -> T

fn clone_into(self: &Self, target: &mut T)

impl<T> ToString for Duration

fn to_string(self: &Self) -> String

impl<T, U> Into for Duration

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for Duration

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for Duration

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>