java-time

deprecated in 1.1.0

This namespace has been deprecated due to #91. Please migrate to java-time.api

This namespace will continue to exist and be updated. For maximum JVM compatibility, please migrate to java-time.api, which provides the same interface. java-time and java-time.api and can be freely intermixed within the same library, so you can safely migrate your own code even if your dependencies use the old namespace.

Migration steps:

  1. rename all references from java-time to java-time.api. eg., (:require [java-time :as jt]) => (:require [java-time.api :as jt])

*

(* o v)

Entity o multiplied by the value v

+

(+ o & os)

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">

-

(- o & os)

Subtracts all of the os from the time entity o

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

<

(< x)(< x y)(< x y & more)

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

<=

(<= x)(<= x y)(<= x y & more)

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

=

(= x)(= x y)(= x y & more)

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

>

(> x)(> x y)(> x y & more)

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

>=

(>= x)(>= x y)(>= x y & more)

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

abs

(abs a)

Returns the absolute value of a temporal amount:

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

abuts?

(abuts? i oi)

True if this interval abut with the other one

adjust

(adjust entity adjuster & args)

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>

advance-clock!

(advance-clock! clock amount)

Advances the clock by the given time amount.

This mutates the mock clock.

after?

(after? x)(after? x y)(after? x y & more)

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

am-pm

(am-pm)(am-pm v)(am-pm fmt arg)

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

am-pm?

(am-pm? o)

True if org.threeten.extra.AmPm.

as

(as o k)(as o k1 k2)(as o k1 k2 & ks)

Values of property/unit identified by keys/objects ks of the temporal entity o, e.g.

(as (duration 1 :hour) :minutes)
=> 60

(as (local-date 2015 9) :year :month-of-year)
=> [2015 9]

as-map

(as-map e)(as-map e value-fn)

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, ...}

available-zone-ids

(available-zone-ids)

Returns a set of string identifiers for all available ZoneIds.

before?

(before? x)(before? x y)(before? x y & more)

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

chronology

(chronology o)

The Chronology of the entity

clock?

(clock? x)

Returns true if x is an instance of java.time.Clock.

contains?

(contains? i o)

True if the interval contains the given instant or interval

convert-amount

(convert-amount amount from-unit to-unit)

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}

day-of-month

(day-of-month)(day-of-month arg)(day-of-month fmt arg)

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

day-of-month?

(day-of-month? o)

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

day-of-week

(day-of-week)(day-of-week v)(day-of-week fmt arg)

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

day-of-week?

(day-of-week? o)

True if java.time.DayOfWeek.

day-of-year

(day-of-year)(day-of-year arg)(day-of-year fmt arg)

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

day-of-year?

(day-of-year? o)

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

days

(days i)

Returns a Period of i days.

duration

(duration)(duration arg0)(duration arg0 arg1)

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)

duration?

(duration? v)

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

end

(end i)

Gets the end instant of the interval

field

(field k)(field entity k)

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.

field?

(field? o)

True if this is a TemporalField.

fields

(fields o)

Fields present in this temporal entity

fixed-clock

(fixed-clock)(fixed-clock i)(fixed-clock i z)

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

format

(format o)(format fmt o)

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"

formatter

(formatter fmt)(formatter fmt arg1)

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, :smartor :lenient
  • case - either :insensitive or :sensitive (defaults to :sensitive)

friday?

(friday? i)

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

gap

(gap i oi)

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

hours

(hours i)

Returns a Duration of i hours.

instant

(instant)(instant arg0)(instant arg0 arg1)

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

instant->sql-timestamp

(instant->sql-timestamp instant-or-millis)

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.

instant?

(instant? v)

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

interval

(interval o)(interval a b)

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.

interval?

(interval? o)

True if Interval

iterate

(iterate f initial v & vs)

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> ...)

java-date

(java-date)(java-date a)(java-date a b)

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-min-value

(largest-min-value p)

Largest minimum value of this property

leap?

(leap? o)

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

local-date

(local-date)(local-date arg0)(local-date arg0 arg1)(local-date arg0 arg1 arg2)

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

local-date-time

(local-date-time)(local-date-time y m d h)(local-date-time y m d h mm)(local-date-time y m d h mm ss)(local-date-time y m d h mm ss n)(local-date-time arg0)(local-date-time arg0 arg1)(local-date-time arg0 arg1 arg2)

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/…

local-date-time?

(local-date-time? v)

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

local-date?

(local-date? v)

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

local-time

(local-time)(local-time h m s nn)(local-time arg0)(local-time arg0 arg1)(local-time arg0 arg1 arg2)

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

local-time?

(local-time? v)

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

max

(max o & os)

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

max-value

(max-value p)

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

micros

(micros micros)

Duration of a specified number of microseconds.

millis

(millis i)

Returns a Duration of i millis.

min

(min o & os)

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

min-value

(min-value p)

Minimum value of this property

minus

(minus o & os)

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">

minutes

(minutes i)

Returns a Duration of i minutes.

mock-clock

(mock-clock)(mock-clock instant)(mock-clock instant zone)

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.

monday?

(monday? i)

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

month

(month)(month v)(month fmt arg)

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

month-day

(month-day)(month-day arg)(month-day a b)

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

month-day?

(month-day? o)

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

month?

(month? o)

True if java.time.Month.

months

(months i)

Returns a Period of i months.

move-end-by

(move-end-by i & os)

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...

move-end-to

(move-end-to i new-end)

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...

move-start-by

(move-start-by i & os)

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...

move-start-to

(move-start-to i new-start)

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...

multiply-by

(multiply-by o v)

Entity o multiplied by the value v

nanos

(nanos i)

Returns a Duration of i nanos.

negate

(negate a)

Negates a temporal amount:

(negate (negate x)) == x

negative?

(negative? a)

True if the amount is negative

not-after?

(not-after? x)(not-after? x y)(not-after? x y & more)

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

not-before?

(not-before? x)(not-before? x y)(not-before? x y & more)

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

offset-clock

(offset-clock d)(offset-clock c d)

Creates a clock offset from the current/provided clock by a given duration.

offset-date-time

(offset-date-time)(offset-date-time y m d h)(offset-date-time y mo d h m)(offset-date-time y mo d h m s)(offset-date-time y mo d h m s n)(offset-date-time y mo d h m s n o)(offset-date-time arg0)(offset-date-time arg0 arg1)(offset-date-time arg0 arg1 arg2)

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).

offset-date-time?

(offset-date-time? v)

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

offset-time

(offset-time)(offset-time h m s)(offset-time h m s n)(offset-time h m s n o)(offset-time arg0)(offset-time arg0 arg1)

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).

offset-time?

(offset-time? v)

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

overlap

(overlap i oi)

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

overlaps?

(overlaps? i oi)

True if this interval overlaps the other one

period

(period)(period arg0)(period arg0 arg1)(period arg0 arg1 arg2)

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.

period?

(period? v)

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

plus

(plus o & os)

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">

properties

(properties o)

Map of properties present in this temporal entity

property

(property o k)

Property of this temporal entity under key k

quarter

(quarter)(quarter v)(quarter fmt arg)

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

quarter?

(quarter? o)

True if org.threeten.extra.Quarter.

range

(range p)

Range of values for this property

saturday?

(saturday? i)

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

seconds

(seconds i)

Returns a Duration of i seconds.

set-clock!

(set-clock! clock time)

Sets the clock to the given time.

This mutates the mock clock.

smallest-max-value

(smallest-max-value p)

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

sql-date

(sql-date)(sql-date arg0)(sql-date arg0 arg1)(sql-date arg0 arg1 arg2)

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.

sql-time

(sql-time)(sql-time arg0)(sql-time arg0 arg1)(sql-time arg0 arg1 arg2)

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.

sql-timestamp

(sql-timestamp)(sql-timestamp arg0)(sql-timestamp arg0 arg1)(sql-timestamp arg0 arg1 arg2)(sql-timestamp arg0 arg1 arg2 arg3)(sql-timestamp arg0 arg1 arg2 arg3 arg4)(sql-timestamp arg0 arg1 arg2 arg3 arg4 arg5)(sql-timestamp arg0 arg1 arg2 arg3 arg4 arg5 arg6)

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.

standard-days

(standard-days i)

Returns a Duration of i days.

start

(start i)

Gets the start instant of the interval

sunday?

(sunday? i)

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

supports?

(supports? o p)

True if the o entity supports the p property

system-clock

(system-clock)(system-clock k)

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

thursday?

(thursday? i)

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

tick-clock

(tick-clock d)(tick-clock c d)

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

time-between

(time-between o e u)

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

to-java-date

deprecated

(to-java-date o)

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.

to-millis-from-epoch

(to-millis-from-epoch o)

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

to-sql-date

deprecated

(to-sql-date o)

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.

to-sql-timestamp

deprecated

(to-sql-timestamp o)

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.

truncate-to

(truncate-to o u)

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).

tuesday?

(tuesday? i)

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

unit

(unit k)(unit entity k)

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.

unit?

(unit? o)

True if this is a TemporalUnit.

units

(units o)

Units present in this temporal entity.

value

(value p)

Value of the property

value-range

(value-range min max)(value-range arg0)

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

wednesday?

(wednesday? i)

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

weekday?

(weekday? dt)

Complement of weekend?.

weekend?

(weekend? dt)

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

weeks

(weeks i)

Returns a Period of i weeks.

when-joda-time-loaded

macro

(when-joda-time-loaded & body)

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!

with-clock

macro

(with-clock c & forms)

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>

with-clock-fn

(with-clock-fn c f)

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.

with-largest-min-value

(with-largest-min-value p)

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

with-max-value

(with-max-value p)

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

with-min-value

(with-min-value p)

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

with-offset

(with-offset o offset)

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>

with-offset-same-instant

(with-offset-same-instant o offset)

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>

with-smallest-max-value

(with-smallest-max-value p)

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

with-value

(with-value p v)

Underlying temporal entity with the value of this property set to v

with-zone

(with-zone o z)

Returns this temporal entity with the specified ZoneId

with-zone-same-instant

(with-zone-same-instant zdt z)

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>

year

(year)(year arg)(year fmt arg)

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

year-month

(year-month)(year-month arg)(year-month a b)

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

year-month?

(year-month? o)

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

year-quarter

(year-quarter)(year-quarter arg)(year-quarter a b)

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

year-quarter?

(year-quarter? o)

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

year?

(year? o)

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

years

(years i)

Returns a Period of i years.

zero?

(zero? a)

True if the amount is zero

zone-id

(zone-id)(zone-id arg0)(zone-id arg0 arg1)

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.

zone-id?

(zone-id? v)

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

zone-offset

(zone-offset)(zone-offset o)(zone-offset h m)(zone-offset h m s)

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.

zoned-date-time

(zoned-date-time)(zoned-date-time y m d h)(zoned-date-time y mo d h m)(zoned-date-time y mo d h m s)(zoned-date-time y mo d h m s n)(zoned-date-time y mo d h m s n o)(zoned-date-time arg0)(zoned-date-time arg0 arg1)(zoned-date-time arg0 arg1 arg2)

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).

zoned-date-time?

(zoned-date-time? v)

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