Change:
Attempting to compile this: will give this error: I was thinking that a clearer error could be something along the lines of: and give this hint:
This should be straightforward to add a help message for. This error message is emitted here: The immediately afterwards is responsible for giving suggestions relevant to the particular type. You'd need to add a new case for () and emit an appropriate message (there are examples for other types in the expression), if the field is numeric. If anyone'd like to tackle this, just post a reply here — I can give more details as needed (but it's always useful to try working things out yourself first, to get a feel for where to find things).
I don't have any experience with Rustc's codebase, but I would be willing to give it a try.
great! If you need any help, you can post a comment here, or ask on or #rustc. Once you add the help message, you'll need to add a test for it (there are plenty of examples in — you can run to test and produce the output).

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) {