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:
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:
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:

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