You see, rust platform support can’t be bad when even meme platforms can get to tier 1.
Duration::from_minsandDuration::from_hoursseems nice. Otherwise kind of a boring release if you ask me.They’re released on a schedule so they are often quite boring.
I know, but they used to be more exciting I feel like - but I guess it’s only natural that development speed goes down as more and more low-hanging fruit has already been picked. What remains of the non-boring stuff is probably quite complicated and difficult to stabilize.
I actually wanted that just the other day. I actually wanted days, but at least now I only need
Duration::from_hours(24).Duration::from_days was proposed but consensus was not reached as “day” is somewhat complicated as that sometimes can be 23 hours or 25 hours due to daylight savings or 23:59 due to leap seconds shenanigans.
Leap seconds are already a problem for minutes and hours, which is probably why they weren’t added until now.
They’re also a problem for adding seconds to system times, since one second duration could mean two seconds wall clock time. As mentioned in discussions, we accept this for seconds, but not daylight savings, which is odd IMO because leap seconds are more “real” than daylight savings.
Ideally,
Durationshould always represent multiples of logical seconds, and they only make sense in the context of a clock, either monotonic or system. There should be specialized functions for translating between the two (e.g.SystemTime::add_monotonic(Duration)andSystemTime.sub_monotonic(SystemTime)), which would account for leap seconds and daylight savings.But all of that can live in an external crate like “chrono”. I just want a way to clearly communicate intent. In my case, I’m writing a ping test tool to find out how often my internet drops and I want to print logs hourly (make sure it’s still running) and daily (longer term logging purposes). This use case doesn’t need exact precision, it just needs to print roughly on a schedule (I’m running for a week or two, not multiple years). If I do actual time math, I’d use a specialized crate with clear documentation, but for something quick and dirty, I’d prefer to use the stdlib.
That sounds like an irrelevant problem though. A duration is explicitly not concerned with daylight savings at all, I’ve always thought of it as the amount of actual time (i.e. from a monotonic clock) that has elapsed between two absolute times. So a time diff between noon on daylight savings change day and the day prior would either be 23 or 25 hours, not exactly equal to
Duration::from_days(1). There’s no time zone or even year context forDuration::from_days(1), so it should always be defined as a naïve calculation involving fixed definitions for hours per day and seconds per hour.Years are a bit more controversial, to the point where 365 days and 365.24 days are both acceptable in different contexts, and that latter value could change in the very long term (millions of years). But I think up to days, most can agree that the value assumes exactly 24 hours and is completely separate from the idea of wall clocks changing based on local law.
Now, if we want to support “logical” time math, add that to the date/time methods like
logical_add(Duration)that adds/subtracts daylight savings hours and leap seconds as needed so if you add a multiple of 24 hours, you’ll get the same wall clock time just on a different day. Maybechronodoes that, IDK, but it would be nice to have day resolution supported at the stdlib level for simple cases where I’m looking for day chunks. It’s not a big deal, andDuration::from_hours(24)is plenty readable.so it should always be defined as a naïve calculation involving fixed definitions for hours per day and seconds per hour.
Well… that’s your opinion. But other people disagree and say that this could be confusing. But I won’t rehash the whole debate, you can read it here instead: https://github.com/rust-lang/rust/issues/120301
I’m sure it’s already been discussed to death 😅
As long as it’s documented well, I don’t think it should matter. If it doesn’t do the thing you expect, don’t use it. I’m assuming there’s almost a 1:1 association between devs who will use
Duration::from_days()wrong and devs who would make their own constants and use them wrong, so the least harmful approach is to make them available and document them clearly.But yeah, this topic has been beaten to death and I’m mostly whining about a bit of typing, which is now substantially less with
Duration::from_hours()being stabilized. I’m happy they stabilized minutes and hours, and I’m hoping they stabilize days at some point.C++ has proven (at great expense) that documenting footguns is not sufficient. At all. You have to make them impossible.
Then make it explicit, e.g.
Duration::from_days_monotonic(...). I’m also fine with just having constants, but those are nightly only. I want a way to clearly express durations in terms of days, and constants and functions are clearer than comments.
The
strict_*set of integer function look interesting though I’m unlikely to use something that panics by design. I’m sure that’s useful in programs that panic to indicate problems. Do those exist? I always treat panics as a design failure.Duration::from_mins()is useful for me since I’ve been doingDuration::from_secs(minutes * 60)for some things in my projects, which bugged me a bit.The non-
strictversions also panic by default, but only in debug mode. So if you were willing to useabs()you should be willing to usestrict_abs().Arguably a bit of a mistake to have the “obvious” function names be surprisingly unsafe, but I guess it’s too late to fix that.
I think this is where safety and performance are actually in conflict.
I think guaranteeing a panic leads to much worse code gen in this case.
Yes that’s true, but the point is you should have to opt in to surprising or risky behaviour.
Those const context additions are neat.
So much excitement here… Dont all talk at once.
User named 1984 wanting us to talk… hmmm
:) Probably right to be careful, im a bit nuts.
