tick.core — tick 0.7.5

*clock* clj/s

*time-literals-printing* clj

If true, include the time-literals printer, which will affect the way java.time and js-joda objects are printed

+ clj/s

(+)

(+ arg)

(+ arg & args)

Sum amounts of time

- clj/s

(-)

(- arg)

(- arg & args)

Subtract amounts of time.

< clj/s

(< _x)

(< x y)

(< x y & more)

Same as clojure.core/<, but works on dates, rather than numbers

<< clj/s

(<< t n-or-d)

shift Temporal backward

<= clj/s

(<= _x)

(<= x y)

(<= x y & more)

Same as clojure.core/<=, but works on dates, rather than numbers

= clj/s

(= _x)

(= x y)

(= x y & more)

Same as clojure.core/=, but works on dates, rather than numbers. can compare different types, e.g. Instant vs ZonedDateTime

> clj/s

(> _x)

(> x y)

(> x y & more)

Same as clojure.core/>, but works on dates, rather than numbers

>= clj/s

(>= _x)

(>= x y)

(>= x y & more)

Same as clojure.core/>=, but works on dates, rather than numbers

>> clj/s

(>> t n-or-d)

shift Temporal forward

ago clj/s

(ago dur)

current instant shifted back by duration 'dur'

APRIL clj/s

at clj/s

(at d t)

Set date to be AT a time

atom clj/s

(atom)

(atom clk)

construct atomic clock

AUGUST clj/s

backward-compatible-time-span-extensions clj/s

(backward-compatible-time-span-extensions)

pre v0.7, ITimeSpan was extended as per this body. run this function to create those extensions.

ITimeSpan is implemented by default on types with a natural beginning and end

beginning clj/s

(beginning v)

the beginning of the range of ITimeSpan v or v

between clj/s

(between v1 v2)

(between v1 v2 unit)

for the 2-arity version, find the temporal-amount between v1 and v2, or for the 3-arity version the amount of 'unit' between v1 and v2

clock clj/s

(clock)

(clock i)

return i as a clock

clock? clj/s

(clock? v)

true if v is a clock?

coincident? clj/s

(coincident? containing-interval contained-interval)

(coincident? start end event)

for the 2-arity ver, Does containing-interval wholly contain the given contained-interval?

for the 3-arity, does the event lie within the span of time described by start and end

compare-and-set! clj/s

(compare-and-set! at oldval newval)

cas on atomic clock 'at'

current-clock clj/s

(current-clock)

current-zone clj/s

(current-zone)

Return the current zone, which can be overridden by the clock dynamic var

date clj/s

(date)

(date v)

date-time clj/s

(date-time)

(date-time v)

date-time? clj/s

(date-time? v)

true if v is a date-time?

date? clj/s

(date? v)

true if v is a date?

day-of-month clj/s

(day-of-month)

(day-of-month v)

extract day-of-month from v

day-of-week clj/s

(day-of-week)

(day-of-week v)

extract day-of-week from v

day-of-week-in-month clj/s

(day-of-week-in-month ordinal day-of-week)

(day-of-week-in-month t ordinal day-of-week)

day-of-week? clj/s

(day-of-week? v)

true if v is a day-of-week?

days clj/s

(days v)

extract days from 'v'

dec clj/s

(dec t)

DECEMBER clj/s

divide clj/s

(divide t divisor)

divide TemporalAmount t by divisor, which is a unit e.g. :hours or a TemporalAmount

duration clj/s

(duration x)

return Duration or Period (whichever appropriate based on type) contained within the range of ITimeSpan x

duration? clj/s

(duration? v)

true if v is a duration?

end clj/s

(end v)

the end of the range of ITimeSpan v or v

epoch clj/s

(epoch)

Constant for the 1970-01-01T00:00:00Z epoch instant

FEBRUARY clj/s

field-map clj/s

keyword to chrono-field

fields clj/s

(fields t)

first-day-of-month clj/s

(first-day-of-month)

(first-day-of-month t)

first-day-of-next-month clj/s

(first-day-of-next-month)

(first-day-of-next-month t)

first-day-of-next-year clj/s

(first-day-of-next-year)

(first-day-of-next-year t)

first-day-of-year clj/s

(first-day-of-year)

(first-day-of-year t)

first-in-month clj/s

(first-in-month day-of-week)

(first-in-month t day-of-week)

format clj/s

(format o)

(format fmt o)

Formats the given time entity as a string. Accepts something that can be converted to a DateTimeFormatter as a first argument. Given one argument uses the default format.

formatter clj/s

(formatter fmt)

(formatter fmt locale)

Constructs a DateTimeFormatter out of either a

• format string - "YYYY/mm/DD" "YYY HH:MM" etc. or
• formatter name - :iso-instant :iso-local-date etc

and a Locale, which is optional.

FRIDAY clj/s

greater clj/s

(greater x y)

the greater of x and y

hence clj/s

(hence dur)

current instant shifted forward by duration 'dur'

hour clj/s

(hour t)

extract hour from t

hours clj/s

(hours v)

extract hours from 'v'

in clj/s

(in ldt z)

Set a date-time to be in a time-zone

inc clj/s

(inc t)

inst clj/s

(inst)

(inst v)

instant clj/s

(instant)

(instant v)

instant? clj/s

(instant? v)

true if v is a instant?

int clj/s

(int arg)

interval? clj/s

(interval? v)

true if v is a interval?

JANUARY clj/s

JULY clj/s

JUNE clj/s

last-day-of-month clj/s

(last-day-of-month)

(last-day-of-month t)

last-day-of-year clj/s

(last-day-of-year)

(last-day-of-year t)

last-in-month clj/s

(last-in-month day-of-week)

(last-in-month t day-of-week)

lesser clj/s

(lesser x y)

the lesser of x and y

long clj/s

(long arg)

MARCH clj/s

max clj/s

(max arg & args)

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

max-key clj/s

(max-key _k x)

(max-key k x y)

(max-key k x y & more)

Same as clojure.core/max-key, but works on dates, rather than numbers

max-of-type clj/s

return e.g Instant/MAX given and Instant

MAY clj/s

micros clj/s

(micros v)

extract micros from 'v'

microsecond clj/s

(microsecond t)

extract microsecond from t

midnight clj/s

(midnight)

(midnight date)

midnight? clj/s

(midnight? t)

millis clj/s

(millis v)

extract millis from 'v'

millisecond clj/s

(millisecond t)

extract millisecond from t

min clj/s

(min arg & args)

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

min-key clj/s

(min-key _k x)

(min-key k x y)

(min-key k x y & more)

Same as clojure.core/min-key, but works on dates, rather than numbers

min-of-type clj/s

return e.g Instant/MIN given and Instant

minute clj/s

(minute t)

extract minute from t

minutes clj/s

(minutes v)

extract minutes from 'v'

modify-printing-of-time-literals-if-enabled! clj/s macro

(modify-printing-of-time-literals-if-enabled!)

MONDAY clj/s

month clj/s

(month)

(month v)

extract month from v

month? clj/s

(month? v)

true if v is a month?

months clj/s

(months v)

extract months from 'v'

nanos clj/s

(nanos v)

extract nanos from 'v'

nanosecond clj/s

(nanosecond t)

extract nanosecond from t

negated clj/s

(negated d)

Return the duration as a negative duration

new-date clj/s

(new-date)

(new-date epoch-day)

(new-date year day-of-year)

(new-date year month day-of-month)

new-duration clj/s

(new-duration n u)

new-period clj/s

(new-period n u)

new-time clj/s

(new-time)

(new-time hour minute)

(new-time hour minute second)

(new-time hour minute second nano)

new-year-month clj/s

(new-year-month)

(new-year-month year month)

next clj/s

(next day-of-week)

(next t day-of-week)

next-or-same clj/s

(next-or-same day-of-week)

(next-or-same t day-of-week)

noon clj/s

(noon)

(noon date)

NOVEMBER clj/s

now clj/s

(now)

same as (t/instant)

OCTOBER clj/s

of-days clj/s

(of-days n)

Takes a java.lang.Long n and returns a period of n days.

of-hours clj/s

(of-hours n)

Takes a java.lang.Long n and returns a duration of n hours.

of-micros clj/s

(of-micros n)

Takes a java.lang.Long n and returns a duration of n micros.

of-millis clj/s

(of-millis n)

Takes a java.lang.Long n and returns a duration of n micros.

of-minutes clj/s

(of-minutes n)

Takes a java.lang.Long n and returns a duration of n minutes.

of-months clj/s

(of-months n)

Takes a java.lang.Long n and returns a period of n months.

of-nanos clj/s

(of-nanos n)

Takes a java.lang.Long n and returns a duration of n nanoseconds.

of-seconds clj/s

(of-seconds n)

Takes a java.lang.Long n and returns a duration of n seconds.

of-years clj/s

(of-years n)

Takes a java.lang.Long n and returns a period of n years.

offset-by clj/s

(offset-by ldt offset)

Set a date-time to be offset by an amount

offset-date-time clj/s

(offset-date-time)

(offset-date-time v)

offset-date-time? clj/s

(offset-date-time? v)

true if v is a offset-date-time?

on clj/s

(on t d)

Set time be ON a date

parse-date clj/s

(parse-date date-str formatter)

to parse an iso-formatted date, use (t/date "2020..") instead

parse-date-time clj/s

(parse-date-time date-str formatter)

to parse an iso-formatted date-time, use (t/date-time "2020..") instead

parse-day clj/s

(parse-day input)

en locale specific and borderline deprecated. consider writing your own regex or use a formatter. For example:

(-> (t/formatter "EEE") (cljc.java-time.format.date-time-formatter/parse "Tue") (cljc.java-time.day-of-week/from))

parse-month clj/s

(parse-month input)

en locale specific and borderline deprecated. Consider writing your own regex or use a formatter. For example:

(-> (t/formatter "MMM") (cljc.java-time.format.date-time-formatter/parse "Jan") (cljc.java-time.month/from))

parse-offset-date-time clj/s

(parse-offset-date-time date-str formatter)

to parse an iso-formatted offset-date-time, use (t/offset-date-time "2020..") instead

parse-time clj/s

(parse-time date-str formatter)

to parse an iso-formatted time, use (t/time "20:20..") instead

parse-year clj/s

(parse-year date-str formatter)

to parse an iso-formatted year, use (t/year "2020") instead

parse-year-month clj/s

(parse-year-month date-str formatter)

to parse an iso-formatted year-month, use (t/year-month "2020..") instead

parse-zoned-date-time clj/s

(parse-zoned-date-time date-str formatter)

to parse an iso-formatted zoned-date-time, use (t/zoned-date-time "2020..") instead

period? clj/s

(period? v)

true if v is a period?

predefined-formatters clj/s

previous clj/s

(previous day-of-week)

(previous t day-of-week)

previous-or-same clj/s

(previous-or-same day-of-week)

(previous-or-same t day-of-week)

range clj/s

Returns a lazy seq of times from start (inclusive) to end (exclusive, nil means forever), by step, where start defaults to 0, step to 1, and end to infinity.

reset! clj/s

(reset! at newval)

reset! on atomic clock 'at'

reset-vals! clj/s

(reset-vals! at newval)

reset-vals! on atomic clock 'at'

reverse-unit-map clj/s

SATURDAY clj/s

second clj/s

(second t)

extract second from t

seconds clj/s

(seconds v)

extract seconds from 'v'

SEPTEMBER clj/s

SUNDAY clj/s

swap! clj/s

(swap! at f & args)

swap! on atomic clock 'at'

swap-vals! clj/s

(swap-vals! at f & args)

swap-vals! on atomic clock 'at'

THURSDAY clj/s

tick-resolution clj/s

(tick-resolution clk)

(tick-resolution clk dur)

Obtains a clock that returns instants from the specified clock truncated to the nearest occurrence of the specified duration.

time clj/s

(time)

(time v)

extract time from v

time? clj/s

(time? v)

true if v is a time?

today clj/s

(today)

same as (t/date)

tomorrow clj/s

(tomorrow)

truncate clj/s

(truncate x u)

Returns a copy of x truncated to the specified unit.

TUESDAY clj/s

unit-map clj/s

keyword to chrono-unit

units clj/s

(units x)

the units contained within TemporalAmount x.

Seconds and nanos for Duration. Years, months, days for Period

UTC clj/s

WEDNESDAY clj/s

with clj/s

(with t adj)

(with t fld new-value)

Adjust a temporal with an adjuster or field

with-clock clj/s macro

(with-clock clock & body)

temporarily change ambient now+zone info the given 'clock' could be an Instant, zone or zoned-date-time

year clj/s

(year)

(year v)

extract year from v

year-month clj/s

(year-month)

(year-month v)

extract year-month from v

year-month? clj/s

(year-month? v)

true if v is a year-month?

year? clj/s

(year? v)

true if v is a year?

years clj/s

(years v)

extract years from 'v'

yesterday clj/s

(yesterday)

zone clj/s

(zone)

(zone z)

zone-offset clj/s

(zone-offset offset)

(zone-offset hours minutes)

(zone-offset hours minutes seconds)

zone-offset? clj/s

(zone-offset? v)

true if v is a zone-offset?

zone? clj/s

(zone? v)

true if v is a zone?

zoned-date-time clj/s

(zoned-date-time)

(zoned-date-time v)

zoned-date-time? clj/s

(zoned-date-time? v)

true if v is a zoned-date-time?