package qcheck-multicoretests-util

  1. Overview
  2. Docs
package qcheck-multicoretests-util
Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module Util.PpSource

Pretty-printing combinators that generate valid OCaml syntax for common types along with combinators for user-defined types

Sourcetype 'a t = bool -> Format.formatter -> 'a -> unit

The type of pretty-printers to valid OCaml syntax. The bool argument asks the printer to wrap its output inside parentheses if it produces a non-atomic expression.

Sourceval to_show : 'a t -> 'a -> string

to_show pp converts a pretty-printer to a simple 'a -> string function that generate everything on one line. If the environment variable MCTUTILS_TRUNCATE is set to a length, it will truncate the resulting string if it exceeds that length.

Sourceval of_show : ('a -> string) -> 'a t

of_show show uses a simple 'a -> string function as a pretty-printer. Unfortunately, it will wrap the resulting string with parentheses in more cases than strictly necessary.

Sourceval cst0 : string -> Format.formatter -> unit

cst0 name fmt pretty-prints a constructor name with no argument.

Sourceval cst1 : 'a t -> string -> bool -> Format.formatter -> 'a -> unit

cst1 pp name par v fmt pretty-prints a constructor name with one parameter, using pp to pretty-print its argument v, wrapping itself into parentheses when par.

Sourceval cst2 : 'a t -> 'b t -> string -> bool -> Format.formatter -> 'a -> 'b -> unit

cst2 pp1 pp2 name par v1 v2 fmt pretty-prints a constructor name with two parameters, using ppi to pretty-print its argument vi, wrapping itself into parentheses when par.

Sourceval cst3 : 'a t -> 'b t -> 'c t -> string -> bool -> Format.formatter -> 'a -> 'b -> 'c -> unit

cst3 pp1 pp2 pp3 name par v1 v2 v3 fmt pretty-prints a constructor name with three parameters, using ppi to pretty-print its argument vi, wrapping itself into parentheses when par.

Sourceval cst4 : 'a t -> 'b t -> 'c t -> 'd t -> string -> bool -> Format.formatter -> 'a -> 'b -> 'c -> 'd -> unit

cst4 pp1 pp2 pp3 pp4 name par v1 v2 v3 v4 fmt pretty-prints a constructor name with four parameters, using ppi to pretty-print its argument vi, wrapping itself into parentheses when par.

Sourceval cst5 : 'a t -> 'b t -> 'c t -> 'd t -> 'e t -> string -> bool -> Format.formatter -> 'a -> 'b -> 'c -> 'd -> 'e -> unit

cst5 pp1 pp2 pp3 pp4 pp5 name par v1 v2 v3 v4 v5 fmt pretty-prints a constructor name with five parameters, using ppi to pretty-print its argument vi, wrapping itself into parentheses when par.

Sourceval pp_exn : exn t

Pretty-printer for exceptions reusing the standard Printexc.to_string. The exception message will be wrapped conservatively (ie too often) in parentheses.

Sourceval pp_unit : unit t

Pretty-printer for type unit

Sourceval pp_bool : bool t

Pretty-printer for type bool

Sourceval pp_int : int t

Pretty-printer for type int

Sourceval pp_int32 : int32 t

Pretty-printer for type int32

Sourceval pp_int64 : int64 t

Pretty-printer for type int64

Sourceval pp_float : float t

Pretty-printer for type float

Sourceval pp_char : char t

Pretty-printer for type char

Sourceval pp_string : string t

Pretty-printer for type string

Sourceval pp_bytes : bytes t

Pretty-printer for type bytes

Sourceval pp_option : 'a t -> 'a option t

pp_option pp pretty-prints a value of type 'a option using pp to pretty-print values of type 'a.

Sourceval pp_result : 'o t -> 'e t -> ('o, 'e) result t

pp_result pp_ok pp_error pretty-prints a value of type ('o, 'e) result using pp_ok to pretty-print values of type 'o and pp_error for values of type 'e.

Sourcetype pp_tuple_item

The abstract type for the pretty-printer of a tuple item

Sourceval pp_tuple_item : 'a t -> 'a -> pp_tuple_item

pp_tuple_item pp v builds a pretty-printer for a tuple item using pp to pretty-print its value v.

Sourceval pp_tuple : pp_tuple_item list t

pp_tuple pretty-prints a tuple taken as a list of pp_tuple_items.

Sourceval pp_pair : 'a t -> 'b t -> ('a * 'b) t

pp_pair pp_a pp_b pretty-prints a value of type 'a * 'b using pp_a to pretty-print values of type 'a and pp_b for values of type 'b.

Sourceval pp_tuple2 : 'a t -> 'b t -> ('a * 'b) t

pp_tuple2 pretty-prints pairs, synonym for pp_pair.

Sourceval pp_tuple3 : 'a t -> 'b t -> 'c t -> ('a * 'b * 'c) t

pp_tuple3 pretty-prints triples.

Sourceval pp_tuple4 : 'a t -> 'b t -> 'c t -> 'd t -> ('a * 'b * 'c * 'd) t

pp_tuple4 pretty-prints tuples of 4 elements.

Sourceval pp_tuple5 : 'a t -> 'b t -> 'c t -> 'd t -> 'e t -> ('a * 'b * 'c * 'd * 'e) t

pp_tuple5 pretty-prints tuples of 5 elements.

Sourceval pp_tuple6 : 'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t -> ('a * 'b * 'c * 'd * 'e * 'f) t

pp_tuple6 pretty-prints tuples of 6 elements.

Sourceval pp_tuple7 : 'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t -> 'g t -> ('a * 'b * 'c * 'd * 'e * 'f * 'g) t

pp_tuple7 pretty-prints tuples of 7 elements.

Sourceval pp_tuple8 : 'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t -> 'g t -> 'h t -> ('a * 'b * 'c * 'd * 'e * 'f * 'g * 'h) t

pp_tuple8 pretty-prints tuples of 8 elements.

Sourceval pp_tuple9 : 'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t -> 'g t -> 'h t -> 'i t -> ('a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i) t

pp_tuple9 pretty-prints tuples of 9 elements.

Sourceval pp_tuple10 : 'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t -> 'g t -> 'h t -> 'i t -> 'j t -> ('a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i * 'j) t

pp_tuple10 pretty-prints tuples of 10 elements.

Sourceval pp_list : 'a t -> 'a list t

pp_list pp pretty-prints a list using pp to pretty-print its elements.

Sourceval pp_seq : 'a t -> 'a Seq.t t

pp_seq pp pretty-prints a sequence using pp to pretty-print its elements.

Sourceval pp_array : 'a t -> 'a array t

pp_array pp pretty-prints an array using pp to pretty-print its elements.

Sourcetype pp_field

The abstract type for the pretty-printer of a record field

Sourceval pp_field : string -> 'a t -> 'a -> pp_field

pp_field name pp v builds a pretty-printer for a record field of given name using pp to pretty-print its content value v.

Sourceval pp_record : pp_field list t

pp_record flds pretty-prints a record using the list of pretty-printers of its fields.

Sourceval pp_fun_ : _ QCheck.fun_ t

Pretty-printer for QCheck's function type fun_