CCFormat
include module type of struct include Stdlib.Format end
val pp_open_box : formatter -> int -> unit
val pp_close_box : formatter -> unit -> unit
val pp_open_hbox : formatter -> unit -> unit
val pp_open_vbox : formatter -> int -> unit
val pp_open_hvbox : formatter -> int -> unit
val pp_open_hovbox : formatter -> int -> unit
val pp_print_string : formatter -> string -> unit
val pp_print_as : formatter -> int -> string -> unit
val pp_print_int : formatter -> int -> unit
val pp_print_float : formatter -> float -> unit
val pp_print_char : formatter -> char -> unit
val pp_print_bool : formatter -> bool -> unit
val pp_print_space : formatter -> unit -> unit
val pp_print_cut : formatter -> unit -> unit
val pp_print_break : formatter -> int -> int -> unit
val pp_print_custom_break : formatter -> fits:(string * int * string) ->
breaks:(string * int * string) -> unit
val pp_force_newline : formatter -> unit -> unit
val pp_print_if_newline : formatter -> unit -> unit
val pp_print_flush : formatter -> unit -> unit
val pp_print_newline : formatter -> unit -> unit
val pp_set_margin : formatter -> int -> unit
val pp_get_margin : formatter -> unit -> int
val pp_set_max_indent : formatter -> int -> unit
val pp_get_max_indent : formatter -> unit -> int
val check_geometry : geometry -> bool
val pp_set_geometry : formatter -> max_indent:int -> margin:int -> unit
val pp_safe_set_geometry : formatter -> max_indent:int -> margin:int -> unit
val get_geometry : unit -> geometry
val pp_set_max_boxes : formatter -> int -> unit
val pp_get_max_boxes : formatter -> unit -> int
val pp_over_max_boxes : formatter -> unit -> bool
val pp_open_tbox : formatter -> unit -> unit
val pp_close_tbox : formatter -> unit -> unit
val pp_set_tab : formatter -> unit -> unit
val pp_print_tab : formatter -> unit -> unit
val pp_print_tbreak : formatter -> int -> int -> unit
val pp_set_ellipsis_text : formatter -> string -> unit
val pp_get_ellipsis_text : formatter -> unit -> string
val open_stag : stag -> unit
val pp_close_stag : formatter -> unit -> unit
val pp_set_tags : formatter -> bool -> unit
val pp_set_print_tags : formatter -> bool -> unit
val pp_set_mark_tags : formatter -> bool -> unit
val pp_get_print_tags : formatter -> unit -> bool
val pp_get_mark_tags : formatter -> unit -> bool
val pp_set_formatter_out_channel : formatter -> Stdlib.out_channel -> unit
val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit
val pp_get_formatter_output_functions : formatter -> unit -> (string -> int -> int -> unit) * (unit -> unit)
val pp_set_formatter_out_functions : formatter -> formatter_out_functions -> unit
val set_formatter_out_functions : formatter_out_functions -> unit
val pp_get_formatter_out_functions : formatter -> unit -> formatter_out_functions
val get_formatter_out_functions : unit -> formatter_out_functions
val pp_set_formatter_stag_functions : formatter -> formatter_stag_functions -> unit
val set_formatter_stag_functions : formatter_stag_functions -> unit
val pp_get_formatter_stag_functions : formatter -> unit -> formatter_stag_functions
val get_formatter_stag_functions : unit -> formatter_stag_functions
val formatter_of_out_channel : Stdlib.out_channel -> formatter
val std_formatter : formatter
val err_formatter : formatter
val formatter_of_buffer : Stdlib.Buffer.t -> formatter
val str_formatter : formatter
val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter
val formatter_of_out_functions : formatter_out_functions -> formatter
val make_symbolic_output_buffer : unit -> symbolic_output_buffer
val clear_symbolic_output_buffer : symbolic_output_buffer -> unit
val get_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list
val flush_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list
val add_symbolic_output_item : symbolic_output_buffer -> symbolic_output_item -> unit
val formatter_of_symbolic_output_buffer : symbolic_output_buffer -> formatter
val pp_print_text : formatter -> string -> unit
val 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 pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) ->
flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit
val pp_get_all_formatter_output_functions : formatter -> unit -> (string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)
val open_tag : tag -> unit
val pp_close_tag : formatter -> unit -> unit
val pp_set_formatter_tag_functions : formatter -> formatter_tag_functions -> unit
val set_formatter_tag_functions : formatter_tag_functions -> unit
val pp_get_formatter_tag_functions : formatter -> unit -> formatter_tag_functions
val get_formatter_tag_functions : unit -> formatter_tag_functions
type -'a printer = t -> 'a -> unit
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 exn : exn printer
Printer using Printexc
.to_string.
val space : unit printer
Alias to pp_print_space
.
val cut : unit printer
Alias to pp_print_cut
.
val break : (int * int) printer
Tuple-ized printer
form of pp_print_break
.
val newline : unit printer
Force newline (see Format
.pp_force_newline).
val substring : (string * int * int) printer
substring (s,i,len)
prints 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 newline
. See pp_print_text
on recent versions of OCaml.
val string_lines : string printer
string_lines out s
prints s
with all newlines ('\n'
) replaced by a cut, in a vertical box. It does NOT insert breakable spaces in place of spaces, unlike text
. This means an already formatted string can be displayed inside another formatter without mangling the indentation.
val char : char printer
val int32 : int32 printer
val int64 : int64 printer
val nativeint : nativeint printer
val flush : unit printer
Alias to Format
.pp_print_flush.
val string_quoted : string printer
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.
append ppa ppb
first prints ppa ()
, then prints ppb ()
.
within a b p
wraps p
inside the strings a
and b
. Convenient, for instances, for brackets, parenthesis, quotes, etc.
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 -> string) -> 'a printer
of_to_string f
converts its input to a string using f
, then prints the string.
some pp
will print options as follows:
Some x
is printed using pp
on x
None
is not printed at allval const_string : string -> 'a printer
const_string s
is a printer that ignores its input and always prints s
.
val opaque : 'a printer
opaque
is const_string "opaque"
. The exact string used is not stable.
lazy_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:
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 -> unit
Add functions to support color tags to the given formatter.
set_color_default b
enables color handling on the standard formatters (stdout, stderr) if b = true
as well as on sprintf
formatters; it disables the color handling if b = false
.
with_color "Blue" pp
behaves like the printer pp
, but with the given style.
status: unstable
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
, 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: 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
, 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];;
module ANSI_codes : sig ... end
ANSI escape codes. This contains lower level functions for them.
val to_string : 'a printer -> 'a -> string
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.
val stdout : t
val stderr : t
val sprintf : ('a, t, unit, string) Stdlib.format4 -> 'a
Print into a string any format string that would usually be compatible with fprintf
. Like Format
.asprintf.
val sprintf_no_color : ('a, t, unit, string) Stdlib.format4 -> 'a
Like sprintf
but never prints colors.
val sprintf_dyn_color : colors:bool -> ('a, t, unit, string) Stdlib.format4 -> 'a
Like 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;;
Like fprintf
but enable/disable colors depending on colors
.
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 sprintf
, and then calls f
on the resulting string.
val to_file : string -> ('a, t, unit, unit) Stdlib.format4 -> 'a
Print to the given file.
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
module Infix : sig ... end