Module CCFormat

module CCFormat: sig .. end

Helpers for Format

Since 0.8

type 'a sequence = ('a -> unit) -> unit

type t = Format.formatter

type 'a printer = t -> 'a -> unit

Combinators

val silent : 'a printer

Prints nothing

val unit : unit printer

Prints "()"

val int : int printer

val string : string printer

val bool : bool printer

val float3 : float printer

val float : float printer

val newline : unit printer

Force newline (see Format.pp_force_newline)
Since 1.2

val substring : (string * int * int) printer

Print the substring (s,i,len), where i is the offset in s and len the number of bytes in the substring.
Since 1.2
Raises Invalid_argument if the triple (s,i,len) does not describe a proper substring.

val text : string printer

Print string, but replacing spaces with breaks and newlines with CCFormat.newline. See pp_print_text on recent versions of OCaml.
Since 1.2

val char : char printer

Since 0.14

val int32 : int32 printer

Since 0.14

val int64 : int64 printer

Since 0.14

val nativeint : nativeint printer

Since 0.14

val flush : unit printer

Alias to Format.pp_print_flush.
Since 1.2

val string_quoted : string printer

Similar to CCString.print.
Since 0.14

val list : ?sep:unit printer -> 'a printer -> 'a list printer

val array : ?sep:unit printer ->
       'a printer -> 'a array printer

val arrayi : ?sep:unit printer ->
       (int * 'a) printer -> 'a array printer

val seq : ?sep:unit printer ->
       'a printer -> 'a sequence printer

val opt : 'a printer -> 'a option printer

opt pp prints options as follows: Some x will become "some foo" if pp x ---> "foo" None will become "none"

In the tuple printers, the sep argument is only available

val pair : ?sep:unit printer ->
       'a printer -> 'b printer -> ('a * 'b) printer

val triple : ?sep:unit printer ->
       'a printer ->
       'b printer -> 'c printer -> ('a * 'b * 'c) printer

val quad : ?sep:unit printer ->
       'a printer ->
       'b printer ->
       'c printer ->
       'd printer -> ('a * 'b * 'c * 'd) printer

val within : string -> string -> 'a printer -> 'a printer

within a b p wraps p inside the strings a and b. Convenient, for instances, for brackets, parenthesis, quotes, etc.
Since 0.17

val map : ('a -> 'b) -> 'b printer -> 'a printer

val vbox : ?i:int -> 'a printer -> 'a printer

Wrap the printer in a vertical box
Since 0.16

i : level of indentation within the box (default 0)

val hvbox : ?i:int -> 'a printer -> 'a printer

Wrap the printer in a horizontal/vertical box
Since 0.16

i : level of indentation within the box (default 0)

val hovbox : ?i:int -> 'a printer -> 'a printer

Wrap the printer in a horizontal or vertical box
Since 0.16

i : level of indentation within the box (default 0)

val hbox : 'a printer -> 'a printer

Wrap the printer in an horizontal box
Since 0.16

val return : ('a, 'b, 'c, 'a) Pervasives.format4 -> unit printer

return "some_format_string" takes a argument-less format string and returns a printer actionable by (). Examples:

return ",@ "
return "@{<Red>and then@}@,"
return "@[<v>a@ b@]"

Since 1.0

val of_to_string : ('a -> string) -> 'a printer

of_to_string f converts its input to a string using f, then prints the string
Since 1.0

val const : 'a printer -> 'a -> unit printer

const pp x is a unit printer that uses pp on x
Since 1.0

val some : 'a printer -> 'a option printer

some pp will print options as follows:

Some x is printed using pp on x
None is not printed at all

Since 1.0

ANSI codes

Use ANSI escape codes https://en.wikipedia.org/wiki/ANSI_escape_code to put some colors on the terminal.

This uses tags in format strings to specify the style. Current styles are the following:

"reset" resets style
"black"
"red"
"green"
"yellow"
"blue"
"magenta"
"cyan"
"white"
"bold" bold font
"Black" bold black
"Red" bold red
"Green" bold green
"Yellow" bold yellow
"Blue" bold blue
"Magenta" bold magenta
"Cyan" bold cyan
"White" bold white

Example:

      set_color_default true;;

      Format.printf
        "what is your @{<White>favorite color@}? @{<blue>blue@}! No, @{<red>red@}! Ahhhhhhh@.";;

status: experimental

val set_color_tag_handling : t -> unit

adds functions to support color tags to the given formatter.
Since 0.15

val set_color_default : bool -> unit

set_color_default b enables color handling on the standard formatters (stdout, stderr) if b = true as well as on CCFormat.sprintf formatters; it disables the color handling if b = false.

val with_color : string -> 'a printer -> 'a printer

with_color "Blue" pp behaves like the printer pp, but with the given style. status: experimental
Since 0.16

val with_colorf : string -> t -> ('a, t, unit, unit) Pervasives.format4 -> 'a

with_colorf "Blue" out "%s %d" "yolo" 42 will behave like Format.fprintf, but wrapping the content with the given style status: experimental
Since 0.16

val with_color_sf : string -> ('a, t, unit, string) Pervasives.format4 -> 'a

with_color_sf "Blue" out "%s %d" "yolo" 42 will behave like CCFormat.sprintf, but wrapping the content with the given style Example:

      CCFormat.with_color_sf "red" "%a" CCFormat.Dump.(list int) [1;2;3] |> print_endline;;

status: experimental
Since 0.21

val with_color_ksf : f:(string -> 'b) ->
       string -> ('a, t, unit, 'b) Pervasives.format4 -> 'a

with_color_ksf "Blue" ~f "%s %d" "yolo" 42 will behave like CCFormat.ksprintf, but wrapping the content with the given style Example: the following with raise Failure with a colored message

      CCFormat.with_color_ksf "red" ~f:failwith "%a" CCFormat.Dump.(list int) [1;2;3];;

Since 1.2

IO

val output : t -> 'a printer -> 'a -> unit

val to_string : 'a printer -> 'a -> string

val of_chan : Pervasives.out_channel -> t

Alias to Format.formatter_of_out_channel
Since 1.2

val with_out_chan : Pervasives.out_channel -> (t -> 'a) -> 'a

with_out_chan oc f turns oc into a formatter fmt, and call f fmt. Behaves like f fmt from then on, but whether the call to f fails or returns, fmt is flushed before the call terminates.
Since 1.2

val stdout : t

val stderr : t

val tee : t -> t -> t

tee a b makes a new formatter that writes in both a and b.
Since 1.0

val sprintf : ('a, t, unit, string) Pervasives.format4 -> 'a

Print into a string any format string that would usually be compatible with CCFormat.fprintf. Similar to Format.asprintf.

val sprintf_no_color : ('a, t, unit, string) Pervasives.format4 -> 'a

Similar to CCFormat.sprintf but never prints colors
Since 0.16

val sprintf_dyn_color : colors:bool -> ('a, t, unit, string) Pervasives.format4 -> 'a

Similar to CCFormat.sprintf but enable/disable colors depending on colors. Example:

      (* with colors *)
      CCFormat.sprintf_dyn_color ~colors:true "@{<Red>%a@}"
        CCFormat.Dump.(list int) [1;2;3] |> print_endline;;

      (* without colors *)
      CCFormat.sprintf_dyn_color ~colors:false "@{<Red>%a@}"
        CCFormat.Dump.(list int) [1;2;3] |> print_endline;;

Since 0.21

val fprintf : t -> ('a, t, unit) Pervasives.format -> 'a

Alias to Format.fprintf
Since 0.14

val fprintf_dyn_color : colors:bool -> t -> ('a, t, unit) Pervasives.format -> 'a

Similar to CCFormat.fprintf but enable/disable colors depending on colors
Since 0.21

val ksprintf : f:(string -> 'b) -> ('a, Format.formatter, unit, 'b) Pervasives.format4 -> 'a

ksprintf fmt ~f formats using fmt, in a way similar to CCFormat.sprintf, and then calls f on the resulting string.
Since 0.14

val to_file : string -> ('a, t, unit, unit) Pervasives.format4 -> 'a

Print to the given file

Dump

Print structures as OCaml values, so that they can be parsed back by OCaml (typically, in the toplevel, for debugging).

Example:

      Format.printf "%a@." CCFormat.Dump.(list int) CCList.(1 -- 200);;

      Format.printf "%a@." CCFormat.Dump.(array (list (pair int bool)))
        [| [1, true; 2, false]; []; [42, false] |];;

module Dump: sig .. end