type 'a sequence = ('a -> -> include module type of struct include Stdlib .Format end val open_box : int -> unitval close_box : unit -> unitval open_hbox : unit -> unitval open_vbox : int -> unitval open_hvbox : int -> unitval pp_open_hovbox : formatter -> int -> unitval open_hovbox : int -> unitval pp_print_string : formatter -> string -> unitval print_string : string -> unitval pp_print_as : formatter -> int -> string -> unitval print_as : int -> string -> unitval print_int : int -> unitval pp_print_float : formatter -> float -> unitval print_float : float -> unitval pp_print_char : formatter -> char -> unitval print_char : char -> unitval pp_print_bool : formatter -> bool -> unitval print_bool : bool -> unitval pp_print_space : formatter -> unit -> unitval print_space : unit -> unitval print_cut : unit -> unitval pp_print_break : formatter -> int -> int -> unitval print_break : int -> int -> unitval pp_force_newline : formatter -> unit -> unitval force_newline : unit -> unitval pp_print_if_newline : formatter -> unit -> unitval print_if_newline : unit -> unitval pp_print_flush : formatter -> unit -> unitval print_flush : unit -> unitval pp_print_newline : formatter -> unit -> unitval print_newline : unit -> unitval set_margin : int -> unitval get_margin : unit -> intval pp_set_max_indent : formatter -> int -> unitval set_max_indent : int -> unitval pp_get_max_indent : formatter -> unit -> intval get_max_indent : unit -> intval pp_set_max_boxes : formatter -> int -> unitval set_max_boxes : int -> unitval pp_get_max_boxes : formatter -> unit -> intval get_max_boxes : unit -> intval pp_over_max_boxes : formatter -> unit -> boolval over_max_boxes : unit -> boolval open_tbox : unit -> unitval pp_close_tbox : formatter -> unit -> unitval close_tbox : unit -> unitval set_tab : unit -> unitval print_tab : unit -> unitval pp_print_tbreak : formatter -> int -> int -> unitval print_tbreak : int -> int -> unitval pp_set_ellipsis_text : formatter -> string -> unitval set_ellipsis_text : string -> unitval pp_get_ellipsis_text : formatter -> unit -> stringval get_ellipsis_text : unit -> stringval pp_open_tag : formatter -> string -> unitval open_tag : tag -> val close_tag : unit -> unitval stdbuf : Stdlib .Buffer.ttype symbolic_output_item = Stdlib__format .symbolic_output_item = | Output_flush | Output_newline | Output_string of string| Output_spaces of int| Output_indent of inttype symbolic_output_buffer = Stdlib__format .symbolic_output_buffer val pp_print_text : formatter -> string -> unitval printf : ('a , formatter , unit) Stdlib .format-> 'a val eprintf : ('a , formatter , unit) Stdlib .format-> 'a val asprintf : ('a , formatter , unit, string) Stdlib .format4-> 'a val kasprintf :
(string -> 'a ) -> ('b , formatter , unit, 'a ) Stdlib .format4-> 'b val bprintf : Stdlib .Buffer.t -> ('a , formatter , unit) Stdlib .format-> 'a val kprintf : (string -> 'a ) -> ('b , unit, string, 'a ) Stdlib .format4-> 'b type t = Stdlib .Format.formatter type 'a printer = t -> 'a -> Force newline (see Format.pp_force_newline).
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.
val text : string printer Print string, but replacing spaces with breaks and newlines with newlinepp_print_text on recent versions of OCaml.
Alias to Format.pp_print_flush.
Similar to CCString.print.
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.
within a b p wraps p inside the strings a and b. Convenient, for instances, for brackets, parenthesis, quotes, etc.
Wrap the printer in a vertical box.
Wrap the printer in a horizontal/vertical box.
Wrap the printer in a horizontal or vertical box.
Wrap the printer in an horizontal box.
val return : ('a , _ , _ , 'a ) Stdlib .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@]"val of_to_string : ('a -> -> 'a printer of_to_string f converts its input to a string using f, then prints the string.
const pp x is a unit printer that uses pp on x.
some pp will print options as follows:
Some x is printed using pp on xNone is not printed at alllazy_force pp out x forces x and prints the result with pp.
lazy_or ?default pp out x prints default if x is not evaluated yet, or uses pp otherwise.
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: unstable
val set_color_tag_handling : t -> Add functions to support color tags to the given formatter.
val set_color_default : bool -> unitset_color_default b enables color handling on the standard formatters (stdout, stderr) if b = true as well as on sprintfb = false.
with_color "Blue" pp behaves like the printer pp, but with the given style.
status: unstable
val with_colorf : string -> t -> ('a , t , unit, unit) Stdlib .format4-> 'a with_colorf "Blue" out "%s %d" "yolo" 42 will behave like Format.fprintf, but wrapping the content with the given style.
status: unstable
val with_color_sf : string -> ('a , t , unit, string) Stdlib .format4-> 'a with_color_sf "Blue" out "%s %d" "yolo" 42 will behave like sprintf
Example:
CCFormat.with_color_sf "red" "%a" CCFormat.Dump.(list int) [1;2;3] |> print_endline;;status: unstable
val with_color_ksf :
f :(string -> 'b ) -> string ->
('a , t , unit, 'b ) Stdlib .format4-> 'a with_color_ksf "Blue" ~f "%s %d" "yolo" 42 will behave like ksprintf
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];;val output : t -> 'a printer -> 'a -> val to_string : 'a printer -> 'a -> val of_chan : Stdlib .out_channel -> t Alias to Format.formatter_of_out_channel.
val with_out_chan : Stdlib .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.
tee a b makes a new formatter that writes in both a and b.
val sprintf : ('a , t , unit, string) Stdlib .format4-> 'a Print into a string any format string that would usually be compatible with fprintfFormat.asprintf.
val sprintf_no_color : ('a , t , unit, string) Stdlib .format4-> 'a Like sprintf
val sprintf_dyn_color :
colors :bool -> ('a , t , unit, string) Stdlib .format4-> 'a Like sprintfcolors.
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;;val fprintf : t -> ('a , t , unit) Stdlib .format-> 'a val fprintf_dyn_color : colors :bool -> t -> ('a , t , unit) Stdlib .format-> 'a Like fprintfcolors.
val ksprintf :
?margin :int -> f :(string -> 'b ) -> ('a , Stdlib .Format.formatter, unit, 'b ) Stdlib .format4-> 'a ksprintf fmt ~f formats using fmt, in a way similar to sprintff on the resulting string.
val to_file : string -> ('a , t , unit, unit) Stdlib .format4-> 'a 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