Module `Line.Using_int64`

Basic line segments

val const : string -> _ Progress.Line.t

const s is the segment that always displays s.

val constf : 
  ('a, Stdlib.Format.formatter, unit, _ Progress.Line.t) Stdlib.format4 ->
  'a

Like const, but takes a format string and corresponding arguments. constf "..." a b c ... is equivalent to const (Format.asprintf "..." a b c ...), except that colours added with Fmt.styled are not discarded.

val string : string Progress.Line.t

A line segment that displays a dynamically-sized string message. Use lpad and rpad to pad the message up to a given length.

val lpad : int -> 'a Progress.Line.t -> 'a Progress.Line.t

lpad n t left-pads the segment t to size n by adding blank space at the start.

val rpad : int -> 'a Progress.Line.t -> 'a Progress.Line.t

rpad n t right-pads the segment t to size n by adding blank space at the end.

val of_printer : ?init:'a -> 'a Progress.Printer.t -> 'a Progress.Line.t

of_printer p is a segment that renders the latest reported value using printer p. See sum for a variant that reports accumulated values instead.

Counting segments

These segments all consume integer values and display the accumulated total of reported values in some way. The top-level Line segments are specialised to int values; see "Alternative integer types" for variants supporting int32, int64 etc.

val count_to : 
  ?pp:int64 Progress.Printer.t ->
  ?sep:unit Progress.Line.t ->
  int64 ->
  int64 Progress.Line.t

count_to target renders both the current running total of reported values and the fixed value target, separated by the the given separator, i.e. 42/100. sep defaults to const "/".

val bytes : int64 Progress.Line.t

Prints the running total as a number of bytes, using ISO/IEC binary prefixes (e.g. 10.4 MiB). See also bytes_per_sec.

val percentage_of : int64 -> int64 Progress.Line.t

percentage_of target renders the running total as a percentage of target, i.e. 42%. Values outside the range [0, 100] will be clamped to either 0 or 100.

val sum : 
  ?pp:int64 Progress.Printer.t ->
  width:int ->
  unit ->
  int64 Progress.Line.t

sum ~width () displays a running total of reported values using width-many terminal columns. If passed, pp overrides the printer used for rendering the count.

Graphical segments

module Bar_style : sig ... end

val bar : 
  ?style:[ `ASCII | `UTF8 | `Custom of Progress.Line.Bar_style.t ] ->
  ?color:Color.t ->
  ?width:[ `Fixed of int | `Expand ] ->
  ?data:[ `Sum | `Latest ] ->
  int64 ->
  int64 Progress.Line.t

bar total is a progress bar of the form: [#################...............]

The proportion of the bar that is filled is given by <reported_so_far> / total. Optional parameters are as follows:

?style specifies whether to use a UTF-8 or an ASCII encoding for the progress bar. The UTF-8 encoding shows a higher resolution of progress, but may not be supported in all terminals. The default is `ASCII.

?color causes the filled portion of the bar to be rendered with the given colour. (Equivalent to setting the colour with Bar_style.with_color.)

?width is the width of the bar in columns. Defaults to `Expand, which causes the bar to occupy the remaining rendering space after accounting for other line segments on the same line.

?data changes the metric that is indicated by the progress bar. `Sum (the default) causes the progress bar to correspond to the running total of values reported so far. `Latest causes each reported value to overwrite the previous one instead.

val spinner : 
  ?frames:string list ->
  ?color:Color.t ->
  ?min_interval:Progress.Duration.t option ->
  unit ->
  _ Progress.Line.t

spinner () is a small segment that cycles over a fixed number of frames each time a value is reported. e.g.

  ⠋ → ⠙ → ⠹ → ⠸ → ⠼ → ⠴ → ⠦ → ⠧ → ⠇ → ⠏ → ...

Optional prameters are as follows:

?frames alters the sequence of frames rendered by the spinner;
?color causes each frame to be rendered with the given colour;
?min_interval is the minimum time interval between frame transitions of the spinner (i.e. a debounce threshold). The default is Some 80ms.

Time-sensitive segments

val bytes_per_sec : int64 Progress.Line.t

bytes_per_sec renders the rate of change of the running total as a number of bytes per second, using ISO/IEC binary prefixes (e.g. 10.4 MiB/s).

val elapsed : 
  ?pp:Progress.Duration.t Progress.Printer.t ->
  unit ->
  _ Progress.Line.t

Displays the time for which the bar has been rendering in MM:SS form.

val eta : 
  ?pp:Progress.Duration.t Progress.Printer.t ->
  int64 ->
  int64 Progress.Line.t

Displays an estimate of the remaining time until total is accumulated by the reporters, in MM:SS form.

val rate : float Progress.Printer.t -> int64 Progress.Line.t

rate pp is an integer segment that uses pp to print the rate of reported values per second. (For instance, bytes_per_sec is rate Units.Bytes.of_float.)

Combining segments

val (++) : 'a Progress.Line.t -> 'a Progress.Line.t -> 'a Progress.Line.t

Horizontally join two segments of the same reported value type.

val list : 
  ?sep:'a Progress.Line.t ->
  'a Progress.Line.t list ->
  'a Progress.Line.t

Horizontally join a list of segments, with a given separator. sep defaults to const " ".

val pair : 
  ?sep:unit Progress.Line.t ->
  'a Progress.Line.t ->
  'b Progress.Line.t ->
  ('a * 'b) Progress.Line.t

Horizontally join a pair of segments consuming different reported values into a single segment that consumes a pair.

val using : ('a -> 'b) -> 'b Progress.Line.t -> 'a Progress.Line.t

using f s is a segment that first applies f to the reported value and then behaves as segment s.

Utilities

The following line segments are definable in terms of the others, but provided for convenience:

val parens : 'a Progress.Line.t -> 'a Progress.Line.t

parens t is const "(" ++ t ++ const ")".

val brackets : 'a Progress.Line.t -> 'a Progress.Line.t

brackets t is const "[" ++ t ++ const "]".

val braces : 'a Progress.Line.t -> 'a Progress.Line.t

braces t is const "{" ++ t ++ const "}".

val noop : unit -> _ Progress.Line.t

A zero-width line segment that does nothing. This segment will not be surrounded with separators when used in a list, making it a useful "off" state for conditionally-enabled segments.

val spacer : int -> _ Progress.Line.t

spacer n is const (String.make n ' ').

val ticker_to : ?sep:unit Progress.Line.t -> int64 -> _ Progress.Line.t

ticker_to total is using ~f:(fun _ -> 1) (counter_to total). i.e. it renders the total number of reported values of some arbitrary type.