Repeated `Timer` that fires immediately after creation

[kaoet]

What problem does this solve or what need does it fill?

I want to have an easy way to create a repeated Timer that fires immediately in the next tick, and then fires periodically.

So rather than

<---wait 10s--->FIRE<---wait 10s--->FIRE

I want

FIRE<---wait 10s--->FIRE<---wait 10s--->FIRE

What solution would you like?

An ergonomic API like:

let timer = Timer::from_seconds(10.0, TimerMode::Repeating).with_finish_immediately();

The actual function name can be discussed.

What alternative(s) have you considered?

Now I use this, which takes 3 lines rather than 1:

let timer = {
    let mut timer = Timer::from_seconds(10.0, TimerMode::Repeating);
    timer.tick(Duration::from_secs_f32(10.0 - EPSILON));
    timer
};

BTW, I've also tried this which doesn't work:

let timer = {
    let mut timer = Timer::from_seconds(10.0, TimerMode::Repeating);
    timer.finish();
    timer
};

[alice-i-cecile]

I'm totally fine with this sort of usability method on Timer: it's a sensible pattern!

There's a bit of design work to figure out in terms of the best way to do this and naming, but I'm generally feeling pretty flexible there.

The options as I see it:

1. Add another parameter to the Timer constructors. Pretty noisy, but easy to discover.
2. Add a method like timer.almost_finish(), and bikeshed a good name for it.
3. Add builder methods, as proposed.
4. Add another variant to TimerMode.
5. Add more arguments to contstructors like in 1, but keep the existing APIs untouched.

I think that 2 and 3 are my favorite, and I could be convinced on 4. Both 1 and 5 are something I would oppose.

[grind086]

Could this be covered with a just_started()? Then you could do something like timer.just_started() || timer.just_finished(), or a helper like timer.tick(dt).just_finished_or_started() so ticking is less awkward.

That would also let you tell if the timer started and finished in the same tick, which may or may not be useful.