cmon 0.2 (latest) · OCaml Package

"Caml Object Notation", a library for pretty-printing ocaml values with sharing.

type id = private int

Unique identifiers to make sharing explicit. Variable names are automatically generated.

type var = id

type t =

| Unit
| Nil
| Bool of bool
| Char of char
| Int of int
| Int32 of int32
| Int64 of int64
| Nativeint of nativeint
| Float of float
| Constant of string
| Cons of {
1. id : id;
2. car : t;
3. cdr : t;
}
| String of {
1. id : id;
2. data : string;
}
| Tuple of {
1. id : id;
2. data : t list;
}
| Record of {
1. id : id;
2. data : (string * t) list;
}
| Constructor of {
1. id : id;
2. tag : string;
3. data : t;
}
| Array of {
1. id : id;
2. data : t array;
}
| Lazy of {
1. id : id;
2. data : t lazy_t;
}
| Var of id
| Let of {
1. id : id;
2. recursive : bool;
3. bindings : (var * t) list;
4. body : t;
}

The output is the syntax of OCaml values (with unique identifiers for structured values) extended with variables and let-bindings to represent sharing.

Primitive values

val unit : t

print `()`

val bool : bool -> t

print `true` or `false`

val char : char -> t

print a single quoted character, escaped if necessary

val int : int -> t

print an integer

val int32 : int32 -> t

print a 32-bit integer

val int64 : int64 -> t

print a 64-bit integer

val nativeint : nativeint -> t

print a native integer

val float : float -> t

print a floating point value

val string : string -> t

print a double quoted string, with necessary escapes

val constant : string -> t

print a literal string (without quoting), useful for non-parameterized data constructors. constant "None" prints `None`.

val constructor : string -> t -> t

print a parameterized dataconstructor. constructor "Some" unit prints `Some ()`.

val tuple : t list -> t

print an OCaml tuple. tuple [int 1; char 'c'] prints `(1, 'c')`.

val record : (string * t) list -> t

print an OCaml record. record ["a", int 1; "b", bool false] prints `a: 1, b: false`.

val cons : t -> t -> t

construct a cons cell. cons (int 1) nil prints `1`, cons (int 1) (constant "xs") prints `1 :: xs`,

val construct : string -> t list -> t

Shortcut for a data constructor with multiple arguments. construct "None" [] = constant "None" prints `None`, construct "Some" [int 1] = constructor "Some" (int 1) prints `Some 1`, construct "A" [int 1; int 2] = [constructor "A" (tuple [int 1; int 2])] prints `A (1, 2)`.

val crecord : string -> (string * t) list -> t

Shortcut for constructor with inline record. crecord "A" ["a", int 1; "b", bool false] prints `A a: 1, b: false`.

val nil : t

nil prints ``

val list : t list -> t

list xs = List.fold_right cons xs nil. list [int 1; int 2; int 3] prints `1; 2; 3`.

val list_map : ('a -> t) -> 'a list -> t

list_map f xs = list (List.map f xs)

val array : t array -> t

array [|int 1; int 2; int 3|] prints `| 1; 2; 3 |`.

val array_map : ('a -> t) -> 'a array -> t

array_map f xs = array (Array.map f xs)

Variants that prevent sharing these values

val unshared_string : string -> t

val unshared_constructor : string -> t -> t

val unshared_tuple : t list -> t

val unshared_record : (string * t) list -> t

val unshared_construct : string -> t list -> t

val unshared_crecord : string -> (string * t) list -> t

val unshared_list : t list -> t

val unshared_array : t array -> t

val of_lazy : t lazy_t -> t

val explicit_sharing : t -> t

Rewrite a value, introducing let-binders to make sharing explicit.

val print_as_is : t -> PPrint.document

Print the value as it is (without changing sharing) to a PPrint.document.

val print : t -> PPrint.document

Print the value with explicit sharing to a PPrint.document. print t == print_as_is (explicit_sharing t).

val format_document : Format.formatter -> PPrint.document -> unit

Print a PPrint document on a formatter while trying to follow respect the margin specification of the formatter.

val format_as_is : Format.formatter -> t -> unit

Format the value as it is (without changing sharing) to a Format.formatter

val format : Format.formatter -> t -> unit

Format the value with explicit sharing to a Format.formatter. format t == format_as_is (explicit_sharing t).

To display cmon values in a top-level, you can use #install_printer format. For instance:

utop # Cmon.unit;;

: Cmon.t = Cmon.Unit utop # #install_printer Cmon.format;; utop # Cmon.unit;;
: Cmon.t = ()

package cmon