Change:
Do you have some more info? Is this something users experience? Or is it mostly custom drivers running into problems?
When implementing myself I accidentally tried to parse a different file type. This returned an error from , but the error was never printed to the user, instead it said ...`.
It's possible if an rlib/dylib gets corrupt, because then it won't say the file is corrupt. Yes

Discussion:
//! assert_eq!(Duration::new(5, 0), Duration::from_secs(5)); //! ``` <del> use fmt; </del> <ins> use {fmt, u64}; </ins> use iter::Sum; use ops::{Add, Sub, Mul, Div, AddAssign, SubAssign, MulAssign, DivAssign};

const NANOS_PER_MICRO: u32 = 1_000; const MILLIS_PER_SEC: u64 = 1_000; const MICROS_PER_SEC: u64 = 1_000_000; <ins> const MAX_NANOS_F64: f64 = ((u64::MAX as u128)*(NANOS_PER_SEC as u128)) as f64; </ins> /// A `Duration` type to represent a span of time, typically used for system /// timeouts.

None } } <ins> /// Multiply `Duration` by `f64`. /// /// # Examples /// ``` /// let dur = Duration::new(2, 700_000_000); /// assert_eq!(dur.mul_f64(3.14), Duration::new(8, 478_000_000)); /// assert_eq!(dur.mul_f64(3.14e5), Duration::new(847_800, 0)); /// ``` #[unstable(feature = "duration_float_ops", reason = "duration/floats operations are unstabe", issue = "0")] #[inline] pub fn mul_f64(self, rhs: f64) -> Duration { const NPS: f64 = NANOS_PER_SEC as f64; let nanos_f64 = rhs * (NPS * (self.secs as f64) + (self.nanos as f64)); if !nanos_f64.is_finite() { panic!("got non-finite value when multiplying duration by float"); } if nanos_f64 > MAX_NANOS_F64 { panic!("overflow when multiplying duration by float"); } if nanos_f64 < 0.0 { panic!("underflow when multiplying duration by float"); } let nanos_u128 = nanos_f64 as u128; Duration { secs: (nanos_u128 / (NANOS_PER_SEC as u128)) as u64, nanos: (nanos_u128 % (NANOS_PER_SEC as u128)) as u32, } } /// Divide `Duration` by `f64`. /// /// # Examples /// ``` /// let dur = Duration::new(2, 700_000_000); /// assert_eq!(dur.div_f64(3.14), Duration::new(0, 859_872_611)); /// // note that truncation is used, not rounding /// assert_eq!(dur.div_f64(3.14e5), Duration::new(0, 8_598)); /// ``` #[unstable(feature = "duration_float_ops", reason = "duration/floats operations are unstabe", issue = "0")] #[inline] pub fn div_f64(self, rhs: f64) -> Duration { const NPS: f64 = NANOS_PER_SEC as f64; let nanos_f64 = (NPS * (self.secs as f64) + (self.nanos as f64)) / rhs; if !nanos_f64.is_finite() { panic!("got non-finite value when dividing duration by float"); } if nanos_f64 > MAX_NANOS_F64 { panic!("overflow when dividing duration by float"); } if nanos_f64 < 0.0 { panic!("underflow when multiplying duration by float"); } let nanos_u128 = nanos_f64 as u128; Duration { secs: (nanos_u128 / (NANOS_PER_SEC as u128)) as u64, nanos: (nanos_u128 % (NANOS_PER_SEC as u128)) as u32, } } /// Divide `Duration` by `Duration` and return `f64`. /// /// # Examples /// ``` /// let dur1 = Duration::new(2, 700_000_000); /// let dur2 = Duration::new(5, 400_000_000); /// assert_eq!(dur1.div_duration(dur2), 0.5); /// ``` #[unstable(feature = "duration_float_ops", reason = "duration/floats operations are unstabe", issue = "0")] #[inline] pub fn div_duration(self, rhs: Duration) -> f64 { const NPS: f64 = NANOS_PER_SEC as f64; let nanos1 = NPS * (self.secs as f64) + (self.nanos as f64); let nanos2 = NPS * (rhs.secs as f64) + (rhs.nanos as f64); nanos1/nanos2 } </ins> } #[stable(feature = "duration", since = "1.3.0")]

} } <ins> #[stable(feature = "symmetric_u32_duration_mul", since = "1.30.0")] impl Mul<Duration> for u32 { type Output = Duration; fn mul(self, rhs: Duration) -> Duration { rhs.checked_mul(self).expect("overflow when multiplying scalar by duration") } } </ins> #[stable(feature = "time_augmented_assignment", since = "1.9.0")] impl MulAssign<u32> for Duration { fn mul_assign(&mut self, rhs: u32) {