Duration: methods to extract non-integral content

[aturon]

Right now, Duration::num_seconds and friends return i64 values, which means you get the number of whole seconds included in the duration. But it's often useful to get fractional values as well.

It's unclear whether the methods should simply be changed to yield f64 values, or whether we should have separate variants.

[aturon]

cc @alexcrichton

What's the general precedent here?

[aturon]

cc @brson

[alexcrichton]

My use case was when I had a duration of time and I wanted to print out how many "things per second" happened in that duration of time. Given a number of "things", I would ideally use a f64 number of seconds to print a more precise amount, but I was unable to do so without acrobatics of calling around num_nanoseconds() and then remember whether to divide or multiple by the number of nanoseconds in a second.

I'm not sure that we want to s/i64/f64/ in the API, just a thought of mine that perhaps it could be a little easier to extract the float-wise number of units.

[1-more]

Let's make Duration fields public. Then everyone will be able to take what he/she wants. It'll also address this issue.

[1-more]

I don't like separate variants. If we can't make Duration fields public, then let's export internals with some function:

impl Duration {
    ...    
    pub fn as_is(&self) -> (i64, i32) {
        (self.secs, self.nanos)
    }
}

and use macros:

macro_rules! f64_milliseconds (
    ($d:expr) => {
        match $d.as_is() {
            (secs, nanos) => (secs as f64)*1000f64 + (nanos as f64)/1000_000f64
        }
    }
)

macro_rules! f64_microseconds (
    ($d:expr) => {
        match $d.as_is() {
            (secs, nanos) => (secs as f64)*1000_000f64 + (nanos as f64)/1000f64
        }
    }
)

[1-more]

Yesterday we were happy with Duration::num_seconds() -> i64. Today we need Duration::num_seconds() -> f64. That's the way life goes. But what is going to happen tomorrow? I like the idea to leave Duration alone and move num_seconds function in a trait:

pub trait TimeSpan {
    fn num_seconds(x: &Duration) -> Self;
}

Then, implement trait for both i64 and f64:

impl TimeSpan for i64 {
    fn num_seconds(x: &Duration) -> i64 {
        x.num_seconds()
    }
}

impl TimeSpan for f64 {
    fn num_seconds(x: &Duration) -> f64 {
        (x.num_seconds() as f64) + (x.nanos as f64)/(NANOS_PER_SEC as f64)
    }
}

And finally use it:

let d = Duration::milliseconds(1500);

let a: i64 = TimeSpan::num_seconds(&d);
assert_eq!(a, 1);

let b: f64 = TimeSpan::num_seconds(&d);
assert_eq!(b, 1.5);

In general, it seems to be a more elegant solution. Though, a single Duration::num_seconds() -> f64 is easier.