Entity o multiplied by the value v

Adds all of the os to the time entity o. + 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 the os from the time entity o

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

Returns true if time entities are ordered from the earliest to the latest (same semantics as <), otherwise false.

(j/< (local-date 2009) (local-date 2010) (local-date 2011))
=> true

(j/< (interval (instant 10000) (instant 1000000))
     (instant 99999999))
=> true

Returns true if time entities are ordered from the earliest to the latest (same semantics as <=), otherwise false.

(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

Returns true if time entities are ordered from the latest to the earliest (same semantics as >), otherwise false.

(j/> (local-date 2011) (local-date 2010) (local-date 2009))
=> true

(j/> (instant 99999999)
     (interval (instant 10000) (instant 1000000)))
=> true

Returns true if time entities are ordered from the latest to the earliest (same semantics as >=), otherwise false.

(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 temporal entity using the provided adjuster with optional args.

The adjuster should either be a keyword which resolves to one of the predefined adjusters (see java-time.repl/show-adjusters) an instance of TemporalAdjuster 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 the clock by the given time amount.

This mutates the mock clock.

Returns true if time entities are ordered from the latest to the earliest (same semantics as >), otherwise false.

(after? (local-date 2011) (local-date 2010) (local-date 2009))
=> true

(after? (instant 99999999)
        (interval (instant 10000) (instant 1000000)))
=> true

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

True if org.threeten.extra.AmPm.

Values of property/unit identified by keys/objects ks of the temporal entity o, 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 in value-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.

Returns true if time entities are ordered from the earliest to the latest (same semantics as <), otherwise false.

(before? (local-date 2009) (local-date 2010) (local-date 2011))
=> true

(before? (interval (instant 10000) (instant 1000000))
         (instant 99999999))
=> true

The Chronology of the entity

Returns true if x is an instance of java.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 the to unit
• :remainder - the remainder in the from unit

Arguments may be keywords or instances of TemporalUnit.

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. See ChronoUnit and IsoFields for all of the supported units. Does not convert between precise and imprecise units.

Throws ArithmeticException if long overflow occurs during computation.

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

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

Returns true if o is org.threeten.extra.DayOfMonth, otherwise false.

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

True if java.time.DayOfWeek.

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

Returns true if o is org.threeten.extra.DayOfYear, otherwise false.

Returns a Period of i 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 another TemporalAmount
• convert from a Joda Period/Duration

Given two arguments will:

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

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

Gets the end instant of the interval

Returns a TemporalField for the given key k or extracts the field from the given temporal entity.

You can see predefined fields via java-time.repl/show-fields.

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

True if this is a TemporalField.

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 a DateTimeFormatter 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 the day-of-week property falls on a Friday, otherwise false.

Gets the gap between this interval and the other one or nil

Returns a Duration of i hours.

Creates an Instant. 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 a java.sql.Timestamp from the provided instant-or-millis - a millisecond numeric time value or something convertible to an Instant.

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

java.sql.Timestamp is a version of a java.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 if v 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 optional threeten-extra dependency.

True if Interval

Returns a lazy sequence of initial , (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 a java.util.Date out of any combination of arguments valid for instant or the Instant itself.

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

Largest minimum value of this property

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

Creates a LocalDate. 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 a LocalDateTime. 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 if v is an instance of java.time.LocalDateTime, otherwise false.

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

Creates a LocalTime. 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 if v 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 a Duration of i millis.

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

Minimum value of this property

Subtracts all of the os from the time entity o

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

Returns a Duration of i minutes.

Returns a mock implementation of the java.time.Clock. The mock supports advance-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 the day-of-week property falls on a Monday, otherwise false.

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

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

Returns true if o is java.time.MonthDay, otherwise false.

True if java.time.Month.

Returns a Period of i 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...

Entity o multiplied by the value v

Returns a Duration of i nanos.

Negates a temporal amount:

(negate (negate x)) == x

True if the amount is negative

Returns true if time entities are ordered from the earliest to the latest (same semantics as <=), otherwise false.

(not-after? (local-date 2009) (local-date 2010) (local-date 2011))
;=> true

(not-after? (interval (instant 10000) (instant 1000000))
            (instant 99999999))
;=> true

Returns true if time entities are ordered from the latest to the earliest (same semantics as >=), otherwise false.

(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 given duration.

Creates an OffsetDateTime. 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 if v is an instance of java.time.OffsetDateTime, otherwise false.

Creates an OffsetTime. 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 if v is an instance of java.time.OffsetTime, otherwise false.

Gets the overlap between this interval and the other one or nil

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 another TemporalAmount
• 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 if v is an instance of java.time.Period, otherwise false.

Adds all of the os to the time entity o. 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 key k

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

True if org.threeten.extra.Quarter.

Range of values for this property

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

Returns a Duration of i seconds.

Sets the clock to the given time.

This mutates the mock clock.

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

Creates a java.sql.Date out of any combination of arguments valid for local-date or the LocalDate itself.

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

Even though java.sql.Date extends a java.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 a java.sql.Time out of any combination of arguments valid for local-time (except the nanos constructor) or the LocalTime itself.

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

Even though java.sql.Time extends a java.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 a java.sql.Timestamp in the local time zone out of any combination of arguments valid for local-date-time or the LocalDateTime itself.

Does not support Timestamp construction from an Instant or a long millis value—please use instant->sql-timestamp for this purpose.

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

java.sql.Timestamp is a version of a java.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 a Duration of i days.

Gets the start instant of the interval

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

True if the o entity supports the p 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 the day-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 entities o and e in unit u.

(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 a java.util.Date.

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

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

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

Deprecated: This function only has a single arity and works for entities directly convertible to java.time.LocalDate. Please consider using sql-date instead.

Converts a date entity to a java.sql.Timestamp.

Deprecated: This function only has a single arity and works for entities directly convertible to java.time.Instant. Please consider using sql-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 the day-of-week property falls on a Tuesday, otherwise false.

Returns a TemporalUnit for the given key k or extracts the field from the given temporal entity.

You can see predefined units via java-time.repl/show-units.

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

True if this is a TemporalUnit.

Units present in this temporal entity.

Value of the property

Creates a ValueRange given the min and max amounts or a map of :min-smallest, :max-smallest, :min-largest and :max-largest.

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

Complement of weekend?.

Returns true if argument is saturday? or sunday?, otherwise false.

Returns a Period of i weeks.

Execute the body 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 given forms in the scope of the provided clock.

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 to v

Returns this temporal entity with the specified ZoneId

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 the Year for the given entity, string, clock, zone or number. Current year if no arguments given.

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

Returns true if o is java.time.YearMonth, otherwise false.

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

Returns true if o is org.threeten.extra.YearQuarter, otherwise false.

Returns true if o is java.time.Year, otherwise false.

Returns a Period of i years.

True if the amount is zero

Creates a ZoneId 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 if v is an instance of java.time.ZoneId, otherwise false.

Creates a ZoneOffset 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 a ZonedDateTime. 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 if v is an instance of java.time.ZonedDateTime, otherwise false.