oh so this is how futures work, huh

futures.rs

use futures::prelude::*;
use futures::task::{Context, Poll};
use std::pin::Pin;
use std::sync::{Arc, Mutex};
use tokio::time;

enum Noise {
    PollMe,
    WakeMe,
}

struct Noisy {
    data: u64,
    state: Arc<Mutex<Noise>>,
}

impl Noisy {
    fn new(t: u64) -> Self {
        Self {
            data: t,
            state: Arc::new(Mutex::new(Noise::PollMe)),
        }
    }
}

impl Future for Noisy {
    type Output = u64;

    fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
        let should_be_woken;

        let mut state = self.state.lock().unwrap();

        match *state {
            Noise::PollMe => {
                println!("polled {:?}", self.data);
                should_be_woken = true;
            }
            Noise::WakeMe => {
                println!(" woken {:?}", self.data);
                should_be_woken = false;
            }
        }

        if should_be_woken {
            *state = Noise::WakeMe;
            let waker = cx.waker().clone();
            tokio::spawn(async move {
                let mut ival = time::interval(time::Duration::from_millis(1000));
                ival.tick().await;
                ival.tick().await;
                waker.wake();
            });
            Poll::Pending
        } else {
            Poll::Ready(self.data)
        }
    }
}

#[tokio::main]
async fn main() {
    let a = Noisy::new(0u64);
    let b = Noisy::new(1u64);
    a.await;
    b.await;

    let c = Noisy::new(2u64);
    let d = Noisy::new(3u64);
    future::join(c, d).await;
}