unit

Units to be shared by the Period and Duration APIs.

Types

Unit

pub type Unit {
  Year
  Month
  Week
  Day
  Hour
  CalculatedYear(years: Int, nanoseconds: Int)
  CalculatedMonth(months: Int, nanoseconds: Int)
  Minute
  Second
  Millisecond
  Microsecond
  Nanosecond
  Nothing
}

Constructors

```
Year
```
```
Month
```
```
Week
```
```
Day
```
```
Hour
```

CalculatedYear(years: Int, nanoseconds: Int)

CalculatedMonth(months: Int, nanoseconds: Int)

```
Minute
```
```
Second
```
```
Millisecond
```
```
Microsecond
```
```
Nanosecond
```
```
Nothing
```

Constants

hour_nanoseconds

</>

pub const hour_nanoseconds: Int

imprecise_day_nanoseconds

</>

pub const imprecise_day_nanoseconds: Int

imprecise_month_nanoseconds

</>

pub const imprecise_month_nanoseconds: Int

imprecise_week_nanoseconds

</>

pub const imprecise_week_nanoseconds: Int

imprecise_year_nanoseconds

</>

pub const imprecise_year_nanoseconds: Int

microsecond_nanoseconds

</>

pub const microsecond_nanoseconds: Int

millisecond_nanoseconds

</>

pub const millisecond_nanoseconds: Int

minute_nanoseconds

</>

pub const minute_nanoseconds: Int

second_nanoseconds

</>

pub const second_nanoseconds: Int

Functions

as_days_fractional

</>

pub fn as_days_fractional(nanoseconds: Int) -> Float

as_days_imprecise

</>

pub fn as_days_imprecise(nanoseconds: Int) -> Int

as_hours

</>

pub fn as_hours(nanoseconds: Int) -> Int

as_hours_fractional

</>

pub fn as_hours_fractional(nanoseconds: Int) -> Float

as_microseconds

</>

pub fn as_microseconds(nanoseconds: Int) -> Int

as_microseconds_fractional

</>

pub fn as_microseconds_fractional(nanoseconds: Int) -> Float

as_milliseconds

</>

pub fn as_milliseconds(nanoseconds: Int) -> Int

as_milliseconds_fractional

</>

pub fn as_milliseconds_fractional(nanoseconds: Int) -> Float

as_minutes

</>

pub fn as_minutes(nanoseconds: Int) -> Int

as_minutes_fractional

</>

pub fn as_minutes_fractional(nanoseconds: Int) -> Float

as_months_imprecise

</>

pub fn as_months_imprecise(nanoseconds: Int) -> Int

as_months_imprecise_fractional

</>

pub fn as_months_imprecise_fractional(nanoseconds: Int) -> Float

as_nanoseconds

</>

pub fn as_nanoseconds(nanoseconds: Int) -> Int

as_seconds

</>

pub fn as_seconds(nanoseconds: Int) -> Int

as_seconds_fractional

</>

pub fn as_seconds_fractional(nanoseconds: Int) -> Float

as_unit

</>

pub fn as_unit(nanoseconds: Int, unit: Unit) -> Int

as_unit_fractional

</>

pub fn as_unit_fractional(nanoseconds: Int, unit: Unit) -> Float

as_weeks_imprecise

</>

pub fn as_weeks_imprecise(nanoseconds: Int) -> Int

as_weeks_imprecise_fractional

</>

pub fn as_weeks_imprecise_fractional(nanoseconds: Int) -> Float

as_years_imprecise

</>

pub fn as_years_imprecise(nanoseconds: Int) -> Int

as_years_imprecise_fractional

</>

pub fn as_years_imprecise_fractional(nanoseconds: Int) -> Float

format_as

</>

pub fn format_as(
  nanoseconds: Int,
  unit unit: Unit,
  decimals decimals: Int,
) -> String

format_as_many

</>

pub fn format_as_many(
  nanoseconds: Int,
  units units: List(Unit),
  decimals decimals: Int,
) -> String

hours

</>

pub fn hours(hours: Int) -> Int

imprecise_days

</>

pub fn imprecise_days(days: Int) -> Int

imprecise_months

</>

pub fn imprecise_months(months: Int) -> Int

imprecise_weeks

</>

pub fn imprecise_weeks(weeks: Int) -> Int

imprecise_years

</>

pub fn imprecise_years(years: Int) -> Int

in_nanoseconds

</>

pub fn in_nanoseconds(unit: Unit) -> Int

microseconds

</>

pub fn microseconds(microseconds: Int) -> Int

milliseconds

</>

pub fn milliseconds(milliseconds: Int) -> Int

minutes

</>

pub fn minutes(minutes: Int) -> Int

nanoseconds

</>

pub fn nanoseconds(nanoseconds: Int) -> Int

seconds

</>

pub fn seconds(seconds: Int) -> Int

unit_to_string

</>

pub fn unit_to_string(unit: Unit) -> String