Entityo multiplied by the valuev

Adds all of theos to the time entityo.+ is not commutative, the first argument is always the entity which will accumulate the rest of the arguments.

(j/+ (j/local-date 2015) (j/years 1))=> <java.time.LocalDate "2016-01-01">

Subtracts all of theos from the time entityo

(j/- (j/local-date 2015) (j/years 1))=> <java.time.LocalDate "2014-01-01">

Returnstrue if time entities are ordered from the earliest to the latest (same semantics as<), otherwisefalse.

(j/< (local-date 2009) (local-date 2010) (local-date 2011))=> true(j/< (interval (instant 10000) (instant 1000000))     (instant 99999999))=> true

Returnstrue if time entities are ordered from the earliest to the latest (same semantics as<=), otherwisefalse.

(j/<= (local-date 2009) (local-date 2010) (local-date 2011));=> true(j/<= (interval (instant 10000) (instant 1000000))      (instant 99999999));=> true

Returns true if all time entities represent the same time, otherwise false.

j/= is not commutative, the first argument is always the entity which will accumulate the rest of the arguments.

e.g., (j/= (j/day-of-week :thursday) :thursday) => true

Returnstrue if time entities are ordered from the latest to the earliest (same semantics as>), otherwisefalse.

(j/> (local-date 2011) (local-date 2010) (local-date 2009))=> true(j/> (instant 99999999)     (interval (instant 10000) (instant 1000000)))=> true

Returnstrue if time entities are ordered from the latest to the earliest (same semantics as>=), otherwisefalse.

(j/>= (local-date 2011) (local-date 2010) (local-date 2009));=> true(j/>= (instant 99999999)      (interval (instant 10000) (instant 1000000)));=> true

Returns the absolute value of a temporal amount:

(abs (negate x)) == (abs x)

True if this interval abut with the other one

Adjusts the temporalentity using the providedadjuster with optionalargs.

The adjuster should either be a keyword which resolves to one of the predefined adjusters (seejava-time.repl/show-adjusters) an instance ofTemporalAdjuster or a function which returns another temporal entity when applied to the given one:

(adjust (local-date 2015 1 1) :next-working-day)=> #<LocalDate 2015-1-2>(adjust (local-date 2015 1 1) :first-in-month :monday)=> #<LocalDate 2015-1-5>(adjust (local-date 2015 1 1) plus (days 1))=> #<LocalDate 2015-1-2>

Advances theclock by the given timeamount.

This mutates the mock clock.

Returnstrue if time entities are ordered from the latest to the earliest (same semantics as>), otherwisefalse.

(after? (local-date 2011) (local-date 2010) (local-date 2009))=> true(after? (instant 99999999)        (interval (instant 10000) (instant 1000000)))=> true

Returns theAmPm for the given keyword name (:am or:pm), ordinal or entity. Current AM/PM if no arguments given.

True iforg.threeten.extra.AmPm.

Values of property/unit identified by keys/objectsks of the temporal entityo, e.g.

(as (duration 1 :hours) :minutes)=> 60(as (local-date 2015 9) :year :month-of-year)=> [2015 9]

Converts a time entity to a map of property key -> value as defined by the passed invalue-fn. By default the actual value of the unit/field is produced.

(as-map (duration))=> {:nanos 0, :seconds 0}(as-map (local-date 2015 1 1))=> {:year 2015, :month-of-year 1, :day-of-month 1, ...}

Returns a set of string identifiers for all available ZoneIds.

Returnstrue if time entities are ordered from the earliest to the latest (same semantics as<), otherwisefalse.

(before? (local-date 2009) (local-date 2010) (local-date 2011))=> true(before? (interval (instant 10000) (instant 1000000))         (instant 99999999))=> true

TheChronology of the entity

Returns true ifx is an instance ofjava.time.Clock.

True if the interval contains the given instant or interval

Converts an amount from one unit to another. Returns a map of:

• :whole - the whole part of the conversion in theto unit
• :remainder - the remainder in thefrom unit

Arguments may be keywords or instances ofTemporalUnit.

Converts between precise units–nanos up to weeks—treating days as exact multiples of 24 hours. Also converts between imprecise units—months up to millennia. SeeChronoUnit andIsoFields for all of the supported units. Does not convert between precise and imprecise units.

ThrowsArithmeticException if long overflow occurs during computation.

(convert-amount 10000 :seconds :hours)=> {:remainder 2800 :whole 2}

Returns theDayOfMonth for the given entity, clock, zone or day of month. Current day of month if no arguments given.

Returns true ifo isorg.threeten.extra.DayOfMonth, otherwise false.

Returns theDayOfWeek for the given day keyword name (e.g.:monday), ordinal or entity. Current day if no arguments given.

True ifjava.time.DayOfWeek.

Returns theDayOfYear for the given entity, clock, zone or day of year. Current day of year if no arguments given.

Returns true ifo isorg.threeten.extra.DayOfYear, otherwise false.

Returns aPeriod ofi days.

Creates a duration - a temporal entity representing standard days, hours, minutes, millis, micros and nanos. The duration itself contains only seconds and nanos as properties.

Given one argument will:

• interpret as millis if a number
• try to parse from the standard format if a string
• extract supported units from anotherTemporalAmount
• convert from a Joda Period/Duration

Given two arguments will:

• get a duration between twoTemporals
• get a duration of a specified unit, e.g.(duration 100 :seconds)

Returns true ifv is an instance of java.time.Duration, otherwise false.

Gets the end instant of the interval

Returns aTemporalField for the given keyk or extracts the field from the given temporalentity.

You can see predefined fields viajava-time.repl/show-fields.

If you want to make your own custom TemporalFields resolvable, you need to rebind thejava-time.properties/*fields* to a customjava_time.properties.FieldGroup.

True if this is aTemporalField.

Fields present in this temporal entity

Creates a fixed clock either at the current instant or at the supplied instant/instant + zone.

Formats the given time entity as a string.

Accepts something that can be converted to aDateTimeFormatter or a formatter key, e.g.:iso-offset-time, as a first argument. Given one argument uses the default format.

(format (zoned-date-time))=> "2015-03-21T09:22:46.677800+01:00[Europe/London]"(format :iso-date (zoned-date-time))"2015-03-21+01:00"

Constructs a DateTimeFormatter out of a

• format string - “yyyy/MM/dd”, “HH:mm”, etc.
• formatter name - :iso-date, :iso-time, etc.

Accepts a map of options as an optional second argument:

• resolver-style - either:strict,:smart or:lenient
• case - either:insensitive or:sensitive (defaults to :sensitive)

Returns true if the given time entity with theday-of-week property falls on a Friday, otherwise false.

Gets the gap between this interval and the other one ornil

Returns aDuration ofi hours.

Creates anInstant. The following arguments are supported:

• no arguments - current instant
• one argument
  • clock
  • java.util.Date/Calendar
  • another temporal entity
  • string representation
  • millis from epoch
• two arguments
  • formatter (format) and a string

Creates ajava.sql.Timestamp from the providedinstant-or-millis - a millisecond numeric time value or something convertible to anInstant.

Please consider using the JSR-310 Java Time types instead ofjava.sql.Timestamp if your drivers support them.

java.sql.Timestamp is a version of ajava.util.Date supposed to be used as a local date-time (no time zone) for the purposes of conversion from/to native JDBC driver TIMESTAMP types.

Returns true ifv is an instance of java.time.Instant, otherwise false.

Constructs an interval out of a string, start and end instants or a start + duration:

(j/interval "2010-01-01T00:00:00Z/2013-01-01T00:00:00Z")=> #<Interval 2010-01-01T00:00:00Z/2013-01-01T00:00:00Z>(j/interval (j/instant 100000) (j/instant 1000000))=> #<Interval 1970-01-01T00:01:40Z/1970-01-01T00:16:40Z>(j/interval (j/instant 100000) (j/duration 15 :minutes))=> #<Interval 1970-01-01T00:01:40Z/1970-01-01T00:16:40Z>

Requires the optionalthreeten-extra dependency.

True ifInterval

Returns a lazy sequence ofinitial ,(apply f initial v vs), etc.

Useful when you want to produce a sequence of temporal entities, for example:

(iterate plus (days 0) 1)=> (#<Period P0D> #<Period P1D> #<Period P2D> ...)(iterate plus (local-date 2010 1 1) (years 1))=> (#<LocalDate 2010-01-01> #<LocalDate 2011-01-01> ...)(iterate adjust (local-date 2010 1 1) :next-working-day)=> (#<LocalDate 2010-01-01> #<LocalDate 2010-01-04> ...)

Creates ajava.util.Date out of any combination of arguments valid forinstant or the Instant itself.

Ajava.util.Date represents an instant in time. It’s a direct analog of thejava.time.Instant type introduced in the JSR-310. Please consider using thejava.time.Instant (throughinstant) directly.

Largest minimum value of this property

True if the year of this entity is a leap year.

Creates aLocalDate. The following arguments are supported:

• no arguments - current local-date
• one argument
  • clock
  • another temporal entity
  • string representation
  • year
• two arguments
  • formatter (format) and a string
  • an instant and a zone id
  • another temporal entity and an offset (preserves local time)
  • year and month
• three arguments
  • year, month and date

Creates aLocalDateTime. The following arguments are supported:

• no arguments - current local date-time
• one argument
  • clock
  • another temporal entity
  • string representation
  • year
• two arguments
  • local date and local time
  • an instant and a zone id
  • formatter (format) and a string
  • year and month

• three and more arguments - year/month/day/…

Returns true ifv is an instance of java.time.LocalDateTime, otherwise false.

Returns true ifv is an instance of java.time.LocalDate, otherwise false.

Creates aLocalTime. The following arguments are supported:

• no arguments - current local time
• one argument
  • clock
  • another temporal entity
  • string representation
  • hours
• two arguments
  • formatter (format) and a string
  • an instant and a zone id
  • hours and minutes
• three/four arguments - hour, minute, second, nanos

Returns true ifv is an instance of java.time.LocalTime, otherwise false.

Latest/longest of the given time entities. Entities should be of the same type

Maximum value of this property, e.g. 29th of February for months

Duration of a specified number of microseconds.

Returns aDuration ofi millis.

Earliest/shortest of the given time entities. Entities should be of the same type

Minimum value of this property

Subtracts all of theos from the time entityo

(j/minus (j/local-date 2015) (j/years 1))=> <java.time.LocalDate "2014-01-01">

Returns aDuration ofi minutes.

Returns a mock implementation of thejava.time.Clock. The mock supportsadvance-clock! operation which allows to move the time in the clock, e.g.:

(let [clock (mock-clock 0 "UTC")]  (with-clock clock    (is (= (value clock) 0))    (is (= (instant) (instant 0)))    (advance-clock! clock (j/millis 1))    (is (= (value clock) 1))    (is (= (instant) (instant 1)))))

You can move the clock back via advancing by a negative temporal amount.

Creates a clock at epoch in the default time zone when called without arguments.

Returns true if the given time entity with theday-of-week property falls on a Monday, otherwise false.

Returns theMonth for the given month keyword name (e.g.:january), ordinal or entity. Current month if no arguments given.

Returns theMonthDay for the given entity, string, clock, zone or month/day combination. Current month-day if no arguments given.

Returns true ifo isjava.time.MonthDay, otherwise false.

True ifjava.time.Month.

Returns aPeriod ofi months.

Moves the end instant of the interval by the sum of given periods/durations/numbers of milliseconds.

(move-start-by (interval 0 10000) (millis 1000) (seconds 1))=> #<Interval ...:00Z/...:12Z>

Fails if the new end instant falls before the start instant.

(move-end-by (interval 0 10000) (millis -11000))=> DateTimeException...

Moves the end of the interval to the given instant (or something convertible to an instant):

(move-end-to (interval 0 10000) (instant 15000))=> #<Interval ...:00Z/...:15Z>

Fails if the new end instant falls before the start instant:

(move-end-to (interval 0 10000) (millis -1))=> DateTimeException...

Moves the start instant of the interval by the sum of given periods/durations/numbers of milliseconds:

(move-start-by (interval 0 10000) (millis 1000) (seconds 1))=> #<Interval ...:02Z/...:10Z>

Fails if the new start instant falls after the end instant.

(move-start-by (interval 0 10000) (millis 11000));=> DateTimeException...

Moves the start instant of the interval to the given instant (or something convertible to an instant):

(move-start-to (interval 0 10000) (instant 5000))=> #<Interval ...:05Z/...:10Z>

Fails if the new start instant falls after the end instant:

(move-start-to (interval 0 10000) (millis 15000))=> DateTimeException...

Entityo multiplied by the valuev

Returns aDuration ofi nanos.

Negates a temporal amount:

(negate (negate x)) == x

True if the amount is negative

Returnstrue if time entities are ordered from the earliest to the latest (same semantics as<=), otherwisefalse.

(not-after? (local-date 2009) (local-date 2010) (local-date 2011));=> true(not-after? (interval (instant 10000) (instant 1000000))            (instant 99999999));=> true

Returnstrue if time entities are ordered from the latest to the earliest (same semantics as>=), otherwisefalse.

(not-before? (local-date 2011) (local-date 2010) (local-date 2009));=> true(not-before? (instant 99999999)             (interval (instant 10000) (instant 1000000)));=> true

Creates a clock offset from the current/provided clock by a givenduration.

Creates anOffsetDateTime. The following arguments are supported:

• no arguments - current date-time with the default offset
• one argument
  • clock
  • zone offset
  • another temporal entity
  • string representation
  • year
• two arguments
  • formatter (format) and a string
  • local date-time and an offset
  • another temporal entity and an offset (preserves local time)
  • year and month
• three arguments
  • local date, local time and an offset
  • year, month and date
• four up to seven arguments - position date-time constructors
• eight arguments - time fields up to nanoseconds and a zone offset

If zone offset is not specified, default will be used. You can check the default offset by invoking(zone-offset).

Returns true ifv is an instance of java.time.OffsetDateTime, otherwise false.

Creates anOffsetTime. The following arguments are supported:

• no arguments - current time with the default offset
• one argument
  • clock
  • zone id
  • another temporal entity
  • string representation
  • hour
• two arguments
  • formatter (format) and a string
  • local time and an offset
  • instant and an offset
  • hour and minutes
• three arguments - hours, minutes, seconds
• four arguments - hours, minutes, seconds, nanos
• five arguments - last is the offset

If zone offset is not specified, default will be used. You can check the default offset by invoking(zone-offset).

Returns true ifv is an instance of java.time.OffsetTime, otherwise false.

Gets the overlap between this interval and the other one ornil

True if this interval overlaps the other one

Creates a period - a temporal entity consisting of years, months and days.

Given one argument will

• interpret as years if a number
• try to parse from the standard format if a string
• extract supported units from anotherTemporalAmount
• convert from a Joda Period

Given two arguments will

• get a period of a specified unit, e.g.(period 10 :months)
• get a period between two temporals by converting them to local dates
• get a period of a specified number of years and months

Given three arguments will create a year/month/day period.

Returns true ifv is an instance of java.time.Period, otherwise false.

Adds all of theos to the time entityo.plus is not commutative, the first argument is always the entity which will accumulate the rest of the arguments.

(j/plus (j/local-date 2015) (j/years 1))=> <java.time.LocalDate "2016-01-01">

Map of properties present in this temporal entity

Property of this temporal entity under keyk

Returns theQuarter for the given quarter keyword name (e.g.:q1), ordinal or entity. Current quarter if no arguments given.

True iforg.threeten.extra.Quarter.

Range of values for this property

Returns true if the given time entity with theday-of-week property falls on a Saturday, otherwise false.

Returns aDuration ofi seconds.

Sets theclock to the giventime.

This mutates the mock clock.

Smallest maximum value of this property, e.g. 28th of February for months

Creates ajava.sql.Date out of any combination of arguments valid forlocal-date or theLocalDate itself.

Please consider using the JSR-310 Java Time types instead ofjava.sql.Date if your drivers support them.

Even thoughjava.sql.Date extends ajava.util.Date, it’s supposed to be used as a local date (no time component or time zone) for the purposes of conversion from/to native JDBC driver DATE types.

Creates ajava.sql.Time out of any combination of arguments valid forlocal-time (except the nanos constructor) or theLocalTime itself.

Please consider using the JSR-310 Java Time types instead ofjava.sql.Time if your drivers support them.

Even thoughjava.sql.Time extends ajava.util.Date, it’s supposed to be used as a local time (no date component or time zone) for the purposes of conversion from/to native JDBC driver TIME types.

Creates ajava.sql.Timestamp in the local time zone out of any combination of arguments valid forlocal-date-time or theLocalDateTime itself.

Does not supportTimestamp construction from anInstant or a long millis value—please useinstant->sql-timestamp for this purpose.

Please consider using the JSR-310 Java Time types instead ofjava.sql.Timestamp if your drivers support them.

java.sql.Timestamp is a version of ajava.util.Date supposed to be used as a local date-time (no time zone) for the purposes of conversion from/to native JDBC driver TIMESTAMP types.

Returns aDuration ofi days.

Gets the start instant of the interval

Returns true if the given time entity with theday-of-week property falls on a Sunday, otherwise false.

True if theo entity supports thep property

Creates a system clock. In the default time zone if called without arguments, otherwise accepts a Zone Id.

Returns true if the given time entity with theday-of-week property falls on a Thursday, otherwise false.

Creates a clock wrapping system/provided clock that only ticks as per specified duration.

Time between temporal entitieso ande in unitu.

(j/time-between (j/local-date 2015) (j/local-date 2016) :days)=> 365(j/time-between :days (j/local-date 2015) (j/local-date 2016))=> 365

Converts a date entity to ajava.util.Date.

Deprecated: This function only has a single arity and works for entities directly convertible tojava.time.Instant. Please consider usingjava-date instead.

Converts a date entity to along representing the number of milliseconds from epoch.

Converts a local date entity to ajava.sql.Date.

Deprecated: This function only has a single arity and works for entities directly convertible tojava.time.LocalDate. Please consider usingsql-date instead.

Converts a date entity to ajava.sql.Timestamp.

Deprecated: This function only has a single arity and works for entities directly convertible tojava.time.Instant. Please consider usingsql-timestamp instead.

Truncates this entity to the specified time unit. Only works for units that divide into the length of standard day without remainder (up to:days).

Returns true if the given time entity with theday-of-week property falls on a Tuesday, otherwise false.

Returns aTemporalUnit for the given keyk or extracts the field from the given temporalentity.

You can see predefined units viajava-time.repl/show-units.

If you want to make your own custom TemporalUnits resolvable, you need to rebind thejava-time.properties/*units* to a customjava_time.properties.UnitGroup.

True if this is aTemporalUnit.

Units present in this temporal entity.

Value of the property

Creates aValueRange given themin andmax amounts or a map of:min-smallest,:max-smallest,:min-largest and:max-largest.

Returns true if the given time entity with theday-of-week property falls on a Wednesday, otherwise false.

Complement ofweekend?.

Returns true if argument issaturday? orsunday?, otherwise false.

Returns aPeriod ofi weeks.

Execute thebody when Joda-Time classes are found on the classpath.

Take care - when AOT-compiling code using this macro, the Joda-Time classes must be on the classpath at compile time!

Executes the givenforms in the scope of the providedclock.

All the temporal entities that get created without parameters will inherit their values from the clock:

(with-clock (system-clock “Europe/London”) (zone-id)) => #<java.time.ZoneRegion Europe/London>

Executes the given function in the scope of the provided clock. All the temporal entities that get created without parameters will inherit their values from the clock.

Underlying temporal entity with the value set to the largest minimum available for this property

Underlying temporal entity with the value set to the maximum available for this property

Underlying temporal entity with the value set to the minimum available for this property

Sets the offset to the specified value ensuring that the local time stays the same.

(offset-time 10 30 0 0 +2) => #<java.time.OffsetTime 10:30+02:00> (with-offset *1 +3) => #<java.time.OffsetTime 10:30+03:00>

Sets the offset to the specified value ensuring that the result has the same instant, e.g.:

(offset-time 10 30 0 0 +2) => #<java.time.OffsetTime 10:30+02:00> (with-offset-same-instant *1 +3) => #<java.time.OffsetTime 11:30+03:00>

Underlying temporal entity with the value set to the smallest maximum available for this property

Underlying temporal entity with the value of this property set tov

Returns this temporal entity with the specifiedZoneId

Sets the zone to the specified value ensuring that the result has the same instant, e.g.:

(zoned-date-time 2015) => #<java.time.ZonedDateTime 2015-01-01T00:00+00:00Europe/London> (with-zone-same-instant *1 “America/New_York”) => #<java.time.ZonedDateTime 2014-12-31T18:00-05:00America/New_York>

Returns theYear for the given entity, string, clock, zone or number. Current year if no arguments given.

Returns theYearMonth for the given entity, string, clock, zone or month/day combination. Current year-month if no arguments given.

Returns true ifo isjava.time.YearMonth, otherwise false.

Returns theYearQuarter for the given entity, clock, zone or year with quarter. Current year quarter if no arguments given.

Returns true ifo isorg.threeten.extra.YearQuarter, otherwise false.

Returns true ifo isjava.time.Year, otherwise false.

Returns aPeriod ofi years.

True if the amount is zero

Creates aZoneId from a string identifier,java.util.TimeZone or extracts from another temporal entity.

Returns default system zone id if no arguments provided.

Given two arguments will use the second as the offset.

Returns true ifv is an instance of java.time.ZoneId, otherwise false.

Creates aZoneOffset from a string identifier (e.g. “+01”), a number of hours/hours and minutes/hours, minutes and seconds or extracts from another temporal entity.

Returns default system zone offset if no arguments provided.

Creates aZonedDateTime. The following arguments are supported:

• no arguments - current date-time in the default zone
• one argument
  • clock
  • zone id
  • another temporal entity
  • string representation
  • year
• two arguments
  • formatter and a string
  • local date-time and a zone id
  • year and month
• three arguments
  • local date, local time and a zone id
  • year, month and day
• four to seven arguments - date-time fields
• eight arguments - last is the zone id

If zone id is not specified, default zone id will be used. You can check the default zone by invoking(zone-id).

Returns true ifv is an instance of java.time.ZonedDateTime, otherwise false.