com.widdindustries.tempo — com.widdindustries/tempo 0.8.0

*block-non-commutative-operations* clj/s

-microsecond clj

(-microsecond f)

-millisecond clj

(-millisecond f)

-nanosecond clj

(-nanosecond f)

< clj/s

(< _x)

(< x y)

(< x y & more)

<< clj/s

(<< temporal temporal-amount)

(<< temporal amount temporal-property)

move a temporal backward by an amount

<= clj/s

(<= _x)

(<= x y)

(<= x y & more)

> clj/s

(> _x)

(> x y)

(> x y & more)

>= clj/s

(>= _x)

(>= x y)

(>= x y & more)

>> clj/s

(>> temporal temporal-amount)

(>> temporal amount temporal-property)

move a temporal forward by an amount

clock clj/s

(clock instant-fn timezone-fn)

clock-fixed clj/s

(clock-fixed zdt)

(clock-fixed instant zone-str)

create a stopped clock

clock-offset-millis clj/s

(clock-offset-millis a-clock offset-millis)

offset an existing clock by offset-millis

clock-system-default-zone clj/s

(clock-system-default-zone)

a ticking clock having the ambient zone.

clock-with-timezone clj/s

(clock-with-timezone timezone)

ticking clock in given timezone

clock-zdt-atom clj/s

(clock-zdt-atom zdt-atom)

create a clock which will dereference the zdt-atom.

The caller must first construct the atom and by keeping a reference to it, may change its value and therefore the value of the clock.

coincident? clj/s

(coincident? start end event)

date+time clj/s

(date+time date time)

create a datetime

date->day-of-month clj/s

(date->day-of-month foo)

date->day-of-week clj/s

(date->day-of-week foo)

date->month clj/s

(date->month foo)

date->monthday clj/s

(date->monthday foo)

date->year clj/s

(date->year foo)

date->yearmonth clj/s

(date->yearmonth foo)

date-deref clj/s

(date-deref clock)

date-from clj/s

(date-from thing)

date-next-or-same-weekday clj/s

(date-next-or-same-weekday date desired-dow-number)

date-parse clj/s

(date-parse foo)

date-prev-or-same-weekday clj/s

(date-prev-or-same-weekday date desired-dow-number)

date? clj/s

(date? v)

datetime+timezone clj/s

(datetime+timezone datetime timezone)

create a zdt

datetime->date clj/s

(datetime->date foo)

datetime->day-of-month clj/s

(datetime->day-of-month foo)

datetime->day-of-week clj/s

(datetime->day-of-week foo)

datetime->hour clj/s

(datetime->hour foo)

datetime->microsecond clj/s

(datetime->microsecond foo)

datetime->millisecond clj/s

(datetime->millisecond foo)

datetime->minute clj/s

(datetime->minute foo)

datetime->month clj/s

(datetime->month foo)

datetime->monthday clj/s

(datetime->monthday foo)

datetime->nanosecond clj/s

(datetime->nanosecond foo)

datetime->second clj/s

(datetime->second foo)

datetime->time clj/s

(datetime->time foo)

datetime->year clj/s

(datetime->year foo)

datetime->yearmonth clj/s

(datetime->yearmonth foo)

datetime-deref clj/s

(datetime-deref clock)

datetime-from clj/s

(datetime-from thing)

datetime-parse clj/s

(datetime-parse foo)

datetime? clj/s

(datetime? v)

days-property clj/s

enable-comparison-for-all-temporal-entities clj/s

(enable-comparison-for-all-temporal-entities)

in cljs envs, this makes =, compare and hash work on the value of Temporal entities. It is optional, so that if this behaviour is not required, the resulting build size can be reduced.

epochmilli->instant clj/s

(epochmilli->instant milli)

get-field clj/s

(get-field temporal property)

HasTime clj protocol

getFractional clj

(getFractional _)

setFractional clj

(setFractional _ _)

hours-property clj/s

instant+timezone clj/s

(instant+timezone instant timezone)

create a zdt

instant->epochmilli clj/s

(instant->epochmilli foo)

instant->legacydate clj/s

(instant->legacydate foo)

instant->zdt-in-UTC clj/s

(instant->zdt-in-UTC instant)

instant-deref clj/s

(instant-deref clock)

instant-from clj/s

(instant-from thing)

instant-parse clj/s

(instant-parse foo)

instant? clj/s

(instant? v)

JavaTruncateable clj/s protocol

-truncate clj/s

(-truncate _ unit)

legacydate->instant clj/s

(legacydate->instant d)

legacydate? clj/s

(legacydate? v)

max clj/s

(max arg & args)

Find the latest of the given arguments. Callers should ensure that no argument is nil.

microseconds-property clj/s

milliseconds-property clj/s

min clj/s

(min arg & args)

Find the earliest of the given arguments. Callers should ensure that no argument is nil.

minutes-property clj/s

month-april clj/s

month-april-name clj/s

month-august clj/s

month-august-name clj/s

month-december clj/s

month-december-name clj/s

month-february clj/s

month-february-name clj/s

month-january clj/s

month-january-name clj/s

month-july clj/s

month-july-name clj/s

month-june clj/s

month-june-name clj/s

month-march clj/s

month-march-name clj/s

month-may clj/s

month-may-name clj/s

month-november clj/s

month-november-name clj/s

month-october clj/s

month-october-name clj/s

month-september clj/s

month-september-name clj/s

monthday+year clj/s

(monthday+year monthday year)

create a date

monthday->day-of-month clj/s

(monthday->day-of-month foo)

monthday->month clj/s

(monthday->month foo)

monthday-deref clj/s

(monthday-deref clock)

monthday-from clj/s

(monthday-from {:keys [month day-of-month]})

monthday-parse clj/s

(monthday-parse foo)

monthday? clj/s

(monthday? v)

months-property clj/s

nanoseconds-property clj/s

Property clj protocol

field clj

(field _)

unit clj

(unit _)

seconds-property clj/s

sub-second-range clj

throw-if-months-or-years-in-amount clj/s

(throw-if-months-or-years-in-amount temporal temporal-amount)

throw-if-set-months-or-years clj/s

(throw-if-set-months-or-years temporal temporal-property)

time+date clj/s

(time+date time date)

create a datetime

time->hour clj/s

(time->hour foo)

time->microsecond clj/s

(time->microsecond foo)

time->millisecond clj/s

(time->millisecond foo)

time->minute clj/s

(time->minute foo)

time->nanosecond clj/s

(time->nanosecond foo)

time->second clj/s

(time->second foo)

time-deref clj/s

(time-deref clock)

time-from clj/s

(time-from thing)

time-parse clj/s

(time-parse foo)

time? clj/s

(time? v)

timezone-deref clj/s

(timezone-deref clock)

truncate clj/s

(truncate temporal property)

zero property field and below of temporal

until clj/s

(until v1 v2 property)

weekday->weekday-name clj/s

weekday-friday clj/s

weekday-friday-name clj/s

weekday-monday clj/s

weekday-monday-name clj/s

weekday-name->weekday clj/s

weekday-saturday clj/s

weekday-saturday-name clj/s

weekday-sunday clj/s

weekday-sunday-name clj/s

weekday-thursday clj/s

weekday-thursday-name clj/s

weekday-tuesday clj/s

weekday-tuesday-name clj/s

weekday-wednesday clj/s

weekday-wednesday-name clj/s

with clj/s

(with temporal value property)

from temporal arg, derive a new temporal object with property field set to value (t/with date 3 t/days-property)

yearmonth+day-at-end-of-month clj/s

(yearmonth+day-at-end-of-month ym)

create a date having last day of month

yearmonth+day-of-month clj/s

(yearmonth+day-of-month yearmonth day)

create a date

yearmonth->month clj/s

(yearmonth->month foo)

yearmonth->year clj/s

(yearmonth->year foo)

yearmonth-deref clj/s

(yearmonth-deref clock)

yearmonth-from clj/s

(yearmonth-from {:keys [year month]})

yearmonth-parse clj/s

(yearmonth-parse foo)

yearmonth? clj/s

(yearmonth? v)

years-property clj/s

zdt->date clj/s

(zdt->date foo)

zdt->datetime clj/s

(zdt->datetime foo)

zdt->day-of-month clj/s

(zdt->day-of-month foo)

zdt->day-of-week clj/s

(zdt->day-of-week foo)

zdt->hour clj/s

(zdt->hour foo)

zdt->instant clj/s

(zdt->instant foo)

zdt->microsecond clj/s

(zdt->microsecond foo)

zdt->millisecond clj/s

(zdt->millisecond foo)

zdt->minute clj/s

(zdt->minute foo)

zdt->month clj/s

(zdt->month foo)

zdt->monthday clj/s

(zdt->monthday foo)

zdt->nanosecond clj/s

(zdt->nanosecond foo)

zdt->second clj/s

(zdt->second foo)

zdt->time clj/s

(zdt->time foo)

zdt->timezone clj/s

(zdt->timezone foo)

zdt->year clj/s

(zdt->year foo)

zdt->yearmonth clj/s

(zdt->yearmonth foo)

zdt-deref clj/s

(zdt-deref clock)

zdt-from clj/s

(zdt-from thing)

zdt-parse clj/s

(zdt-parse foo)

zdt? clj/s

(zdt? v)