Easy timeout/setInterval

[theduke]

It would be great to have a easy way to schedule timeouts and intervals.

Something like:

orders.interval(1000, Msg::Tick);
orders.timeout(500, Msg::Delayed);

As mentioned in the futures cancellation issue, it would be great to return a drop guard that clears the timeout/interval when dropped.

For inspiration, draco does it this way.

[MartinKavik]

interval seems to me more like a subscription than order/cmd. So I think it would make more sense to use it like e.g. keyboard events - in .window_events(..) (or a new concept like .subscriptions(..) which will be like window_events(..) , but more general).
There are more subscriptions which we can implement (e.g. OnRequestAnimationFrame, OnWebsocketMesssage, etc.) so I think it isn't good idea to implement interval as Orders's method because it will be mess in the future and it's not very flexible.

Alternative can be also something like this:

orders.subscribe(Sub::interval(1000, Msg::Tick));

timeout makes more sense imho, but we can reuse existing Api and be prepared for more similar cases - i.e. something like:

orders.perform_cmd(Cmd::timeout(500, Msg::Delayed));

So it's clear on the first look that it's a command and we can easily add more commands in the future.

[tiberiusferreira]

Is there a way to use stream now? I wanted to make an API call each X seconds. I tried to use

fn fetch_data() -> impl Future<Item = Msg, Error = Msg> {
    let url = "https://api.github.com/repos/david-oconnor/seed/branches/master";
    Request::new(url).fetch_json_data(Msg::DataFetched)
}

fn init(_: Url, orders: &mut impl Orders<Msg>) -> Init<Model> {
    orders
        .send_msg(Msg::StartGeoTracking);


    let (app, msg_mapper) = (orders.clone_app(), orders.msg_mapper());

    let strm = IntervalStream::new(1000)
        .map(
            move |_|{
            fetch_data()
        }
        )
        .then(
            |_| Ok(Msg::Listening)
        );
    orders.perform_cmd(strm);

    let map = initMap();
    Init::new(Model{
        curr_lat: None,
        curr_longi: None,
        markers: vec![],
        map
    })

}

But I get:

 the trait `futures::future::Future` is not implemented for `futures::stream::then::Then<futures::stream::map::Map<gloo_timers::future::IntervalStream, [closure@src/lib.rs:167:14: 169:10]>, [closure@src/lib.rs:170:12: 170:34], std::result::Result<Msg, _>>`

Is there a workaround for now?

[MartinKavik]

    let stream = IntervalStream::new(1_000).for_each(move |_| {
        let condition = true;
        if !condition {
            return Err(())
        }
        app.update(msg_mapper(Msg::DoSomething));
        Ok(())
    })
        .then(|_| Ok(Msg::Finished));

    orders.perform_cmd(stream);

We should return back to this issue once async/await is stable and libraries like reqwest are ready so we can try more real-world cases.