package containers

  1. Overview
  2. Docs
package containers
Legend:
Library
Module
Module type
Parameter
Class
Class type

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:

  • a value of type 'a t (buffer printer)
  • a value of type 'a (value to print)

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