package treeprint

  1. Overview
  2. Docs
package treeprint
Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module TreeprintSource

Pretty printing combinator based on Format with automatic parenthese insertion

Sourcetype assoc =
  1. | Left
  2. | Right
  3. | Noassoc
    (*

    Associativity

    *)
Sourcetype level = float

Operator precedence. Smaller is stronger.

Pretty printing monad

Sourcetype 'a t = assoc -> level -> 'a

Type of the pretty printer combinator: under the given assoc position and precendence level, compute some 'a

Pretty printer combinator is a state monad

include Spotlib.Spot.Monad.T with type 'a t := 'a t
Sourceval return : 'a -> 'a t
Sourceval bind : 'a t -> ('a -> 'b t) -> 'b t
Sourceval fmap : ('a -> 'b) -> 'a t -> 'b t

fmap in Haskell

Sourceval liftM : ('a -> 'b) -> 'a t -> 'b t

synonym of fmap

Sourceval fmap2 : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t

fmap2 in Haskell

Sourceval liftM2 : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t

synonym of fmap2

Sourceval void : 'a t -> unit t
Sourceval seq_ : unit t list -> unit t

sequence_ in Haskell. Not tail recursive.

Sourceval mapM : ('a -> 'b t) -> 'a list -> 'b list t

Not tail recursive by default

Sourceval mapM_ : ('a -> unit t) -> 'a list -> unit t

Not tail recursive by default

Sourceval iteri : (int -> 'a -> unit t) -> 'a list -> unit t

Iteration with index starting from 0. Not tail recursive by default

Sourceval for_ : int -> int -> (int -> unit t) -> unit t

for like iteration. Not tail recursive by default

Sourceval join : 'a t t -> 'a t
Sourcemodule Token : sig ... end
Sourcetype token = Token.t

Pretty printing command

Sourcetype ppr = token t

Type of pretty printers

1 Basic printer functions

Sourceval string : string -> ppr

string s pretty-prints the string s

Sourceval box : int -> ppr -> ppr

box n ppr creates a horizontal layout box. An internal call of space and cut may cause a line break if the entire contents do not fit with the current printable width. If a line break is required the following contents are printed with additional indentation of n.

Sourceval vbox : int -> ppr -> ppr

vbox n ppr creates a vertical layout box. If the entire contents do not fit with the current printable width, all calls of space and cut cause line breaks. If a line break is required the following contents are printed with additional indentation of n.

Sourceval (++) : ppr -> ppr -> ppr

ppr1 ++ ppr2 concatenates pretty printings

Sourceval seq : ppr list -> ppr

Concatenation of pretty printings.

Sourceval cut : ppr

A hint of a line break.

Sourceval space : ppr

A hint of a line break, preceded with a white space.

Sourceval flush : ppr

Force flushing. All the opened boxes are closed and a line break is inserted.

Sourceval nop : ppr

Do nothing

1 Level and environments

Sourceval left : 'a t -> 'a t

Put the arg in the "left" environment

Sourceval right : 'a t -> 'a t

Put the arg in the "right" environment

Sourceval noassoc : 'a t -> 'a t

Put the arg in the "noassoc" environment

Sourceval level : level -> 'a t -> 'a t

Put the arg in the specified level

Sourceval reset : 'a t -> 'a t

Put the arg in "noassoc" env and 0.0 level

Sourceval check_against_current_level : level -> [ `Same | `Stronger | `Weaker ] t

Compare the argument against the current level: `Same : the same as the current level `Stronger : the argument is stronger than the current `Weak : the argument is weaker than the current

Sourceval need_paren : assoc -> level -> bool t

Check the printer object of assoc and level requires parenthesis wrapping or not in the current environment

Combinators with automatic parenthese insertion

These implements common printing with auto parenthesis wrapping. Note: They may not suit with your own taste.

Sourcetype parens = string * string

left and right parenthese. The default is "(" and ")"

Sourceval parenbox : ?parens:parens -> assoc -> level -> ppr -> ppr

parenbox ?parens assoc level ppr pretty-prints ppr as an object of associativity assoc and precedence level. Parentheses '(' and ')' are automatically wrapped when required.

Sourceval binop : ?parens:parens -> assoc -> level -> op:ppr -> ppr -> ppr -> ppr

binop ?parens assoc level ~op left right pretty prints binary operation <left> <op> <right> where op has assoc and level. Parentheses '(' and ')' are automatically wrapped when required.

Sourceval list : ?parens:parens -> level -> ppr -> ppr list -> ppr

list ?parens lev sep pprs is to create a list without a box. lev is the level of the separator sep. Parentheses '(' and ')' are automatically wrapped when required.

Sourceval prefix : ?parens:parens -> level -> op:ppr -> ppr -> ppr

prefix ?parens level ~op p pretty-prints an prefix operator application expression <op> <p> where op's level is level. Parentheses '(' and ')' are automatically wrapped when required.

Sourceval postfix : ?parens:parens -> level -> op:ppr -> ppr -> ppr

postfix ?parens level ~op p pretty-prints an postfix operator application expression <p> <op> where op's level is level. Parentheses '(' and ')' are automatically wrapped when required.

Sourceval parens : string -> string -> ppr -> ppr

parens left right ppr surrounds ppr with the left and right strings. The level used for pretty-printing the internal ppr is reset to -1.0 to prevent from having auto parens for it

OCaml like printers

Printing combinators which use the same operator assciativity and precedence as OCaml language.

Sourcemodule OCaml : sig ... end

Drivers

Sourceval format : ?assoc:assoc -> ?level:level -> ('a -> ppr) -> Spotlib.Spot.Format.t -> 'a -> unit

format ?assoc ?level conv ppf a pretty-prints a using the conversion function conv to the formatter ppf. The initial associativity and level are given by assoc and level.

Sourceval buffer : ('a -> ppr) -> Buffer.t -> ?assoc:assoc -> ?level:level -> 'a -> unit

buffer conv buf ?assoc ?level a pretty-prints a using the conversion function conv to the buffer buf. The initial associativity and level are given by assoc and level.

Sourceval show : ('a -> ppr) -> ?assoc:assoc -> ?level:level -> 'a -> string

show conv ?assoc ?level a pretty-prints a using the conversion function conv then returns the result as a string. The initial associativity and level are given by assoc and level.

Sourcemodule MakeDrivers (M : sig ... end) : sig ... end

Functor version of drivers