This type represents a PostgreSQL interval. Intervals can have month, day, and microsecond components. Each component is bounded, so they are not arbitrary precision. For more information about intervals, consult the PostgreSQL documentation: https://www.postgresql.org/docs/17/datatype-datetime.html#DATATYPE-INTERVAL-INPUT.

Note that the time library provides several duration types that are not appropriate to use as PostgreSQL intervals:

• NominalDiffTime: Does not handle days or months. Allows up to picosecond precision. Is not bounded.
• CalendarDiffTime: Does not handle days. Embeds a NominalDiffTime. Is not bounded.
• CalendarDiffDays: Does not handle seconds. Is not bounded.

WARNING: The PostgreSQL interval parser is broken in versions prior to 15. It is not possible to round trip all intervals through PostgreSQL on those versions. You should upgrade to at least PostgreSQL version 15. For more information, see this patch: https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=e39f99046

The empty interval, representing no time at all.

>>> zero
MkInterval {months = 0, days = 0, microseconds = 0}

Creates an interval from a number of microseconds.

>>> fromMicroseconds 1
MkInterval {months = 0, days = 0, microseconds = 1}

Creates an interval from a number of milliseconds. Returns Nothing if the interval would overflow.

>>> fromMilliseconds 1
Just (MkInterval {months = 0, days = 0, microseconds = 1000})
>>> fromMilliseconds 9223372036854776
Nothing

Creates an interval from a number of seconds. Returns Nothing if the interval would overflow.

>>> fromSeconds 1
Just (MkInterval {months = 0, days = 0, microseconds = 1000000})
>>> fromSeconds 9223372036855
Nothing

Creates an interval from a number of minutes. Returns Nothing if the interval would overflow.

>>> fromMinutes 1
Just (MkInterval {months = 0, days = 0, microseconds = 60000000})
>>> fromMinutes 153722867281
Nothing

Creates an interval from a number of hours. Returns Nothing if the interval would overflow.

>>> fromHours 1
Just (MkInterval {months = 0, days = 0, microseconds = 3600000000})
>>> fromHours 2562047789
Nothing

Creates an interval from a number of days.

>>> fromDays 1
MkInterval {months = 0, days = 1, microseconds = 0}

Creates an interval from a number of weeks. Returns Nothing if the interval would overflow.

>>> fromWeeks 1
Just (MkInterval {months = 0, days = 7, microseconds = 0})
>>> fromWeeks 306783379
Nothing

Creates an interval from a number of months.

>>> fromMonths 1
MkInterval {months = 1, days = 0, microseconds = 0}

Creates an interval from a number of years. Returns Nothing if the interval would overflow.

>>> fromYears 1
Just (MkInterval {months = 12, days = 0, microseconds = 0})
>>> fromYears 178956971
Nothing

Like fromMilliseconds but uses saturating arithmetic rather than returning Maybe.

>>> fromMillisecondsSaturating 1
MkInterval {months = 0, days = 0, microseconds = 1000}
>>> fromMillisecondsSaturating 9223372036854776
MkInterval {months = 0, days = 0, microseconds = 9223372036854775807}

Like fromSeconds but uses saturating arithmetic rather than returning Maybe.

>>> fromSecondsSaturating 1
MkInterval {months = 0, days = 0, microseconds = 1000000}
>>> fromSecondsSaturating 9223372036855
MkInterval {months = 0, days = 0, microseconds = 9223372036854775807}

Like fromMinutes but uses saturating arithmetic rather than returning Maybe.

>>> fromMinutesSaturating 1
MkInterval {months = 0, days = 0, microseconds = 60000000}
>>> fromMinutesSaturating 153722867281
MkInterval {months = 0, days = 0, microseconds = 9223372036854775807}

Like fromHours but uses saturating arithmetic rather than returning Maybe.

>>> fromHoursSaturating 1
MkInterval {months = 0, days = 0, microseconds = 3600000000}
>>> fromHoursSaturating 2562047789
MkInterval {months = 0, days = 0, microseconds = 9223372036854775807}

Like fromWeeks but uses saturating arithmetic rather than returning Maybe.

>>> fromWeeksSaturating 1
MkInterval {months = 0, days = 7, microseconds = 0}
>>> fromWeeksSaturating 306783379
MkInterval {months = 0, days = 2147483647, microseconds = 0}

Like fromYears but uses saturating arithmetic rather than returning Maybe.

>>> fromYearsSaturating 1
MkInterval {months = 12, days = 0, microseconds = 0}
>>> fromYearsSaturating 178956971
MkInterval {months = 2147483647, days = 0, microseconds = 0}

Like fromMilliseconds but takes a type-level natural number as input. This is useful for writing literals without risk of overflow.

>>> fromMillisecondsLiteral (Proxy :: Proxy 1)
MkInterval {months = 0, days = 0, microseconds = 1000}

Like fromSeconds but takes a type-level natural number as input. This is useful for writing literals without risk of overflow.

>>> fromSecondsLiteral (Proxy :: Proxy 1)
MkInterval {months = 0, days = 0, microseconds = 1000000}

Like fromMinutes but takes a type-level natural number as input. This is useful for writing literals without risk of overflow.

>>> fromMinutesLiteral (Proxy :: Proxy 1)
MkInterval {months = 0, days = 0, microseconds = 60000000}

Like fromHours but takes a type-level natural number as input. This is useful for writing literals without risk of overflow.

>>> fromHoursLiteral (Proxy :: Proxy 1)
MkInterval {months = 0, days = 0, microseconds = 3600000000}

Like fromWeeks but takes a type-level natural number as input. This is useful for writing literals without risk of overflow.

>>> fromWeeksLiteral (Proxy :: Proxy 1)
MkInterval {months = 0, days = 7, microseconds = 0}

Like fromYears but takes a type-level natural number as input. This is useful for writing literals without risk of overflow.

>>> fromYearsLiteral (Proxy :: Proxy 1)
MkInterval {months = 12, days = 0, microseconds = 0}

Negates an interval. Returns Nothing if the result would overflow.

>>> negate (MkInterval 1 2 3)
Just (MkInterval {months = -1, days = -2, microseconds = -3})
>>> negate (MkInterval (-2147483648) 0 0)
Nothing

Like negate but uses saturating arithmetic rather than returning Maybe.

>>> negateSaturating (MkInterval 1 2 3)
MkInterval {months = -1, days = -2, microseconds = -3}
>>> negateSaturating (MkInterval (-2147483648) 0 0)
MkInterval {months = 2147483647, days = 0, microseconds = 0}

Adds two intervals. Returns Nothing if the result would overflow.

>>> add (fromMonths 1) (fromDays 2)
Just (MkInterval {months = 1, days = 2, microseconds = 0})
>>> add (fromDays 2147483647) (fromDays 1)
Nothing

Like add but uses saturating arithmetic rather than returning Maybe.

>>> addSaturating (fromMonths 1) (fromDays 2)
MkInterval {months = 1, days = 2, microseconds = 0}
>>> addSaturating (fromDays 2147483647) (fromDays 1)
MkInterval {months = 0, days = 2147483647, microseconds = 0}