Previous  Up  Next

Module CCPrint

module CCPrint: sig .. end

Printer Combinators

This module provides combinators to build printers for user-defined types. It doesn't try to do pretty-printing (see for instance Pprint for this), but a simple way to print complicated values without writing a lot of code.

Those combinators work with "%a". For instance to print a (int * bool) list list and a float array, one can write: 

  CCPrint.(printf "int: %d list: %a, array: %a\n"

    42

    (list (list (pair int bool))) [[1, true; 2, false]; [4, true]]

    (array float) [| 1. ; 2. ; 3e18 |] ;;

Remember that "%a" in this context requires two arguments:

To define new printers, one can either use existing ones (e.g. list int), or use Printf.bprintf. For instance a printer for colored points in 2D: 

 type point = {x:int; y:int; colors: string list};;



let pp_point buf p =

  Printf.bprintf buf "{x=%d, y=%d, colors=%a}"

    p.x p.y CCPrint.(list string) p.colors;;



type 'a sequence = ('a -> unit) -> unit 
type 'a t = Buffer.t -> 'a -> unit
A printer for the type 'a

Combinators


val silent : 'a t
prints nothing
val unit : unit t
val int : int t
val string : string t
val bool : bool t
val float3 : float t
val float : float t
val char : char t
Since 0.14
val list : ?start:string ->
       ?stop:string -> ?sep:string -> 'a t -> 'a list t
val array : ?start:string ->
       ?stop:string -> ?sep:string -> 'a t -> 'a array t
val arrayi : ?start:string ->
       ?stop:string -> ?sep:string -> (int * 'a) t -> 'a array t
val seq : ?start:string ->
       ?stop:string -> ?sep:string -> 'a t -> 'a sequence t
val opt : 'a t -> 'a option t
val pair : 'a t -> 'b t -> ('a * 'b) t
val triple : 'a t -> 'b t -> 'c t -> ('a * 'b * 'c) t
val quad : 'a t ->
       'b t -> 'c t -> 'd t -> ('a * 'b * 'c * 'd) t
val map : ('a -> 'b) -> 'b t -> 'a t

IO


val output : Pervasives.out_channel -> 'a t -> 'a -> unit
val to_string : 'a t -> 'a -> string
val sprintf : ('a, Buffer.t, unit, string) Pervasives.format4 -> 'a
Print into a string
val fprintf : Pervasives.out_channel -> ('a, Buffer.t, unit, unit) Pervasives.format4 -> 'a
Print on a channel
val to_file : string -> ('a, Buffer.t, unit, unit) Pervasives.format4 -> 'a
Print to the given file
val printf : ('a, Buffer.t, unit, unit) Pervasives.format4 -> 'a
val eprintf : ('a, Buffer.t, unit, unit) Pervasives.format4 -> 'a

Monadic IO


module type MONAD_IO = sig .. end
module MakeIO (M : MONAD_IO) : sig .. end
Example: 
 module PrintLwt = CCPrint.MakeIO(struct

    include Lwt

    type output = Lwt_io.output_channel

    let write = Lwt_io.write

  end);;



  PrintLwt.printl Lwt_io.stdout (CCList.pp CCInt.pp) [1;2;3;4];;

  - : unit Lwt.t