package containers

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Printer Combinators

containers
- CCArray
  - S
  - Sub
- CCBV
- CCBool
- CCCache
- CCDeque
- CCError
  - MONAD
  - Traverse
    
    M
- CCFQueue
- CCFlatHashtbl
  - HASHABLE
  - Make
    
    X
  - S
- CCFloat
- CCFun
  - Monad
    
    X
- CCGen
  - Infix
  - Restart
    
    Infix
- CCHash
- CCHashtbl
  - COUNTER
  - DEFAULT
  - Make
    
    X
  - MakeCounter
    
    X
  - MakeDefault
    
    X
  - S
- CCHeap
  - Make
    
    E
  - PARTIAL_ORD
  - S
- CCIO
  - File
- CCInt
- CCKList
  - MONAD
  - Traverse
    
    M
- CCKTree
  - Dot
  - pset
- CCList
  - Assoc
  - Idx
  - MONAD
  - Ref
  - Set
  - Traverse
    
    M
  - Zipper
- CCMap
  - Make
    
    O
  - S
- CCMultiMap
  - BIDIR
  - Make
    
    K
    
    V
  - MakeBidir
    
    L
    
    R
  - OrderedType
  - S
- CCMultiSet
  - Make
    
    O
  - S
- CCOpt
- CCOrd
- CCPair
- CCPersistentHashtbl
  - HashedType
  - Make
    
    H
  - S
- CCPrint
  - MONAD_IO
  - MakeIO
    
    M
- CCRandom
- CCSequence
  - IO
  - Infix
  - Map
    
    Adapt
    
    M
    
    Make
    
    V
    
    S
  - Set
    
    Adapt
    
    X
    
    Make
    
    X
    
    S
- CCSexp
  - L
  - Lexer
  - ParseGen
  - Source
    
    Manual
  - Traverse
- CCString
  - S
  - Split
  - Sub
- CCTrie
  - Make
    
    W
  - MakeArray
    
    X
  - MakeList
    
    X
  - ORDERED
  - S
  - String
  - WORD
- CCVector
- Gen_intf
  - S
    
    Infix
containers.advanced
- Containers_advanced
containers.misc
- Containers_misc
containers.pervasives
- CCPervasives
  - Array
  - List
  - String
containers.string
- Containers_string

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: