Odtnhj

I'm working with Tokio doing some UDP stuff.

I want to record the amount of time my UDP probe future takes to resolve. I came up with the following function, time_future(), to wrap a future and give me the result and a duration. The function seems very naive and I think Rust has the power to express the concept much more cleanly.

My working code (Playground):

extern crate futures; // 0.1.25
extern crate tokio; // 0.1.11

use std::time::Duration, Instant;

use futures::future::lazy, ok;
use futures::Future;
use tokio::runtime::current_thread::Runtime;
use tokio::timer::Delay;

struct TimedFutureResult<T, E> 
 elapsed: Duration,
 result: Result<T, E>,


impl<T, E> TimedFutureResult<T, E> 
 pub fn elapsed_ms(&self) -> i64 
 return (self.elapsed.as_secs() * 1000 + (self.elapsed.subsec_nanos() / 1000000) as u64)
 as i64;
 


fn time_future<F: Future>(f: F) -> impl Future<Item = TimedFutureResult<F::Item, F::Error>> 
 lazy(

fn main() 
 let when = Instant::now() + Duration::from_millis(100);

 let f = time_future(Delay::new(when)).then(

How can I improve this and make it more idiomatic? Can I somehow get the interface to work similarly to inspect() or then()?

Delay::new(when)
 .timed(|res, elapsed| println!("ms!", elapsed))
 .and_then(...);

I tried creating a Timed trait and implementing it for Future but I didn't feel at all confident in how I was going about it. The types just really threw me for a loop.

Am I at least barking up the right tree?

The act of writing the future is easy enough, and adding a chainable method is the same technique as that shown in How can I add new methods to Iterator?.

The only really tricky aspect is deciding when the time starts — is it when the future is created or when it is first polled?

I chose to use when it's first polled, as that seems more useful:

extern crate futures; // 0.1.25
extern crate tokio; // 0.1.11

use std::time::Duration, Instant;

use futures::try_ready, Async, Future, Poll;
use tokio::runtime::current_thread::Runtime, timer::Delay;

struct Timed<Fut, F>
where
 Fut: Future,
 F: FnMut(&Fut::Item, Duration),

 inner: Fut,
 f: F,
 start: Option<Instant>,


impl<Fut, F> Future for Timed<Fut, F>
where
 Fut: Future,
 F: FnMut(&Fut::Item, Duration),

 type Item = Fut::Item;
 type Error = Fut::Error;

 fn poll(&mut self) -> Poll<Self::Item, Self::Error> 
 let start = self.start.get_or_insert_with(Instant::now);

 let v = try_ready!(self.inner.poll());

 let elapsed = start.elapsed();
 (self.f)(&v, elapsed);

 Ok(Async::Ready(v))
 


trait TimedExt: Sized + Future 
 fn timed<F>(self, f: F) -> Timed<Self, F>
 where
 F: FnMut(&Self::Item, Duration),
 
 Timed 
 inner: self,
 f,
 start: None,
 
 


impl<F: Future> TimedExt for F 

fn main() 
 let when = Instant::now() + Duration::from_millis(100);

 let f = Delay::new(when).timed(