package timmy

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Type
Construction
Time manipulation
1. Comparison
2. Operators
Scalar conversions
1. Pretty-print
2. Ptime

package timmy

timmy
- Timmy
  - Date
    
    O
  - Daytime
    
    O
  - Month
    
    O
  - Span
    
    O
  - Time
    
    O
  - Timezone
  - Versions
    
    V1_0
  - Week
    
    O
  - Weekday
    
    O
timmy.clock-virtual
- Clock_virtual
timmy.clock.virtual
- Clock

Legend:
Library
Module
Module type
Parameter
Class
Class type

A duration.

Type

type t

A duration.

Spans may be negative.

Construction

val days : int -> t

days n is a duration of n days.

val hours : int -> t

minutes n is a duration of n hours.

val minutes : int -> t

minutes n is a duration of n minutes.

val seconds : int -> t

seconds n is a duration of n seconds.

Time manipulation

val to_days : t -> int

to_days span is the number of days in span floored.

val to_seconds : t -> int

to_days span is the number of seconds in span floored.

Comparison

include Base.Comparable.S with type t := t

val equal : t -> t -> bool

val compare : t -> t -> int

val min : t -> t -> t

val max : t -> t -> t

val ascending : t -> t -> int

val descending : t -> t -> int

val between : t -> low:t -> high:t -> bool

val clamp_exn : t -> min:t -> max:t -> t

val clamp : t -> min:t -> max:t -> t Base__.Or_error.t

type comparator_witness

val comparator : (t, comparator_witness) Base__Comparator.comparator

Operators

module O : sig ... end

Convenience module to only pull operators.

include module type of O

Convenience module to only pull operators.

include Base.Comparable.Infix with type t := t

val (>=) : t -> t -> bool

val (<=) : t -> t -> bool

val (=) : t -> t -> bool

val (>) : t -> t -> bool

val (<) : t -> t -> bool

val (<>) : t -> t -> bool

val (~-) : t -> t

-span's duration is the opposite of span's duration.

val (+) : t -> t -> t

l + r's duration is the sum of l's duration and r's duration.

val (-) : t -> t -> t

l + r's duration is the difference between l's duration and r's duration.

val (*.) : t -> float -> t

span * f's duration is f times span's duration.

val (*) : t -> int -> t

span * i's duration is i times span's duration.

val (/) : t -> t -> int

l / r is l's duration divedid by r's duration, with the semantics of Caml.( / ).

Scalar conversions

Pretty-print

val pp : t Fmt.t

pp f span prints span to f in an unspecified human readable format, e.g. 45s or 2h.

Ptime

val of_ptime : Ptime.Span.t -> t

of_ptime ptime_span is the span equivalent to ptime_span.

val to_ptime : t -> Ptime.Span.t

to_ptime span is the Ptime span equivalent to span.