birl/duration

Types

Duration

pub type Duration {
  Duration(Int)
}

Constructors

```
Duration(Int)
```

Unit

</>

pub type Unit {
  MicroSecond
  MilliSecond
  Second
  Minute
  Hour
  Day
  Week
  Month
  Year
}

Constructors

```
MicroSecond
```
```
MilliSecond
```
```
Second
```
```
Minute
```
```
Hour
```
```
Day
```
```
Week
```
```
Month
```
```
Year
```

Values

accurate_decompose

</>

pub fn accurate_decompose(
  duration: Duration,
) -> List(#(Int, Unit))

use this if you need very long durations where small inaccuracies could lead to large errors

accurate_new

</>

pub fn accurate_new(values: List(#(Int, Unit))) -> Duration

use this if you need very long durations where small inaccuracies could lead to large errors

add

</>

pub fn add(a: Duration, b: Duration) -> Duration

blur

</>

pub fn blur(duration: Duration) -> #(Int, Unit)

approximates the duration by a value in a single unit

blur_to

</>

pub fn blur_to(duration: Duration, unit: Unit) -> Int

approximates the duration by only the given unit

if the duration is not an integer multiple of the unit, the remainder will be disgarded if it’s less than two thirds of the unit, otherwise a single unit will be added to the multiplier.

blur_to(days(16), Month) -> 0
blur_to(days(20), Month) -> 1

compare

</>

pub fn compare(a: Duration, b: Duration) -> order.Order

days

</>

pub fn days(value: Int) -> Duration

decompose

</>

pub fn decompose(duration: Duration) -> List(#(Int, Unit))

use this if you need short durations where a year just means 365 days and a month just means 30 days

from_gleam_duration

</>

pub fn from_gleam_duration(d: duration.Duration) -> Duration

Convert gleam_time Duration to birl Duration.

gleam_time uses nanoseconds internally, while birl uses microseconds. Sub-microsecond precision will be lost.

hours

</>

pub fn hours(value: Int) -> Duration

micro_seconds

</>

pub fn micro_seconds(value: Int) -> Duration

milli_seconds

</>

pub fn milli_seconds(value: Int) -> Duration

minutes

</>

pub fn minutes(value: Int) -> Duration

months

</>

pub fn months(value: Int) -> Duration

new

</>

pub fn new(values: List(#(Int, Unit))) -> Duration

use this if you need short durations where a year just means 365 days and a month just means 30 days

parse

</>

pub fn parse(expression: String) -> Result(Duration, Nil)

you can use this function to create a new duration using expressions like:

"accurate: 1 Year - 2days + 152M -1h + 25 years + 25secs"

where the units are:

Year:         y, Y, YEAR, years, Years, ...

Month:        mon, Month, mONths, ...

Week:         w, W, Week, weeks, ...

Day:          d, D, day, Days, ...

Hour:         h, H, Hour, Hours, ...

Minute:       m, M, Min, minute, Minutes, ...

Second:       s, S, sec, Secs, second, Seconds, ...

MilliSecond:  ms, Msec, mSecs, milliSecond, MilliSecond, ...

numbers with no unit are considered as microseconds. specifying accurate: is equivalent to using accurate_new.

scale_down

</>

pub fn scale_down(value: Duration, factor: Int) -> Duration

scale_up

</>

pub fn scale_up(value: Duration, factor: Int) -> Duration

seconds

</>

pub fn seconds(value: Int) -> Duration

subtract

</>

pub fn subtract(a: Duration, b: Duration) -> Duration

to_gleam_duration

</>

pub fn to_gleam_duration(d: Duration) -> duration.Duration

Convert birl Duration to gleam_time Duration.

birl uses microseconds internally, while gleam_time uses nanoseconds.

weeks

</>

pub fn weeks(value: Int) -> Duration

years

</>

pub fn years(value: Int) -> Duration