Std.Time.Date.Basic

source

@[inline]

def Std.Time.Nanosecond.Offset.toDays (nanoseconds : Std.Time.Nanosecond.Offset) :

Std.Time.Day.Offset

Convert Nanosecond.Offset into Day.Offset.

Equations

nanoseconds.toDays = Std.Time.Internal.UnitVal.div nanoseconds 86400000000000

Instances For

source

@[inline]

def Std.Time.Nanosecond.Offset.ofDays (days : Std.Time.Day.Offset) :

Std.Time.Nanosecond.Offset

Convert Day.Offset into Nanosecond.Offset.

Equations

Std.Time.Nanosecond.Offset.ofDays days = Std.Time.Internal.UnitVal.mul days 86400000000000

Instances For

source

@[inline]

def Std.Time.Nanosecond.Offset.toWeeks (nanoseconds : Std.Time.Nanosecond.Offset) :

Std.Time.Week.Offset

Convert Nanosecond.Offset into Week.Offset.

Equations

nanoseconds.toWeeks = Std.Time.Internal.UnitVal.div nanoseconds 604800000000000

Instances For

source

@[inline]

def Std.Time.Nanosecond.Offset.ofWeeks (weeks : Std.Time.Week.Offset) :

Std.Time.Nanosecond.Offset

Convert Week.Offset into Nanosecond.Offset.

Equations

Std.Time.Nanosecond.Offset.ofWeeks weeks = Std.Time.Internal.UnitVal.mul weeks 604800000000000

Instances For

source

@[inline]

def Std.Time.Millisecond.Offset.toDays (milliseconds : Std.Time.Millisecond.Offset) :

Std.Time.Day.Offset

Convert Millisecond.Offset into Day.Offset.

Equations

milliseconds.toDays = Std.Time.Internal.UnitVal.div milliseconds 86400000

Instances For

source

@[inline]

def Std.Time.Millisecond.Offset.ofDays (days : Std.Time.Day.Offset) :

Std.Time.Millisecond.Offset

Convert Day.Offset into Millisecond.Offset.

Equations

Std.Time.Millisecond.Offset.ofDays days = Std.Time.Internal.UnitVal.mul days 86400000

Instances For

source

@[inline]

def Std.Time.Millisecond.Offset.toWeeks (milliseconds : Std.Time.Millisecond.Offset) :

Std.Time.Week.Offset

Convert Millisecond.Offset into Week.Offset.

Equations

milliseconds.toWeeks = Std.Time.Internal.UnitVal.div milliseconds 604800000

Instances For

source

@[inline]

def Std.Time.Millisecond.Offset.ofWeeks (weeks : Std.Time.Week.Offset) :

Std.Time.Millisecond.Offset

Convert Week.Offset into Millisecond.Offset.

Equations

Std.Time.Millisecond.Offset.ofWeeks weeks = Std.Time.Internal.UnitVal.mul weeks 604800000

Instances For

source

@[inline]

def Std.Time.Second.Offset.toDays (seconds : Std.Time.Second.Offset) :

Std.Time.Day.Offset

Convert Second.Offset into Day.Offset.

Equations

seconds.toDays = Std.Time.Internal.UnitVal.div seconds 86400

Instances For

source

@[inline]

def Std.Time.Second.Offset.ofDays (days : Std.Time.Day.Offset) :

Std.Time.Second.Offset

Convert Day.Offset into Second.Offset.

Equations

Std.Time.Second.Offset.ofDays days = Std.Time.Internal.UnitVal.mul days 86400

Instances For

source

@[inline]

def Std.Time.Second.Offset.toWeeks (seconds : Std.Time.Second.Offset) :

Std.Time.Week.Offset

Convert Second.Offset into Week.Offset.

Equations

seconds.toWeeks = Std.Time.Internal.UnitVal.div seconds 604800

Instances For

source

@[inline]

def Std.Time.Second.Offset.ofWeeks (weeks : Std.Time.Week.Offset) :

Std.Time.Second.Offset

Convert Week.Offset into Second.Offset.

Equations

Std.Time.Second.Offset.ofWeeks weeks = Std.Time.Internal.UnitVal.mul weeks 604800

Instances For

source

@[inline]

def Std.Time.Minute.Offset.toDays (minutes : Std.Time.Minute.Offset) :

Std.Time.Day.Offset

Convert Minute.Offset into Day.Offset.

Equations

minutes.toDays = Std.Time.Internal.UnitVal.div minutes 1440

Instances For

source

@[inline]

def Std.Time.Minute.Offset.ofDays (days : Std.Time.Day.Offset) :

Std.Time.Minute.Offset

Convert Day.Offset into Minute.Offset.

Equations

Std.Time.Minute.Offset.ofDays days = Std.Time.Internal.UnitVal.mul days 1440

Instances For

source

@[inline]

def Std.Time.Minute.Offset.toWeeks (minutes : Std.Time.Minute.Offset) :

Std.Time.Week.Offset

Convert Minute.Offset into Week.Offset.

Equations

minutes.toWeeks = Std.Time.Internal.UnitVal.div minutes 10080

Instances For

source

@[inline]

def Std.Time.Minute.Offset.ofWeeks (weeks : Std.Time.Week.Offset) :

Std.Time.Minute.Offset

Convert Week.Offset into Minute.Offset.

Equations

Std.Time.Minute.Offset.ofWeeks weeks = Std.Time.Internal.UnitVal.mul weeks 10080

Instances For

source

@[inline]

def Std.Time.Hour.Offset.toDays (hours : Std.Time.Hour.Offset) :

Std.Time.Day.Offset

Convert Hour.Offset into Day.Offset.

Equations

hours.toDays = Std.Time.Internal.UnitVal.div hours 24

Instances For

source

@[inline]

def Std.Time.Hour.Offset.ofDays (days : Std.Time.Day.Offset) :

Std.Time.Hour.Offset

Convert Day.Offset into Hour.Offset.

Equations

Std.Time.Hour.Offset.ofDays days = Std.Time.Internal.UnitVal.mul days 24

Instances For

source

@[inline]

def Std.Time.Hour.Offset.toWeeks (hours : Std.Time.Hour.Offset) :

Std.Time.Week.Offset

Convert Hour.Offset into Week.Offset.

Equations

hours.toWeeks = Std.Time.Internal.UnitVal.div hours 168

Instances For

source

@[inline]

def Std.Time.Hour.Offset.ofWeeks (weeks : Std.Time.Week.Offset) :

Std.Time.Hour.Offset

Convert Week.Offset into Hour.Offset.

Equations

Std.Time.Hour.Offset.ofWeeks weeks = Std.Time.Internal.UnitVal.mul weeks 168

Instances For

source

instance Std.Time.instHAddOffset :

HAdd Std.Time.Nanosecond.Offset Std.Time.Nanosecond.Offset Std.Time.Nanosecond.Offset

Equations

Std.Time.instHAddOffset = { hAdd := fun (x y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.add x y }

source

instance Std.Time.instHAddOffsetOffset :

HAdd Std.Time.Nanosecond.Offset Std.Time.Millisecond.Offset Std.Time.Nanosecond.Offset

Equations

Std.Time.instHAddOffsetOffset = { hAdd := fun (x : Std.Time.Nanosecond.Offset) (y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.add x y.toNanoseconds }

source

instance Std.Time.instHAddOffsetOffset_1 :

HAdd Std.Time.Nanosecond.Offset Std.Time.Second.Offset Std.Time.Nanosecond.Offset

Equations

Std.Time.instHAddOffsetOffset_1 = { hAdd := fun (x : Std.Time.Nanosecond.Offset) (y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.add x y.toNanoseconds }

source

instance Std.Time.instHAddOffsetOffset_2 :

HAdd Std.Time.Nanosecond.Offset Std.Time.Minute.Offset Std.Time.Nanosecond.Offset

Equations

Std.Time.instHAddOffsetOffset_2 = { hAdd := fun (x : Std.Time.Nanosecond.Offset) (y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.add x y.toNanoseconds }

source

instance Std.Time.instHAddOffsetOffset_3 :

HAdd Std.Time.Nanosecond.Offset Std.Time.Hour.Offset Std.Time.Nanosecond.Offset

Equations

Std.Time.instHAddOffsetOffset_3 = { hAdd := fun (x : Std.Time.Nanosecond.Offset) (y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.add x y.toNanoseconds }

source

instance Std.Time.instHAddOffsetOffset_4 :

HAdd Std.Time.Nanosecond.Offset Std.Time.Day.Offset Std.Time.Nanosecond.Offset

Equations

Std.Time.instHAddOffsetOffset_4 = { hAdd := fun (x : Std.Time.Nanosecond.Offset) (y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.add x y.toNanoseconds }

source

instance Std.Time.instHAddOffsetOffset_5 :

HAdd Std.Time.Nanosecond.Offset Std.Time.Week.Offset Std.Time.Nanosecond.Offset

Equations

Std.Time.instHAddOffsetOffset_5 = { hAdd := fun (x : Std.Time.Nanosecond.Offset) (y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.add x y.toNanoseconds }

source

instance Std.Time.instHAddOffsetOffset_6 :

HAdd Std.Time.Millisecond.Offset Std.Time.Nanosecond.Offset Std.Time.Nanosecond.Offset

Equations

Std.Time.instHAddOffsetOffset_6 = { hAdd := fun (x : Std.Time.Millisecond.Offset) (y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.add x.toNanoseconds y }

source

instance Std.Time.instHAddOffset_1 :

HAdd Std.Time.Millisecond.Offset Std.Time.Millisecond.Offset Std.Time.Millisecond.Offset

Equations

Std.Time.instHAddOffset_1 = { hAdd := fun (x y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.add x y }

source

instance Std.Time.instHAddOffsetOffset_7 :

HAdd Std.Time.Millisecond.Offset Std.Time.Second.Offset Std.Time.Millisecond.Offset

Equations

Std.Time.instHAddOffsetOffset_7 = { hAdd := fun (x : Std.Time.Millisecond.Offset) (y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.add x y.toMilliseconds }

source

instance Std.Time.instHAddOffsetOffset_8 :

HAdd Std.Time.Millisecond.Offset Std.Time.Minute.Offset Std.Time.Millisecond.Offset

Equations

Std.Time.instHAddOffsetOffset_8 = { hAdd := fun (x : Std.Time.Millisecond.Offset) (y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.add x y.toMilliseconds }

source

instance Std.Time.instHAddOffsetOffset_9 :

HAdd Std.Time.Millisecond.Offset Std.Time.Hour.Offset Std.Time.Millisecond.Offset

Equations

Std.Time.instHAddOffsetOffset_9 = { hAdd := fun (x : Std.Time.Millisecond.Offset) (y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.add x y.toMilliseconds }

source

instance Std.Time.instHAddOffsetOffset_10 :

HAdd Std.Time.Millisecond.Offset Std.Time.Day.Offset Std.Time.Millisecond.Offset

Equations

Std.Time.instHAddOffsetOffset_10 = { hAdd := fun (x : Std.Time.Millisecond.Offset) (y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.add x y.toMilliseconds }

source

instance Std.Time.instHAddOffsetOffset_11 :

HAdd Std.Time.Millisecond.Offset Std.Time.Week.Offset Std.Time.Millisecond.Offset

Equations

Std.Time.instHAddOffsetOffset_11 = { hAdd := fun (x : Std.Time.Millisecond.Offset) (y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.add x y.toMilliseconds }

source

instance Std.Time.instHAddOffsetOffset_12 :

HAdd Std.Time.Second.Offset Std.Time.Nanosecond.Offset Std.Time.Nanosecond.Offset

Equations

Std.Time.instHAddOffsetOffset_12 = { hAdd := fun (x : Std.Time.Second.Offset) (y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.add x.toNanoseconds y }

source

instance Std.Time.instHAddOffsetOffset_13 :

HAdd Std.Time.Second.Offset Std.Time.Millisecond.Offset Std.Time.Millisecond.Offset

Equations

Std.Time.instHAddOffsetOffset_13 = { hAdd := fun (x : Std.Time.Second.Offset) (y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.add x.toMilliseconds y }

source

instance Std.Time.instHAddOffset_2 :

HAdd Std.Time.Second.Offset Std.Time.Second.Offset Std.Time.Second.Offset

Equations

Std.Time.instHAddOffset_2 = { hAdd := fun (x y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.add x y }

source

instance Std.Time.instHAddOffsetOffset_14 :

HAdd Std.Time.Second.Offset Std.Time.Minute.Offset Std.Time.Second.Offset

Equations

Std.Time.instHAddOffsetOffset_14 = { hAdd := fun (x : Std.Time.Second.Offset) (y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.add x y.toSeconds }

source

instance Std.Time.instHAddOffsetOffset_15 :

HAdd Std.Time.Second.Offset Std.Time.Hour.Offset Std.Time.Second.Offset

Equations

Std.Time.instHAddOffsetOffset_15 = { hAdd := fun (x : Std.Time.Second.Offset) (y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.add x y.toSeconds }

source

instance Std.Time.instHAddOffsetOffset_16 :

HAdd Std.Time.Second.Offset Std.Time.Day.Offset Std.Time.Second.Offset

Equations

Std.Time.instHAddOffsetOffset_16 = { hAdd := fun (x : Std.Time.Second.Offset) (y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.add x y.toSeconds }

source

instance Std.Time.instHAddOffsetOffset_17 :

HAdd Std.Time.Second.Offset Std.Time.Week.Offset Std.Time.Second.Offset

Equations

Std.Time.instHAddOffsetOffset_17 = { hAdd := fun (x : Std.Time.Second.Offset) (y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.add x y.toSeconds }

source

instance Std.Time.instHAddOffsetOffset_18 :

HAdd Std.Time.Minute.Offset Std.Time.Nanosecond.Offset Std.Time.Nanosecond.Offset

Equations

Std.Time.instHAddOffsetOffset_18 = { hAdd := fun (x : Std.Time.Minute.Offset) (y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.add x.toNanoseconds y }

source

instance Std.Time.instHAddOffsetOffset_19 :

HAdd Std.Time.Minute.Offset Std.Time.Millisecond.Offset Std.Time.Millisecond.Offset

Equations

Std.Time.instHAddOffsetOffset_19 = { hAdd := fun (x : Std.Time.Minute.Offset) (y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.add x.toMilliseconds y }

source

instance Std.Time.instHAddOffsetOffset_20 :

HAdd Std.Time.Minute.Offset Std.Time.Second.Offset Std.Time.Second.Offset

Equations

Std.Time.instHAddOffsetOffset_20 = { hAdd := fun (x : Std.Time.Minute.Offset) (y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.add x.toSeconds y }

source

instance Std.Time.instHAddOffset_3 :

HAdd Std.Time.Minute.Offset Std.Time.Minute.Offset Std.Time.Minute.Offset

Equations

Std.Time.instHAddOffset_3 = { hAdd := fun (x y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.add x y }

source

instance Std.Time.instHAddOffsetOffset_21 :

HAdd Std.Time.Minute.Offset Std.Time.Hour.Offset Std.Time.Minute.Offset

Equations

Std.Time.instHAddOffsetOffset_21 = { hAdd := fun (x : Std.Time.Minute.Offset) (y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.add x y.toMinutes }

source

instance Std.Time.instHAddOffsetOffset_22 :

HAdd Std.Time.Minute.Offset Std.Time.Day.Offset Std.Time.Minute.Offset

Equations

Std.Time.instHAddOffsetOffset_22 = { hAdd := fun (x : Std.Time.Minute.Offset) (y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.add x y.toMinutes }

source

instance Std.Time.instHAddOffsetOffset_23 :

HAdd Std.Time.Minute.Offset Std.Time.Week.Offset Std.Time.Minute.Offset

Equations

Std.Time.instHAddOffsetOffset_23 = { hAdd := fun (x : Std.Time.Minute.Offset) (y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.add x y.toMinutes }

source

instance Std.Time.instHAddOffsetOffset_24 :

HAdd Std.Time.Hour.Offset Std.Time.Nanosecond.Offset Std.Time.Nanosecond.Offset

Equations

Std.Time.instHAddOffsetOffset_24 = { hAdd := fun (x : Std.Time.Hour.Offset) (y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.add x.toNanoseconds y }

source

instance Std.Time.instHAddOffsetOffset_25 :

HAdd Std.Time.Hour.Offset Std.Time.Millisecond.Offset Std.Time.Millisecond.Offset

Equations

Std.Time.instHAddOffsetOffset_25 = { hAdd := fun (x : Std.Time.Hour.Offset) (y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.add x.toMilliseconds y }

source

instance Std.Time.instHAddOffsetOffset_26 :

HAdd Std.Time.Hour.Offset Std.Time.Second.Offset Std.Time.Second.Offset

Equations

Std.Time.instHAddOffsetOffset_26 = { hAdd := fun (x : Std.Time.Hour.Offset) (y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.add x.toSeconds y }

source

instance Std.Time.instHAddOffsetOffset_27 :

HAdd Std.Time.Hour.Offset Std.Time.Minute.Offset Std.Time.Minute.Offset

Equations

Std.Time.instHAddOffsetOffset_27 = { hAdd := fun (x : Std.Time.Hour.Offset) (y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.add x.toMinutes y }

source

instance Std.Time.instHAddOffset_4 :

HAdd Std.Time.Hour.Offset Std.Time.Hour.Offset Std.Time.Hour.Offset

Equations

Std.Time.instHAddOffset_4 = { hAdd := fun (x y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.add x y }

source

instance Std.Time.instHAddOffsetOffset_28 :

HAdd Std.Time.Hour.Offset Std.Time.Day.Offset Std.Time.Hour.Offset

Equations

Std.Time.instHAddOffsetOffset_28 = { hAdd := fun (x : Std.Time.Hour.Offset) (y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.add x y.toHours }

source

instance Std.Time.instHAddOffsetOffset_29 :

HAdd Std.Time.Hour.Offset Std.Time.Week.Offset Std.Time.Hour.Offset

Equations

Std.Time.instHAddOffsetOffset_29 = { hAdd := fun (x : Std.Time.Hour.Offset) (y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.add x y.toHours }

source

instance Std.Time.instHAddOffsetOffset_30 :

HAdd Std.Time.Day.Offset Std.Time.Nanosecond.Offset Std.Time.Nanosecond.Offset

Equations

Std.Time.instHAddOffsetOffset_30 = { hAdd := fun (x : Std.Time.Day.Offset) (y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.add x.toNanoseconds y }

source

instance Std.Time.instHAddOffsetOffset_31 :

HAdd Std.Time.Day.Offset Std.Time.Millisecond.Offset Std.Time.Millisecond.Offset

Equations

Std.Time.instHAddOffsetOffset_31 = { hAdd := fun (x : Std.Time.Day.Offset) (y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.add x.toMilliseconds y }

source

instance Std.Time.instHAddOffsetOffset_32 :

HAdd Std.Time.Day.Offset Std.Time.Second.Offset Std.Time.Second.Offset

Equations

Std.Time.instHAddOffsetOffset_32 = { hAdd := fun (x : Std.Time.Day.Offset) (y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.add x.toSeconds y }

source

instance Std.Time.instHAddOffsetOffset_33 :

HAdd Std.Time.Day.Offset Std.Time.Minute.Offset Std.Time.Minute.Offset

Equations

Std.Time.instHAddOffsetOffset_33 = { hAdd := fun (x : Std.Time.Day.Offset) (y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.add x.toMinutes y }

source

instance Std.Time.instHAddOffsetOffset_34 :

HAdd Std.Time.Day.Offset Std.Time.Hour.Offset Std.Time.Hour.Offset

Equations

Std.Time.instHAddOffsetOffset_34 = { hAdd := fun (x : Std.Time.Day.Offset) (y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.add x.toHours y }

source

instance Std.Time.instHAddOffset_5 :

HAdd Std.Time.Day.Offset Std.Time.Day.Offset Std.Time.Day.Offset

Equations

Std.Time.instHAddOffset_5 = { hAdd := fun (x y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.add x y }

source

instance Std.Time.instHAddOffsetOffset_35 :

HAdd Std.Time.Day.Offset Std.Time.Week.Offset Std.Time.Day.Offset

Equations

Std.Time.instHAddOffsetOffset_35 = { hAdd := fun (x : Std.Time.Day.Offset) (y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.add x y.toDays }

source

instance Std.Time.instHAddOffsetOffset_36 :

HAdd Std.Time.Week.Offset Std.Time.Nanosecond.Offset Std.Time.Nanosecond.Offset

Equations

Std.Time.instHAddOffsetOffset_36 = { hAdd := fun (x : Std.Time.Week.Offset) (y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.add x.toNanoseconds y }

source

instance Std.Time.instHAddOffsetOffset_37 :

HAdd Std.Time.Week.Offset Std.Time.Millisecond.Offset Std.Time.Millisecond.Offset

Equations

Std.Time.instHAddOffsetOffset_37 = { hAdd := fun (x : Std.Time.Week.Offset) (y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.add x.toMilliseconds y }

source

instance Std.Time.instHAddOffsetOffset_38 :

HAdd Std.Time.Week.Offset Std.Time.Second.Offset Std.Time.Second.Offset

Equations

Std.Time.instHAddOffsetOffset_38 = { hAdd := fun (x : Std.Time.Week.Offset) (y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.add x.toSeconds y }

source

instance Std.Time.instHAddOffsetOffset_39 :

HAdd Std.Time.Week.Offset Std.Time.Minute.Offset Std.Time.Minute.Offset

Equations

Std.Time.instHAddOffsetOffset_39 = { hAdd := fun (x : Std.Time.Week.Offset) (y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.add x.toMinutes y }

source

instance Std.Time.instHAddOffsetOffset_40 :

HAdd Std.Time.Week.Offset Std.Time.Hour.Offset Std.Time.Hour.Offset

Equations

Std.Time.instHAddOffsetOffset_40 = { hAdd := fun (x : Std.Time.Week.Offset) (y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.add x.toHours y }

source

instance Std.Time.instHAddOffsetOffset_41 :

HAdd Std.Time.Week.Offset Std.Time.Day.Offset Std.Time.Day.Offset

Equations

Std.Time.instHAddOffsetOffset_41 = { hAdd := fun (x : Std.Time.Week.Offset) (y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.add x.toDays y }

source

instance Std.Time.instHAddOffset_6 :

HAdd Std.Time.Week.Offset Std.Time.Week.Offset Std.Time.Week.Offset

Equations

Std.Time.instHAddOffset_6 = { hAdd := fun (x y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.add x y }

source

instance Std.Time.instHSubOffset :

HSub Std.Time.Nanosecond.Offset Std.Time.Nanosecond.Offset Std.Time.Nanosecond.Offset

Equations

Std.Time.instHSubOffset = { hSub := fun (x y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.sub x y }

source

instance Std.Time.instHSubOffsetOffset :

HSub Std.Time.Nanosecond.Offset Std.Time.Millisecond.Offset Std.Time.Nanosecond.Offset

Equations

Std.Time.instHSubOffsetOffset = { hSub := fun (x : Std.Time.Nanosecond.Offset) (y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.sub x y.toNanoseconds }

source

instance Std.Time.instHSubOffsetOffset_1 :

HSub Std.Time.Nanosecond.Offset Std.Time.Second.Offset Std.Time.Nanosecond.Offset

Equations

Std.Time.instHSubOffsetOffset_1 = { hSub := fun (x : Std.Time.Nanosecond.Offset) (y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.sub x y.toNanoseconds }

source

instance Std.Time.instHSubOffsetOffset_2 :

HSub Std.Time.Nanosecond.Offset Std.Time.Minute.Offset Std.Time.Nanosecond.Offset

Equations

Std.Time.instHSubOffsetOffset_2 = { hSub := fun (x : Std.Time.Nanosecond.Offset) (y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.sub x y.toNanoseconds }

source

instance Std.Time.instHSubOffsetOffset_3 :

HSub Std.Time.Nanosecond.Offset Std.Time.Hour.Offset Std.Time.Nanosecond.Offset

Equations

Std.Time.instHSubOffsetOffset_3 = { hSub := fun (x : Std.Time.Nanosecond.Offset) (y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.sub x y.toNanoseconds }

source

instance Std.Time.instHSubOffsetOffset_4 :

HSub Std.Time.Nanosecond.Offset Std.Time.Day.Offset Std.Time.Nanosecond.Offset

Equations

Std.Time.instHSubOffsetOffset_4 = { hSub := fun (x : Std.Time.Nanosecond.Offset) (y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.sub x y.toNanoseconds }

source

instance Std.Time.instHSubOffsetOffset_5 :

HSub Std.Time.Nanosecond.Offset Std.Time.Week.Offset Std.Time.Nanosecond.Offset

Equations

Std.Time.instHSubOffsetOffset_5 = { hSub := fun (x : Std.Time.Nanosecond.Offset) (y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.sub x y.toNanoseconds }

source

instance Std.Time.instHSubOffsetOffset_6 :

HSub Std.Time.Millisecond.Offset Std.Time.Nanosecond.Offset Std.Time.Nanosecond.Offset

Equations

Std.Time.instHSubOffsetOffset_6 = { hSub := fun (x : Std.Time.Millisecond.Offset) (y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.sub x.toNanoseconds y }

source

instance Std.Time.instHSubOffset_1 :

HSub Std.Time.Millisecond.Offset Std.Time.Millisecond.Offset Std.Time.Millisecond.Offset

Equations

Std.Time.instHSubOffset_1 = { hSub := fun (x y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.sub x y }

source

instance Std.Time.instHSubOffsetOffset_7 :

HSub Std.Time.Millisecond.Offset Std.Time.Second.Offset Std.Time.Millisecond.Offset

Equations

Std.Time.instHSubOffsetOffset_7 = { hSub := fun (x : Std.Time.Millisecond.Offset) (y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.sub x y.toMilliseconds }

source

instance Std.Time.instHSubOffsetOffset_8 :

HSub Std.Time.Millisecond.Offset Std.Time.Minute.Offset Std.Time.Millisecond.Offset

Equations

Std.Time.instHSubOffsetOffset_8 = { hSub := fun (x : Std.Time.Millisecond.Offset) (y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.sub x y.toMilliseconds }

source

instance Std.Time.instHSubOffsetOffset_9 :

HSub Std.Time.Millisecond.Offset Std.Time.Hour.Offset Std.Time.Millisecond.Offset

Equations

Std.Time.instHSubOffsetOffset_9 = { hSub := fun (x : Std.Time.Millisecond.Offset) (y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.sub x y.toMilliseconds }

source

instance Std.Time.instHSubOffsetOffset_10 :

HSub Std.Time.Millisecond.Offset Std.Time.Day.Offset Std.Time.Millisecond.Offset

Equations

Std.Time.instHSubOffsetOffset_10 = { hSub := fun (x : Std.Time.Millisecond.Offset) (y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.sub x y.toMilliseconds }

source

instance Std.Time.instHSubOffsetOffset_11 :

HSub Std.Time.Millisecond.Offset Std.Time.Week.Offset Std.Time.Millisecond.Offset

Equations

Std.Time.instHSubOffsetOffset_11 = { hSub := fun (x : Std.Time.Millisecond.Offset) (y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.sub x y.toMilliseconds }

source

instance Std.Time.instHSubOffsetOffset_12 :

HSub Std.Time.Second.Offset Std.Time.Nanosecond.Offset Std.Time.Nanosecond.Offset

Equations

Std.Time.instHSubOffsetOffset_12 = { hSub := fun (x : Std.Time.Second.Offset) (y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.sub x.toNanoseconds y }

source

instance Std.Time.instHSubOffsetOffset_13 :

HSub Std.Time.Second.Offset Std.Time.Millisecond.Offset Std.Time.Millisecond.Offset

Equations

Std.Time.instHSubOffsetOffset_13 = { hSub := fun (x : Std.Time.Second.Offset) (y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.sub x.toMilliseconds y }

source

instance Std.Time.instHSubOffset_2 :

HSub Std.Time.Second.Offset Std.Time.Second.Offset Std.Time.Second.Offset

Equations

Std.Time.instHSubOffset_2 = { hSub := fun (x y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.sub x y }

source

instance Std.Time.instHSubOffsetOffset_14 :

HSub Std.Time.Second.Offset Std.Time.Minute.Offset Std.Time.Second.Offset

Equations

Std.Time.instHSubOffsetOffset_14 = { hSub := fun (x : Std.Time.Second.Offset) (y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.sub x y.toSeconds }

source

instance Std.Time.instHSubOffsetOffset_15 :

HSub Std.Time.Second.Offset Std.Time.Hour.Offset Std.Time.Second.Offset

Equations

Std.Time.instHSubOffsetOffset_15 = { hSub := fun (x : Std.Time.Second.Offset) (y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.sub x y.toSeconds }

source

instance Std.Time.instHSubOffsetOffset_16 :

HSub Std.Time.Second.Offset Std.Time.Day.Offset Std.Time.Second.Offset

Equations

Std.Time.instHSubOffsetOffset_16 = { hSub := fun (x : Std.Time.Second.Offset) (y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.sub x y.toSeconds }

source

instance Std.Time.instHSubOffsetOffset_17 :

HSub Std.Time.Second.Offset Std.Time.Week.Offset Std.Time.Second.Offset

Equations

Std.Time.instHSubOffsetOffset_17 = { hSub := fun (x : Std.Time.Second.Offset) (y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.sub x y.toSeconds }

source

instance Std.Time.instHSubOffsetOffset_18 :

HSub Std.Time.Minute.Offset Std.Time.Nanosecond.Offset Std.Time.Nanosecond.Offset

Equations

Std.Time.instHSubOffsetOffset_18 = { hSub := fun (x : Std.Time.Minute.Offset) (y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.sub x.toNanoseconds y }

source

instance Std.Time.instHSubOffsetOffset_19 :

HSub Std.Time.Minute.Offset Std.Time.Millisecond.Offset Std.Time.Millisecond.Offset

Equations

Std.Time.instHSubOffsetOffset_19 = { hSub := fun (x : Std.Time.Minute.Offset) (y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.sub x.toMilliseconds y }

source

instance Std.Time.instHSubOffsetOffset_20 :

HSub Std.Time.Minute.Offset Std.Time.Second.Offset Std.Time.Second.Offset

Equations

Std.Time.instHSubOffsetOffset_20 = { hSub := fun (x : Std.Time.Minute.Offset) (y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.sub x.toSeconds y }

source

instance Std.Time.instHSubOffset_3 :

HSub Std.Time.Minute.Offset Std.Time.Minute.Offset Std.Time.Minute.Offset

Equations

Std.Time.instHSubOffset_3 = { hSub := fun (x y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.sub x y }

source

instance Std.Time.instHSubOffsetOffset_21 :

HSub Std.Time.Minute.Offset Std.Time.Hour.Offset Std.Time.Minute.Offset

Equations

Std.Time.instHSubOffsetOffset_21 = { hSub := fun (x : Std.Time.Minute.Offset) (y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.sub x y.toMinutes }

source

instance Std.Time.instHSubOffsetOffset_22 :

HSub Std.Time.Minute.Offset Std.Time.Day.Offset Std.Time.Minute.Offset

Equations

Std.Time.instHSubOffsetOffset_22 = { hSub := fun (x : Std.Time.Minute.Offset) (y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.sub x y.toMinutes }

source

instance Std.Time.instHSubOffsetOffset_23 :

HSub Std.Time.Minute.Offset Std.Time.Week.Offset Std.Time.Minute.Offset

Equations

Std.Time.instHSubOffsetOffset_23 = { hSub := fun (x : Std.Time.Minute.Offset) (y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.sub x y.toMinutes }

source

instance Std.Time.instHSubOffsetOffset_24 :

HSub Std.Time.Hour.Offset Std.Time.Nanosecond.Offset Std.Time.Nanosecond.Offset

Equations

Std.Time.instHSubOffsetOffset_24 = { hSub := fun (x : Std.Time.Hour.Offset) (y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.sub x.toNanoseconds y }

source

instance Std.Time.instHSubOffsetOffset_25 :

HSub Std.Time.Hour.Offset Std.Time.Millisecond.Offset Std.Time.Millisecond.Offset

Equations

Std.Time.instHSubOffsetOffset_25 = { hSub := fun (x : Std.Time.Hour.Offset) (y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.sub x.toMilliseconds y }

source

instance Std.Time.instHSubOffsetOffset_26 :

HSub Std.Time.Hour.Offset Std.Time.Second.Offset Std.Time.Second.Offset

Equations

Std.Time.instHSubOffsetOffset_26 = { hSub := fun (x : Std.Time.Hour.Offset) (y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.sub x.toSeconds y }

source

instance Std.Time.instHSubOffsetOffset_27 :

HSub Std.Time.Hour.Offset Std.Time.Minute.Offset Std.Time.Minute.Offset

Equations

Std.Time.instHSubOffsetOffset_27 = { hSub := fun (x : Std.Time.Hour.Offset) (y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.sub x.toMinutes y }

source

instance Std.Time.instHSubOffset_4 :

HSub Std.Time.Hour.Offset Std.Time.Hour.Offset Std.Time.Hour.Offset

Equations

Std.Time.instHSubOffset_4 = { hSub := fun (x y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.sub x y }

source

instance Std.Time.instHSubOffsetOffset_28 :

HSub Std.Time.Hour.Offset Std.Time.Day.Offset Std.Time.Hour.Offset

Equations

Std.Time.instHSubOffsetOffset_28 = { hSub := fun (x : Std.Time.Hour.Offset) (y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.sub x y.toHours }

source

instance Std.Time.instHSubOffsetOffset_29 :

HSub Std.Time.Hour.Offset Std.Time.Week.Offset Std.Time.Hour.Offset

Equations

Std.Time.instHSubOffsetOffset_29 = { hSub := fun (x : Std.Time.Hour.Offset) (y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.sub x y.toHours }

source

instance Std.Time.instHSubOffsetOffset_30 :

HSub Std.Time.Day.Offset Std.Time.Nanosecond.Offset Std.Time.Nanosecond.Offset

Equations

Std.Time.instHSubOffsetOffset_30 = { hSub := fun (x : Std.Time.Day.Offset) (y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.sub x.toNanoseconds y }

source

instance Std.Time.instHSubOffsetOffset_31 :

HSub Std.Time.Day.Offset Std.Time.Millisecond.Offset Std.Time.Millisecond.Offset

Equations

Std.Time.instHSubOffsetOffset_31 = { hSub := fun (x : Std.Time.Day.Offset) (y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.sub x.toMilliseconds y }

source

instance Std.Time.instHSubOffsetOffset_32 :

HSub Std.Time.Day.Offset Std.Time.Second.Offset Std.Time.Second.Offset

Equations

Std.Time.instHSubOffsetOffset_32 = { hSub := fun (x : Std.Time.Day.Offset) (y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.sub x.toSeconds y }

source

instance Std.Time.instHSubOffsetOffset_33 :

HSub Std.Time.Day.Offset Std.Time.Minute.Offset Std.Time.Minute.Offset

Equations

Std.Time.instHSubOffsetOffset_33 = { hSub := fun (x : Std.Time.Day.Offset) (y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.sub x.toMinutes y }

source

instance Std.Time.instHSubOffsetOffset_34 :

HSub Std.Time.Day.Offset Std.Time.Hour.Offset Std.Time.Hour.Offset

Equations

Std.Time.instHSubOffsetOffset_34 = { hSub := fun (x : Std.Time.Day.Offset) (y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.sub x.toHours y }

source

instance Std.Time.instHSubOffset_5 :

HSub Std.Time.Day.Offset Std.Time.Day.Offset Std.Time.Day.Offset

Equations

Std.Time.instHSubOffset_5 = { hSub := fun (x y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.sub x y }

source

instance Std.Time.instHSubOffsetOffset_35 :

HSub Std.Time.Day.Offset Std.Time.Week.Offset Std.Time.Day.Offset

Equations

Std.Time.instHSubOffsetOffset_35 = { hSub := fun (x : Std.Time.Day.Offset) (y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.sub x y.toDays }

source

instance Std.Time.instHSubOffsetOffset_36 :

HSub Std.Time.Week.Offset Std.Time.Nanosecond.Offset Std.Time.Nanosecond.Offset

Equations

Std.Time.instHSubOffsetOffset_36 = { hSub := fun (x : Std.Time.Week.Offset) (y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.sub x.toNanoseconds y }

source

instance Std.Time.instHSubOffsetOffset_37 :

HSub Std.Time.Week.Offset Std.Time.Millisecond.Offset Std.Time.Millisecond.Offset

Equations

Std.Time.instHSubOffsetOffset_37 = { hSub := fun (x : Std.Time.Week.Offset) (y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.sub x.toMilliseconds y }

source

instance Std.Time.instHSubOffsetOffset_38 :

HSub Std.Time.Week.Offset Std.Time.Second.Offset Std.Time.Second.Offset

Equations

Std.Time.instHSubOffsetOffset_38 = { hSub := fun (x : Std.Time.Week.Offset) (y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.sub x.toSeconds y }

source

instance Std.Time.instHSubOffsetOffset_39 :

HSub Std.Time.Week.Offset Std.Time.Minute.Offset Std.Time.Minute.Offset

Equations

Std.Time.instHSubOffsetOffset_39 = { hSub := fun (x : Std.Time.Week.Offset) (y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.sub x.toMinutes y }

source

instance Std.Time.instHSubOffsetOffset_40 :

HSub Std.Time.Week.Offset Std.Time.Hour.Offset Std.Time.Hour.Offset

Equations

Std.Time.instHSubOffsetOffset_40 = { hSub := fun (x : Std.Time.Week.Offset) (y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.sub x.toHours y }

source

instance Std.Time.instHSubOffsetOffset_41 :

HSub Std.Time.Week.Offset Std.Time.Day.Offset Std.Time.Day.Offset

Equations

Std.Time.instHSubOffsetOffset_41 = { hSub := fun (x : Std.Time.Week.Offset) (y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.sub x.toDays y }

source

instance Std.Time.instHSubOffset_6 :

HSub Std.Time.Week.Offset Std.Time.Week.Offset Std.Time.Week.Offset

Equations

Std.Time.instHSubOffset_6 = { hSub := fun (x y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.sub x y }