A  
abs [Ptime.Span]  abs d is the absolute value of span d .

add [Ptime.Span]  add d d' is d + d' .

add_span [Ptime]  add_span t d is timestamp t + d , that is t with the signed
POSIX span d added.

C  
compare [Ptime.Span]  compare d d' is a total order on durations that is compatible
with signed time span order.

compare [Ptime]  compare t t' is a total order on timestamps that is compatible
with timeline order.

current_tz_offset_s [Ptime_clock]  current_tz_offset_s () is the system's current local time zone
offset to UTC in seconds, if known.

D  
diff [Ptime]  diff t t' is the signed POSIX span t  t' that happens between
the timestamps t and t' .

dump [Ptime.Span]  dump ppf s prints an unspecified raw representation of d
on ppf .

dump [Ptime]  dump ppf t prints an unspecified raw representation of t
on ppf .

E  
epoch [Ptime]  epoch is 19700101 00:00:00 UTC.

equal [Ptime.Span]  equal d d' is true iff d and d' are the same time span.

equal [Ptime]  equal t t' is true iff t and t' are the same timestamps.

F  
frac_s [Ptime]  frac_s t is the (positive) fractional second duration in t .

I  
is_earlier [Ptime]  is_earlier t ~than is true iff compare t than = 1 .

is_later [Ptime]  is_later t than is true iff compare t than = 1 .

M  
max [Ptime]  max is 99991231 23:59:59.999999999999 UTC, the latest timestamp
representable by Ptime .

min [Ptime]  min is 00000101 00:00:00 UTC, the earliest timestamp
representable by Ptime .

N  
neg [Ptime.Span]  neg d is the span d negated.

now [Ptime_clock]  now () is the current POSIX time, by definition always on the
UTC timeline.

now_d_ps [Ptime_clock]  now_d_ps () is (d, ps) representing POSIX time occuring at
d * 86'400e12 + ps POSIX picoseconds from the epoch
19700101 00:00:00 UTC.

O  
of_d_ps [Ptime.Span]  of_d_ps (d, ps) is a span for the signed POSIX picosecond
span d * 86_400e12 + ps .

of_date [Ptime]  of_date d is of_date_time (d, ((00, 00, 00), 0 (* UTC *))) .

of_date_time [Ptime]  of_date_time dt is the POSIX timestamp corresponding to
datetime dt or None if dt has an invalid date,
invalid time or the datetime is not in the range
[Ptime.min ;Ptime.max ].

of_float_s [Ptime.Span]  of_float_s secs is a span from the signed floating point POSIX
second span d .

of_float_s [Ptime]  
of_int_s [Ptime.Span]  of_int_s secs is a span from the signed integer POSIX second
span secs .

of_rfc3339 [Ptime]  of_rfc3339 ~strict ~sub ~start s parses an RFC 3339
datetime
starting at start (defaults to 0 ) in s to a triple (t, tz, count)
with:
t the POSIX timestamp (hence on the UTC timeline)., tz , the optional time zone offset found in the
timestamp. None is returned iff the datetime satisfies the
unknown local
offset convention., count the number of bytes read starting at start to parse the
timestamp. If sub is false (default) this is always
String.length s  start and Error `Trailing_input is returned
if there are still bytes in s after the datetime was parsed. Use
~sub:true for allowing trailing input to exist.
If strict is true (defaults to false ) the parsing function
errors on timestamps with lowercase 'T' or 'Z' characters or
space separated date and times.

of_span [Ptime]  of_span d is the POSIX time stamp that:
Happens at the POSIX span d after Ptime.epoch
if d is positive., Happens at the POSIX span d before Ptime.epoch
if d is negative.
None is returned if the timestamp is not in the range
[Ptime.min ;Ptime.max ].

P  
period [Ptime_clock]  period () is a positive POSIX time span representing
the clock's period (if available).

period_d_ps [Ptime_clock]  period_d_ps () is if available Some (d, ps) representing the
clock's picosecond period d * 86'400e12 + ps .

pp [Ptime.Span]  pp ppf d prints an unspecified, approximative, representation of d
on ppf .

pp [Ptime]  pp is pp_human ~tz_offset_s:0 .

pp_human [Ptime]  pp_human ~frac_s ~tz_offset_s () ppf t prints an unspecified, human
readable, localeindependent, representation of t with:
tz_offset_s hints the time zone offset to use. The hint is ignored
in the following cases: if tz_offset_s is not an integral number of
minutes and its magnitude not in the range permitted by the standard,
if add_span t (Span.of_int_s tz_offset_s) is None .
If either the hint is ignored or tz_offset_s is unspecified then
RFC 3339's
unknown local offset
convention is used to render the time zone component., frac_s clipped to the range [0 ;12 ] specifies that exactly
frac_s decimal digits of the fractional second of t are
rendered (defaults to 0 ).

pp_rfc3339 [Ptime]  pp_rfc3339 ?space ?frac_s ?tz_offset_s () ppf t is
Format.fprintf ppf "%s" (to_rfc3339 ?space ?frac_s ?tz_offset_s t) .

pp_rfc3339_error [Ptime]  pp_rfc3339_error ppf e prints an unspecified representation of
e on ppf .

R  
rfc3339_error_to_msg [Ptime]  rfc3339_error_to_msg r converts RFC 3339 parse errors to error
messages.

round [Ptime.Span]  round ~frac_s t is t rounded to the frac_s decimal
fractional second.

S  
sub [Ptime.Span]  sub d d' is d  d' .

sub_span [Ptime]  sub_span t d is the timestamp t  d , that is t with the
signed POSIX span d subtracted.

T  
to_d_ps [Ptime.Span]  to_d_ps d is the span d as a pair (d, ps) expressing the
POSIX picosecond span d * 86_400e12 + ps with
ps in the range [0 ;86_399_999_999_999_999L ]

to_date [Ptime]  to_date t is fst (to_date_time t) .

to_date_time [Ptime]  to_date_time ~tz_offset_s t is the datetime of the timestamp t .

to_float_s [Ptime.Span]  to_float_s s is the span d as floating point POSIX seconds.

to_float_s [Ptime]  to_float_s t is like Ptime.to_span but returns a floating point second
POSIX span.

to_int_s [Ptime.Span]  to_int_s d is the span d as a signed integer POSIX second
span, if int 's range can represent it (note that this
depends on Sys.word_size ).

to_rfc3339 [Ptime]  to_rfc3339_tz ~space ~frac_s ~tz_offset_s t formats the timestamp
t according to a RFC 3339
datetime
production with:
tz_offset_s hints the time zone offset to use, use 0 for UTC.
The hint is ignored in the following cases: if tz_offset_s is not an
integral number of minutes and its magnitude not in the range permitted
by the standard, if add_span t (Span.of_int_s tz_offset_s) is None
(the resulting timestamp rendering would not be RFC 3339 compliant).
If either the hint is ignored or tz_offset_s is unspecified then
the
unknown local offset
convention is used to render the time zone component., frac_s , clipped to the range [0 ;12 ] specifies that exactly
frac_s decimal digits of the fractional second of t are
rendered (defaults to 0 )., space if true the date and time separator is a space
rather than a 'T' (not recommended but may be allowed by the
protocol you are dealing with, defaults to false ).

to_span [Ptime]  to_span t is the signed POSIX span that happen between t
and Ptime.epoch :
If the number is positive t happens after Ptime.epoch ., If the number is negative t happens before Ptime.epoch .

truncate [Ptime.Span]  truncate ~frac_s t is t truncated to the frac_s decimal
fractional second.

truncate [Ptime]  truncate ~frac_s t is t truncated to the frac_s decimal
fractional second.

V  
v [Ptime.Span]  
v [Ptime]  v s is of_span (Span.v s) but

W  
weekday [Ptime]  weekday ~tz_offset_s t is the day in the 7day week of timestamp t
expressed in the time zone offset ts_offset_s (defaults to 0 ).

Z  
zero [Ptime.Span]  zero is the neutral element of Ptime.Span.add .
